Implement option explicit for dynamic objects.

Closes #218

.decent_ci-Linux.yaml

@@ -4,13 +4,18 @@ compilers:
     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
+    build_tag: "LibC++"
     version: "3.5"
     skip_packaging: true
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=ON -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: "clang"
+    build_tag: AddressSanitizer
+    version: "3.6"
+    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"
+    version: "3.6"
     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"
@@ -21,5 +26,5 @@ compilers:
     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*"
+    compiler_extra_flags: --enable=all -I include --inline-suppr -Umax  --suppress="*:cmake*" --suppress="*:unittests/catch.hpp" --force
 

.decent_ci-Windows.yaml

@@ -13,10 +13,8 @@ compilers:
   - 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
 

.travis.yml

@@ -2,30 +2,55 @@ language: cpp
 compiler:
   - gcc
 env:
-  - GCC_VER=4.6
-  - GCC_VER=4.8
+  matrix:
+    - GCC_VER="4.6"
+    - GCC_VER="4.8"
+
+  global:
+    - secure: eiaR6pXiiEpyB8+LLQ1NvZdl0Yylru1BLy9lMoHl+IpUNGGQGywmW/2WAn77rFfmR1OPA2qWQLfgPwgK0HxUA9HHlot9tre5QhiN2Lw8NOT8tCZ6tTm2+QntDBjBGJyal/knRvQkn/6qs6GxlXRerz4ArnnuPL1vESt3zwB0YtU=
+    # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
+    - secure: "LfolGjP8tWm3yAwthfu3yp8Zn40aueFae580UUR34gusG87cyglq2tQDtxdy+63gWEeNfArbv9n5rZv+bDW3ggHyPjuCKKc1PlZAy07lfXUXf1uz+SFhNvNoYTn3mQG3VZ08o116p4Le2p8yqu4bylJ8wckEq7PrTwvSGVQWTWM="
+
 before_install:
+  - export CXX="g++-$GCC_VER" CC="gcc-$GCC_VER" GCOV="gcov-$GCC_VER"
+  - if [ "$GCC_VER" = "4.8" ]; then export COVERAGE=1 CPPCHECK=1; fi
+  - if [ ${COVERAGE} = 1 ]; then export FUZZY_CMD="-D RUN_FUZZY_TESTS:BOOL=TRUE"; fi
   - sudo pip install cpp-coveralls
   - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
   - sudo apt-get update
-  - sudo apt-get install -qq g++-4.8
-  - if [ "$GCC_VER" = "4.8" ]; then export CXX="g++-4.8" CC="gcc-4.8" GCOV="gcov-4.8"; else export CXX="g++-4.6" CC="gcc-4.6" GCOV="gcov-4.6"; fi
+  - sudo apt-get install -qq g++-$GCC_VER
+
 script: 
-  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug .
-  - make -j2
+  - if [ ${COVERITY_SCAN_BRANCH} != 1 ]; then cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug $FUZZY_CMD . ; fi
+  - if [ ${COVERITY_SCAN_BRANCH} != 1 ]; then make -j2 ; fi
   - make test
-  - mkdir gcov
-  - find CMakeFiles/ -name "*.gc*" -exec mv {} gcov/ \;
-  - $GCOV -d -o gcov gcov/*.gcda
-  - coveralls -n -E ".*\.cpp"
+  - if [ ${COVERAGE} = 1 ]; then bash <(curl -s https://raw.githubusercontent.com/codecov/codecov-bash/master/codecov) -x $GCOV -a "-s `pwd`" ; fi
+
 after_script:
-  - contrib/codeanalysis/runcppcheck.sh
+  - if [ ${CPPCHECK} = 1 ]; then contrib/codeanalysis/runcppcheck.sh ; fi
+
+
 notifications:
   email:
     recipients:
       - jason@emptycrate.com
     on_success: always
     on_failure: always
-env:
-  global:
-    secure: eiaR6pXiiEpyB8+LLQ1NvZdl0Yylru1BLy9lMoHl+IpUNGGQGywmW/2WAn77rFfmR1OPA2qWQLfgPwgK0HxUA9HHlot9tre5QhiN2Lw8NOT8tCZ6tTm2+QntDBjBGJyal/knRvQkn/6qs6GxlXRerz4ArnnuPL1vESt3zwB0YtU=
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/4be9a2720eaa1bb2a6c9
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false
+
+addons:
+  coverity_scan:
+    project:
+      name: "ChaiScript/ChaiScript"
+      description: "Build submitted via Travis CI"
+    notification_email: jason@emptycrate.com
+    build_command_prepend: "cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug . "
+    build_command:   "cmake --build . -- -j2"
+    branch_pattern: coverity_scan
+
+

CMakeLists.txt

@@ -1,18 +1,31 @@
 cmake_minimum_required(VERSION 2.8)
 
+if(NOT ${CMAKE_VERSION} VERSION_LESS "3.1")
+  cmake_policy(SET CMP0054 NEW)
+endif()
+
+IF(BIICODE)
+  INIT_BIICODE_BLOCK()
+  ADD_BIICODE_TARGETS()
+ELSE()
+  # Your regular CMakeLists configuration here
+
+
 project(chaiscript)
 
-# MINGW does not yet support C++11's concurrency features
-if(MINGW)
-  option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" FALSE)
-else()
-  option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
-endif()
+option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
 
 
 option(BUILD_MODULES "Build Extra Modules (stl)" TRUE)
 option(BUILD_SAMPLES "Build Samples Folder" FALSE)
+option(RUN_FUZZY_TESTS "Run tests generated by AFL" FALSE)
+option(USE_STD_MAKE_SHARED "Use std::make_shared instead of chaiscript::make_shared" FALSE)
 
+mark_as_advanced(USE_STD_MAKE_SHARED)
+
+if(USE_STD_MAKE_SHARED)
+  add_definitions(-DCHAISCRIPT_USE_STD_MAKE_SHARED)
+endif()
 
 if(CMAKE_COMPILER_IS_GNUCC)
   option(ENABLE_COVERAGE "Enable Coverage Reporting in GCC" FALSE)
@@ -55,6 +68,13 @@ if(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     set(LINKER_FLAGS "${LINKER_FLAGS} -flto")
   endif()
 
+  option(GPROF_OUTPUT "Generate profile data" FALSE)
+  if (GPROF_OUTPUT)
+    add_definitions(-pg)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -pg")
+  endif()
+
+
   option(PROFILE_GENERATE "Generate profile data" FALSE)
   if (PROFILE_GENERATE)
     add_definitions(-fprofile-generate)
@@ -81,8 +101,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 6)
-set(CPACK_PACKAGE_VERSION_PATCH 0)
+set(CPACK_PACKAGE_VERSION_MINOR 7)
+set(CPACK_PACKAGE_VERSION_PATCH 2)
 
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
@@ -141,7 +161,13 @@ else()
 endif()
 
 if(MSVC)
-  add_definitions(/W4 /w44640)
+  add_definitions(/W4)
+
+  # VS2013 doesn't have magic statics
+  if (MSVC_VERSION STREQUAL "1800")
+    add_definitions(/w44640)
+  endif()
+
   add_definitions(/bigobj)
   # Note on MSVC compiler flags.
   # The code base selective disables warnings as necessary when the compiler is complaining too much
@@ -152,10 +178,10 @@ 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 -Wold-style-cast -Wcast-align -Wcast-qual -Woverloaded-virtual  -pedantic ${CPP11_FLAG})
+  add_definitions(-Wall -Wextra -Wshadow -Wnon-virtual-dtor -Wold-style-cast -Wcast-align -Wcast-qual -Wunused -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)
+    add_definitions(-Weverything -Wno-c++98-compat-pedantic  -Wno-c++98-compat -Wno-documentation -Wno-switch-enum -Wno-weak-vtables -Wno-sign-conversion -Wno-missing-prototypes -Wno-padded -Wno-missing-noreturn -Wno-exit-time-destructors)
   else()
     add_definitions(-Wnoexcept)
   endif()
@@ -234,6 +260,8 @@ add_dependencies(chai chaiscript_stdlib-${CHAI_VERSION})
 if(BUILD_SAMPLES)
   add_executable(example samples/example.cpp)
   target_link_libraries(example ${LIBS})
+  add_executable(test_num_exceptions samples/test_num_exceptions.cpp)
+  target_link_libraries(test_num_exceptions ${LIBS})
   add_executable(memory_leak_test samples/memory_leak_test.cpp)
   target_link_libraries(memory_leak_test ${LIBS})
   add_executable(inheritance samples/inheritance.cpp)
@@ -251,10 +279,84 @@ if(BUILD_MODULES)
 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)
-
 list(SORT UNIT_TESTS)
 
+
+if (RUN_FUZZY_TESTS)
+
+  file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/unittests")
+
+  execute_process(
+    COMMAND ${CMAKE_COMMAND} -E tar xjf ${CMAKE_CURRENT_SOURCE_DIR}/unittests/fuzzy_tests-2015-07-16.tar.bz2
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/unittests
+    )
+
+
+  file(GLOB FUZZY_CRASH_TESTS RELATIVE ${CMAKE_BINARY_DIR}/unittests/ ${CMAKE_BINARY_DIR}/unittests/fuzzy_tests/crashes/id*)
+  list(SORT FUZZY_CRASH_TESTS)
+
+  file(GLOB FUZZY_EXCEPTION_TESTS RELATIVE ${CMAKE_BINARY_DIR}/unittests/ ${CMAKE_BINARY_DIR}/unittests/fuzzy_tests/exceptions/id*)
+  list(SORT FUZZY_EXCEPTION_TESTS)
+
+
+  foreach(filename ${FUZZY_CRASH_TESTS})
+    message(STATUS "Adding test ${filename}")
+    add_test(${filename} chai "-e" ${CMAKE_BINARY_DIR}/unittests/fuzzy_tests/crashes/unit_test.inc ${CMAKE_BINARY_DIR}/unittests/${filename})
+  endforeach()
+
+  set_property(TEST ${FUZZY_CRASH_TESTS}
+    PROPERTY ENVIRONMENT
+    "CHAI_USE_PATH=${CMAKE_BINARY_DIR}/unittests/"
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+    )
+
+  foreach(filename ${FUZZY_EXCEPTION_TESTS})
+    message(STATUS "Adding test ${filename}")
+    add_test(${filename} chai "--exception" ${CMAKE_BINARY_DIR}/unittests/fuzzy_tests/exceptions/unit_test.inc ${CMAKE_BINARY_DIR}/unittests/${filename})
+  endforeach()
+
+  set_property(TEST ${FUZZY_EXCEPTION_TESTS}
+    PROPERTY ENVIRONMENT
+    "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+    )
+
+endif()
+
+
 if(BUILD_TESTING)
+
+  # Add catch tests macro
+  macro(ADD_CATCH_TESTS executable)
+    if (MSVC)
+      file(TO_NATIVE_PATH "${QT_LIBRARY_DIR}" QT_LIB_PATH)
+      set(NEWPATH "${QT_LIB_PATH};$ENV{PATH}")
+    else()
+      set(NEWPATH $ENV{PATH})
+    endif()
+
+    get_target_property(target_files ${executable} SOURCES)
+
+    foreach(source ${target_files})
+      if(NOT "${source}" MATCHES "/moc_.*cxx")
+        string(REGEX MATCH .*cpp source "${source}")
+        if(source)
+          file(READ "${source}" contents)
+          string(REGEX MATCHALL "TEST_CASE\\([ ]*\"[^\"]+\"" found_tests ${contents})
+          foreach(hit ${found_tests})
+            string(REGEX REPLACE "TEST_CASE\\([ ]*(\"[^\"]+\").*" "\\1" test_name ${hit})
+            add_test(${test_name} "${executable}" ${test_name})
+            set_tests_properties(${test_name} PROPERTIES TIMEOUT 660 ENVIRONMENT "PATH=${NEWPATH}")
+          endforeach()
+        endif()
+      endif()
+    endforeach()
+  endmacro()
+
+
+
+
+
   option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
 
   add_test(version_check chai -c  "if(\"\\\${ version() };\\\${version_major()};\\\${version_minor()};\\\${version_patch()}\" != \"${CHAI_VERSION};${CPACK_PACKAGE_VERSION_MAJOR};${CPACK_PACKAGE_VERSION_MINOR};${CPACK_PACKAGE_VERSION_PATCH}\") { exit(-1) }")
@@ -264,6 +366,19 @@ if(BUILD_TESTING)
     "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
   )
 
+  add_test(version_check_2 chai --version )
+  set_property(TEST version_check_2
+    PROPERTY ENVIRONMENT
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+    PROPERTY PASS_REGULAR_EXPRESSION "${CHAI_VERSION}"
+  )
+
+  add_test(help chai --help )
+  set_property(TEST help
+    PROPERTY ENVIRONMENT
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+  )
+
 
   foreach(filename ${UNIT_TESTS})
     message(STATUS "Adding test ${filename}")
@@ -277,75 +392,19 @@ if(BUILD_TESTING)
   )
 
   if(NOT UNIT_TEST_LIGHT)
-    # commented out because uniform initializer syntax is not working properly in MSVC 2013
-    add_executable(utility_test unittests/utility_test.cpp)
-    target_link_libraries(utility_test ${LIBS})
-    add_test(NAME Utility_Test COMMAND utility_test)
+    add_executable(compiled_tests unittests/compiled_tests.cpp)
+    target_link_libraries(compiled_tests ${LIBS})
+    ADD_CATCH_TESTS(compiled_tests)
 
-    add_executable(dynamic_object_test unittests/dynamic_object_test.cpp)
-    target_link_libraries(dynamic_object_test ${LIBS})
-    add_test(NAME Dynamic_Object_Test COMMAND dynamic_object_test)
-
-    add_executable(functor_creation_test unittests/functor_creation_test.cpp)
-    target_link_libraries(functor_creation_test ${LIBS})
-    add_test(NAME Functor_Creation_Test COMMAND functor_creation_test)
-
-    add_executable(functor_cast_test unittests/functor_cast_test.cpp)
-    target_link_libraries(functor_cast_test ${LIBS})
-    add_test(NAME Functor_Cast_Test COMMAND functor_cast_test)
 
     add_executable(boxed_cast_test unittests/boxed_cast_test.cpp)
     target_link_libraries(boxed_cast_test ${LIBS})
     add_test(NAME Boxed_Cast_Test COMMAND boxed_cast_test)
 
-    add_executable(object_lifetime_test unittests/object_lifetime_test.cpp)
-    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)
-
     add_executable(type_info_test unittests/type_info_test.cpp)
     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)
-
-    add_executable(short_comparison_test unittests/short_comparison_test.cpp)
-    target_link_libraries(short_comparison_test ${LIBS})
-    add_test(NAME Short_Comparison_Test COMMAND short_comparison_test)
-
-    add_executable(cpp_lambda_test unittests/cpp_lambda_test.cpp)
-    target_link_libraries(cpp_lambda_test ${LIBS})
-    add_test(NAME cpp_lambda_test COMMAND cpp_lambda_test)
-
-    add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
-    target_link_libraries(expected_eval_errors_test ${LIBS})
-    add_test(NAME Expected_Eval_Errors_Test COMMAND expected_eval_errors_test)
-
-    add_executable(set_state_test unittests/set_state_test.cpp)
-    target_link_libraries(set_state_test ${LIBS})
-    add_test(NAME Set_State_Test COMMAND set_state_test)
-
-    add_executable(simultaneous_chaiscript_test unittests/simultaneous_chaiscript_test.cpp)
-    target_link_libraries(simultaneous_chaiscript_test ${LIBS})
-    add_test(NAME Simultaneous_ChaiScript_Test COMMAND simultaneous_chaiscript_test)
-
-    add_executable(heap_allocated_chaiscript_test unittests/heap_allocated_chaiscript_test.cpp)
-    target_link_libraries(heap_allocated_chaiscript_test ${LIBS})
-    add_test(NAME Heap_Allocated_ChaiScript_Test COMMAND heap_allocated_chaiscript_test)
-
     add_executable(c_linkage_test unittests/c_linkage_test.cpp)
     target_link_libraries(c_linkage_test ${LIBS})
     add_test(NAME C_Linkage_Test COMMAND c_linkage_test)
@@ -354,10 +413,6 @@ if(BUILD_TESTING)
     target_link_libraries(integer_literal_test ${LIBS})
     add_test(NAME Integer_Literal_Test COMMAND integer_literal_test)
 
-    add_executable(arithmetic_conversions_test unittests/arithmetic_conversions_test.cpp)
-    target_link_libraries(arithmetic_conversions_test ${LIBS})
-    add_test(NAME Arithmetic_Conversions_Test COMMAND arithmetic_conversions_test)
-
     if(MULTITHREAD_SUPPORT_ENABLED)
       add_executable(multithreaded_test unittests/multithreaded_test.cpp)
       target_link_libraries(multithreaded_test ${LIBS})
@@ -409,3 +464,6 @@ configure_file(contrib/pkgconfig/chaiscript.pc.in lib/pkgconfig/chaiscript.pc @O
 install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc"
         DESTINATION lib/pkgconfig)
 
+    
+ENDIF()
+

LICENSE

@@ -0,0 +1,29 @@
+Copyright 2009-2015 Jason Turner
+Copyright 2009-2012 Jonathan Turner. 
+
+All Rights Reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following
+    disclaimer in the documentation and/or other materials provided
+    with the distribution.
+  * Neither the name of Jason Turner nor Jonathan Turner nor the 
+    name of contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

biicode.conf

@@ -0,0 +1,5 @@
+[paths]
+        include
+
+[parent]
+	ChaiScript/ChaiScript: 0

cheatsheet.md

@@ -0,0 +1,402 @@
+# ChaiScript Versioning
+
+ChaiScript tries to follow the [Semantic Versioning](http://semver.org/) scheme. This basically means:
+
+  * Major Version Number: API changes / breaking changes
+  * Minor Version Number: New Features
+  * Patch Version Number: Minor changes / enhancements
+  
+
+
+# Initializing ChaiScript
+
+```
+chaiscript::ChaiScript chai; // loads stdlib from loadable module on file system
+chaiscript::ChaiScript chai(chaiscript::Std_Lib::library()); // compiles in stdlib
+```
+
+# Adding Things To The Engine
+
+## Adding a Function / Method / Member
+
+### General
+
+```
+chai.add(chaiscript::fun(&function_name), "function_name");
+chai.add(chaiscript::fun(&Class::method_name), "method_name");
+chai.add(chaiscript::fun(&Class::member_name), "member_name");
+```
+
+### With Overloads 
+
+#### Preferred
+
+```
+chai.add(chaiscript::fun<ReturnType (ParamType1, ParamType2)>(&function_with_overloads), "function_name");
+```
+
+#### Alternative
+
+```
+chai.add(chaiscript::fun(std::static_cast<ReturnType (*)(ParamType1, ParamType2)>(&function_with_overloads)), "function_name");
+```
+This overload technique is also used when exposing base member using derived type
+
+```
+struct Base
+{
+  int data;
+};
+
+struct Derived : public Base
+{};
+
+chai.add(chaiscript::fun(static_cast<int(Derived::*)>(&Derived::data)), "data");
+```
+
+### Lambda
+
+```
+chai.add(
+  chaiscript::fun<std::string (bool)>(
+    [](bool type) { 
+      if (type) { return "x"; } 
+      else { return "y"; } 
+    }), "function_name");
+```
+
+### Constructors
+
+```
+chai.add(chaiscript::constructor<MyType ()>(), "MyType");
+chai.add(chaiscript::constructor<MyType (const MyType &)>(), "MyType");
+```
+
+## Adding Types
+
+It's not strictly necessary to add types, but it helps with many things. Cloning, better errors, etc.
+
+```
+chai.add(chaiscript::user_type<MyClass>, "MyClass");
+```
+
+## Adding Type Conversions
+
+User defined type conversions are possible, defined in either script or in C++.
+
+A helper function exists for strongly typed and ChaiScript `Vector` function conversion definition:
+
+```
+chai.add(chaiscript::vector_conversion<std::vector<int>>());
+```
+
+This allows you to pass a ChaiScript function to a function requiring `std::vector<int>`
+
+## Adding Objects
+
+```
+chai.add(chaiscript::var(somevar), "somevar"); // copied in
+chai.add(chaiscript::var(std::ref(somevar), "somevar"); // by reference, shared between C++ and chai
+auto shareddouble = std::make_shared<double>(4.3);
+chai.add(chaiscript::var(shareddouble), "shareddouble"); // by shared_ptr, shared between c++ and chai
+chai.add(chaiscript::const_var(somevar), "somevar"); // copied in and made const
+chai.add_global_const(chaiscript::const_var(somevar), "somevar"); // global const. Throws if value is non-const
+chai.add_global(chaiscript::var(somevar), "somevar"); // global non-const
+```
+# Using STL
+ChaiScript recognize many types from STL, but you have to add specific instantiation yourself.
+
+```
+typedef std::vector<std::pair<int, std::string>> data_list;
+data_list my_list{ make_pair(0, "Hello"), make_pair(1, "World") };
+chai.add(chaiscript::bootstrap::standard_library::vector_type<data_list>("DataList"));
+chai.add(chaiscript::bootstrap::standard_library::pair_type<data_list::value_type>("DataElement"));
+chai.add(chaiscript::var(&my_list), "data_list");
+chai.eval(R"_(
+    for(var i=0; i<data_list.size(); ++i)
+    {
+      print(to_string(data_list[i].first) + " " + data_list[i].second)
+    }
+  )_");
+```
+
+# Executing Script
+
+## General
+
+```
+chai.eval("print(\"Hello World\")");
+chai.eval(R"(print("Hello World"))");
+```
+
+## Unboxing Return Values
+
+Returns values are of the type `Boxed_Value` which is meant to be opaque to the programmer. Use one of the unboxing methods to access the internal data.
+
+### Prefered
+
+```
+chai.eval<double>("5.3 + 2.1"); // returns 7.4 as a C++ double
+```
+
+### Alternative
+
+```
+auto v = chai.eval("5.3 + 2.1");
+chai.boxed_cast<double>(v); // extracts double value from boxed_value and applies known conversions
+chaiscript::boxed_cast<double>(v); // free function version, does not know about conversions
+```
+
+### Converting Between Algebraic Types
+
+```
+chaiscript::Boxed_Number(chai.eval("5.3 + 2.1")).get_as<int>(); // works with any number type
+// which is equivalent to, but much more automatic than:
+static_cast<int>(chai.eval<double>("5.3+2.1")); // this version only works if we know that it's a double
+```
+
+## Sharing Values
+
+```
+double &d = chai.eval("var i = 5.2; i"); // d is now a reference to i in the script
+std::shared_ptr<double> d = chai.eval("var i = 5.2; i"); // same result but reference counted
+
+d = 3;
+chai.eval("print(i)"); // prints 3
+```
+
+## Catching Eval Errors
+
+```
+try {
+  chai.eval("2.3 + \"String\"");
+} catch (const chaiscript::exception::eval_error &e) {
+  std::cout << "Error\n" << e.pretty_print() << '\n';
+}
+```
+
+## Catching Errors Thrown From Script
+
+```
+try {
+  chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+} catch (const double e) {
+} catch (int) {
+} catch (float) {
+} catch (const std::string &) {
+} catch (const std::exception &e) {
+  // This is the one what will be called in the specific throw() above
+}
+```
+
+## Sharing Functions
+
+
+```
+auto p = chai.eval<std::function<std::string (double)>>("to_string"); 
+p(5); // calls chaiscript's 'to_string' function, returning std::string("5")
+```
+
+Note: backtick treats operators as normal functions
+
+```
+auto p = chai.eval<std::function<int (int, int)>>(`+`); 
+p(5, 6); // calls chaiscript's '+' function, returning 11
+```
+
+```
+auto p = chai.eval<std::function<std::string (int, double)>>("fun(x,y) { to_string(x) + to_string(y); }");
+p(3,4.2); // evaluates the lambda function, returning the string "34.2" to C++
+```
+
+# Language Reference
+
+## Variables
+
+```
+var i; // uninitialized variable, can take any value on first assignment;
+auto j; // equiv to var
+
+var k = 5; // initialized to 5 (integer)
+var l := k; // reference to k
+auto &m = k; // reference to k
+
+GLOBAL g = 5; // creates a global variable. If global already exists, it is not re-added
+GLOBAL g = 2; // global 'g' now equals 2
+
+GLOBAL g2;
+if (g2.is_var_undef()) { g2 = 4; } // only initialize g2 once, if GLOBAL decl hit more than once
+```
+
+## Built in Types
+
+```
+var v = [1,2,3u,4ll,"16", `+`]; // creates vector of heterogenous values
+var m = ["a":1, "b":2]; // map of string:value pairs
+```
+
+Floating point values default to `double` type and integers default to `int` type. All C++ suffixes
+such as `f`, `ll`, `u` as well as scientific notation are supported
+
+```
+1.0 // double
+1.0f // float
+1.0l // long double
+1 // int
+1u // unsigned int
+1ul // unsigned long
+1ull // unsigned long long
+```
+
+Literals are automatically sized, just as in C++. For example: `10000000000` is > 32bits and the appropriate type is used to hold it
+on your platform.
+
+
+## Functions
+
+Note that any type of ChaiScript function can be passed freely to C++ and automatically
+converted into an `std::function` object.
+
+### General 
+
+```
+def myfun(x, y) { x + y; } // last statement in body is the return value
+def myfun(x, y) { return x + y; } // equiv 
+```
+
+### Optionally Typed
+
+```
+def myfun(x, int y) { x + y; } // requires y to be an int
+```
+
+### With Guards
+
+```
+def myfun(x, int y) : y > 5 { x - y; } // only called if y > 5
+```
+
+### Methods
+
+Methods and functions are mostly equivalent
+
+```
+def string::add(int y) { this + to_string(y); }
+def add(string s, int y) { s + to_string(y); } //equiv functionality
+
+// calling new function/method
+"a".add(1); // returns a1
+add("a", 1); // returns a1, either calling syntax works with either def above
+```
+
+### Lambdas
+
+```
+var l = fun(x) { x * 15; }
+l(2) // returns 30
+
+var a = 13
+var m = fun[a](x) { x * a; } 
+m(3); // a was captured (by reference), returns 39
+
+var n = bind(fun(x,y) { x * y; }, _, 10);
+n(2); // returns 20 
+```
+
+
+
+## ChaiScript Defined Types
+
+Define a type called "MyType" with one member value "a" and a getter
+
+### Preferred
+
+```
+class MyType {
+  var value;
+  def MyType() { this.value = "a"; }
+  def get_value() { "Value Is: " + this.value; }
+};
+```
+
+### Alternative 
+
+```
+attr MyType::value;
+def MyType::MyType() { this.value = "a"; }
+def MyType::get_value() { "Value Is: " + this.value; }
+```
+
+### Using
+
+```
+var m = MyType(); // calls constructor
+print(m.get_value()); // prints "Value Is: a"
+print(get_value(m)); // prints "Value Is: a"
+```
+
+## Dynamic Objects
+
+All ChaiScript defined types and generic Dynamic_Object support dynamic parameters
+
+```
+var o = Dynamic_Object();
+o.f = fun(x) { print(x); }
+o.f(3); // prints "3"
+```
+
+Implicit 'this' is allowed:
+
+```
+var o = Dynamic_Object();
+o.x = 3;
+o.f = fun(y) { print(this.x + y); }
+o.f(10); // prints 13
+```
+
+### Option Explicit
+
+If you want to disable dynamic parameter definitions, you can `set_explicit`.
+
+```
+class My_Class {
+  def My_Class() {
+    this.set_explicit(true);
+    this.x = 2; // this would fail with explicit set to true
+  }
+};
+
+## method_missing
+
+A function of the signature `method_missing(object, name, param1, param2, param3)` will be called if an appropriate
+method cannot be found
+
+```
+def method_missing(int i, string name, Vector v) {
+  print("method_missing(${i}, ${name}), ${v.size()} params");
+}
+
+5.bob(1,2,3); // prints "method_missing(5, bob, 3 params)"
+```
+
+`method_missing` signature can be either 2 parameters or 3 parameters. If the signature contains two parameters
+it is treated as a property. If the property contains a function then additional parameters are passed to
+the contained function.
+
+If both a 2 parameter and a 3 parameter signature match, the 3 parameter function always wins.
+
+
+# Built In Functions
+
+## Evaluation
+
+```
+eval("4 + 5") // dynamically eval script string and returns value of last statement
+eval_file("filename") // evals file and returns value of last statement
+use("filename") // evals file exactly once and returns value of last statement
+                // if the file had already been 'used' nothing happens and undefined is returned
+```
+
+Both `use` and `eval_file` search the 'usepaths' passed to the ChaiScript constructor
+
+

cmake/CheckCXX11Features.cmake

@@ -1,103 +1,103 @@
-# Checks for C++11 features
-#  CXX11_FEATURE_LIST - a list containing all supported features
-#  HAS_CXX11_AUTO               - auto keyword
-#  HAS_CXX11_NULLPTR            - nullptr
-#  HAS_CXX11_LAMBDA             - lambdas
-#  HAS_CXX11_STATIC_ASSERT      - static_assert()
-#  HAS_CXX11_RVALUE_REFERENCES  - rvalue references
-#  HAS_CXX11_DECLTYPE           - decltype keyword
-#  HAS_CXX11_CSTDINT_H          - cstdint header
-#  HAS_CXX11_LONG_LONG          - long long signed & unsigned types
-#  HAS_CXX11_VARIADIC_TEMPLATES - variadic templates
-#  HAS_CXX11_CONSTEXPR          - constexpr keyword
-#  HAS_CXX11_SIZEOF_MEMBER      - sizeof() non-static members
-#  HAS_CXX11_FUNC               - __func__ preprocessor constant
-#
-# Original script by Rolf Eike Beer
-# Modifications by Andreas Weis
-#
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.3)
-
-SET(CHECK_CXX11_OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-IF(CMAKE_COMPILER_IS_GNUCXX)
-	SET(CMAKE_CXX_FLAGS "-std=c++0x")
-endif()
-
-MACRO(CXX11_CHECK_FEATURE FEATURE_NAME FEATURE_NUMBER RESULT_VAR)
-	IF (NOT DEFINED ${RESULT_VAR})
-		SET(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11/cxx11_${FEATURE_NAME}")
-
-		IF (${FEATURE_NUMBER})
-			SET(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/c++11-test-${FEATURE_NAME}-N${FEATURE_NUMBER})
-			SET(_LOG_NAME "\"${FEATURE_NAME}\" (N${FEATURE_NUMBER})")
-		ELSE (${FEATURE_NUMBER})
-			SET(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/c++11-test-${FEATURE_NAME})
-			SET(_LOG_NAME "\"${FEATURE_NAME}\"")
-		ENDIF (${FEATURE_NUMBER})
-		MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME}")
-
-		SET(_SRCFILE "${_SRCFILE_BASE}.cpp")
-		SET(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp")
-		SET(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp")
-
-		IF (CROSS_COMPILING)
-			try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}")
-			IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
-				try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}")
-			ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
-		ELSE (CROSS_COMPILING)
-			try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
-					"${_bindir}" "${_SRCFILE}")
-			IF (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
-				SET(${RESULT_VAR} TRUE)
-			ELSE (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
-				SET(${RESULT_VAR} FALSE)
-			ENDIF (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
-			IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
-				try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
-						"${_bindir}_fail" "${_SRCFILE_FAIL}")
-				IF (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
-					SET(${RESULT_VAR} TRUE)
-				ELSE (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
-					SET(${RESULT_VAR} FALSE)
-				ENDIF (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
-			ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
-		ENDIF (CROSS_COMPILING)
-		IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
-			try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}")
-			IF (_TMP_RESULT)
-				SET(${RESULT_VAR} FALSE)
-			ELSE (_TMP_RESULT)
-				SET(${RESULT_VAR} TRUE)
-			ENDIF (_TMP_RESULT)
-		ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
-
-		IF (${RESULT_VAR})
-			MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME} -- works")
-			LIST(APPEND CXX11_FEATURE_LIST ${RESULT_VAR})
-		ELSE (${RESULT_VAR})
-			MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME} -- not supported")
-		ENDIF (${RESULT_VAR})
-		SET(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}")
-	ENDIF (NOT DEFINED ${RESULT_VAR})
-ENDMACRO(CXX11_CHECK_FEATURE)
-
-CXX11_CHECK_FEATURE("auto"               2546 HAS_CXX11_AUTO)
-CXX11_CHECK_FEATURE("nullptr"            2431 HAS_CXX11_NULLPTR)
-CXX11_CHECK_FEATURE("lambda"             2927 HAS_CXX11_LAMBDA)
-CXX11_CHECK_FEATURE("static_assert"      1720 HAS_CXX11_STATIC_ASSERT)
-CXX11_CHECK_FEATURE("rvalue_references"  2118 HAS_CXX11_RVALUE_REFERENCES)
-CXX11_CHECK_FEATURE("decltype"           2343 HAS_CXX11_DECLTYPE)
-CXX11_CHECK_FEATURE("cstdint"            ""   HAS_CXX11_CSTDINT_H)
-CXX11_CHECK_FEATURE("long_long"          1811 HAS_CXX11_LONG_LONG)
-CXX11_CHECK_FEATURE("variadic_templates" 2555 HAS_CXX11_VARIADIC_TEMPLATES)
-CXX11_CHECK_FEATURE("constexpr"          2235 HAS_CXX11_CONSTEXPR)
-CXX11_CHECK_FEATURE("sizeof_member"      2253 HAS_CXX11_SIZEOF_MEMBER)
-CXX11_CHECK_FEATURE("__func__"           2340 HAS_CXX11_FUNC)
-
-SET(CXX11_FEATURE_LIST ${CXX11_FEATURE_LIST} CACHE STRING "C++11 feature support list")
-MARK_AS_ADVANCED(FORCE CXX11_FEATURE_LIST)
-
-SET(CMAKE_CXX_FLAGS ${CHECK_CXX11_OLD_CMAKE_CXX_FLAGS})
-UNSET(CHECK_CXX11_OLD_CMAKE_CXX_FLAGS)
-
+# Checks for C++11 features
+#  CXX11_FEATURE_LIST - a list containing all supported features
+#  HAS_CXX11_AUTO               - auto keyword
+#  HAS_CXX11_NULLPTR            - nullptr
+#  HAS_CXX11_LAMBDA             - lambdas
+#  HAS_CXX11_STATIC_ASSERT      - static_assert()
+#  HAS_CXX11_RVALUE_REFERENCES  - rvalue references
+#  HAS_CXX11_DECLTYPE           - decltype keyword
+#  HAS_CXX11_CSTDINT_H          - cstdint header
+#  HAS_CXX11_LONG_LONG          - long long signed & unsigned types
+#  HAS_CXX11_VARIADIC_TEMPLATES - variadic templates
+#  HAS_CXX11_CONSTEXPR          - constexpr keyword
+#  HAS_CXX11_SIZEOF_MEMBER      - sizeof() non-static members
+#  HAS_CXX11_FUNC               - __func__ preprocessor constant
+#
+# Original script by Rolf Eike Beer
+# Modifications by Andreas Weis
+#
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.3)
+
+SET(CHECK_CXX11_OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+IF(CMAKE_COMPILER_IS_GNUCXX)
+	SET(CMAKE_CXX_FLAGS "-std=c++0x")
+endif()
+
+MACRO(CXX11_CHECK_FEATURE FEATURE_NAME FEATURE_NUMBER RESULT_VAR)
+	IF (NOT DEFINED ${RESULT_VAR})
+		SET(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11/cxx11_${FEATURE_NAME}")
+
+		IF (${FEATURE_NUMBER})
+			SET(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/c++11-test-${FEATURE_NAME}-N${FEATURE_NUMBER})
+			SET(_LOG_NAME "\"${FEATURE_NAME}\" (N${FEATURE_NUMBER})")
+		ELSE (${FEATURE_NUMBER})
+			SET(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/c++11-test-${FEATURE_NAME})
+			SET(_LOG_NAME "\"${FEATURE_NAME}\"")
+		ENDIF (${FEATURE_NUMBER})
+		MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME}")
+
+		SET(_SRCFILE "${_SRCFILE_BASE}.cpp")
+		SET(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp")
+		SET(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp")
+
+		IF (CROSS_COMPILING)
+			try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}")
+			IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+				try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}")
+			ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+		ELSE (CROSS_COMPILING)
+			try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+					"${_bindir}" "${_SRCFILE}")
+			IF (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+				SET(${RESULT_VAR} TRUE)
+			ELSE (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+				SET(${RESULT_VAR} FALSE)
+			ENDIF (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+			IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+				try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+						"${_bindir}_fail" "${_SRCFILE_FAIL}")
+				IF (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+					SET(${RESULT_VAR} TRUE)
+				ELSE (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+					SET(${RESULT_VAR} FALSE)
+				ENDIF (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+			ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+		ENDIF (CROSS_COMPILING)
+		IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+			try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}")
+			IF (_TMP_RESULT)
+				SET(${RESULT_VAR} FALSE)
+			ELSE (_TMP_RESULT)
+				SET(${RESULT_VAR} TRUE)
+			ENDIF (_TMP_RESULT)
+		ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+
+		IF (${RESULT_VAR})
+			MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME} -- works")
+			LIST(APPEND CXX11_FEATURE_LIST ${RESULT_VAR})
+		ELSE (${RESULT_VAR})
+			MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME} -- not supported")
+		ENDIF (${RESULT_VAR})
+		SET(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}")
+	ENDIF (NOT DEFINED ${RESULT_VAR})
+ENDMACRO(CXX11_CHECK_FEATURE)
+
+CXX11_CHECK_FEATURE("auto"               2546 HAS_CXX11_AUTO)
+CXX11_CHECK_FEATURE("nullptr"            2431 HAS_CXX11_NULLPTR)
+CXX11_CHECK_FEATURE("lambda"             2927 HAS_CXX11_LAMBDA)
+CXX11_CHECK_FEATURE("static_assert"      1720 HAS_CXX11_STATIC_ASSERT)
+CXX11_CHECK_FEATURE("rvalue_references"  2118 HAS_CXX11_RVALUE_REFERENCES)
+CXX11_CHECK_FEATURE("decltype"           2343 HAS_CXX11_DECLTYPE)
+CXX11_CHECK_FEATURE("cstdint"            ""   HAS_CXX11_CSTDINT_H)
+CXX11_CHECK_FEATURE("long_long"          1811 HAS_CXX11_LONG_LONG)
+CXX11_CHECK_FEATURE("variadic_templates" 2555 HAS_CXX11_VARIADIC_TEMPLATES)
+CXX11_CHECK_FEATURE("constexpr"          2235 HAS_CXX11_CONSTEXPR)
+CXX11_CHECK_FEATURE("sizeof_member"      2253 HAS_CXX11_SIZEOF_MEMBER)
+CXX11_CHECK_FEATURE("__func__"           2340 HAS_CXX11_FUNC)
+
+SET(CXX11_FEATURE_LIST ${CXX11_FEATURE_LIST} CACHE STRING "C++11 feature support list")
+MARK_AS_ADVANCED(FORCE CXX11_FEATURE_LIST)
+
+SET(CMAKE_CXX_FLAGS ${CHECK_CXX11_OLD_CMAKE_CXX_FLAGS})
+UNSET(CHECK_CXX11_OLD_CMAKE_CXX_FLAGS)
+

cmake/c++11-test-__func__-N2340.cpp

@@ -1,8 +1,8 @@
-#include <cstring>
-
-int main()
-{
-	if (!__func__) { return 1; }
-	if(std::strlen(__func__) <= 0) { return 1; }
-	return 0;
-}
+#include <cstring>
+
+int main()
+{
+	if (!__func__) { return 1; }
+	if(std::strlen(__func__) <= 0) { return 1; }
+	return 0;
+}

cmake/c++11-test-auto-N2546.cpp

@@ -1,12 +1,12 @@
-
-int main()
-{
-	auto i = 5;
-	auto f = 3.14159f;
-	auto d = 3.14159;
-	bool ret = (
-		(sizeof(f) < sizeof(d)) &&
-		(sizeof(i) == sizeof(int))
-	);
-	return ret ? 0 : 1;
-}
+
+int main()
+{
+	auto i = 5;
+	auto f = 3.14159f;
+	auto d = 3.14159;
+	bool ret = (
+		(sizeof(f) < sizeof(d)) &&
+		(sizeof(i) == sizeof(int))
+	);
+	return ret ? 0 : 1;
+}

cmake/c++11-test-constexpr-N2235.cpp

@@ -1,19 +1,19 @@
-constexpr int square(int x)
-{
-	return x*x;
-}
-
-constexpr int the_answer()
-{
-	return 42;
-}
-
-int main()
-{
-	int test_arr[square(3)];
-	bool ret = (
-		(square(the_answer()) == 1764) &&
-		(sizeof(test_arr)/sizeof(test_arr[0]) == 9)
-	);
-	return ret ? 0 : 1;
-}
+constexpr int square(int x)
+{
+	return x*x;
+}
+
+constexpr int the_answer()
+{
+	return 42;
+}
+
+int main()
+{
+	int test_arr[square(3)];
+	bool ret = (
+		(square(the_answer()) == 1764) &&
+		(sizeof(test_arr)/sizeof(test_arr[0]) == 9)
+	);
+	return ret ? 0 : 1;
+}

cmake/c++11-test-cstdint.cpp

@@ -1,10 +1,10 @@
-#include <cstdint>
-int main()
-{
-	bool test = 
-		(sizeof(int8_t) == 1) &&
-		(sizeof(int16_t) == 2) &&
-		(sizeof(int32_t) == 4) &&
-		(sizeof(int64_t) == 8);
-	return test ? 0 : 1;
-}
+#include <cstdint>
+int main()
+{
+	bool test = 
+		(sizeof(int8_t) == 1) &&
+		(sizeof(int16_t) == 2) &&
+		(sizeof(int32_t) == 4) &&
+		(sizeof(int64_t) == 8);
+	return test ? 0 : 1;
+}

cmake/c++11-test-decltype-N2343.cpp

@@ -1,11 +1,11 @@
-
-bool check_size(int i)
-{
-	return sizeof(int) == sizeof(decltype(i));
-}
-
-int main()
-{
-	bool ret = check_size(42);
-	return ret ? 0 : 1;
-}
+
+bool check_size(int i)
+{
+	return sizeof(int) == sizeof(decltype(i));
+}
+
+int main()
+{
+	bool ret = check_size(42);
+	return ret ? 0 : 1;
+}

cmake/c++11-test-lambda-N2927.cpp

@@ -1,5 +1,5 @@
-int main()
-{
-	int ret = 0;
-	return ([&ret]() -> int { return ret; })();
-}
+int main()
+{
+	int ret = 0;
+	return ([&ret]() -> int { return ret; })();
+}

cmake/c++11-test-long_long-N1811.cpp

@@ -1,7 +1,7 @@
-int main(void)
-{
-	long long l;
-	unsigned long long ul;
-
-	return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
-}
+int main(void)
+{
+	long long l;
+	unsigned long long ul;
+
+	return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
+}

cmake/c++11-test-nullptr-N2431.cpp

@@ -1,5 +1,5 @@
-int main()
-{
-	int* test = nullptr;
-	return test ? 1 : 0;
-}
+int main()
+{
+	int* test = nullptr;
+	return test ? 1 : 0;
+}

cmake/c++11-test-nullptr-N2431_fail_compile.cpp

@@ -1,5 +1,5 @@
-int main()
-{
-	int i = nullptr;
-	return 1;
-}
+int main()
+{
+	int i = nullptr;
+	return 1;
+}

cmake/c++11-test-rvalue_references-N2118.cpp

@@ -1,15 +1,15 @@
-int foo(int& lvalue)
-{
-	return 123;
-}
-
-int foo(int&& rvalue)
-{
-	return 321;
-}
-
-int main()
-{
-	int i = 42;
-	return ((foo(i) == 123) && (foo(42) == 321)) ? 0 : 1;
-}
+int foo(int& lvalue)
+{
+	return 123;
+}
+
+int foo(int&& rvalue)
+{
+	return 321;
+}
+
+int main()
+{
+	int i = 42;
+	return ((foo(i) == 123) && (foo(42) == 321)) ? 0 : 1;
+}

cmake/c++11-test-sizeof_member-N2253.cpp

@@ -1,14 +1,14 @@
-struct foo {
-	char bar;
-	int baz;
-};
-
-int main(void)
-{
-	bool ret = (
-		(sizeof(foo::bar) == 1) &&
-		(sizeof(foo::baz) >= sizeof(foo::bar)) &&
-		(sizeof(foo) >= sizeof(foo::bar)+sizeof(foo::baz))
-	);
-	return ret ? 0 : 1;
-}
+struct foo {
+	char bar;
+	int baz;
+};
+
+int main(void)
+{
+	bool ret = (
+		(sizeof(foo::bar) == 1) &&
+		(sizeof(foo::baz) >= sizeof(foo::bar)) &&
+		(sizeof(foo) >= sizeof(foo::bar)+sizeof(foo::baz))
+	);
+	return ret ? 0 : 1;
+}

cmake/c++11-test-static_assert-N1720.cpp

@@ -1,5 +1,5 @@
-int main()
-{
-	static_assert(0 < 1, "your ordering of integers is screwed");
-	return 0;
-}
+int main()
+{
+	static_assert(0 < 1, "your ordering of integers is screwed");
+	return 0;
+}

cmake/c++11-test-static_assert-N1720_fail_compile.cpp

@@ -1,5 +1,5 @@
-int main()
-{
-	static_assert(1 < 0, "this should fail");
-	return 0;
-}
+int main()
+{
+	static_assert(1 < 0, "this should fail");
+	return 0;
+}

cmake/c++11-test-variadic_templates-N2555.cpp

@@ -1,23 +1,23 @@
-int Accumulate()
-{
-	return 0;
-}
-
-template<typename T, typename... Ts>
-int Accumulate(T v, Ts... vs)
-{
-	return v + Accumulate(vs...);
-}
-
-template<int... Is>
-int CountElements()
-{
-	return sizeof...(Is);
-}
-
-int main()
-{
-	int acc = Accumulate(1, 2, 3, 4, -5);
-	int count = CountElements<1,2,3,4,5>();
-	return ((acc == 5) && (count == 5)) ? 0 : 1;
-}
+int Accumulate()
+{
+	return 0;
+}
+
+template<typename T, typename... Ts>
+int Accumulate(T v, Ts... vs)
+{
+	return v + Accumulate(vs...);
+}
+
+template<int... Is>
+int CountElements()
+{
+	return sizeof...(Is);
+}
+
+int main()
+{
+	int acc = Accumulate(1, 2, 3, 4, -5);
+	int count = CountElements<1,2,3,4,5>();
+	return ((acc == 5) && (count == 5)) ? 0 : 1;
+}

contrib/codeanalysis/heterogenous_array_loop.chai

@@ -1,10 +1,19 @@
 
-var my_array=["1", 4, 6.6l, 10ul, "1000", 100, 10.9f ];
-
-for (var j = 0; j < 10000; ++j)
+def go()
 {
-  for (var i = 0; i < 6; ++i)
+  var my_array=["1", 4, 6.6l, 10ul, "1000", 100, 10.9f ];
+
+  var q = 0;
+
+  for (var j = 0; j < 10000; ++j)
   {
-    to_string(my_array[i]);
+    for (var i = 0; i < 6; ++i)
+    {
+      to_string(my_array[i]);
+    }
+
+    q += j;
   }
 }
+
+go();

contrib/codeanalysis/profile_cpp_calls.chai

@@ -0,0 +1,26 @@
+
+var test_str = "bob was a string";
+
+for( var i = 0; i < 200000; ++i)
+{
+  test_str.size();
+//  test_str.find("a", i);
+  test_str.c_str();
+  test_str.erase_at(1);
+  test_str.erase_at(1);
+  test_str.erase_at(1);
+  test_str.erase_at(1);
+  test_str.erase_at(1);
+  test_str.erase_at(1);
+
+  size(test_str);
+//  test_str.find("a", i);
+  c_str(test_str);
+  erase_at(test_str, 1);
+  erase_at(test_str, 1);
+  erase_at(test_str, 1);
+  erase_at(test_str, 1);
+  erase_at(test_str, 1);
+  erase_at(test_str, 1);
+  test_str = "bob was a string";
+}

contrib/codeanalysis/type_conversions.chai

@@ -0,0 +1,22 @@
+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);
+
+//dump_system();
+
+for (var i = 0; i < 50000; ++i) {
+  var str = string(get_str(t2));
+  size(get_str(t2));
+  t2.get_str().size();
+  t.get_str().size();
+}
+
+

contrib/sublimetext/ChaiScript.YAML-tmLanguage

@@ -0,0 +1,93 @@
+# [PackageDev] target_format: plist, ext: tmLanguage
+---
+comment: 'ChaiScript Syntax: version 2.0'
+fileTypes: [chai]
+firstLineMatch: ^#!/usr/bin/env node
+foldingStartMarker: ^.*\bdef\s*(\w+\s*)?\([^\)]*\)(\s*\{[^\}]*)?\s*$
+foldingStopMarker: ^\s*\}
+keyEquivalent: ^~J
+name: ChaiScript
+patterns:
+- {comment: chaiscript shebang, match: ^#, name: comment.line.chai}
+- {match: '\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?))\b', name: constant.numeric.chai}
+- begin: ''''
+  beginCaptures:
+    '0': {name: punctuation.definition.string.begin.chai}
+  end: ''''
+  endCaptures:
+    '0': {name: punctuation.definition.string.end.chai}
+  name: string.quoted.single.chai
+  patterns:
+  - {match: '\\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)', name: constant.character.escape.chai}
+- begin: '"'
+  beginCaptures:
+    '0': {name: punctuation.definition.string.begin.chai}
+  end: '"'
+  endCaptures:
+    '0': {name: punctuation.definition.string.end.chai}
+  name: string.quoted.double.chai
+  patterns:
+  - {match: '\\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)', name: constant.character.escape.chai}
+- begin: /\*\*(?!/)
+  captures:
+    '0': {name: punctuation.definition.comment.chai}
+  end: \*/
+  name: comment.block.documentation.chai
+- begin: /\*
+  captures:
+    '0': {name: punctuation.definition.comment.chai}
+  end: \*/
+  name: comment.block.chai
+- captures:
+    '1': {name: punctuation.definition.comment.chai}
+  match: (//).*$\n?
+  name: comment.line.double-slash.chai
+- captures:
+    '0': {name: punctuation.definition.comment.html.chai}
+    '2': {name: punctuation.definition.comment.html.chai}
+  match: (<!--|-->)
+  name: comment.block.html.chai
+- {match: \b(boolean|byte|char|class|double|enum|float|fun|def|int|interface|long|short|var|auto|attr)\b,
+  name: storage.type.chai}
+- {match: \b(break|case|catch|continue|default|do|else|finally|else if|for|goto|if|return|switch|throw|try|while)\b,
+  name: keyword.control.chai}
+- {match: \b(delete|in|instanceof|new|typeof|with)\b, name: keyword.operator.chai}
+- {match: \btrue\b, name: constant.language.boolean.true.chai}
+- {match: \bfalse\b, name: constant.language.boolean.false.chai}
+- {match: \bnull\b, name: constant.language.null.chai}
+- {match: \b(Anchor|Applet|Area|Array|Boolean|Button|Checkbox|Date|document|event|FileUpload|Form|Frame|Function|Hidden|History|Image|JavaArray|JavaClass|JavaObject|JavaPackage|java|Layer|Link|Location|Math|MimeType|Number|navigator|netscape|Object|Option|Packages|Password|Plugin|Radio|RegExp|Reset|Select|String|Style|Submit|screen|sun|Text|Textarea|window|XMLHttpRequest)\b,
+  name: support.class.chai}
+- {match: '\b(s(h(ift|ow(Mod(elessDialog|alDialog)|Help))|croll(X|By(Pages|Lines)?|Y|To)?|t(op|rike)|i(n|zeToContent|debar|gnText)|ort|u(p|b(str(ing)?)?)|pli(ce|t)|e(nd|t(Re(sizable|questHeader)|M(i(nutes|lliseconds)|onth)|Seconds|Ho(tKeys|urs)|Year|Cursor|Time(out)?|Interval|ZOptions|Date|UTC(M(i(nutes|lliseconds)|onth)|Seconds|Hours|Date|FullYear)|FullYear|Active)|arch)|qrt|lice|avePreferences|mall)|h(ome|andleEvent)|navigate|c(har(CodeAt|At)|o(s|n(cat|textual|firm)|mpile)|eil|lear(Timeout|Interval)?|a(ptureEvents|ll)|reate(StyleSheet|Popup|EventObject))|t(o(GMTString|S(tring|ource)|U(TCString|pperCase)|Lo(caleString|werCase))|est|a(n|int(Enabled)?))|i(s(NaN|Finite)|ndexOf|talics)|d(isableExternalCapture|ump|etachEvent)|u(n(shift|taint|escape|watch)|pdateCommands)|j(oin|avaEnabled)|p(o(p|w)|ush|lugins.refresh|a(ddings|rse(Int|Float)?)|r(int|ompt|eference))|e(scape|nableExternalCapture|val|lementFromPoint|x(p|ec(Script|Command)?))|valueOf|UTC|queryCommand(State|Indeterm|Enabled|Value)|f(i(nd|le(ModifiedDate|Size|CreatedDate|UpdatedDate)|xed)|o(nt(size|color)|rward)|loor|romCharCode)|watch|l(ink|o(ad|g)|astIndexOf)|a(sin|nchor|cos|t(tachEvent|ob|an(2)?)|pply|lert|b(s|ort))|r(ou(nd|teEvents)|e(size(By|To)|calc|turnValue|place|verse|l(oad|ease(Capture|Events)))|andom)|g(o|et(ResponseHeader|M(i(nutes|lliseconds)|onth)|Se(conds|lection)|Hours|Year|Time(zoneOffset)?|Da(y|te)|UTC(M(i(nutes|lliseconds)|onth)|Seconds|Hours|Da(y|te)|FullYear)|FullYear|A(ttention|llResponseHeaders)))|m(in|ove(B(y|elow)|To(Absolute)?|Above)|ergeAttributes|a(tch|rgins|x))|b(toa|ig|o(ld|rderWidths)|link|ack))\b(?=\()',
+  name: support.function.chai}
+- {match: '\b(s(ub(stringData|mit)|plitText|e(t(NamedItem|Attribute(Node)?)|lect))|has(ChildNodes|Feature)|namedItem|c(l(ick|o(se|neNode))|reate(C(omment|DATASection|aption)|T(Head|extNode|Foot)|DocumentFragment|ProcessingInstruction|E(ntityReference|lement)|Attribute))|tabIndex|i(nsert(Row|Before|Cell|Data)|tem)|open|delete(Row|C(ell|aption)|T(Head|Foot)|Data)|focus|write(ln)?|a(dd|ppend(Child|Data))|re(set|place(Child|Data)|move(NamedItem|Child|Attribute(Node)?)?)|get(NamedItem|Element(sBy(Name|TagName)|ById)|Attribute(Node)?)|blur)\b(?=\()',
+  name: support.function.dom.chai}
+- {match: '(?<=\.)(s(ystemLanguage|cr(ipts|ollbars|een(X|Y|Top|Left))|t(yle(Sheets)?|atus(Text|bar)?)|ibling(Below|Above)|ource|uffixes|e(curity(Policy)?|l(ection|f)))|h(istory|ost(name)?|as(h|Focus))|y|X(MLDocument|SLDocument)|n(ext|ame(space(s|URI)|Prop))|M(IN_VALUE|AX_VALUE)|c(haracterSet|o(n(structor|trollers)|okieEnabled|lorDepth|mp(onents|lete))|urrent|puClass|l(i(p(boardData)?|entInformation)|osed|asses)|alle(e|r)|rypto)|t(o(olbar|p)|ext(Transform|Indent|Decoration|Align)|ags)|SQRT(1_2|2)|i(n(ner(Height|Width)|put)|ds|gnoreCase)|zIndex|o(scpu|n(readystatechange|Line)|uter(Height|Width)|p(sProfile|ener)|ffscreenBuffering)|NEGATIVE_INFINITY|d(i(splay|alog(Height|Top|Width|Left|Arguments)|rectories)|e(scription|fault(Status|Ch(ecked|arset)|View)))|u(ser(Profile|Language|Agent)|n(iqueID|defined)|pdateInterval)|_content|p(ixelDepth|ort|ersonalbar|kcs11|l(ugins|atform)|a(thname|dding(Right|Bottom|Top|Left)|rent(Window|Layer)?|ge(X(Offset)?|Y(Offset)?))|r(o(to(col|type)|duct(Sub)?|mpter)|e(vious|fix)))|e(n(coding|abledPlugin)|x(ternal|pando)|mbeds)|v(isibility|endor(Sub)?|Linkcolor)|URLUnencoded|P(I|OSITIVE_INFINITY)|f(ilename|o(nt(Size|Family|Weight)|rmName)|rame(s|Element)|gColor)|E|whiteSpace|l(i(stStyleType|n(eHeight|kColor))|o(ca(tion(bar)?|lName)|wsrc)|e(ngth|ft(Context)?)|a(st(M(odified|atch)|Index|Paren)|yer(s|X)|nguage))|a(pp(MinorVersion|Name|Co(deName|re)|Version)|vail(Height|Top|Width|Left)|ll|r(ity|guments)|Linkcolor|bove)|r(ight(Context)?|e(sponse(XML|Text)|adyState))|global|x|m(imeTypes|ultiline|enubar|argin(Right|Bottom|Top|Left))|L(N(10|2)|OG(10E|2E))|b(o(ttom|rder(Width|RightWidth|BottomWidth|Style|Color|TopWidth|LeftWidth))|ufferDepth|elow|ackground(Color|Image)))\b',
+  name: support.constant.chai}
+- {match: '(?<=\.)(s(hape|ystemId|c(heme|ope|rolling)|ta(ndby|rt)|ize|ummary|pecified|e(ctionRowIndex|lected(Index)?)|rc)|h(space|t(tpEquiv|mlFor)|e(ight|aders)|ref(lang)?)|n(o(Resize|tation(s|Name)|Shade|Href|de(Name|Type|Value)|Wrap)|extSibling|ame)|c(h(ildNodes|Off|ecked|arset)?|ite|o(ntent|o(kie|rds)|de(Base|Type)?|l(s|Span|or)|mpact)|ell(s|Spacing|Padding)|l(ear|assName)|aption)|t(ype|Bodies|itle|Head|ext|a(rget|gName)|Foot)|i(sMap|ndex|d|m(plementation|ages))|o(ptions|wnerDocument|bject)|d(i(sabled|r)|o(c(type|umentElement)|main)|e(clare|f(er|ault(Selected|Checked|Value)))|at(eTime|a))|useMap|p(ublicId|arentNode|r(o(file|mpt)|eviousSibling))|e(n(ctype|tities)|vent|lements)|v(space|ersion|alue(Type)?|Link|Align)|URL|f(irstChild|orm(s)?|ace|rame(Border)?)|width|l(ink(s)?|o(ngDesc|wSrc)|a(stChild|ng|bel))|a(nchors|c(ce(ssKey|pt(Charset)?)|tion)|ttributes|pplets|l(t|ign)|r(chive|eas)|xis|Link|bbr)|r(ow(s|Span|Index)|ules|e(v|ferrer|l|adOnly))|m(ultiple|e(thod|dia)|a(rgin(Height|Width)|xLength))|b(o(dy|rder)|ackground|gColor))\b',
+  name: support.constant.dom.chai}
+- {match: \b(ELEMENT_NODE|ATTRIBUTE_NODE|TEXT_NODE|CDATA_SECTION_NODE|ENTITY_REFERENCE_NODE|ENTITY_NODE|PROCESSING_INSTRUCTION_NODE|COMMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE|DOCUMENT_FRAGMENT_NODE|NOTATION_NODE|INDEX_SIZE_ERR|DOMSTRING_SIZE_ERR|HIERARCHY_REQUEST_ERR|WRONG_DOCUMENT_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR|NOT_SUPPORTED_ERR|INUSE_ATTRIBUTE_ERR)\b,
+  name: support.constant.dom.chai}
+- {match: '\bon(R(ow(s(inserted|delete)|e(nter|xit))|e(s(ize(start|end)?|et)|adystatechange))|Mouse(o(ut|ver)|down|up|move)|B(efore(cut|deactivate|u(nload|pdate)|p(aste|rint)|editfocus|activate)|lur)|S(croll|top|ubmit|elect(start|ionchange)?)|H(over|elp)|C(hange|ont(extmenu|rolselect)|ut|ellchange|l(ick|ose))|D(eactivate|ata(setc(hanged|omplete)|available)|r(op|ag(start|over|drop|en(ter|d)|leave)?)|blclick)|Unload|P(aste|ropertychange)|Error(update)?|Key(down|up|press)|Focus|Load|A(ctivate|fter(update|print)|bort))\b',
+  name: support.function.event-handler.chai}
+- {match: '!|\$|%|&|\*|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\|\||\?\:|\*=|(?<!\()/=|%=|\+=|\-=|&=|\^=|\b(in|instanceof|new|delete|typeof|void)\b',
+  name: keyword.operator.chai}
+- {match: \b(Infinity|NaN|undefined)\b, name: constant.language.chai}
+- begin: (?<=[=(:]|^|return|&&|\|\||!)\s*(/)(?![/*+{}?])
+  beginCaptures:
+    '1': {name: punctuation.definition.string.begin.chai}
+  end: (/)[igm]*
+  endCaptures:
+    '1': {name: punctuation.definition.string.end.chai}
+  name: string.regexp.chai
+  patterns:
+  - {match: \\., name: constant.character.escape.chai}
+- {match: \;, name: punctuation.terminator.statement.chai}
+- {match: ',[ |\t]*', name: meta.delimiter.object.comma.chai}
+- {match: \., name: meta.delimiter.method.period.chai}
+- {match: '\{|\}', name: meta.brace.curly.chai}
+- {match: \(|\), name: meta.brace.round.chai}
+- {match: '\[|\]', name: meta.brace.square.chai}
+scopeName: source.chai
+uuid: 93E017CC-6F27-11D9-90EB-000D93589AF6
+ 
+...

contrib/sublimetext/ChaiScript.tmLanguage

@@ -0,0 +1,333 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>comment</key>
+	<string>ChaiScript Syntax: version 2.0</string>
+	<key>fileTypes</key>
+	<array>
+		<string>chai</string>
+	</array>
+	<key>firstLineMatch</key>
+	<string>^#!/usr/bin/env node</string>
+	<key>foldingStartMarker</key>
+	<string>^.*\bdef\s*(\w+\s*)?\([^\)]*\)(\s*\{[^\}]*)?\s*$</string>
+	<key>foldingStopMarker</key>
+	<string>^\s*\}</string>
+	<key>keyEquivalent</key>
+	<string>^~J</string>
+	<key>name</key>
+	<string>ChaiScript</string>
+	<key>patterns</key>
+	<array>
+		<dict>
+			<key>comment</key>
+			<string>chaiscript shebang</string>
+			<key>match</key>
+			<string>^#</string>
+			<key>name</key>
+			<string>comment.line.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?))\b</string>
+			<key>name</key>
+			<string>constant.numeric.chai</string>
+		</dict>
+		<dict>
+			<key>begin</key>
+			<string>'</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.begin.chai</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>'</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.end.chai</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>string.quoted.single.chai</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>\\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)</string>
+					<key>name</key>
+					<string>constant.character.escape.chai</string>
+				</dict>
+			</array>
+		</dict>
+		<dict>
+			<key>begin</key>
+			<string>"</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.begin.chai</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>"</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.end.chai</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>string.quoted.double.chai</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>\\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)</string>
+					<key>name</key>
+					<string>constant.character.escape.chai</string>
+				</dict>
+			</array>
+		</dict>
+		<dict>
+			<key>begin</key>
+			<string>/\*\*(?!/)</string>
+			<key>captures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.comment.chai</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>\*/</string>
+			<key>name</key>
+			<string>comment.block.documentation.chai</string>
+		</dict>
+		<dict>
+			<key>begin</key>
+			<string>/\*</string>
+			<key>captures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.comment.chai</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>\*/</string>
+			<key>name</key>
+			<string>comment.block.chai</string>
+		</dict>
+		<dict>
+			<key>captures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.comment.chai</string>
+				</dict>
+			</dict>
+			<key>match</key>
+			<string>(//).*$\n?</string>
+			<key>name</key>
+			<string>comment.line.double-slash.chai</string>
+		</dict>
+		<dict>
+			<key>captures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.comment.html.chai</string>
+				</dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.comment.html.chai</string>
+				</dict>
+			</dict>
+			<key>match</key>
+			<string>(&lt;!--|--&gt;)</string>
+			<key>name</key>
+			<string>comment.block.html.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(boolean|byte|char|class|double|enum|float|fun|def|int|interface|long|short|var|auto|attr)\b</string>
+			<key>name</key>
+			<string>storage.type.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(break|case|catch|continue|default|do|else|finally|else if|for|goto|if|return|switch|throw|try|while)\b</string>
+			<key>name</key>
+			<string>keyword.control.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(delete|in|instanceof|new|typeof|with)\b</string>
+			<key>name</key>
+			<string>keyword.operator.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\btrue\b</string>
+			<key>name</key>
+			<string>constant.language.boolean.true.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\bfalse\b</string>
+			<key>name</key>
+			<string>constant.language.boolean.false.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\bnull\b</string>
+			<key>name</key>
+			<string>constant.language.null.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(Anchor|Applet|Area|Array|Boolean|Button|Checkbox|Date|document|event|FileUpload|Form|Frame|Function|Hidden|History|Image|JavaArray|JavaClass|JavaObject|JavaPackage|java|Layer|Link|Location|Math|MimeType|Number|navigator|netscape|Object|Option|Packages|Password|Plugin|Radio|RegExp|Reset|Select|String|Style|Submit|screen|sun|Text|Textarea|window|XMLHttpRequest)\b</string>
+			<key>name</key>
+			<string>support.class.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(s(h(ift|ow(Mod(elessDialog|alDialog)|Help))|croll(X|By(Pages|Lines)?|Y|To)?|t(op|rike)|i(n|zeToContent|debar|gnText)|ort|u(p|b(str(ing)?)?)|pli(ce|t)|e(nd|t(Re(sizable|questHeader)|M(i(nutes|lliseconds)|onth)|Seconds|Ho(tKeys|urs)|Year|Cursor|Time(out)?|Interval|ZOptions|Date|UTC(M(i(nutes|lliseconds)|onth)|Seconds|Hours|Date|FullYear)|FullYear|Active)|arch)|qrt|lice|avePreferences|mall)|h(ome|andleEvent)|navigate|c(har(CodeAt|At)|o(s|n(cat|textual|firm)|mpile)|eil|lear(Timeout|Interval)?|a(ptureEvents|ll)|reate(StyleSheet|Popup|EventObject))|t(o(GMTString|S(tring|ource)|U(TCString|pperCase)|Lo(caleString|werCase))|est|a(n|int(Enabled)?))|i(s(NaN|Finite)|ndexOf|talics)|d(isableExternalCapture|ump|etachEvent)|u(n(shift|taint|escape|watch)|pdateCommands)|j(oin|avaEnabled)|p(o(p|w)|ush|lugins.refresh|a(ddings|rse(Int|Float)?)|r(int|ompt|eference))|e(scape|nableExternalCapture|val|lementFromPoint|x(p|ec(Script|Command)?))|valueOf|UTC|queryCommand(State|Indeterm|Enabled|Value)|f(i(nd|le(ModifiedDate|Size|CreatedDate|UpdatedDate)|xed)|o(nt(size|color)|rward)|loor|romCharCode)|watch|l(ink|o(ad|g)|astIndexOf)|a(sin|nchor|cos|t(tachEvent|ob|an(2)?)|pply|lert|b(s|ort))|r(ou(nd|teEvents)|e(size(By|To)|calc|turnValue|place|verse|l(oad|ease(Capture|Events)))|andom)|g(o|et(ResponseHeader|M(i(nutes|lliseconds)|onth)|Se(conds|lection)|Hours|Year|Time(zoneOffset)?|Da(y|te)|UTC(M(i(nutes|lliseconds)|onth)|Seconds|Hours|Da(y|te)|FullYear)|FullYear|A(ttention|llResponseHeaders)))|m(in|ove(B(y|elow)|To(Absolute)?|Above)|ergeAttributes|a(tch|rgins|x))|b(toa|ig|o(ld|rderWidths)|link|ack))\b(?=\()</string>
+			<key>name</key>
+			<string>support.function.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(s(ub(stringData|mit)|plitText|e(t(NamedItem|Attribute(Node)?)|lect))|has(ChildNodes|Feature)|namedItem|c(l(ick|o(se|neNode))|reate(C(omment|DATASection|aption)|T(Head|extNode|Foot)|DocumentFragment|ProcessingInstruction|E(ntityReference|lement)|Attribute))|tabIndex|i(nsert(Row|Before|Cell|Data)|tem)|open|delete(Row|C(ell|aption)|T(Head|Foot)|Data)|focus|write(ln)?|a(dd|ppend(Child|Data))|re(set|place(Child|Data)|move(NamedItem|Child|Attribute(Node)?)?)|get(NamedItem|Element(sBy(Name|TagName)|ById)|Attribute(Node)?)|blur)\b(?=\()</string>
+			<key>name</key>
+			<string>support.function.dom.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>(?&lt;=\.)(s(ystemLanguage|cr(ipts|ollbars|een(X|Y|Top|Left))|t(yle(Sheets)?|atus(Text|bar)?)|ibling(Below|Above)|ource|uffixes|e(curity(Policy)?|l(ection|f)))|h(istory|ost(name)?|as(h|Focus))|y|X(MLDocument|SLDocument)|n(ext|ame(space(s|URI)|Prop))|M(IN_VALUE|AX_VALUE)|c(haracterSet|o(n(structor|trollers)|okieEnabled|lorDepth|mp(onents|lete))|urrent|puClass|l(i(p(boardData)?|entInformation)|osed|asses)|alle(e|r)|rypto)|t(o(olbar|p)|ext(Transform|Indent|Decoration|Align)|ags)|SQRT(1_2|2)|i(n(ner(Height|Width)|put)|ds|gnoreCase)|zIndex|o(scpu|n(readystatechange|Line)|uter(Height|Width)|p(sProfile|ener)|ffscreenBuffering)|NEGATIVE_INFINITY|d(i(splay|alog(Height|Top|Width|Left|Arguments)|rectories)|e(scription|fault(Status|Ch(ecked|arset)|View)))|u(ser(Profile|Language|Agent)|n(iqueID|defined)|pdateInterval)|_content|p(ixelDepth|ort|ersonalbar|kcs11|l(ugins|atform)|a(thname|dding(Right|Bottom|Top|Left)|rent(Window|Layer)?|ge(X(Offset)?|Y(Offset)?))|r(o(to(col|type)|duct(Sub)?|mpter)|e(vious|fix)))|e(n(coding|abledPlugin)|x(ternal|pando)|mbeds)|v(isibility|endor(Sub)?|Linkcolor)|URLUnencoded|P(I|OSITIVE_INFINITY)|f(ilename|o(nt(Size|Family|Weight)|rmName)|rame(s|Element)|gColor)|E|whiteSpace|l(i(stStyleType|n(eHeight|kColor))|o(ca(tion(bar)?|lName)|wsrc)|e(ngth|ft(Context)?)|a(st(M(odified|atch)|Index|Paren)|yer(s|X)|nguage))|a(pp(MinorVersion|Name|Co(deName|re)|Version)|vail(Height|Top|Width|Left)|ll|r(ity|guments)|Linkcolor|bove)|r(ight(Context)?|e(sponse(XML|Text)|adyState))|global|x|m(imeTypes|ultiline|enubar|argin(Right|Bottom|Top|Left))|L(N(10|2)|OG(10E|2E))|b(o(ttom|rder(Width|RightWidth|BottomWidth|Style|Color|TopWidth|LeftWidth))|ufferDepth|elow|ackground(Color|Image)))\b</string>
+			<key>name</key>
+			<string>support.constant.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>(?&lt;=\.)(s(hape|ystemId|c(heme|ope|rolling)|ta(ndby|rt)|ize|ummary|pecified|e(ctionRowIndex|lected(Index)?)|rc)|h(space|t(tpEquiv|mlFor)|e(ight|aders)|ref(lang)?)|n(o(Resize|tation(s|Name)|Shade|Href|de(Name|Type|Value)|Wrap)|extSibling|ame)|c(h(ildNodes|Off|ecked|arset)?|ite|o(ntent|o(kie|rds)|de(Base|Type)?|l(s|Span|or)|mpact)|ell(s|Spacing|Padding)|l(ear|assName)|aption)|t(ype|Bodies|itle|Head|ext|a(rget|gName)|Foot)|i(sMap|ndex|d|m(plementation|ages))|o(ptions|wnerDocument|bject)|d(i(sabled|r)|o(c(type|umentElement)|main)|e(clare|f(er|ault(Selected|Checked|Value)))|at(eTime|a))|useMap|p(ublicId|arentNode|r(o(file|mpt)|eviousSibling))|e(n(ctype|tities)|vent|lements)|v(space|ersion|alue(Type)?|Link|Align)|URL|f(irstChild|orm(s)?|ace|rame(Border)?)|width|l(ink(s)?|o(ngDesc|wSrc)|a(stChild|ng|bel))|a(nchors|c(ce(ssKey|pt(Charset)?)|tion)|ttributes|pplets|l(t|ign)|r(chive|eas)|xis|Link|bbr)|r(ow(s|Span|Index)|ules|e(v|ferrer|l|adOnly))|m(ultiple|e(thod|dia)|a(rgin(Height|Width)|xLength))|b(o(dy|rder)|ackground|gColor))\b</string>
+			<key>name</key>
+			<string>support.constant.dom.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(ELEMENT_NODE|ATTRIBUTE_NODE|TEXT_NODE|CDATA_SECTION_NODE|ENTITY_REFERENCE_NODE|ENTITY_NODE|PROCESSING_INSTRUCTION_NODE|COMMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE|DOCUMENT_FRAGMENT_NODE|NOTATION_NODE|INDEX_SIZE_ERR|DOMSTRING_SIZE_ERR|HIERARCHY_REQUEST_ERR|WRONG_DOCUMENT_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR|NOT_SUPPORTED_ERR|INUSE_ATTRIBUTE_ERR)\b</string>
+			<key>name</key>
+			<string>support.constant.dom.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\bon(R(ow(s(inserted|delete)|e(nter|xit))|e(s(ize(start|end)?|et)|adystatechange))|Mouse(o(ut|ver)|down|up|move)|B(efore(cut|deactivate|u(nload|pdate)|p(aste|rint)|editfocus|activate)|lur)|S(croll|top|ubmit|elect(start|ionchange)?)|H(over|elp)|C(hange|ont(extmenu|rolselect)|ut|ellchange|l(ick|ose))|D(eactivate|ata(setc(hanged|omplete)|available)|r(op|ag(start|over|drop|en(ter|d)|leave)?)|blclick)|Unload|P(aste|ropertychange)|Error(update)?|Key(down|up|press)|Focus|Load|A(ctivate|fter(update|print)|bort))\b</string>
+			<key>name</key>
+			<string>support.function.event-handler.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>!|\$|%|&amp;|\*|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|&lt;=|&gt;=|&lt;&lt;=|&gt;&gt;=|&gt;&gt;&gt;=|&lt;&gt;|&lt;|&gt;|!|&amp;&amp;|\|\||\?\:|\*=|(?&lt;!\()/=|%=|\+=|\-=|&amp;=|\^=|\b(in|instanceof|new|delete|typeof|void)\b</string>
+			<key>name</key>
+			<string>keyword.operator.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b(Infinity|NaN|undefined)\b</string>
+			<key>name</key>
+			<string>constant.language.chai</string>
+		</dict>
+		<dict>
+			<key>begin</key>
+			<string>(?&lt;=[=(:]|^|return|&amp;&amp;|\|\||!)\s*(/)(?![/*+{}?])</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.begin.chai</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>(/)[igm]*</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.end.chai</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>string.regexp.chai</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>\\.</string>
+					<key>name</key>
+					<string>constant.character.escape.chai</string>
+				</dict>
+			</array>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\;</string>
+			<key>name</key>
+			<string>punctuation.terminator.statement.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>,[ |\t]*</string>
+			<key>name</key>
+			<string>meta.delimiter.object.comma.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\.</string>
+			<key>name</key>
+			<string>meta.delimiter.method.period.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\{|\}</string>
+			<key>name</key>
+			<string>meta.brace.curly.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\(|\)</string>
+			<key>name</key>
+			<string>meta.brace.round.chai</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\[|\]</string>
+			<key>name</key>
+			<string>meta.brace.square.chai</string>
+		</dict>
+	</array>
+	<key>scopeName</key>
+	<string>source.chai</string>
+	<key>uuid</key>
+	<string>93E017CC-6F27-11D9-90EB-000D93589AF6</string>
+</dict>
+</plist>

include/chaiscript/chaiscript.hpp

@@ -170,7 +170,7 @@
 ///
 /// ~~~~~~~~~{.cpp}
 /// chai.add_global_const(const_var(i), "i");
-/// chai("def somefun() { print(i); }; sumfun();");
+/// chai("def somefun() { print(i); }; somefun();");
 /// ~~~~~~~~~
 /// 
 /// @subsubsection adding_functions Adding Functions
@@ -663,6 +663,19 @@
 ///
 /// @sa @ref LangObjectSystemRef
 ///
+///
+/// -----------------------------------------------------------------------
+///
+/// @section keywordauto auto
+///
+/// Defines a variable
+///
+/// ~~~~~~~~
+/// Variable ::= "auto" identifier
+/// ~~~~~~~~
+///
+/// Synonym for @ref keywordvar
+///
 /// -----------------------------------------------------------------------
 ///
 /// @section keywordbreak break
@@ -682,13 +695,13 @@
 /// Begins a function or method definition
 ///
 /// ~~~~~~~~
-/// Function Definition ::= [annotation + CR/LF] "def" identifier "(" [arg ("," arg)*] ")" [":" guard] block
-/// Method Definition ::= [annotation + CR/LF] "def" class_name "::" method_name "(" [arg ("," arg)*] ")" [":" guard] block
+/// Function Definition ::= [annotation + CR/LF] "def" identifier "(" [[type] arg ("," [type] arg)*] ")" [":" guard] block
+/// Method Definition ::= [annotation + CR/LF] "def" class_name "::" method_name "(" [[type] arg ("," [type] arg)*] ")" [":" guard] block
 /// ~~~~~~~~
 /// 
 /// annotation: meta-annotation on function, currently used as documentation. Optional.
 /// identifier: name of function. Required.
-/// args: comma-delimited list of parameter names. Optional.
+/// args: comma-delimited list of parameter names with optional type specifiers. Optional.
 /// guards: guarding statement that act as a prerequisite for the function. Optional.
 /// { }: scoped block as function body. Required.
 ///
@@ -765,12 +778,13 @@
 /// @section keywordtry try
 /// ~~~~~~~~
 /// Try Block ::= "try" block 
-///  ("catch" ["(" variable ")"] [":" guards] block)+ 
+///  ("catch" ["(" [type] variable ")"] [":" guards] block)+ 
 ///    ["finally" block]
 /// ~~~~~~~~
 ///
 /// @sa ChaiScript_Language::throw
 ///
+///
 /// -----------------------------------------------------------------------
 ///
 /// @section keywordwhile while
@@ -782,6 +796,19 @@
 /// ~~~~~~~~
 ///
 /// This loop can be broken using the @ref keywordbreak command.
+///
+///
+/// -----------------------------------------------------------------------
+///
+/// @section keywordvar var
+/// 
+/// Defines a variable
+///
+/// ~~~~~~~~
+/// Variable ::= "var" identifier
+/// ~~~~~~~~
+///
+/// Synonym for @ref keywordauto
 
 
 /// @namespace chaiscript

include/chaiscript/chaiscript_defines.hpp

@@ -10,18 +10,35 @@
 #ifdef _MSC_VER
 #define CHAISCRIPT_MSVC _MSC_VER
 #define CHAISCRIPT_HAS_DECLSPEC
+#if _MSC_VER <= 1800
+#define CHAISCRIPT_MSVC_12
+#endif
+#endif
+
+#ifndef CHAISCRIPT_MSVC_12
+#define CHAISCRIPT_HAS_MAGIC_STATICS
+#endif
+
+#include <vector>
+
+#if defined( _LIBCPP_VERSION )
+#define CHAISCRIPT_LIBCPP
 #endif
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 #define CHAISCRIPT_WINDOWS
 #endif
 
-#if (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+#if (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || (defined(__llvm__) && !defined(CHAISCRIPT_LIBCPP))  
 /// Currently only g++>=4.8 supports this natively
 /// \todo Make this support other compilers when possible
 #define CHAISCRIPT_HAS_THREAD_LOCAL
 #endif
 
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 6)
+#define CHAISCRIPT_GCC_4_6
+#endif
+
 #if (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) || defined(CHAISCRIPT_MSVC) || defined(__llvm__)
 #define CHAISCRIPT_OVERRIDE override
 #else
@@ -35,7 +52,7 @@
 #define CHAISCRIPT_MODULE_EXPORT extern "C" 
 #endif
 
-#ifdef CHAISCRIPT_MSVC
+#ifdef CHAISCRIPT_MSVC_12
 #define CHAISCRIPT_NOEXCEPT throw()
 #define CHAISCRIPT_CONSTEXPR 
 #else
@@ -43,11 +60,23 @@
 #define CHAISCRIPT_CONSTEXPR constexpr
 #endif
 
+#include <memory>
+
 namespace chaiscript {
   static const int version_major = 5;
-  static const int version_minor = 6;
-  static const int version_patch = 0;
-}
+  static const int version_minor = 7;
+  static const int version_patch = 2;
 
+  template<typename B, typename D, typename ...Arg>
+  inline std::shared_ptr<B> make_shared(Arg && ... arg)
+  {
+#ifdef CHAISCRIPT_USE_STD_MAKE_SHARED
+    return std::make_shared<D>(std::forward<Arg>(arg)...);
+#else
+    return std::shared_ptr<B>(static_cast<B*>(new D(std::forward<Arg>(arg)...)));
+#endif
+  }
+
+}
 #endif
 

include/chaiscript/chaiscript_stdlib.hpp

@@ -18,6 +18,8 @@
 #include "dispatchkit/bootstrap.hpp"
 #include "dispatchkit/bootstrap_stl.hpp"
 #include "dispatchkit/boxed_value.hpp"
+#include "language/chaiscript_prelude.chai"
+#include "utility/json_wrap.hpp"
 
 #ifndef CHAISCRIPT_NO_THREADS
 #include <future>
@@ -47,9 +49,13 @@ namespace chaiscript
 
 #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");
+        lib->add(chaiscript::fun([](const std::function<chaiscript::Boxed_Value ()> &t_func){ return std::async(std::launch::async, t_func);}), "async");
 #endif
 
+        lib->add(json_wrap::library());
+
+        lib->eval(ChaiScript_Prelude::chaiscript_prelude() /*, "standard prelude"*/ );
+
         return lib;
       }
 

include/chaiscript/chaiscript_threading.hpp

@@ -7,14 +7,19 @@
 #ifndef CHAISCRIPT_THREADING_HPP_
 #define CHAISCRIPT_THREADING_HPP_
 
+
 #include <unordered_map>
 
 #ifndef CHAISCRIPT_NO_THREADS
 #include <thread>
 #include <mutex>
 #else
+#ifndef CHAISCRIPT_NO_THREADS_WARNING
 #pragma message ("ChaiScript is compiling without thread safety.")
 #endif
+#endif
+
+#include "chaiscript_defines.hpp"
 
 /// \file
 ///
@@ -150,6 +155,7 @@ namespace chaiscript
 
 
           private:
+            /// \todo this leaks thread instances. It needs to be culled from time to time
             std::shared_ptr<T> get_tls() const
             {
               unique_lock<mutex> lock(m_mutex);
@@ -158,7 +164,7 @@ namespace chaiscript
 
               if (itr != m_instances.end()) { return itr->second; }
 
-              std::shared_ptr<T> new_instance(new T());
+              std::shared_ptr<T> new_instance(std::make_shared<T>());
 
               m_instances.insert(std::make_pair(std::this_thread::get_id(), new_instance));
 

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -36,7 +36,7 @@ namespace chaiscript
         }
 
         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")
+          : from(std::move(t_from)), to(&t_to), m_what("Cannot perform boxed_cast: " + t_from.name() + " to: " + t_to.name())
         {
         }
 

include/chaiscript/dispatchkit/bind_first.hpp

@@ -14,63 +14,58 @@ namespace chaiscript
   namespace detail
   {
 
-    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<typename T>
+      T* get_pointer(T *t)
+      {
+        return t;
       }
-    };
 
-    template<int count, int maxcount, typename Sig>
-      struct Bind_First
+    template<typename T>
+      T* get_pointer(const std::reference_wrapper<T> &t)
       {
-        template<typename F, typename ... InnerParams>
-          static std::function<Sig> bind(F&& f, InnerParams ... innerparams)
-          {
-            return Bind_First<count - 1, maxcount, Sig>::bind(std::forward<F>(f), innerparams..., std::get<maxcount - count>(Placeholder::placeholder()));
-          } 
-      };
-
-    template<int maxcount, typename Sig>
-      struct Bind_First<0, maxcount, Sig>
-      {
-        template<typename F, typename ... InnerParams>
-          static std::function<Sig> bind(F&& f, InnerParams ... innerparams)
-          {
-    return std::bind(std::forward<F>(f), innerparams...);
-          }
-      };
-
+        return &t.get();
+      }
 
     template<typename O, typename Ret, typename P1, typename ... Param>
       std::function<Ret (Param...)> bind_first(Ret (*f)(P1, Param...), O&& o)
       {
-        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, std::forward<O>(o));
+        return std::function<Ret (Param...)>(
+            [f, o](Param...param) -> Ret {
+              return f(std::forward<O>(o), std::forward<Param>(param)...);
+            }
+          );
       }
 
     template<typename O, typename Ret, typename Class, typename ... Param>
       std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...), O&& o)
       {
-        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, std::forward<O>(o));
+        return std::function<Ret (Param...)>(
+            [f, o](Param...param) -> Ret {
+              return (get_pointer(o)->*f)(std::forward<Param>(param)...);
+            }
+          );
       }
 
     template<typename O, typename Ret, typename Class, typename ... Param>
       std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...) const, O&& o)
       {
-        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, std::forward<O>(o));
+        return std::function<Ret (Param...)>(
+            [f, o](Param...param) -> Ret {
+              return (get_pointer(o)->*f)(std::forward<Param>(param)...);
+            }
+          );
+
       }
 
     template<typename O, typename Ret, typename P1, typename ... Param>
       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, std::forward<O>(o));
+        return std::function<Ret (Param...)>(
+            [f, o](Param...param) -> Ret {
+              return f(o, std::forward<Param>(param)...);
+            });
       }
 
-    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

@@ -10,14 +10,13 @@
 #include <cstdint>
 #include <exception>
 #include <functional>
-#include <iostream>
-#include <map>
 #include <memory>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <vector>
+#include <iterator>
 
 #include "bad_boxed_cast.hpp"
 #include "boxed_cast.hpp"
@@ -52,13 +51,50 @@ namespace chaiscript
       }
     }
 
+    template<typename T, typename = typename std::enable_if<std::is_array<T>::value>::type >
+      ModulePtr array(const std::string &type, ModulePtr m = std::make_shared<Module>())
+      {
+        typedef typename std::remove_extent<T>::type ReturnType;
+        const auto extent = std::extent<T>::value;
+        m->add(user_type<T>(), type);
+        m->add(fun(
+              [extent](T& t, size_t index)->ReturnType &{
+                if (extent > 0 && index >= extent) {
+                  throw std::range_error("Array index out of range. Received: " + std::to_string(index)  + " expected < " + std::to_string(extent));
+                } else {
+                  return t[index];
+                }
+              }
+              ), "[]"
+            );
+
+        m->add(fun(
+              [extent](const T &t, size_t index)->const ReturnType &{
+                if (extent > 0 && index >= extent) {
+                  throw std::range_error("Array index out of range. Received: " + std::to_string(index)  + " expected < " + std::to_string(extent));
+                } else {
+                  return t[index];
+                }
+              }
+              ), "[]"
+            );
+
+        m->add(fun(
+              [extent](const T &) {
+                return extent;
+              }), "size");
+
+
+        return m;
+      }
+
     /// \brief Adds a copy constructor for the given type to the given Model
     /// \param[in] type The name of the type. The copy constructor will be named "type".
     /// \param[in,out] m The Module to add the copy constructor to
     /// \tparam T The type to add a copy constructor for
     /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
     template<typename T>
-    ModulePtr copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    ModulePtr copy_constructor(const std::string &type, ModulePtr m = std::make_shared<Module>())
     {
       m->add(constructor<T (const T &)>(), type);
       return m;
@@ -69,7 +105,7 @@ namespace chaiscript
     /// \param[in,out] m module to add comparison operators to
     /// \returns the passed in ModulePtr or the newly constructed one if the default params are used.
     template<typename T>
-    ModulePtr opers_comparison(ModulePtr m = ModulePtr(new Module()))
+    ModulePtr opers_comparison(ModulePtr m = std::make_shared<Module>())
     {
       operators::equal<T>(m);
       operators::greater_than<T>(m);
@@ -90,7 +126,7 @@ namespace chaiscript
     /// \sa copy_constructor
     /// \sa constructor
     template<typename T>
-    ModulePtr basic_constructors(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    ModulePtr basic_constructors(const std::string &type, ModulePtr m = std::make_shared<Module>())
     {
       m->add(constructor<T ()>(), type);
       copy_constructor<T>(type, m);
@@ -102,7 +138,7 @@ namespace chaiscript
     /// \param[in] type The name of the type
     /// \param[in,out] m The Module to add the constructor to
     template<typename T>
-    ModulePtr construct_pod(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    ModulePtr construct_pod(const std::string &type, ModulePtr m = std::make_shared<Module>())
     {
       m->add(fun(&detail::construct_pod<T>), type);
       return m;
@@ -121,7 +157,12 @@ namespace chaiscript
     /// 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)
+    auto parse_string(const std::string &i)
+      -> typename std::enable_if<
+             !std::is_same<Input, wchar_t>::value
+             && !std::is_same<Input, char16_t>::value
+             && !std::is_same<Input, char32_t>::value,
+      Input>::type
     {
       std::stringstream ss(i);
       Input t;
@@ -129,17 +170,27 @@ namespace chaiscript
       return t;
     }
 
+    template<typename Input>
+    auto parse_string(const std::string &) 
+      -> typename std::enable_if<
+             std::is_same<Input, wchar_t>::value
+             || std::is_same<Input, char16_t>::value
+             || std::is_same<Input, char32_t>::value,
+      Input>::type
+    {
+      throw std::runtime_error("Parsing of wide characters is not yet supported");
+    }
+
 
     /// 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()))
+    ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = std::make_shared<Module>())
     {
       m->add(user_type<T>(), name);
-      m->add(constructor<T ()>(), name);
+      m->add(constructor<T()>(), name);
       construct_pod<T>(name, m);
 
-      m->add(fun(&to_string<T>), "to_string");
       m->add(fun(&parse_string<T>), "to_" + name);
       return m;
     }
@@ -187,9 +238,7 @@ namespace chaiscript
     class Bootstrap
     {
     private:
-      /**
-      * Function allowing for assignment of an unknown type to any other value
-      */
+      /// Function allowing for assignment of an unknown type to any other value
       static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs)
       {
         if (lhs.is_undef())
@@ -212,7 +261,7 @@ namespace chaiscript
 
 
       /// Add all arithmetic operators for PODs
-      static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
+      static void opers_arithmetic_pod(ModulePtr m = std::make_shared<Module>())
       {
         m->add(fun(&Boxed_Number::equals), "==");
         m->add(fun(&Boxed_Number::less_than), "<");
@@ -255,14 +304,18 @@ namespace chaiscript
       /// 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)
-        {
-          throw exception::arity_error(static_cast<int>(params.size()), 2);
+        if (params.empty()) {
+          throw exception::arity_error(0, 1);
         }
 
         Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
 
-        return Boxed_Value(Const_Proxy_Function(std::make_shared<dispatch::Bound_Function>(f,
+        if (f->get_arity() != -1 && size_t(f->get_arity()) != params.size() - 1)
+        {
+          throw exception::arity_error(static_cast<int>(params.size()), f->get_arity());
+        }
+
+        return Boxed_Value(Const_Proxy_Function(std::make_shared<dispatch::Bound_Function>(std::move(f),
           std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
       }
 
@@ -270,29 +323,15 @@ namespace chaiscript
       static bool has_guard(const Const_Proxy_Function &t_pf)
       {
         auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
-        if (pf)
-        {
-          if (pf->get_guard()) {
-            return true;
-          } else {
-            return false;
-          }
-        } else {
-          return false;
-        }
+        return pf && pf->get_guard();
       }
 
       static Const_Proxy_Function get_guard(const Const_Proxy_Function &t_pf)
       {
-        auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
-        if (pf)
+        const auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        if (pf && pf->get_guard())
         {
-          if (pf->get_guard())
-          {
-            return pf->get_guard();
-          } else {
-            throw std::runtime_error("Function does not have a guard");
-          }
+          return pf->get_guard();
         } else {
           throw std::runtime_error("Function does not have a guard");
         }
@@ -337,29 +376,16 @@ namespace chaiscript
 
       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;
-        }
+        const auto pf = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+        return pf && pf->get_parse_tree();
       }
 
       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))
+        const auto pf = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+        if (pf && pf->get_parse_tree())
         {
-          if (pf->get_parse_tree())
-          {
-            return pf->get_parse_tree();
-          } else {
-            throw std::runtime_error("Function does not have a parse tree");
-          }
+          return pf->get_parse_tree();
         } else {
           throw std::runtime_error("Function does not have a parse tree");
         }
@@ -368,7 +394,9 @@ namespace chaiscript
       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);
+        return [f](const dispatch::Proxy_Function_Base *b) {
+          return do_return_boxed_value_vector(f, b);
+        };
       }
 
 
@@ -376,13 +404,14 @@ namespace chaiscript
       /// \brief perform all common bootstrap functions for std::string, void and POD types
       /// \param[in,out] m Module to add bootstrapped functions to
       /// \returns passed in ModulePtr, or newly created one if default argument is used
-      static ModulePtr bootstrap(ModulePtr m = ModulePtr(new Module()))
+      static ModulePtr bootstrap(ModulePtr m = std::make_shared<Module>())
       {
         m->add(user_type<void>(), "void");
         m->add(user_type<bool>(), "bool");
         m->add(user_type<Boxed_Value>(), "Object");
         m->add(user_type<Boxed_Number>(), "Number");
         m->add(user_type<Proxy_Function>(), "Function");
+        m->add(user_type<dispatch::Assignable_Proxy_Function>(), "Assignable_Function");
         m->add(user_type<std::exception>(), "exception");
 
         m->add(fun(&dispatch::Proxy_Function_Base::get_arity), "get_arity");
@@ -394,6 +423,12 @@ namespace chaiscript
         m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_contained_functions)), "get_contained_functions");
 
 
+        m->add(user_type<std::out_of_range>(), "out_of_range");
+        m->add(user_type<std::logic_error>(), "logic_error");
+        m->add(chaiscript::base_class<std::exception, std::logic_error>());
+        m->add(chaiscript::base_class<std::logic_error, std::out_of_range>());
+        m->add(chaiscript::base_class<std::exception, std::out_of_range>());
+
         m->add(user_type<std::runtime_error>(), "runtime_error");
         m->add(chaiscript::base_class<std::exception, std::runtime_error>());
 
@@ -402,11 +437,28 @@ namespace chaiscript
 
         m->add(user_type<dispatch::Dynamic_Object>(), "Dynamic_Object");
         m->add(constructor<dispatch::Dynamic_Object (const std::string &)>(), "Dynamic_Object");
+        m->add(constructor<dispatch::Dynamic_Object ()>(), "Dynamic_Object");
         m->add(fun(&dispatch::Dynamic_Object::get_type_name), "get_type_name");
         m->add(fun(&dispatch::Dynamic_Object::get_attrs), "get_attrs");
-        m->add(fun(&dispatch::Dynamic_Object::get_attr), "get_attr");
+        m->add(fun(&dispatch::Dynamic_Object::set_explicit), "set_explicit");
+        m->add(fun(&dispatch::Dynamic_Object::is_explicit), "is_explicit");
 
-        m->eval("def Dynamic_Object::clone() { auto &new_o = Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
+        m->add(fun(static_cast<Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &)>(&dispatch::Dynamic_Object::get_attr)), "get_attr");
+        m->add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::get_attr)), "get_attr");
+
+        m->add(fun(static_cast<Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &)>(&dispatch::Dynamic_Object::method_missing)), "method_missing");
+        m->add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::method_missing)), "method_missing");
+
+        m->add(fun(static_cast<Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &)>(&dispatch::Dynamic_Object::get_attr)), "[]");
+        m->add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::get_attr)), "[]");
+
+        m->eval(R""(
+          def Dynamic_Object::clone() { 
+            auto &new_o = Dynamic_Object(this.get_type_name()); 
+            for_each(this.get_attrs(), fun[new_o](x) { new_o.get_attr(x.first) = x.second; } ); 
+            new_o; 
+          }
+          )"");
 
         m->add(fun(&has_guard), "has_guard");
         m->add(fun(&get_guard), "get_guard");
@@ -416,9 +468,12 @@ namespace chaiscript
         m->add(fun(&Boxed_Value::is_const), "is_var_const");
         m->add(fun(&Boxed_Value::is_ref), "is_var_reference");
         m->add(fun(&Boxed_Value::is_pointer), "is_var_pointer");
+        m->add(fun(&Boxed_Value::is_return_value), "is_var_return_value");
+        m->add(fun(&Boxed_Value::reset_return_value), "reset_var_return_value");
         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::clone_attrs), "clone_var_attrs");
 
         m->add(fun(&Boxed_Value::get_type_info), "get_type_info");
         m->add(user_type<Type_Info>(), "Type_Info");
@@ -441,13 +496,17 @@ namespace chaiscript
         basic_constructors<bool>("bool", m);
         operators::assign<bool>(m);
         operators::equal<bool>(m);
+        operators::not_equal<bool>(m);
 
-        m->add(fun<std::string (const std::string &t_ss)>([](const std::string &s) -> std::string { return s; }), "to_string");
+        m->add(fun([](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");
 
+        m->add(fun(&to_string<char>), "to_string");
+        m->add(fun(&Boxed_Number::to_string), "to_string");
+
         bootstrap_pod_type<double>("double", m);
         bootstrap_pod_type<long double>("long_double", m);
         bootstrap_pod_type<float>("float", m);
@@ -455,8 +514,13 @@ namespace chaiscript
         bootstrap_pod_type<long>("long", m);
         bootstrap_pod_type<unsigned int>("unsigned_int", m);
         bootstrap_pod_type<unsigned long>("unsigned_long", m);
+        bootstrap_pod_type<long long>("long_long", m);
+        bootstrap_pod_type<unsigned long long>("unsigned_long_long", m);
         bootstrap_pod_type<size_t>("size_t", m);
         bootstrap_pod_type<char>("char", m);
+        bootstrap_pod_type<wchar_t>("wchar_t", m);
+        bootstrap_pod_type<char16_t>("char16_t", m);
+        bootstrap_pod_type<char32_t>("char32_t", m);
         bootstrap_pod_type<std::int8_t>("int8_t", m);
         bootstrap_pod_type<std::int16_t>("int16_t", m);
         bootstrap_pod_type<std::int32_t>("int32_t", m);
@@ -474,11 +538,18 @@ namespace chaiscript
         m->add(fun(&print), "print_string");
         m->add(fun(&println), "println_string");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(&bind_function)), "bind");
+        m->add(dispatch::make_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>), "=");
         m->add(fun(&ptr_assign<std::add_const<dispatch::Proxy_Function_Base>::type>), "=");
+        m->add(chaiscript::base_class<dispatch::Proxy_Function_Base, dispatch::Assignable_Proxy_Function>());
+        m->add(fun(
+                  [](dispatch::Assignable_Proxy_Function &t_lhs, const std::shared_ptr<const dispatch::Proxy_Function_Base> &t_rhs) {
+                    t_lhs.assign(t_rhs);
+                  }
+                ), "="
+              );
 
         m->add(fun(&Boxed_Value::type_match), "type_match");
 
@@ -486,7 +557,6 @@ namespace chaiscript
         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");
@@ -500,13 +570,14 @@ namespace chaiscript
             "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"} }
+              {fun(&chaiscript::exception::eval_error::pretty_print), "pretty_print"},
+              {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<const std::shared_ptr<const chaiscript::AST_Node> &>);
+                  return retval;
+                })), "call_stack"} }
             );
 
 
@@ -532,7 +603,7 @@ namespace chaiscript
                 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>>);
+                               &chaiscript::var<const std::shared_ptr<chaiscript::AST_Node> &>);
                 return retval;
               })), "children"},
               {fun(&AST_Node::replace_child), "replace_child"}

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -14,10 +14,8 @@
 #define CHAISCRIPT_BOOTSTRAP_STL_HPP_
 
 #include <functional>
-#include <iterator>
 #include <memory>
 #include <stdexcept>
-#include <string>
 #include <typeinfo>
 #include <vector>
 
@@ -179,7 +177,7 @@ namespace chaiscript
 
         /// Add Bidir_Range support for the given ContainerType
         template<typename Bidir_Type>
-          ModulePtr input_range_type_impl(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+          ModulePtr input_range_type_impl(const std::string &type, ModulePtr m = std::make_shared<Module>())
           {
             m->add(user_type<Bidir_Type>(), type + "_Range");
 
@@ -228,12 +226,11 @@ namespace chaiscript
 
             std::advance(itr, pos);
             container.erase(itr);
-          }      
-
+          }
       }
 
       template<typename ContainerType>
-        ModulePtr input_range_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr input_range_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           detail::input_range_type_impl<Bidir_Range<ContainerType> >(type,m);
           detail::input_range_type_impl<Const_Bidir_Range<ContainerType> >("Const_" + type, m);
@@ -244,20 +241,21 @@ namespace chaiscript
       /// Add random_access_container concept to the given ContainerType
       /// http://www.sgi.com/tech/stl/RandomAccessContainer.html
       template<typename ContainerType>
-        ModulePtr random_access_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr random_access_container_type(const std::string &/*type*/, ModulePtr m = std::make_shared<Module>())
         {
-          // cppcheck-suppress syntaxError
-          typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
-          typedef typename ContainerType::const_reference(ContainerType::*constindexoper)(size_t) const;
-
           //In the interest of runtime safety for the m, we prefer the at() method for [] access,
           //to throw an exception in an out of bounds condition.
           m->add(
-              fun(std::function<typename ContainerType::reference (ContainerType *, int)>
-                (std::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
+              fun(
+                [](ContainerType &c, int index) -> typename ContainerType::reference {
+                  return c.at(index);
+                }), "[]");
+
           m->add(
-              fun(std::function<typename ContainerType::const_reference (const ContainerType *, int)>
-                (std::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
+              fun(
+                [](const ContainerType &c, int index) -> typename ContainerType::const_reference {
+                  return c.at(index);
+                }), "[]");
 
           return m;
         }
@@ -266,9 +264,9 @@ namespace chaiscript
       /// Add assignable concept to the given ContainerType
       /// http://www.sgi.com/tech/stl/Assignable.html
       template<typename ContainerType>
-        ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assignable_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
-          basic_constructors<ContainerType>(type, m);
+          copy_constructor<ContainerType>(type, m);
           operators::assign<ContainerType>(m);
           return m;
         }
@@ -277,11 +275,11 @@ namespace chaiscript
       /// Add container concept to the given ContainerType
       /// http://www.sgi.com/tech/stl/Container.html
       template<typename ContainerType>
-        ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr container_type(const std::string &/*type*/, ModulePtr m = std::make_shared<Module>())
         {
-          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");
+          m->add(fun([](const ContainerType *a) { return a->size(); } ), "size");
+          m->add(fun([](const ContainerType *a) { return a->empty(); } ), "empty");
+          m->add(fun([](ContainerType *a) { a->clear(); } ), "clear");
           return m;
         }
 
@@ -289,7 +287,7 @@ namespace chaiscript
       /// Add default constructable concept to the given Type
       /// http://www.sgi.com/tech/stl/DefaultConstructible.html
       template<typename Type>
-        ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr default_constructible_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           m->add(constructor<Type ()>(), type);
           return m;
@@ -301,17 +299,17 @@ namespace chaiscript
       /// Add sequence concept to the given ContainerType
       /// http://www.sgi.com/tech/stl/Sequence.html
       template<typename ContainerType>
-        ModulePtr sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr sequence_type(const std::string &/*type*/, ModulePtr m = std::make_shared<Module>())
         {
-          std::string insert_name;
-          if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
-          {
-            insert_name = "insert_ref_at";
-          } else {
-            insert_name = "insert_at";
-          }
+          m->add(fun(&detail::insert_at<ContainerType>), 
+              []()->std::string{
+                if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value)) {
+                  return "insert_ref_at";
+                } else {
+                  return "insert_at";
+                }
+              }());
 
-          m->add(fun(&detail::insert_at<ContainerType>), insert_name);
           m->add(fun(&detail::erase_at<ContainerType>), "erase_at");
 
           return m;
@@ -321,22 +319,36 @@ namespace chaiscript
       /// Add back insertion sequence concept to the given ContainerType
       /// http://www.sgi.com/tech/stl/BackInsertionSequence.html
       template<typename ContainerType>
-        ModulePtr back_insertion_sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr back_insertion_sequence_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           typedef typename ContainerType::reference (ContainerType::*backptr)();
 
           m->add(fun(static_cast<backptr>(&ContainerType::back)), "back");
 
-          std::string push_back_name;
-          if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
-          {
-            push_back_name = "push_back_ref";
-          } else {
-            push_back_name = "push_back";
-          }
 
           typedef void (ContainerType::*push_back)(const typename ContainerType::value_type &);
-          m->add(fun(static_cast<push_back>(&ContainerType::push_back)), push_back_name);
+          m->add(fun(static_cast<push_back>(&ContainerType::push_back)),
+              [&]()->std::string{
+              if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value)) {
+                m->eval(
+                    "# Pushes the second value onto the container while making a clone of the value\n"
+                    "def push_back(" + type + " container, x)\n"
+                    "{ \n"
+                    "  if (x.is_var_return_value()) {\n"
+                    "    x.reset_var_return_value() \n"
+                    "    container.push_back_ref(x) \n"
+                    "  } else { \n"
+                    "    container.push_back_ref(clone(x)); \n"
+                    "  }\n"
+                    "} \n"
+                    );
+
+                  return "push_back_ref";
+                } else {
+                  return "push_back";
+                }
+              }());
+
           m->add(fun(&ContainerType::pop_back), "pop_back");
           return m;
         }
@@ -346,26 +358,38 @@ namespace chaiscript
       /// Front insertion sequence
       /// http://www.sgi.com/tech/stl/FrontInsertionSequence.html
       template<typename ContainerType>
-        ModulePtr front_insertion_sequence_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr front_insertion_sequence_type(const std::string &type, ModulePtr m = std::make_shared<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)();
+          typedef typename ContainerType::reference (ContainerType::*front_ptr)();
+          typedef typename ContainerType::const_reference (ContainerType::*const_front_ptr)() const;
+          typedef void (ContainerType::*push_ptr)(typename ContainerType::const_reference);
+          typedef void (ContainerType::*pop_ptr)();
 
-          m->add(fun(static_cast<frontptr>(&ContainerType::front)), "front");
-          m->add(fun(static_cast<constfrontptr>(&ContainerType::front)), "front");
+          m->add(fun(static_cast<front_ptr>(&ContainerType::front)), "front");
+          m->add(fun(static_cast<const_front_ptr>(&ContainerType::front)), "front");
 
-          std::string push_front_name;
-          if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
-          {
-            push_front_name = "push_front_ref";
-          } else {
-            push_front_name = "push_front";
-          }
+          m->add(fun(static_cast<push_ptr>(&ContainerType::push_front)),
+              [&]()->std::string{
+                if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value)) {
+                  m->eval(
+                      "# Pushes the second value onto the front of container while making a clone of the value\n"
+                      "def push_front(" + type + " container, x)\n"
+                      "{ \n"
+                      "  if (x.is_var_return_value()) {\n"
+                      "    x.reset_var_return_value() \n"
+                      "    container.push_front_ref(x) \n"
+                      "  } else { \n"
+                      "    container.push_front_ref(clone(x)); \n"
+                      "  }\n"
+                      "} \n"
+                      );
+                  return "push_front_ref";
+                } else {
+                  return "push_front";
+                }
+              }());
 
-          m->add(fun(static_cast<pushptr>(&ContainerType::push_front)), push_front_name);
-          m->add(fun(static_cast<popptr>(&ContainerType::pop_front)), "pop_front");
+          m->add(fun(static_cast<pop_ptr>(&ContainerType::pop_front)), "pop_front");
           return m;
         }
 
@@ -373,7 +397,7 @@ namespace chaiscript
       /// bootstrap a given PairType
       /// http://www.sgi.com/tech/stl/pair.html
       template<typename PairType>
-        ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr pair_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           m->add(user_type<PairType>(), type);
 
@@ -396,7 +420,7 @@ namespace chaiscript
       /// http://www.sgi.com/tech/stl/PairAssociativeContainer.html
 
       template<typename ContainerType>
-        ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           pair_type<typename ContainerType::value_type>(type + "_Pair", m);
 
@@ -407,7 +431,7 @@ namespace chaiscript
       /// Add unique associative container concept to the given ContainerType
       /// http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
       template<typename ContainerType>
-        ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = std::make_shared<Module>())
         {
           m->add(fun(detail::count<ContainerType>), "count");
 
@@ -417,15 +441,16 @@ namespace chaiscript
 
           m->add(fun(&detail::insert<ContainerType>), "insert");
 
-          std::string insert_name;
-          if (typeid(typename ContainerType::mapped_type) == typeid(Boxed_Value))
-          {
-            insert_name = "insert_ref";
-          } else {
-            insert_name = "insert";
-          }
+          m->add(fun(&detail::insert_ref<ContainerType>), 
+              []()->std::string{
+                if (typeid(typename ContainerType::mapped_type) == typeid(Boxed_Value)) {
+                  return "insert_ref";
+                } else {
+                  return "insert";
+                }
+              }());
+
 
-          m->add(fun(&detail::insert_ref<ContainerType>), insert_name);
           return m;
         }
 
@@ -433,15 +458,44 @@ namespace chaiscript
       /// Add a MapType container
       /// http://www.sgi.com/tech/stl/Map.html
       template<typename MapType>
-        ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr map_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           m->add(user_type<MapType>(), type);
 
-          typedef typename MapType::mapped_type &(MapType::*elemaccess)(const typename MapType::key_type &);
+          typedef typename MapType::mapped_type &(MapType::*elem_access)(const typename MapType::key_type &);
+          typedef const typename MapType::mapped_type &(MapType::*const_elem_access)(const typename MapType::key_type &) const;
 
-          m->add(fun(static_cast<elemaccess>(&MapType::operator[])), "[]");
+          m->add(fun(static_cast<elem_access>(&MapType::operator[])), "[]");
+
+          m->add(fun(static_cast<elem_access>(&MapType::at)), "at");
+          m->add(fun(static_cast<const_elem_access>(&MapType::at)), "at");
+
+          if (typeid(MapType) == typeid(std::map<std::string, Boxed_Value>))
+          {
+            m->eval(R"(
+                    def Map::`==`(Map rhs) {
+                       if ( rhs.size() != this.size() ) {
+                         return false;
+                       } else {
+                         auto r1 = range(this);
+                         auto r2 = range(rhs);
+                         while (!r1.empty())
+                         {
+                           if (!eq(r1.front().first, r2.front().first) || !eq(r1.front().second, r2.front().second))
+                           {
+                             return false;
+                           }
+                           r1.pop_front();
+                           r2.pop_front();
+                         }
+                         true;
+                       }
+                   } )"
+                 );
+          } 
 
           container_type<MapType>(type, m);
+          default_constructible_type<MapType>(type, m);
           assignable_type<MapType>(type, m);
           unique_associative_container_type<MapType>(type, m);
           pair_associative_container_type<MapType>(type, m);
@@ -454,7 +508,7 @@ namespace chaiscript
       /// hopefully working List type
       /// http://www.sgi.com/tech/stl/List.html
       template<typename ListType>
-        ModulePtr list_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr list_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           m->add(user_type<ListType>(), type);
 
@@ -473,7 +527,7 @@ namespace chaiscript
       /// Create a vector type with associated concepts
       /// http://www.sgi.com/tech/stl/Vector.html
       template<typename VectorType>
-        ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr vector_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           m->add(user_type<VectorType>(), type);
 
@@ -495,7 +549,7 @@ namespace chaiscript
           if (typeid(VectorType) == typeid(std::vector<Boxed_Value>))
           {
             m->eval(R"(
-                    def Vector::`==`(rhs) : type_match(rhs, this) {
+                    def Vector::`==`(Vector rhs) {
                        if ( rhs.size() != this.size() ) {
                          return false;
                        } else {
@@ -522,7 +576,7 @@ namespace chaiscript
       /// Add a String container
       /// http://www.sgi.com/tech/stl/basic_string.html
       template<typename String>
-        ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        ModulePtr string_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           m->add(user_type<String>(), type);
           operators::addition<String>(m);
@@ -536,32 +590,30 @@ namespace chaiscript
           input_range_type<String>(type, m);
 
           //Special case: add push_back to string (which doesn't support other back_insertion operations
-          std::string push_back_name;
-          if (typeid(typename String::value_type) == typeid(Boxed_Value))
-          {
-            push_back_name = "push_back_ref";
-          } else {
-            push_back_name = "push_back";
-          }
-          m->add(fun(&String::push_back), push_back_name);
-
-          typedef std::function<size_t (const String *, const String &, size_t)> find_func;
+          m->add(fun(&String::push_back), 
+              []()->std::string{
+                if (typeid(typename String::value_type) == typeid(Boxed_Value)) {
+                  return "push_back_ref";
+                } else {
+                  return "push_back";
+                }
+              }());
 
 
-          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find(f, pos); } )), "find");
-          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->rfind(f, pos); } ) ), "rfind");
-          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_first_of(f, pos); } ) ), "find_first_of");
-          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_last_of(f, pos); } ) ), "find_last_of");
-          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_last_not_of(f, pos); } ) ), "find_last_not_of");
-          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_first_not_of(f, pos); } ) ), "find_first_not_of");
+          m->add(fun([](const String *s, const String &f, size_t pos) { return s->find(f, pos); } ), "find");
+          m->add(fun([](const String *s, const String &f, size_t pos) { return s->rfind(f, pos); } ), "rfind");
+          m->add(fun([](const String *s, const String &f, size_t pos) { return s->find_first_of(f, pos); } ), "find_first_of");
+          m->add(fun([](const String *s, const String &f, size_t pos) { return s->find_last_of(f, pos); } ), "find_last_of");
+          m->add(fun([](const String *s, const String &f, size_t pos) { return s->find_last_not_of(f, pos); } ), "find_last_not_of");
+          m->add(fun([](const String *s, const String &f, size_t pos) { return s->find_first_not_of(f, pos); } ), "find_first_not_of");
 
-          m->add(fun( std::function<void (String *)>( [](String *s) { return s->clear(); } ) ), "clear");
-          m->add(fun( std::function<bool (const String *)>( [](const String *s) { return s->empty(); } ) ), "empty");
-          m->add(fun( std::function<size_t (const String *)>( [](const String *s) { return s->size(); } ) ), "size");
+          m->add(fun([](String *s) { s->clear(); } ), "clear");
+          m->add(fun([](const String *s) { return s->empty(); } ), "empty");
+          m->add(fun([](const String *s) { return s->size(); } ), "size");
 
-          m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->c_str(); } ) ), "c_str");
-          m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->data(); } ) ), "data");
-          m->add(fun( std::function<String (const String *, size_t, size_t)>( [](const String *s, size_t pos, size_t len) { return s->substr(pos, len); } ) ), "substr");
+          m->add(fun([](const String *s) { return s->c_str(); } ), "c_str");
+          m->add(fun([](const String *s) { return s->data(); } ), "data");
+          m->add(fun([](const String *s, size_t pos, size_t len) { return s->substr(pos, len); } ), "substr");
 
           return m;
         }
@@ -571,19 +623,16 @@ namespace chaiscript
       /// 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()))
+        ModulePtr future_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
         {
           m->add(user_type<FutureType>(), type);
 
-          m->add(fun<bool (const FutureType &)>([](const FutureType &t) { return t.valid(); }), "valid");
+          m->add(fun([](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

@@ -7,10 +7,7 @@
 #ifndef CHAISCRIPT_BOXED_CAST_HPP_
 #define CHAISCRIPT_BOXED_CAST_HPP_
 
-#include <type_traits>
-
 #include "../chaiscript_defines.hpp"
-#include "../chaiscript_threading.hpp"
 #include "bad_boxed_cast.hpp"
 #include "boxed_cast_helper.hpp"
 #include "boxed_value.hpp"
@@ -74,46 +71,36 @@ namespace chaiscript
   template<typename Type>
   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);
-    } catch (const chaiscript::detail::exception::bad_any_cast &) {
-
-
-#ifdef CHAISCRIPT_MSVC
-      //Thank you MSVC, yes we know that a constant value is being used in the if
-      // statment in THIS VERSION of the template instantiation
-#pragma warning(push)
-#pragma warning(disable : 4127)
-#endif
-
-      if (t_conversions && t_conversions->convertable_type<Type>())
-      {
-        try {
-          // 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_type_conversion<Type>(bv), t_conversions);
-        } catch (...) {
-          try {
-          //  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_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));
-          }
-        }
-      } else {
-        // If it's not polymorphic, just throw the error, don't waste the time on the 
-        // attempted dynamic_cast
-        throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+    if (!t_conversions || bv.get_type_info().bare_equal(user_type<Type>()) || (t_conversions && !t_conversions->convertable_type<Type>())) {
+      try {
+        return detail::Cast_Helper<Type>::cast(bv, t_conversions);
+      } catch (const chaiscript::detail::exception::bad_any_cast &) {
       }
-
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(pop)
-#endif
+    }
 
 
-    } 
+    if (t_conversions && t_conversions->convertable_type<Type>())
+    {
+      try {
+        // 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_type_conversion<Type>(bv), t_conversions);
+      } catch (...) {
+        try {
+        //  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_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));
+        }
+      }
+    } else {
+      // If it's not polymorphic, just throw the error, don't waste the time on the 
+      // attempted dynamic_cast
+      throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+    }
+
   }
 
 }

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -7,7 +7,6 @@
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 #define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 
-#include <functional>
 #include <memory>
 #include <type_traits>
 
@@ -34,13 +33,14 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner
       {
-        typedef typename std::reference_wrapper<typename std::add_const<Result>::type > Result_Type;
+        typedef std::reference_wrapper<typename std::add_const<Result>::type > Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
           if (ob.get_type_info().bare_equal_type_info(typeid(Result)))
           {
-            return *(static_cast<const Result *>(throw_if_null(ob.get_const_ptr())));
+            auto p = throw_if_null(ob.get_const_ptr());
+            return std::cref(*static_cast<const Result *>(p));
           } else {
             throw chaiscript::detail::exception::bad_any_cast();
           }
@@ -58,6 +58,7 @@ namespace chaiscript
       {
       };
 
+
     /// Cast_Helper_Inner for casting to a const * type
     template<typename Result>
       struct Cast_Helper_Inner<const Result *>
@@ -65,21 +66,11 @@ namespace chaiscript
         typedef const Result * Result_Type;
         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 &(ob.get().cast<std::reference_wrapper<Result> >()).get();
-            } else {
-              return &(ob.get().cast<std::reference_wrapper<const Result> >()).get();
-            }
+            return static_cast<const Result *>(throw_if_null(ob.get_const_ptr()));
           } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return (ob.get().cast<std::shared_ptr<Result> >()).get();
-            } else {
-              return (ob.get().cast<std::shared_ptr<const Result> >()).get();
-            }
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -91,16 +82,17 @@ namespace chaiscript
         typedef Result * Result_Type;
         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() == typeid(Result))
           {
-            return &(ob.get().cast<std::reference_wrapper<Result> >()).get();
+            return static_cast<Result *>(throw_if_null(ob.get_ptr()));
           } else {
-            return (ob.get().cast<std::shared_ptr<Result> >()).get();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
 
 
+
     /// Cast_Helper_Inner for casting to a & type
     template<typename Result>
       struct Cast_Helper_Inner<Result &>
@@ -120,9 +112,9 @@ namespace chaiscript
 
     /// Cast_Helper_Inner for casting to a std::shared_ptr<> type
     template<typename Result>
-      struct Cast_Helper_Inner<typename std::shared_ptr<Result> >
+      struct Cast_Helper_Inner<std::shared_ptr<Result> >
       {
-        typedef typename std::shared_ptr<Result> Result_Type;
+        typedef std::shared_ptr<Result> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
@@ -132,9 +124,9 @@ namespace chaiscript
 
     /// 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> >
+      struct Cast_Helper_Inner<std::shared_ptr<const Result> >
       {
-        typedef typename std::shared_ptr<const Result> Result_Type;
+        typedef std::shared_ptr<const Result> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
@@ -158,7 +150,6 @@ namespace chaiscript
       {
       };
 
-
     /// 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> >
@@ -171,12 +162,11 @@ namespace chaiscript
       };
 
 
-
     /// Cast_Helper_Inner for casting to a Boxed_Value type
     template<>
       struct Cast_Helper_Inner<Boxed_Value>
       {
-        typedef const Boxed_Value & Result_Type;
+        typedef Boxed_Value Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
@@ -188,11 +178,11 @@ namespace chaiscript
     template<>
       struct Cast_Helper_Inner<Boxed_Value &>
       {
-        typedef Boxed_Value& Result_Type;
+        typedef std::reference_wrapper<Boxed_Value> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
-          return const_cast<Boxed_Value &>(ob);
+          return std::ref(const_cast<Boxed_Value &>(ob));
         }
       };
 

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -26,7 +26,7 @@ namespace chaiscript
 {
   namespace exception
   {
-    struct arithmetic_error : public std::runtime_error
+    struct arithmetic_error : std::runtime_error
     {
       arithmetic_error(const std::string& reason) : std::runtime_error("Arithmetic error: " + reason) {}
       arithmetic_error(const arithmetic_error &) = default;
@@ -43,7 +43,7 @@ namespace chaiscript
 // this is OK, so we're disabling size/and sign type warnings
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
-#pragma warning(disable : 4244 4018 4389 4146 4365)
+#pragma warning(disable : 4244 4018 4389 4146 4365 4267)
 #endif
 
 
@@ -59,8 +59,22 @@ namespace chaiscript
   class Boxed_Number
   {
     private:
+      enum class Common_Types {
+        t_int32,
+        t_double,
+        t_uint8,
+        t_int8,
+        t_uint16,
+        t_int16,
+        t_uint32,
+        t_uint64,
+        t_int64,
+        t_float,
+        t_long_double
+      };
+
       template<typename T>
-      static void check_divide_by_zero(T t, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
+      static inline void check_divide_by_zero(T t, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr)
       {
 #ifndef CHAISCRIPT_NO_PROTECT_DIVIDEBYZERO
         if (t == 0) {
@@ -70,292 +84,406 @@ namespace chaiscript
       }
 
       template<typename T>
-      static void check_divide_by_zero(T, typename std::enable_if<std::is_floating_point<T>::value>::type* = 0)
+      static inline void check_divide_by_zero(T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr)
       {
       }
 
-      struct boolean
+      static CHAISCRIPT_CONSTEXPR Common_Types get_common_type(size_t t_size, bool t_signed)
       {
+        return   (t_size == 1 && t_signed)?(Common_Types::t_int8)
+                :(t_size == 1)?(Common_Types::t_uint8)
+                :(t_size == 2 && t_signed)?(Common_Types::t_int16)
+                :(t_size == 2)?(Common_Types::t_uint16)
+                :(t_size == 4 && t_signed)?(Common_Types::t_int32)
+                :(t_size == 4)?(Common_Types::t_uint32)
+                :(t_size == 8 && t_signed)?(Common_Types::t_int64)
+                :(Common_Types::t_uint64);
+      }
 
-        template<typename T, typename U>
-        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &)
-        {
-          switch (t_oper)
-          {
-            case Operators::equals:
-              return const_var(t == u);
-            case Operators::less_than:
-              return const_var(t < u);
-            case Operators::greater_than:
-              return const_var(t > u);
-            case Operators::less_than_equal:
-              return const_var(t <= u);
-            case Operators::greater_than_equal:
-              return const_var(t >= u);
-            case Operators::not_equal:
-              return const_var(t != u);
-            default:
-              throw chaiscript::detail::exception::bad_any_cast();
-          }
+
+      static Common_Types get_common_type(const Boxed_Value &t_bv)
+      {
+        const Type_Info &inp_ = t_bv.get_type_info();
+
+        if (inp_ == typeid(int)) {
+          return get_common_type(sizeof(int), true);
+        } else if (inp_ == typeid(double)) {
+          return Common_Types::t_double;
+        } else if (inp_ == typeid(long double)) {
+          return Common_Types::t_long_double;
+        } else if (inp_ == typeid(float)) {
+          return Common_Types::t_float;
+        } else if (inp_ == typeid(char)) {
+          return get_common_type(sizeof(char), std::is_signed<char>::value);
+        } else if (inp_ == typeid(unsigned char)) {
+          return get_common_type(sizeof(unsigned char), false);
+        } else if (inp_ == typeid(unsigned int)) {
+          return get_common_type(sizeof(unsigned int), false);
+        } else if (inp_ == typeid(long)) {
+          return get_common_type(sizeof(long), true);
+        } else if (inp_ == typeid(long long)) {
+          return get_common_type(sizeof(long long), true);
+        } else if (inp_ == typeid(unsigned long)) {
+          return get_common_type(sizeof(unsigned long), false);
+        } else if (inp_ == typeid(unsigned long long)) {
+          return get_common_type(sizeof(unsigned long long), false);
+        } else if (inp_ == typeid(std::int8_t)) {
+          return Common_Types::t_int8;
+        } else if (inp_ == typeid(std::int16_t)) {
+          return Common_Types::t_int16;
+        } else if (inp_ == typeid(std::int32_t)) {
+          return Common_Types::t_int32;
+        } else if (inp_ == typeid(std::int64_t)) {
+          return Common_Types::t_int64;
+        } else if (inp_ == typeid(std::uint8_t)) {
+          return Common_Types::t_uint8;
+        } else if (inp_ == typeid(std::uint16_t)) {
+          return Common_Types::t_uint16;
+        } else if (inp_ == typeid(std::uint32_t)) {
+          return Common_Types::t_uint32;
+        } else if (inp_ == typeid(std::uint64_t)) {
+          return Common_Types::t_uint64;
+        } else if (inp_ == typeid(wchar_t)) {
+          return get_common_type(sizeof(wchar_t), std::is_signed<wchar_t>::value);
+        } else if (inp_ == typeid(char16_t)) {
+          return get_common_type(sizeof(char16_t), std::is_signed<char16_t>::value);
+        } else if (inp_ == typeid(char32_t)) {
+          return get_common_type(sizeof(char32_t), std::is_signed<char32_t>::value);
+        } else  {
+          throw chaiscript::detail::exception::bad_any_cast();
         }
-      };
+      }
 
-      struct binary 
+      template<typename T>
+      static Boxed_Value boolean_go(Operators::Opers t_oper, const T &t, const T &u)
       {
-        template<typename T, typename U>
-        static Boxed_Value go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
+        switch (t_oper)
         {
-          switch (t_oper)
-          {
-            case Operators::assign:
-              t = u;
-              break;
-            case Operators::pre_increment:
-              ++t;
-              break;
-            case Operators::pre_decrement:
-              --t;
-              break;
-            case Operators::assign_product:
-              t *= u;
-              break;
-            case Operators::assign_sum:
-              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();
-          }
-
-          return t_lhs;
-        }
-      };
-
-      struct binary_int
-      {
-        template<typename T, typename U>
-        static Boxed_Value go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
-        {
-          switch (t_oper)
-          {
-            case Operators::assign_bitwise_and:
-              t &= u;
-              break;
-            case Operators::assign_bitwise_or:
-              t |= u;
-              break;
-            case Operators::assign_shift_left:
-              t <<= u;
-              break;
-            case Operators::assign_shift_right:
-              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();
-          }
-          return t_lhs;
-        }
-      };
-
-      struct const_binary_int
-      {
-        template<typename T, typename U>
-        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &) 
-        {
-          switch (t_oper)
-          {
-            case Operators::shift_left:
-              return const_var(t << u);
-            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);
-            case Operators::bitwise_or:
-              return const_var(t | u);
-            case Operators::bitwise_xor:
-              return const_var(t ^ u);
-            case Operators::bitwise_complement:
-              return const_var(~t);
-            default:
-              throw chaiscript::detail::exception::bad_any_cast();
-          }
-        }
-      };
-
-      struct const_binary
-      {
-        template<typename T, typename U>
-        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &) 
-        {
-          switch (t_oper)
-          {
-            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);
-            case Operators::difference:
-              return const_var(t - u);
-            case Operators::unary_minus:
-              return const_var(-t);
-            case Operators::unary_plus:
-              return const_var(+t);
-            default:
-              throw chaiscript::detail::exception::bad_any_cast();
-          }
-        }
-      };
-
-      template<typename LHS, typename RHS, bool Float>
-      struct Go
-      {
-        static Boxed_Value go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
-        {
-          if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
-          {
-            return boolean::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
-            return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag && !t_lhs.is_const()) {
-            return binary_int::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
-            return const_binary_int::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else if (t_oper > Operators::const_flag) {
-            return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else {
+          case Operators::equals:
+            return const_var(t == u);
+          case Operators::less_than:
+            return const_var(t < u);
+          case Operators::greater_than:
+            return const_var(t > u);
+          case Operators::less_than_equal:
+            return const_var(t <= u);
+          case Operators::greater_than_equal:
+            return const_var(t >= u);
+          case Operators::not_equal:
+            return const_var(t != u);
+          default:
             throw chaiscript::detail::exception::bad_any_cast();
-          }
         }
-      };
+      }
+
+      template<typename T>
+      static Boxed_Value unary_go(Operators::Opers t_oper, T &t, const Boxed_Value &t_lhs) 
+      {
+        switch (t_oper)
+        {
+          case Operators::pre_increment:
+            ++t;
+            break;
+          case Operators::pre_decrement:
+            --t;
+            break;
+          default:
+            throw chaiscript::detail::exception::bad_any_cast();
+        }
+
+        return t_lhs;
+      }
+
+      template<typename T, typename U>
+      static Boxed_Value binary_go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
+      {
+        switch (t_oper)
+        {
+          case Operators::assign:
+            t = u;
+            break;
+          case Operators::assign_product:
+            t *= u;
+            break;
+          case Operators::assign_sum:
+            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();
+        }
+
+        return t_lhs;
+      }
+
+      template<typename T, typename U>
+      static Boxed_Value binary_int_go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
+      {
+        switch (t_oper)
+        {
+          case Operators::assign_bitwise_and:
+            t &= u;
+            break;
+          case Operators::assign_bitwise_or:
+            t |= u;
+            break;
+          case Operators::assign_shift_left:
+            t <<= u;
+            break;
+          case Operators::assign_shift_right:
+            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();
+        }
+        return t_lhs;
+      }
+
+      template<typename T>
+      static Boxed_Value const_unary_int_go(Operators::Opers t_oper, const T &t) 
+      {
+        switch (t_oper)
+        {
+          case Operators::bitwise_complement:
+            return const_var(~t);
+          default:
+            throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      template<typename T>
+      static Boxed_Value const_binary_int_go(Operators::Opers t_oper, const T &t, const T &u) 
+      {
+        switch (t_oper)
+        {
+          case Operators::shift_left:
+            return const_var(t << u);
+          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);
+          case Operators::bitwise_or:
+            return const_var(t | u);
+          case Operators::bitwise_xor:
+            return const_var(t ^ u);
+          default:
+            throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      template<typename T>
+      static Boxed_Value const_unary_go(Operators::Opers t_oper, const T &t)
+      {
+        switch (t_oper)
+        {
+          case Operators::unary_minus:
+            return const_var(-t);
+          case Operators::unary_plus:
+            return const_var(+t);
+          default:
+            throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      template<typename T>
+      static Boxed_Value const_binary_go(Operators::Opers t_oper, const T &t, const T &u) 
+      {
+        switch (t_oper)
+        {
+          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);
+          case Operators::difference:
+            return const_var(t - u);
+          default:
+            throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
 
       template<typename LHS, typename RHS>
-      struct Go<LHS, RHS, true>
+      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+          -> typename std::enable_if<!std::is_floating_point<LHS>::value && !std::is_floating_point<RHS>::value, Boxed_Value>::type
       {
-        static Boxed_Value go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        typedef typename std::common_type<LHS, RHS>::type common_type;
+        if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
         {
-          if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
-          {
-            return boolean::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
-            return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag) {
-            throw chaiscript::detail::exception::bad_any_cast();
-          } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
-            throw chaiscript::detail::exception::bad_any_cast();
-          } else if (t_oper > Operators::const_flag) {
-            return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
-          } else {
-            throw chaiscript::detail::exception::bad_any_cast();
-          }
+          return boolean_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
+        } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
+          return binary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), get_as_aux<common_type, RHS>(t_rhs), t_lhs);
+        } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
+          return binary_int_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), get_as_aux<common_type, RHS>(t_rhs), t_lhs);
+        } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
+          return const_binary_int_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
+        } else if (t_oper > Operators::const_flag) {
+          return const_binary_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
         }
-      };
+      }
 
-      template<typename LHS, bool Float>
-        static Boxed_Value oper_rhs(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+      template<typename LHS, typename RHS>
+      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs) 
+          -> typename std::enable_if<std::is_floating_point<LHS>::value || std::is_floating_point<RHS>::value, Boxed_Value>::type
+      {
+        typedef typename std::common_type<LHS, RHS>::type common_type;
+        if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
         {
-          const auto &inp_ = t_rhs.get_type_info();
+          return boolean_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
+        } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
+          return binary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), get_as_aux<common_type, RHS>(t_rhs), t_lhs);
+        } else if (t_oper > Operators::const_flag) {
+          return const_binary_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
 
-          if (inp_ == typeid(int)) {
-            return Go<LHS, int, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(double)) {
-            return Go<LHS, double, true>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(float)) {
-            return Go<LHS, float, true>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(long double)) {
-            return Go<LHS, long double, true>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(char)) {
-            return Go<LHS, char, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(unsigned int)) {
-            return Go<LHS, unsigned int, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(long)) {
-            return Go<LHS, long, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(unsigned long)) {
-            return Go<LHS, unsigned long, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int8_t)) {
-            return Go<LHS, std::int8_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int16_t)) {
-            return Go<LHS, std::int16_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int32_t)) {
-            return Go<LHS, std::int32_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int64_t)) {
-            return Go<LHS, std::int64_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint8_t)) {
-            return Go<LHS, std::uint8_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint16_t)) {
-            return Go<LHS, std::uint16_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint32_t)) {
-            return Go<LHS, std::uint32_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint64_t)) {
-            return Go<LHS, std::uint64_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else {
-            throw chaiscript::detail::exception::bad_any_cast();
-          }
-        } 
+      // Unary 
+      template<typename LHS>
+      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs)
+          -> typename std::enable_if<!std::is_floating_point<LHS>::value, Boxed_Value>::type
+      {
+        if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
+          return unary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), t_lhs);
+        } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
+          return const_unary_int_go(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()));
+        } else if (t_oper > Operators::const_flag) {
+          return const_unary_go(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()));
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
 
-        static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+      template<typename LHS>
+      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs) 
+          -> typename std::enable_if<std::is_floating_point<LHS>::value, Boxed_Value>::type
+      {
+        if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
+          return unary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), t_lhs);
+        } else if (t_oper > Operators::const_flag) {
+          return const_unary_go(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()));
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      template<typename LHS>
+        inline static Boxed_Value oper_rhs(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
         {
-          const Type_Info &inp_ = t_lhs.get_type_info();
-
-          if (inp_ == typeid(int)) {
-            return oper_rhs<int, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(double)) {
-            return oper_rhs<double, true>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(long double)) {
-            return oper_rhs<long double, true>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(float)) {
-            return oper_rhs<float, true>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(char)) {
-            return oper_rhs<char, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(unsigned int)) {
-            return oper_rhs<unsigned int, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(long)) {
-            return oper_rhs<long, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(unsigned long)) {
-            return oper_rhs<unsigned long, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int8_t)) {
-            return oper_rhs<std::int8_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int16_t)) {
-            return oper_rhs<std::int16_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int32_t)) {
-            return oper_rhs<std::int32_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::int64_t)) {
-            return oper_rhs<std::int64_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint8_t)) {
-            return oper_rhs<std::uint8_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint16_t)) {
-            return oper_rhs<std::uint16_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint32_t)) {
-            return oper_rhs<std::uint32_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(std::uint64_t)) {
-            return oper_rhs<std::uint64_t, false>(t_oper, t_lhs, t_rhs);
-          } else  {
-            throw chaiscript::detail::exception::bad_any_cast();
+          switch (get_common_type(t_rhs)) {
+            case Common_Types::t_int32:
+              return go<LHS, int32_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint8:
+              return go<LHS, uint8_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_int8:
+              return go<LHS, int8_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint16:
+              return go<LHS, uint16_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_int16:
+              return go<LHS, int16_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint32:
+              return go<LHS, uint32_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint64:
+              return go<LHS, uint64_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_int64:
+              return go<LHS, int64_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_double:
+              return go<LHS, double>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_float:
+              return go<LHS, float>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_long_double:
+              return go<LHS, long double>(t_oper, t_lhs, t_rhs);
           }
+
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+
+        inline static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs)
+        {
+          switch (get_common_type(t_lhs)) {
+            case Common_Types::t_int32:
+              return go<int32_t>(t_oper, t_lhs);
+            case Common_Types::t_uint8:
+              return go<uint8_t>(t_oper, t_lhs);
+            case Common_Types::t_int8:
+              return go<int8_t>(t_oper, t_lhs);
+            case Common_Types::t_uint16:
+              return go<uint16_t>(t_oper, t_lhs);
+            case Common_Types::t_int16:
+              return go<int16_t>(t_oper, t_lhs);
+            case Common_Types::t_uint32:
+              return go<uint32_t>(t_oper, t_lhs);
+            case Common_Types::t_uint64:
+              return go<uint64_t>(t_oper, t_lhs);
+            case Common_Types::t_int64:
+              return go<int64_t>(t_oper, t_lhs);
+            case Common_Types::t_double:
+              return go<double>(t_oper, t_lhs);
+            case Common_Types::t_float:
+              return go<float>(t_oper, t_lhs);
+            case Common_Types::t_long_double:
+              return go<long double>(t_oper, t_lhs);
+          }
+
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+
+
+        inline static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          switch (get_common_type(t_lhs)) {
+            case Common_Types::t_int32:
+              return oper_rhs<int32_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint8:
+              return oper_rhs<uint8_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_int8:
+              return oper_rhs<int8_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint16:
+              return oper_rhs<uint16_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_int16:
+              return oper_rhs<int16_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint32:
+              return oper_rhs<uint32_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_uint64:
+              return oper_rhs<uint64_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_int64:
+              return oper_rhs<int64_t>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_double:
+              return oper_rhs<double>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_float:
+              return oper_rhs<float>(t_oper, t_lhs, t_rhs);
+            case Common_Types::t_long_double:
+              return oper_rhs<long double>(t_oper, t_lhs, t_rhs);
+          }
+
+          throw chaiscript::detail::exception::bad_any_cast();
         }
 
         template<typename Target, typename Source>
-          Target get_as_aux() const
-        {
-          return static_cast<Target>(*static_cast<const Source *>(bv.get_const_ptr()));
-        }
+          static inline Target get_as_aux(const Boxed_Value &t_bv)
+          {
+            return static_cast<Target>(*static_cast<const Source *>(t_bv.get_const_ptr()));
+          }
 
         template<typename Source>
          static std::string to_string_aux(const Boxed_Value &v)
@@ -390,6 +518,21 @@ namespace chaiscript
         validate_boxed_number(bv);
       }
 
+      static bool is_floating_point(const Boxed_Value &t_bv)
+      {
+        const Type_Info &inp_ = t_bv.get_type_info();
+
+        if (inp_ == typeid(double)) {
+          return true;
+        } else if (inp_ == typeid(long double)) {
+          return true;
+        } else if (inp_ == typeid(float)) {
+          return true;
+        } else {
+          return false;
+        }
+      }
+
       Boxed_Number get_as(const Type_Info &inp_) const
       {
         if (inp_.bare_equal_type_info(typeid(int))) {
@@ -402,12 +545,24 @@ namespace chaiscript
           return Boxed_Number(get_as<long double>());
         } else if (inp_.bare_equal_type_info(typeid(char))) {
           return Boxed_Number(get_as<char>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned char))) {
+          return Boxed_Number(get_as<unsigned char>());
+        } else if (inp_.bare_equal_type_info(typeid(wchar_t))) {
+          return Boxed_Number(get_as<wchar_t>());
+        } else if (inp_.bare_equal_type_info(typeid(char16_t))) {
+          return Boxed_Number(get_as<char16_t>());
+        } else if (inp_.bare_equal_type_info(typeid(char32_t))) {
+          return Boxed_Number(get_as<char32_t>());
         } else if (inp_.bare_equal_type_info(typeid(unsigned int))) {
           return Boxed_Number(get_as<unsigned int>());
         } else if (inp_.bare_equal_type_info(typeid(long))) {
           return Boxed_Number(get_as<long>());
+        } else if (inp_.bare_equal_type_info(typeid(long long))) {
+          return Boxed_Number(get_as<long long>());
         } else if (inp_.bare_equal_type_info(typeid(unsigned long))) {
           return Boxed_Number(get_as<unsigned long>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned long long))) {
+          return Boxed_Number(get_as<unsigned long long>());
         } else if (inp_.bare_equal_type_info(typeid(int8_t))) {
           return Boxed_Number(get_as<int8_t>());
         } else if (inp_.bare_equal_type_info(typeid(int16_t))) {
@@ -432,84 +587,62 @@ namespace chaiscript
 
       template<typename Target> Target get_as() const
       {
-        const Type_Info &inp_ = bv.get_type_info();
-
-        if (inp_ == typeid(int)) {
-          return get_as_aux<Target, int>();
-        } else if (inp_ == typeid(double)) {
-          return get_as_aux<Target, double>();
-        } else if (inp_ == typeid(float)) {
-          return get_as_aux<Target, float>();
-        } else if (inp_ == typeid(long double)) {
-          return get_as_aux<Target, long double>();
-        } else if (inp_ == typeid(char)) {
-          return get_as_aux<Target, char>();
-        } else if (inp_ == typeid(unsigned int)) {
-          return get_as_aux<Target, unsigned int>();
-        } else if (inp_ == typeid(long)) {
-          return get_as_aux<Target, long>();
-        } else if (inp_ == typeid(unsigned long)) {
-          return get_as_aux<Target, unsigned long>();
-        } else if (inp_ == typeid(std::int8_t)) {
-          return get_as_aux<Target, std::int8_t>();
-        } else if (inp_ == typeid(std::int16_t)) {
-          return get_as_aux<Target, std::int16_t>();
-        } else if (inp_ == typeid(std::int32_t)) {
-          return get_as_aux<Target, std::int32_t>();
-        } else if (inp_ == typeid(std::int64_t)) {
-          return get_as_aux<Target, std::int64_t>();
-        } else if (inp_ == typeid(std::uint8_t)) {
-          return get_as_aux<Target, std::uint8_t>();
-        } else if (inp_ == typeid(std::uint16_t)) {
-          return get_as_aux<Target, std::uint16_t>();
-        } else if (inp_ == typeid(std::uint32_t)) {
-          return get_as_aux<Target, std::uint32_t>();
-        } else if (inp_ == typeid(std::uint64_t)) {
-          return get_as_aux<Target, std::uint64_t>();
-        } else {
-          throw chaiscript::detail::exception::bad_any_cast();
+        switch (get_common_type(bv)) {
+          case Common_Types::t_int32:
+            return get_as_aux<Target, int32_t>(bv);
+          case Common_Types::t_uint8:
+            return get_as_aux<Target, uint8_t>(bv);
+          case Common_Types::t_int8:
+            return get_as_aux<Target, int8_t>(bv);
+          case Common_Types::t_uint16:
+            return get_as_aux<Target, uint16_t>(bv);
+          case Common_Types::t_int16:
+            return get_as_aux<Target, int16_t>(bv);
+          case Common_Types::t_uint32:
+            return get_as_aux<Target, uint32_t>(bv);
+          case Common_Types::t_uint64:
+            return get_as_aux<Target, uint64_t>(bv);
+          case Common_Types::t_int64:
+            return get_as_aux<Target, int64_t>(bv);
+          case Common_Types::t_double:
+            return get_as_aux<Target, double>(bv);
+          case Common_Types::t_float:
+            return get_as_aux<Target, float>(bv);
+          case Common_Types::t_long_double:
+            return get_as_aux<Target, long double>(bv);
         }
+
+        throw chaiscript::detail::exception::bad_any_cast();
       }
 
       std::string to_string() const
       {
-        const Type_Info &inp_ = bv.get_type_info();
-
-        if (inp_ == typeid(int)) {
-          return to_string_aux<int>(bv);
-        } else if (inp_ == typeid(double)) {
-          return to_string_aux<double>(bv);
-        } else if (inp_ == typeid(float)) {
-          return to_string_aux<float>(bv);
-        } else if (inp_ == typeid(long double)) {
-          return to_string_aux<long double>(bv);
-        } else if (inp_ == typeid(char)) {
-          return to_string_aux<int>(Boxed_Value(get_as_aux<int, char>()));
-        } else if (inp_ == typeid(unsigned int)) {
-          return to_string_aux<unsigned int>(bv);
-        } else if (inp_ == typeid(long)) {
-          return to_string_aux<long>(bv);
-        } else if (inp_ == typeid(unsigned long)) {
-          return to_string_aux<unsigned long>(bv);
-        } else if (inp_ == typeid(std::int8_t)) {
-          return to_string_aux<int>(Boxed_Value(get_as_aux<int, std::int8_t>()));
-        } else if (inp_ == typeid(std::int16_t)) {
-          return to_string_aux<std::int16_t>(bv);
-        } else if (inp_ == typeid(std::int32_t)) {
-          return to_string_aux<std::int32_t>(bv);
-        } else if (inp_ == typeid(std::int64_t)) {
-          return to_string_aux<std::int64_t>(bv);
-        } else if (inp_ == typeid(std::uint8_t)) {
-          return to_string_aux<unsigned int>(Boxed_Value(get_as_aux<unsigned int, std::uint8_t>()));
-        } else if (inp_ == typeid(std::uint16_t)) {
-          return to_string_aux<std::uint16_t>(bv);
-        } else if (inp_ == typeid(std::uint32_t)) {
-          return to_string_aux<std::uint32_t>(bv);
-        } else if (inp_ == typeid(std::uint64_t)) {
-          return to_string_aux<std::uint64_t>(bv);
-        } else {
-          throw chaiscript::detail::exception::bad_any_cast();
+        switch (get_common_type(bv)) {
+          case Common_Types::t_int32:
+            return std::to_string(get_as<int32_t>());
+          case Common_Types::t_uint8:
+            return std::to_string(get_as<uint32_t>());
+          case Common_Types::t_int8:
+            return std::to_string(get_as<int32_t>());
+          case Common_Types::t_uint16:
+            return std::to_string(get_as<uint16_t>());
+          case Common_Types::t_int16:
+            return std::to_string(get_as<int16_t>());
+          case Common_Types::t_uint32:
+            return std::to_string(get_as<uint32_t>());
+          case Common_Types::t_uint64:
+            return std::to_string(get_as<uint64_t>());
+          case Common_Types::t_int64:
+            return std::to_string(get_as<int64_t>());
+          case Common_Types::t_double:
+            return to_string_aux<double>(bv);
+          case Common_Types::t_float:
+            return to_string_aux<float>(bv);
+          case Common_Types::t_long_double:
+            return to_string_aux<long double>(bv);
         }
+
+        throw chaiscript::detail::exception::bad_any_cast();
       }
 
       bool operator==(const Boxed_Number &t_rhs) const
@@ -544,12 +677,12 @@ namespace chaiscript
 
       Boxed_Number operator--()
       {
-        return oper(Operators::pre_decrement, this->bv, var(0));
+        return oper(Operators::pre_decrement, this->bv);
       }
 
       Boxed_Number operator++() 
       {
-        return oper(Operators::pre_increment, this->bv, var(0));
+        return oper(Operators::pre_increment, this->bv);
       }
 
       Boxed_Number operator+(const Boxed_Number &t_rhs) const
@@ -559,12 +692,12 @@ namespace chaiscript
 
       Boxed_Number operator+() const
       {
-        return oper(Operators::unary_plus, this->bv, Boxed_Value(0));
+        return oper(Operators::unary_plus, this->bv);
       }
 
       Boxed_Number operator-() const
       {
-        return oper(Operators::unary_minus, this->bv, Boxed_Value(0));
+        return oper(Operators::unary_minus, this->bv);
       }
 
       Boxed_Number operator-(const Boxed_Number &t_rhs) const
@@ -637,7 +770,7 @@ namespace chaiscript
 
       Boxed_Number operator~() const
       {
-        return oper(Operators::bitwise_complement, this->bv, Boxed_Value(0));
+        return oper(Operators::bitwise_complement, this->bv);
       }
 
       Boxed_Number operator^(const Boxed_Number &t_rhs) const
@@ -726,12 +859,12 @@ namespace chaiscript
 
       static Boxed_Number pre_decrement(Boxed_Number t_lhs)
       {
-        return oper(Operators::pre_decrement, t_lhs.bv, var(0));
+        return oper(Operators::pre_decrement, t_lhs.bv);
       }
 
       static Boxed_Number pre_increment(Boxed_Number t_lhs) 
       {
-        return oper(Operators::pre_increment, t_lhs.bv, var(0));
+        return oper(Operators::pre_increment, t_lhs.bv);
       }
 
       static const Boxed_Number sum(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
@@ -741,12 +874,12 @@ namespace chaiscript
 
       static const Boxed_Number unary_plus(const Boxed_Number &t_lhs) 
       {
-        return oper(Operators::unary_plus, t_lhs.bv, Boxed_Value(0));
+        return oper(Operators::unary_plus, t_lhs.bv);
       }
 
       static const Boxed_Number unary_minus(const Boxed_Number &t_lhs)
       {
-        return oper(Operators::unary_minus, t_lhs.bv, Boxed_Value(0));
+        return oper(Operators::unary_minus, t_lhs.bv);
       }
 
       static const Boxed_Number difference(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
@@ -862,7 +995,7 @@ namespace chaiscript
 
       static Boxed_Value do_oper(Operators::Opers t_oper, const Boxed_Value &t_lhs)
       {
-        return oper(t_oper, t_lhs, const_var(0));
+        return oper(t_oper, t_lhs);
       }
 
 

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -7,12 +7,10 @@
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
 #define CHAISCRIPT_BOXED_VALUE_HPP_
 
-#include <functional>
 #include <map>
 #include <memory>
 #include <type_traits>
 
-#include "../chaiscript_threading.hpp"
 #include "../chaiscript_defines.hpp"
 #include "any.hpp"
 #include "type_info.hpp"
@@ -38,9 +36,10 @@ namespace chaiscript
         Data(const Type_Info &ti,
             chaiscript::detail::Any to,
             bool tr,
-            const void *t_void_ptr)
+            const void *t_void_ptr,
+            bool t_return_value)
           : 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)
+            m_is_ref(tr), m_return_value(t_return_value)
         {
         }
 
@@ -51,10 +50,11 @@ namespace chaiscript
           m_is_ref = rhs.m_is_ref;
           m_data_ptr = rhs.m_data_ptr;
           m_const_data_ptr = rhs.m_const_data_ptr;
+          m_return_value = rhs.m_return_value;
 
           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));
+            m_attrs = std::unique_ptr<std::map<std::string, std::shared_ptr<Data>>>(new std::map<std::string, std::shared_ptr<Data>>(*rhs.m_attrs));
           }
 
           return *this;
@@ -72,78 +72,83 @@ namespace chaiscript
         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;
+        std::unique_ptr<std::map<std::string, std::shared_ptr<Data>>> m_attrs;
         bool m_is_ref;
+        bool m_return_value;
       };
 
       struct Object_Data
       {
-        static std::shared_ptr<Data> get(Boxed_Value::Void_Type)
+        static std::shared_ptr<Data> get(Boxed_Value::Void_Type, bool t_return_value)
         {
           return std::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
                 chaiscript::detail::Any(), 
                 false,
-                nullptr)
+                nullptr,
+                t_return_value)
               ;
         }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const std::shared_ptr<T> *obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> *obj, bool t_return_value)
           {
-            return get(*obj);
+            return get(*obj, t_return_value);
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const std::shared_ptr<T> &obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> &obj, bool t_return_value)
           {
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
                   chaiscript::detail::Any(obj), 
                   false,
-                  obj.get()
+                  obj.get(),
+                  t_return_value
                 );
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(std::shared_ptr<T> &&obj)
+          static std::shared_ptr<Data> get(std::shared_ptr<T> &&obj, bool t_return_value)
           {
             auto ptr = obj.get();
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
                   chaiscript::detail::Any(std::move(obj)), 
                   false,
-                  ptr
+                  ptr,
+                  t_return_value
                 );
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(T *t)
+          static std::shared_ptr<Data> get(T *t, bool t_return_value)
           {
-            return get(std::ref(*t));
+            return get(std::ref(*t), t_return_value);
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const T *t)
+          static std::shared_ptr<Data> get(const T *t, bool t_return_value)
           {
-            return get(std::cref(*t));
+            return get(std::cref(*t), t_return_value);
           }
 
 
         template<typename T>
-          static std::shared_ptr<Data> get(std::reference_wrapper<T> obj)
+          static std::shared_ptr<Data> get(std::reference_wrapper<T> obj, bool t_return_value)
           {
             auto p = &obj.get();
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
                   chaiscript::detail::Any(std::move(obj)),
                   true,
-                  p
+                  p,
+                  t_return_value
                 );
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(T t)
+          static std::shared_ptr<Data> get(T t, bool t_return_value)
           {
             auto p = std::make_shared<T>(std::move(t));
             auto ptr = p.get();
@@ -151,7 +156,8 @@ namespace chaiscript
                   detail::Get_Type_Info<T>::get(), 
                   chaiscript::detail::Any(std::move(p)),
                   false,
-                  ptr
+                  ptr,
+                  t_return_value
                 );
           }
 
@@ -161,7 +167,8 @@ namespace chaiscript
                 Type_Info(),
                 chaiscript::detail::Any(),
                 false,
-                nullptr 
+                nullptr,
+                false
               );
         }
 
@@ -171,8 +178,8 @@ namespace chaiscript
       /// Basic Boxed_Value constructor
         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)))
+        explicit Boxed_Value(T &&t, bool t_return_value = false)
+          : m_data(Object_Data::get(std::forward<T>(t), t_return_value))
         {
         }
 
@@ -239,6 +246,16 @@ namespace chaiscript
         return m_data->m_is_ref;
       }
 
+      bool is_return_value() const CHAISCRIPT_NOEXCEPT
+      {
+        return m_data->m_return_value;
+      }
+
+      void reset_return_value() const CHAISCRIPT_NOEXCEPT
+      {
+        m_data->m_return_value = false;
+      }
+
       bool is_pointer() const CHAISCRIPT_NOEXCEPT
       {
         return !is_ref();
@@ -258,21 +275,35 @@ namespace chaiscript
       {
         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>());
+          m_data->m_attrs = std::unique_ptr<std::map<std::string, std::shared_ptr<Data>>>(new std::map<std::string, std::shared_ptr<Data>>());
         }
 
-        return (*m_data->m_attrs)[t_name];
+        auto &attr = (*m_data->m_attrs)[t_name];
+        if (attr) {
+          return Boxed_Value(attr, Internal_Construction());
+        } else {
+          Boxed_Value bv; //default construct a new one
+          attr = bv.m_data;
+          return bv;
+        }
       }
 
       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));
+          m_data->m_attrs = std::unique_ptr<std::map<std::string, std::shared_ptr<Data>>>(new std::map<std::string, std::shared_ptr<Data>>(*t_obj.m_data->m_attrs));
         }
         return *this;
       }
 
+      Boxed_Value &clone_attrs(const Boxed_Value &t_obj)
+      {
+        copy_attrs(t_obj);
+        reset_return_value();
+        return *this;
+      }
+
 
       /// \returns true if the two Boxed_Values share the same internal type
       static bool type_match(const Boxed_Value &l, const Boxed_Value &r) CHAISCRIPT_NOEXCEPT
@@ -281,6 +312,13 @@ namespace chaiscript
       }
 
     private:
+      // necessary to avoid hitting the templated && constructor of Boxed_Value
+      struct Internal_Construction{};
+
+      Boxed_Value(const std::shared_ptr<Data> &t_data, Internal_Construction)
+        : m_data(t_data) {
+      }
+
       std::shared_ptr<Data> m_data;
   };
 
@@ -299,9 +337,9 @@ namespace chaiscript
   ///
   /// @sa @ref adding_objects
   template<typename T>
-    Boxed_Value var(T t)
+    Boxed_Value var(T &&t)
     {
-      return Boxed_Value(t);
+      return Boxed_Value(std::forward<T>(t));
     }
 
   namespace detail {
@@ -378,7 +416,18 @@ namespace chaiscript
       return detail::const_var_impl(t);
     }
 
+#ifdef CHAISCRIPT_HAS_MAGIC_STATICS
+  inline Boxed_Value const_var(bool b) {
+    static auto t = detail::const_var_impl(true);
+    static auto f = detail::const_var_impl(false);
 
+    if (b) {
+      return t;
+    } else {
+      return f;
+    }
+  }
+#endif
 
 }
 

include/chaiscript/dispatchkit/callable_traits.hpp

@@ -0,0 +1,107 @@
+// 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_CALLABLE_TRAITS_HPP_
+#define CHAISCRIPT_CALLABLE_TRAITS_HPP_
+
+#include <memory>
+
+namespace chaiscript {
+  namespace dispatch {
+    namespace detail {
+
+      template<typename Class, typename ... Param>
+      struct Constructor
+      {
+        template<typename ... Inner>
+        std::shared_ptr<Class> operator()(Inner&& ... inner) const {
+          return std::make_shared<Class>(std::forward<Inner>(inner)...);
+        }
+      };
+
+      template<typename Ret, typename Class, typename ... Param>
+      struct Const_Caller
+      {
+        Const_Caller(Ret (Class::*t_func)(Param...) const) : m_func(t_func) {}
+
+        template<typename ... Inner>
+        Ret operator()(const Class &o, Inner&& ... inner) const {
+          return (o.*m_func)(std::forward<Inner>(inner)...);
+        }
+
+        Ret (Class::*m_func)(Param...) const;
+      };
+
+      template<typename Ret, typename ... Param>
+      struct Fun_Caller
+      {
+        Fun_Caller(Ret( * t_func)(Param...) ) : m_func(t_func) {}
+
+        template<typename ... Inner>
+        Ret operator()(Inner&& ... inner) const {
+          return (m_func)(std::forward<Inner>(inner)...);
+        }
+
+        Ret(*m_func)(Param...);
+      };
+
+      template<typename Ret, typename Class, typename ... Param>
+      struct Caller
+      {
+        Caller(Ret (Class::*t_func)(Param...)) : m_func(t_func) {}
+
+        template<typename ... Inner>
+        Ret operator()(Class &o, Inner&& ... inner) const {
+          return (o.*m_func)(std::forward<Inner>(inner)...);
+        }
+
+        Ret (Class::*m_func)(Param...);
+      };
+
+      template<typename T>
+        struct Arity
+        {
+        };
+
+      template<typename Ret, typename ... Params>
+      struct Arity<Ret (Params...)>
+        {
+          static const size_t arity = sizeof...(Params);
+        };
+
+
+      template<typename T>
+        struct Function_Signature
+        {
+        };
+
+      template<typename Ret, typename ... Params>
+      struct Function_Signature<Ret (Params...)>
+        {
+          typedef Ret Return_Type;
+          typedef Ret (Signature)(Params...);
+        };
+
+      template<typename Ret, typename T, typename ... Params>
+      struct Function_Signature<Ret (T::*)(Params...) const>
+        {
+          typedef Ret Return_Type;
+          typedef Ret (Signature)(Params...);
+        };
+
+
+      template<typename T>
+        struct Callable_Traits
+        {
+          typedef typename Function_Signature<decltype(&T::operator())>::Signature Signature;
+          typedef typename Function_Signature<decltype(&T::operator())>::Return_Type Return_Type;
+        };
+    }
+  }
+}
+
+#endif
+

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -7,19 +7,11 @@
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 #define CHAISCRIPT_DYNAMIC_OBJECT_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 "type_info.hpp"
 
 namespace chaiscript {
 class Type_Conversions;
@@ -32,24 +24,88 @@ namespace chaiscript
 {
   namespace dispatch
   {
+    struct option_explicit_set : std::runtime_error {
+      option_explicit_set(const std::string &t_param_name)
+        : std::runtime_error("option explicit set and parameter '" + t_param_name + "' does not exist")
+      {
+
+      }
+
+      virtual ~option_explicit_set() CHAISCRIPT_NOEXCEPT {}
+    };
+
     class Dynamic_Object
     {
       public:
         Dynamic_Object(std::string t_type_name)
-          : m_type_name(std::move(t_type_name))
+          : m_type_name(std::move(t_type_name)), m_option_explicit(false)
         {
         }
 
+        Dynamic_Object() : m_type_name(""), m_option_explicit(false)
+        {
+        }
+
+        bool is_explicit() const
+        {
+          return m_option_explicit;
+        }
+
+        void set_explicit(const bool t_explicit)
+        {
+          m_option_explicit = t_explicit;
+        }
+
         std::string get_type_name() const
         {
           return m_type_name;
         }
 
-        Boxed_Value get_attr(const std::string &t_attr_name)
+        const Boxed_Value &operator[](const std::string &t_attr_name) const
+        {
+          return get_attr(t_attr_name);
+        }
+
+        Boxed_Value &operator[](const std::string &t_attr_name)
+        {
+          return get_attr(t_attr_name);
+        }
+
+        const Boxed_Value &get_attr(const std::string &t_attr_name) const
+        {
+          auto a = m_attrs.find(t_attr_name);
+
+          if (a != m_attrs.end()) {
+            return a->second;
+          } else {
+            throw std::range_error("Attr not found '" + t_attr_name + "' and cannot be added to const obj");
+          }
+        }
+
+        Boxed_Value &get_attr(const std::string &t_attr_name)
         {
           return m_attrs[t_attr_name];
         }
 
+        Boxed_Value &method_missing(const std::string &t_method_name)
+        {
+          if (m_option_explicit && m_attrs.find(t_method_name) == m_attrs.end()) {
+            throw option_explicit_set(t_method_name);
+          }
+
+          return get_attr(t_method_name);
+        }
+
+        const Boxed_Value &method_missing(const std::string &t_method_name) const
+        {
+          if (m_option_explicit && m_attrs.find(t_method_name) == m_attrs.end()) {
+            throw option_explicit_set(t_method_name);
+          }
+
+          return get_attr(t_method_name);
+        }
+
+
         std::map<std::string, Boxed_Value> get_attrs() const
         {
           return m_attrs;
@@ -57,6 +113,7 @@ namespace chaiscript
 
       private:
         std::string m_type_name;
+        bool m_option_explicit;
 
         std::map<std::string, Boxed_Value> m_attrs;
     };

include/chaiscript/dispatchkit/dynamic_object_detail.hpp

@@ -44,9 +44,11 @@ namespace chaiscript
         public:
           Dynamic_Object_Function(
               std::string t_type_name,
-              const Proxy_Function &t_func)
+              const Proxy_Function &t_func,
+              bool t_is_attribute = false)
             : 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>())
+              m_type_name(std::move(t_type_name)), m_func(t_func), m_doti(user_type<Dynamic_Object>()),
+              m_is_attribute(t_is_attribute)
           {
             assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
                 && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
@@ -55,9 +57,11 @@ namespace chaiscript
           Dynamic_Object_Function(
               std::string t_type_name,
               const Proxy_Function &t_func,
-              const Type_Info &t_ti)
+              const Type_Info &t_ti,
+              bool t_is_attribute = false)
             : 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>())
+              m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(t_ti.is_undef()?nullptr:new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>()),
+              m_is_attribute(t_is_attribute)
           {
             assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
                 && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
@@ -78,6 +82,8 @@ namespace chaiscript
             }
           }
 
+          virtual bool is_attribute_function() const CHAISCRIPT_OVERRIDE { return m_is_attribute; } 
+
           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))
@@ -164,6 +170,7 @@ namespace chaiscript
           Proxy_Function m_func;
           std::unique_ptr<Type_Info> m_ti;
           const Type_Info m_doti;
+          bool m_is_attribute;
 
 
       };
@@ -206,12 +213,7 @@ namespace chaiscript
           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;
-            }
+            return dc && dc->m_type_name == m_type_name && (*dc->m_func) == (*m_func);
           }
 
           virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
@@ -230,7 +232,7 @@ namespace chaiscript
         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));
+            auto bv = Boxed_Value(Dynamic_Object(m_type_name), true);
             std::vector<Boxed_Value> new_params{bv};
             new_params.insert(new_params.end(), params.begin(), params.end());
 

include/chaiscript/dispatchkit/function_call.hpp

@@ -8,13 +8,13 @@
 #define CHAISCRIPT_FUNCTION_CALL_HPP_
 
 #include <functional>
-#include <iostream>
 #include <string>
 #include <vector>
 
 #include "boxed_cast.hpp"
 #include "function_call_detail.hpp"
 #include "proxy_functions.hpp"
+#include "callable_traits.hpp"
 
 namespace chaiscript {
 class Boxed_Value;
@@ -38,6 +38,15 @@ namespace chaiscript
       std::function<FunctionType>
       functor(const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions *t_conversions)
       {
+        const bool has_arity_match = std::any_of(funcs.begin(), funcs.end(),
+            [](const Const_Proxy_Function &f) {
+              return f->get_arity() == -1 || size_t(f->get_arity()) == chaiscript::dispatch::detail::Arity<FunctionType>::arity;
+            });
+
+        if (!has_arity_match) {
+          throw exception::bad_boxed_cast(user_type<Const_Proxy_Function>(), typeid(std::function<FunctionType>));
+        }
+
         FunctionType *p=nullptr;
         return detail::build_function_caller_helper(p, funcs, t_conversions);
       }
@@ -57,7 +66,7 @@ namespace chaiscript
       std::function<FunctionType>
       functor(Const_Proxy_Function func, const Type_Conversions *t_conversions)
       {
-        return functor<FunctionType>(std::vector<Const_Proxy_Function>({func}), t_conversions);
+        return functor<FunctionType>(std::vector<Const_Proxy_Function>({std::move(func)}), t_conversions);
       }
 
     /// Helper for automatically unboxing a Boxed_Value that contains a function object

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -7,7 +7,6 @@
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 
-#include <algorithm>
 #include <functional>
 #include <memory>
 #include <string>
@@ -32,9 +31,9 @@ namespace chaiscript
         struct Function_Caller_Ret
         {
           static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params, const Type_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));
+            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, t_conversions?*t_conversions:Type_Conversions()), t_conversions);
           }
         };
 
@@ -45,9 +44,9 @@ 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 Type_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>();
+            return Boxed_Number(dispatch::dispatch(t_funcs, params, t_conversions?*t_conversions:Type_Conversions())).get_as<Ret>();
           }
         };
 
@@ -59,9 +58,9 @@ 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 Type_Conversions &t_conversions)
+              const std::vector<Boxed_Value> &params, const Type_Conversions *t_conversions)
           {
-            dispatch::dispatch(t_funcs, params, t_conversions);
+            dispatch::dispatch(t_funcs, params, t_conversions?*t_conversions:Type_Conversions());
           }
         };
 
@@ -71,31 +70,53 @@ namespace chaiscript
       template<typename Ret, typename ... Param>
         struct Build_Function_Caller_Helper
         {
-          Build_Function_Caller_Helper(std::vector<Const_Proxy_Function> t_funcs, const Type_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)
           {
           }
 
-          Ret operator()(Param...param)
+          template<typename ... P>
+          Ret operator()(P&&  ...  param)
           {
             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)... 
+                box<P>(std::forward<P>(param))...
                 }, m_conversions
 
                 );
 
           }
 
+          template<typename P, typename Q>
+          static auto box(Q&& q) -> typename std::enable_if<std::is_reference<P>::value&&!std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<P>::type>::type>::value, Boxed_Value>::type
+          {
+            return Boxed_Value(std::ref(std::forward<Q>(q)));
+          }
+
+          template<typename P, typename Q>
+          static auto box(Q&& q) -> typename std::enable_if<!std::is_reference<P>::value&&!std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<P>::type>::type>::value, Boxed_Value>::type
+          {
+            return Boxed_Value(std::forward<Q>(q));
+          }
+
+          template<typename P>
+          static Boxed_Value box(Boxed_Value bv)
+          {
+            return bv;
+          }
+
+
           std::vector<Const_Proxy_Function> m_funcs;
-          Type_Conversions m_conversions;
+          const Type_Conversions *m_conversions;
         };
 
 
 
+      /// \todo what happens if t_conversions is deleted out from under us?!
       template<typename Ret, typename ... Params>
         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)
           {
             std::shared_ptr<const Proxy_Function_Impl<Ret (Params...)>> pfi = 
@@ -109,8 +130,9 @@ namespace chaiscript
             // looks like this either wasn't a Proxy_Function_Impl or the types didn't match
             // 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:Type_Conversions()));
+          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions));
         }
     }
   }

include/chaiscript/dispatchkit/handle_return.hpp

@@ -9,13 +9,10 @@
 
 #include <functional>
 #include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
+#include <type_traits>
 
 #include "boxed_number.hpp"
 #include "boxed_value.hpp"
-#include "type_info.hpp"
 
 namespace chaiscript {
 class Boxed_Number;
@@ -25,6 +22,9 @@ namespace chaiscript
 {
   namespace dispatch
   {
+    template<class T, class U> class Proxy_Function_Callable_Impl;
+    template<class T> class Assignable_Proxy_Function_Impl;
+
     namespace detail
     {
       /**
@@ -33,14 +33,85 @@ namespace chaiscript
       template<typename Ret>
         struct Handle_Return
         {
-          static Boxed_Value handle(const Ret &r)
+          template<typename T,
+                   typename = typename std::enable_if<std::is_pod<typename std::decay<T>::type>::value>::type>
+          static Boxed_Value handle(T r)
           {
-            return const_var(r);
+            return Boxed_Value(std::move(r), true);
           }
 
-          static Boxed_Value handle(Ret &&r)
+          template<typename T,
+                   typename = typename std::enable_if<!std::is_pod<typename std::decay<T>::type>::value>::type>
+          static Boxed_Value handle(T &&r)
           {
-            return Boxed_Value(std::move(r));
+            return Boxed_Value(std::make_shared<T>(std::forward<T>(r)), true);
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const std::function<Ret> &>
+        {
+          static Boxed_Value handle(const std::function<Ret> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret, std::function<Ret>>>(f)
+              );
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::function<Ret>>
+        {
+          static Boxed_Value handle(const std::function<Ret> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret, std::function<Ret>>>(f)
+              );
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const std::shared_ptr<std::function<Ret>>>
+        {
+          static Boxed_Value handle(const std::shared_ptr<std::function<Ret>> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Assignable_Proxy_Function_Impl<Ret>>(std::ref(*f),f)
+                );
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const std::shared_ptr<std::function<Ret>> &>
+        {
+          static Boxed_Value handle(const std::shared_ptr<std::function<Ret>> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Assignable_Proxy_Function_Impl<Ret>>(std::ref(*f),f)
+              );
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::shared_ptr<std::function<Ret>>>
+        {
+          static Boxed_Value handle(const std::shared_ptr<std::function<Ret>> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Assignable_Proxy_Function_Impl<Ret>>(std::ref(*f),f)
+              );
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::function<Ret> &>
+        {
+          static Boxed_Value handle(std::function<Ret> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Assignable_Proxy_Function_Impl<Ret>>(std::ref(f),
+                  std::shared_ptr<std::function<Ret>>())
+              );
+          }
+
+          static Boxed_Value handle(const std::function<Ret> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret, std::function<Ret>>>(f)
+              );
           }
         };
 
@@ -49,7 +120,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(Ret *p)
           {
-            return Boxed_Value(p);
+            return Boxed_Value(p, true);
           }
         };
 
@@ -58,7 +129,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const Ret *p)
           {
-            return Boxed_Value(p);
+            return Boxed_Value(p, true);
           }
         };
 
@@ -67,7 +138,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
-            return Boxed_Value(r);
+            return Boxed_Value(r, true);
           }
         };
 
@@ -76,7 +147,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
-            return Boxed_Value(r);
+            return Boxed_Value(r, true);
           }
         };
 
@@ -85,7 +156,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
-            return Boxed_Value(r);
+            return Boxed_Value(r, true);
           }
         };
 
@@ -94,7 +165,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const Ret &r)
           {
-            return Boxed_Value(std::cref(r));
+            return Boxed_Value(std::cref(r), true);
           }
         };
 

include/chaiscript/dispatchkit/operators.hpp

@@ -229,231 +229,231 @@ namespace chaiscript
 
 
       template<typename T>
-        ModulePtr assign(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign<T &, const T&>), "=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_bitwise_and(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_bitwise_and(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_bitwise_and<T &, const T&>), "&=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_xor(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_xor(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_xor<T &, const T&>), "^=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_bitwise_or(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_bitwise_or(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_bitwise_or<T &, const T&>), "|=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_difference(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_difference(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_difference<T &, const T&>), "-=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_left_shift(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_left_shift(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_left_shift<T &, const T&>), "<<=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_product(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_product(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_product<T &, const T&>), "*=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_quotient(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_quotient(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_quotient<T &, const T&>), "/=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_remainder(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_remainder(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_remainder<T &, const T&>), "%=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_right_shift(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_right_shift(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_right_shift<T &, const T&>), ">>=");
           return m;
         }
 
       template<typename T>
-        ModulePtr assign_sum(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr assign_sum(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::assign_sum<T &, const T&>), "+=");
           return m;
         }
 
       template<typename T>
-        ModulePtr prefix_decrement(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr prefix_decrement(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::prefix_decrement<T &>), "--");
           return m;
         }
 
       template<typename T>
-        ModulePtr prefix_increment(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr prefix_increment(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::prefix_increment<T &>), "++");
           return m;
         }
 
       template<typename T>
-        ModulePtr equal(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr equal(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::equal<const T&, const T&>), "==");
           return m;
         }
 
       template<typename T>
-        ModulePtr greater_than(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr greater_than(ModulePtr m = std::make_shared<Module>())
         {
           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()))
+        ModulePtr greater_than_equal(ModulePtr m = std::make_shared<Module>())
         {
           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()))
+        ModulePtr less_than(ModulePtr m = std::make_shared<Module>())
         {
           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()))
+        ModulePtr less_than_equal(ModulePtr m = std::make_shared<Module>())
         {
           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()))
+        ModulePtr logical_compliment(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::logical_compliment<const T &>), "!");
           return m;
         }
 
       template<typename T>
-        ModulePtr not_equal(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr not_equal(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::not_equal<const T &, const T &>), "!=");
           return m;
         }
 
       template<typename T>
-        ModulePtr addition(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr addition(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::addition<const T &, const T &>), "+");
           return m;
         }
 
       template<typename T>
-        ModulePtr unary_plus(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr unary_plus(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::unary_plus<const T &>), "+");
           return m;
         }
 
       template<typename T>
-        ModulePtr subtraction(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr subtraction(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::subtraction<const T &, const T &>), "-");
           return m;
         }
 
       template<typename T>
-        ModulePtr unary_minus(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr unary_minus(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::unary_minus<const T &>), "-");
           return m;
         }
 
       template<typename T>
-        ModulePtr bitwise_and(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr bitwise_and(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::bitwise_and<const T &, const T &>), "&");
           return m;
         }
 
       template<typename T>
-        ModulePtr bitwise_compliment(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr bitwise_compliment(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::bitwise_compliment<const T &>), "~");
           return m;
         }
 
       template<typename T>
-        ModulePtr bitwise_xor(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr bitwise_xor(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::bitwise_xor<const T &, const T &>), "^");
           return m;
         }
 
       template<typename T>
-        ModulePtr bitwise_or(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr bitwise_or(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::bitwise_or<const T &, const T &>), "|");
           return m;
         }
 
       template<typename T>
-        ModulePtr division(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr division(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::division<const T &, const T &>), "/");
           return m;
         }
 
       template<typename T>
-        ModulePtr left_shift(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr left_shift(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::left_shift<const T &, const T &>), "<<");
           return m;
         }
 
       template<typename T>
-        ModulePtr multiplication(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr multiplication(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::multiplication<const T &, const T &>), "*");
           return m;
         }
 
       template<typename T>
-        ModulePtr remainder(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr remainder(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::remainder<const T &, const T &>), "%");
           return m;
         }
 
       template<typename T>
-        ModulePtr right_shift(ModulePtr m = ModulePtr(new Module()))
+        ModulePtr right_shift(ModulePtr m = std::make_shared<Module>())
         {
           m->add(chaiscript::fun(&detail::right_shift<const T &, const T &>), ">>");
           return m;

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -16,21 +16,14 @@ namespace chaiscript
   {
     namespace detail
     {
-      /**
-       * A constructor function, used for creating a new object
-       * of a given type with a given set of params
-       */
-      template<typename Class, typename ... Params>
-        std::shared_ptr<Class> constructor_(Params ... params)
-        {
-          return std::make_shared<Class>(params...);
-        }
 
       template<typename Class, typename ... Params  >
         Proxy_Function build_constructor_(Class (*)(Params...))
         {
-          typedef std::shared_ptr<Class> (sig)(Params...);
-          return Proxy_Function(new Proxy_Function_Impl<sig>(std::function<sig>(&(constructor_<Class, Params...>))));
+          auto call = dispatch::detail::Constructor<Class, Params...>();
+
+          return Proxy_Function(
+            chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<std::shared_ptr<Class> (Params...), decltype(call)>>(call));
         }
     }
   }

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -9,7 +9,6 @@
 #define CHAISCRIPT_PROXY_FUNCTIONS_HPP_
 
 
-#include <algorithm>
 #include <cassert>
 #include <functional>
 #include <memory>
@@ -17,10 +16,10 @@
 #include <string>
 #include <type_traits>
 #include <vector>
+#include <iterator>
 
 #include "../chaiscript_defines.hpp"
 #include "boxed_cast.hpp"
-#include "boxed_cast_helper.hpp"
 #include "boxed_value.hpp"
 #include "proxy_functions_detail.hpp"
 #include "type_info.hpp"
@@ -43,6 +42,9 @@ namespace chaiscript
 
   namespace dispatch
   {
+    template<typename FunctionType>
+      std::function<FunctionType> functor(std::shared_ptr<const Proxy_Function_Base> func, const Type_Conversions *t_conversions);
+
     class Param_Types
     {
       public:
@@ -147,8 +149,11 @@ namespace chaiscript
 
         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;
+          if (m_arity < 0 || size_t(m_arity) == params.size()) {
+            return do_call(params, t_conversions);
+          } else {
+            throw exception::arity_error(static_cast<int>(params.size()), m_arity);
+          }
         }
 
         /// Returns a vector containing all of the types of the parameters the function returns/takes
@@ -160,6 +165,8 @@ namespace chaiscript
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
         virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const = 0;
 
+        virtual bool is_attribute_function() const { return false; }
+
         bool has_arithmetic_param() const 
         {
           return m_has_arithmetic_param;
@@ -177,12 +184,14 @@ namespace chaiscript
           if (m_arity < 0)
           {
             return true;
-          } else if (size_t(m_arity) == vals.size()) {
+          } else if (static_cast<size_t>(m_arity) == vals.size()) {
             if (m_arity == 0)
             {
               return true;
+            } else if (m_arity > 1) {
+              return compare_type_to_param(m_types[1], vals[0], t_conversions) && compare_type_to_param(m_types[2], vals[1], t_conversions);
             } else {
-              return compare_first_type(vals[0], t_conversions);
+              return compare_type_to_param(m_types[1], vals[0], t_conversions);
             }
           } else {
             return false;
@@ -202,7 +211,7 @@ namespace chaiscript
           if (ti.is_undef() 
               || ti.bare_equal(user_type<Boxed_Value>())
               || (!bv.get_type_info().is_undef()
-                && (ti.bare_equal(user_type<Boxed_Number>())
+                && ( (ti.bare_equal(user_type<Boxed_Number>()) && bv.get_type_info().is_arithmetic())
                   || ti.bare_equal(bv.get_type_info())
                   || bv.get_type_info().bare_equal(user_type<std::shared_ptr<const Proxy_Function_Base> >())
                   || t_conversions.converts(ti, bv.get_type_info()) 
@@ -215,6 +224,12 @@ namespace chaiscript
             return false;
           }
         }
+
+        virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions &t_conversions) const
+        {
+          return compare_type_to_param(m_types[1], bv, t_conversions);
+        }
+
       protected:
         virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const = 0;
 
@@ -232,33 +247,17 @@ namespace chaiscript
 
         }
 
-        virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions &t_conversions) const
-        {
-          const std::vector<Type_Info> &types = get_param_types();
 
-          if (types.size() < 2)
-          {
-            return true;
-          }
-
-          const Type_Info &ti = types[1];
-          return compare_type_to_param(ti, bv, t_conversions);
-
-        }
-
-        static bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs)
+        static bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs, const Type_Conversions &t_conversions)
         {
           if (tis.size() - 1 != bvs.size())
           {
             return false;
           } else {
-            size_t size = bvs.size();
+            const size_t size = bvs.size();
             for (size_t i = 0; i < size; ++i)
             {
-              if (!(tis[i+1].bare_equal(bvs[i].get_type_info()) && tis[i+1].is_const() >= bvs[i].get_type_info().is_const() ))
-              {
-                return false;
-              }
+              if (!compare_type_to_param(tis[i + 1], bvs[i], t_conversions)) { return false;  }
             }
           }
           return true;
@@ -304,7 +303,6 @@ namespace chaiscript
     {
       public:
         Dynamic_Proxy_Function(
-            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(),
@@ -312,8 +310,7 @@ namespace chaiscript
             Proxy_Function t_guard = Proxy_Function())
           : 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))
+            m_guard(std::move(t_guard)), m_parsenode(std::move(t_parsenode)), m_description(std::move(t_description))
         {
         }
 
@@ -352,24 +349,8 @@ namespace chaiscript
           return m_description;
         }
 
+
       protected:
-        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 (call_match(params, t_conversions) && test_guard(params, t_conversions))
-            {
-              return m_f(params);
-            } else {
-              throw exception::guard_error();
-            }
-
-          } else {
-            throw exception::arity_error(static_cast<int>(params.size()), m_arity);
-          } 
-        }
-
-      private:
         bool test_guard(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const
         {
           if (m_guard)
@@ -386,12 +367,11 @@ namespace chaiscript
           }
         }
 
+      private:
         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());
+          std::vector<Type_Info> types{chaiscript::detail::Get_Type_Info<Boxed_Value>::get()};
 
           for (const auto &t : t_types.types())
           {
@@ -409,23 +389,68 @@ namespace chaiscript
         Proxy_Function m_guard;
         AST_NodePtr m_parsenode;
         std::string m_description;
-        std::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
     };
 
-    /**
-     * An object used by Bound_Function to represent "_" parameters
-     * of a binding. This allows for unbound parameters during bind.
-     */
+
+
+    template<typename Callable>
+    class Dynamic_Proxy_Function_Impl : public Dynamic_Proxy_Function
+    {
+      public:
+        Dynamic_Proxy_Function_Impl(
+            Callable 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())
+          : Dynamic_Proxy_Function(
+                t_arity,
+                std::move(t_parsenode),
+                std::move(t_param_types),
+                std::move(t_description),
+                std::move(t_guard)
+              ),
+            m_f(std::move(t_f))
+        {
+        }
+
+        virtual ~Dynamic_Proxy_Function_Impl() {}
+
+
+      protected:
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        {
+          if (call_match(params, t_conversions) && test_guard(params, t_conversions))
+          {
+            return m_f(params);
+          } else {
+            throw exception::guard_error();
+          }
+        }
+
+      private:
+
+        Callable m_f;
+    };
+
+    template<typename Callable, typename ... Arg>
+    Proxy_Function make_dynamic_proxy_function(Callable &&c, Arg&& ... a)
+    {
+      return chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Dynamic_Proxy_Function_Impl<Callable>>(
+          std::forward<Callable>(c), std::forward<Arg>(a)...);
+    }
+
+    /// An object used by Bound_Function to represent "_" parameters
+    /// of a binding. This allows for unbound parameters during bind.
     struct Placeholder_Object
     {
     };
 
-    /**
-     * An implementation of Proxy_Function that takes a Proxy_Function
-     * and substitutes bound parameters into the parameter list
-     * at runtime, when call() is executed.
-     * it is used for bind(function, param1, _, param2) style calls
-     */
+    /// An implementation of Proxy_Function that takes a Proxy_Function
+    /// and substitutes bound parameters into the parameter list
+    /// at runtime, when call() is executed.
+    /// it is used for bind(function, param1, _, param2) style calls
     class Bound_Function : public Proxy_Function_Base
     {
       public:
@@ -451,9 +476,7 @@ namespace chaiscript
 
         virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
         {
-          std::vector<Const_Proxy_Function> fs;
-          fs.push_back(m_f);
-          return fs;
+          return std::vector<Const_Proxy_Function>{m_f};
         }
 
 
@@ -504,9 +527,17 @@ namespace chaiscript
           std::vector<Type_Info> types = t_f->get_param_types();
           assert(types.size() == t_args.size() + 1);
 
-          std::vector<Type_Info> retval;
-          retval.push_back(types[0]);
-          for (size_t i = 0; i < types.size()-1; ++i)
+#ifdef CHAISCRIPT_MSVC_12
+#pragma warning(push)
+#pragma warning(disable : 6011)
+#endif
+          // this analysis warning is invalid in MSVC12 and doesn't exist in MSVC14
+          std::vector<Type_Info> retval{types[0]};
+#ifdef CHAISCRIPT_MSVC_12
+#pragma warning(pop)
+#endif
+
+          for (size_t i = 0; i < types.size() - 1; ++i)
           {
             if (t_args[i].get_type_info() == chaiscript::detail::Get_Type_Info<Placeholder_Object>::get())
             {
@@ -544,63 +575,110 @@ namespace chaiscript
 
         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);
+          return static_cast<int>(vals.size()) == get_arity() && (compare_types(m_types, vals, t_conversions) && 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;
     };
 
-    /**
-     * The standard typesafe function call implementation of Proxy_Function
-     * It takes a std::function<> object and performs runtime 
-     * type checking of Boxed_Value parameters, in a type safe manner
-     */
-    template<typename Func>
-      class Proxy_Function_Impl : public Proxy_Function_Impl_Base
+
+
+    /// For any callable object
+    template<typename Func, typename Callable>
+      class Proxy_Function_Callable_Impl : public Proxy_Function_Impl_Base
     {
       public:
-        Proxy_Function_Impl(std::function<Func> f)
+        Proxy_Function_Callable_Impl(Callable f)
           : Proxy_Function_Impl_Base(detail::build_param_type_list(static_cast<Func *>(nullptr))),
-            m_f(std::move(f)), m_dummy_func(nullptr)
+            m_f(std::move(f))
         {
         }
 
-        virtual ~Proxy_Function_Impl() {}
+        virtual ~Proxy_Function_Callable_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);
+          return detail::compare_types_cast(static_cast<Func *>(nullptr), vals, t_conversions);
         }
 
         virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
         {
-          return dynamic_cast<const Proxy_Function_Impl<Func> *>(&t_func) != nullptr;
+          return dynamic_cast<const Proxy_Function_Callable_Impl<Func, Callable> *>(&t_func) != nullptr;
+        }
+
+
+      protected:
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        {
+          typedef typename detail::Function_Signature<Func>::Return_Type Return_Type;
+          return detail::Do_Call<Return_Type>::template go<Func>(m_f, params, t_conversions);
+        }
+
+      private:
+        Callable m_f;
+    };
+
+
+    class Assignable_Proxy_Function : public Proxy_Function_Impl_Base
+    {
+      public:
+        Assignable_Proxy_Function(const std::vector<Type_Info> &t_types)
+          : Proxy_Function_Impl_Base(t_types)
+        {
+        }
+
+        virtual ~Assignable_Proxy_Function() {}
+
+
+        virtual void assign(const std::shared_ptr<const Proxy_Function_Base> &t_rhs)  = 0;
+
+
+    };
+
+    template<typename Func>
+      class Assignable_Proxy_Function_Impl : public Assignable_Proxy_Function
+    {
+      public:
+        Assignable_Proxy_Function_Impl(std::reference_wrapper<std::function<Func>> t_f, std::shared_ptr<std::function<Func>> t_ptr)
+          : Assignable_Proxy_Function(detail::build_param_type_list(static_cast<Func *>(nullptr))),
+            m_f(std::move(t_f)), m_shared_ptr_holder(std::move(t_ptr))
+        {
+          assert(!m_shared_ptr_holder || m_shared_ptr_holder.get() == &m_f.get());
+        }
+
+        virtual ~Assignable_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(static_cast<Func *>(nullptr), vals, t_conversions);
+        }
+
+        virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
+        {
+          return dynamic_cast<const Assignable_Proxy_Function_Impl<Func> *>(&t_func) != nullptr;
         }
 
         std::function<Func> internal_function() const
         {
-          return m_f;
+          return m_f.get();
+        }
+
+        virtual void assign(const std::shared_ptr<const Proxy_Function_Base> &t_rhs) CHAISCRIPT_OVERRIDE {
+          m_f.get() = dispatch::functor<Func>(t_rhs, nullptr);
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
-          return detail::Do_Call<typename std::function<Func>::result_type>::go(m_f, params, t_conversions);
+          return detail::Do_Call<typename std::function<Func>::result_type>::template go<Func>(m_f.get(), params, t_conversions);
         }
 
-      private:
-        std::function<Func> m_f;
-        Func *m_dummy_func;
-    };
 
-    /**
-     * Attribute getter Proxy_Function implementation
-     */
+      private:
+        std::reference_wrapper<std::function<Func>> m_f;
+        std::shared_ptr<std::function<Func>> m_shared_ptr_holder;
+    };
+    /// Attribute getter Proxy_Function implementation
     template<typename T, typename Class>
       class Attribute_Access : public Proxy_Function_Base
     {
@@ -613,6 +691,8 @@ namespace chaiscript
 
         virtual ~Attribute_Access() {}
 
+        virtual bool is_attribute_function() const CHAISCRIPT_OVERRIDE { return true; } 
+
         virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
         {
           const Attribute_Access<T, Class> * aa 
@@ -643,19 +723,14 @@ namespace chaiscript
       protected:
         virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
-          if (params.size() == 1)
+          const Boxed_Value &bv = params[0];
+          if (bv.is_const())
           {
-            const Boxed_Value &bv = params[0];
-            if (bv.is_const())
-            {
-              const Class *o = boxed_cast<const Class *>(bv, &t_conversions);
-              return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
-            } else {
-              Class *o = boxed_cast<Class *>(bv, &t_conversions);
-              return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
-            }
+            const Class *o = boxed_cast<const Class *>(bv, &t_conversions);
+            return detail::Handle_Return<const typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
           } else {
-            throw exception::arity_error(static_cast<int>(params.size()), 1);
+            Class *o = boxed_cast<Class *>(bv, &t_conversions);
+            return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
           }
         }
 
@@ -685,6 +760,14 @@ namespace chaiscript
         {
         }
 
+        dispatch_error(std::vector<Boxed_Value> t_parameters, 
+            std::vector<Const_Proxy_Function> t_functions,
+            const std::string &t_desc)
+          : std::runtime_error(t_desc), parameters(std::move(t_parameters)), functions(std::move(t_functions))
+        {
+        }
+
+
         dispatch_error(const dispatch_error &) = default;
         virtual ~dispatch_error() CHAISCRIPT_NOEXCEPT {}
 
@@ -701,48 +784,47 @@ namespace chaiscript
         bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
             const Type_Conversions &t_conversions)
         {
-          if (t_func->get_arity() != static_cast<int>(plist.size()))
-          {
-            return false;
-          }
-
           const std::vector<Type_Info> &types = t_func->get_param_types();
 
+          if (t_func->get_arity() == -1) return false;
+
           assert(plist.size() == types.size() - 1);
 
-          for (size_t i = 0; i < plist.size(); ++i)
-          {
-            if (Proxy_Function_Base::compare_type_to_param(types[i+1], plist[i], t_conversions)
-                || (types[i+1].is_arithmetic() && plist[i].get_type_info().is_arithmetic()))
-            {
-              // types continue to match
-            } else {
-              return false;
-            }
-          }
-
-          // all types match
-          return true;
+          return std::mismatch(plist.begin(), plist.end(),
+                               types.begin()+1,
+                               [&](const Boxed_Value &bv, const Type_Info &ti) {
+                                 return Proxy_Function_Base::compare_type_to_param(ti, bv, t_conversions)
+                                       || (bv.get_type_info().is_arithmetic() && ti.is_arithmetic());
+                               }
+              ) == std::make_pair(plist.end(), types.end());
         }
 
-      template<typename InItr>
+      template<typename InItr, typename Funcs>
         Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist, 
-            const Type_Conversions &t_conversions)
+            const Type_Conversions &t_conversions, const Funcs &t_funcs)
         {
-          InItr orig(begin);
-
           InItr matching_func(end);
 
           while (begin != end)
           {
-            if (types_match_except_for_arithmetic(*begin, plist, t_conversions))
+            if (types_match_except_for_arithmetic(begin->second, plist, t_conversions))
             {
               if (matching_func == end)
               {
                 matching_func = begin;
               } else {
-                // More than one function matches, not attempting
-                throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+                // handle const members vs non-const member, which is not really ambiguous
+                const auto &mat_fun_param_types = matching_func->second->get_param_types();
+                const auto &next_fun_param_types = begin->second->get_param_types();
+
+                if (plist[0].is_const() && !mat_fun_param_types[1].is_const() && next_fun_param_types[1].is_const()) {
+                  matching_func = begin; // keep the new one, the const/non-const matchup is correct
+                } else if (!plist[0].is_const() && !mat_fun_param_types[1].is_const() && next_fun_param_types[1].is_const()) {
+                  // keep the old one, it has a better const/non-const matchup
+                } else {
+                  // ambiguous function call
+                  throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(t_funcs.begin(), t_funcs.end()));
+                }
               }
             }
 
@@ -752,25 +834,30 @@ namespace chaiscript
           if (matching_func == end)
           {
             // no appropriate function to attempt arithmetic type conversion on
-            throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+            throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(t_funcs.begin(), t_funcs.end()));
           }
 
 
           std::vector<Boxed_Value> newplist;
-          const std::vector<Type_Info> &tis = (*matching_func)->get_param_types();
+          newplist.reserve(plist.size());
+
+          const std::vector<Type_Info> &tis = matching_func->second->get_param_types();
+          std::transform(tis.begin() + 1, tis.end(),
+                         plist.begin(),
+                         std::back_inserter(newplist),
+                         [](const Type_Info &ti, const Boxed_Value &param) -> Boxed_Value {
+                           if (ti.is_arithmetic() && param.get_type_info().is_arithmetic()) {
+                             return Boxed_Number(param).get_as(ti).bv;
+                           } else {
+                             return param;
+                           }
+                         }
+                       );
+
 
-          for (size_t i = 0; i < plist.size(); ++i)
-          {
-            if (tis[i+1].is_arithmetic()
-                && plist[i].get_type_info().is_arithmetic()) {
-              newplist.push_back(Boxed_Number(plist[i]).get_as(tis[i+1]).bv);
-            } else {
-              newplist.push_back(plist[i]);
-            }
-          }
 
           try {
-            return (*(*matching_func))(newplist, t_conversions);
+            return (*(matching_func->second))(newplist, t_conversions);
           } catch (const exception::bad_boxed_cast &) {
             //parameter failed to cast
           } catch (const exception::arity_error &) {
@@ -779,7 +866,7 @@ namespace chaiscript
             //guard failed to allow the function to execute
           }
 
-          throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+          throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(t_funcs.begin(), t_funcs.end()));
 
         }
     }
@@ -793,18 +880,18 @@ namespace chaiscript
       Boxed_Value dispatch(const Funcs &funcs,
           const std::vector<Boxed_Value> &plist, const Type_Conversions &t_conversions)
       {
-
-        std::multimap<size_t, const Proxy_Function_Base *> ordered_funcs;
+        std::vector<std::pair<size_t, const Proxy_Function_Base *>> ordered_funcs;
+        ordered_funcs.reserve(funcs.size());
 
         for (const auto &func : funcs)
         {
-          size_t numdiffs = 0;
           const auto arity = func->get_arity();
 
           if (arity == -1)
           {
-            numdiffs = plist.size();
+            ordered_funcs.emplace_back(plist.size(), func.get());
           } else if (arity == static_cast<int>(plist.size())) {
+            size_t numdiffs = 0;
             for (size_t i = 0; i < plist.size(); ++i)
             {
               if (!func->get_param_types()[i+1].bare_equal(plist[i].get_type_info()))
@@ -812,31 +899,32 @@ namespace chaiscript
                 ++numdiffs;
               }
             }
-          } else {
-            continue;
+            ordered_funcs.emplace_back(numdiffs, func.get());
           }
-
-          ordered_funcs.insert(std::make_pair(numdiffs, func.get()));
         }
 
-        for (const auto &func : ordered_funcs )
+
+        for (size_t i = 0; i <= plist.size(); ++i)
         {
-          try {
-            if (func.second->filter(plist, t_conversions))
-            {
-              return (*(func.second))(plist, t_conversions);
+          for (const auto &func : ordered_funcs )
+          {
+            try {
+              if (func.first == i && func.second->filter(plist, t_conversions))
+              {
+                return (*(func.second))(plist, t_conversions);
+              }
+            } catch (const exception::bad_boxed_cast &) {
+              //parameter failed to cast, try again
+            } catch (const exception::arity_error &) {
+              //invalid num params, try again
+            } catch (const exception::guard_error &) {
+              //guard failed to allow the function to execute,
+              //try again
             }
-          } catch (const exception::bad_boxed_cast &) {
-            //parameter failed to cast, try again
-          } catch (const exception::arity_error &) {
-            //invalid num params, try again
-          } catch (const exception::guard_error &) {
-            //guard failed to allow the function to execute,
-            //try again
           }
         }
 
-        return detail::dispatch_with_conversions(funcs.cbegin(), funcs.cend(), plist, t_conversions);
+        return detail::dispatch_with_conversions(ordered_funcs.cbegin(), ordered_funcs.cend(), plist, t_conversions, funcs);
       }
   }
 }

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -7,10 +7,8 @@
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
-#include <algorithm>
 #include <functional>
 #include <stdexcept>
-#include <string>
 #include <vector>
 
 #include "../chaiscript_defines.hpp"
@@ -18,6 +16,7 @@
 #include "boxed_value.hpp"
 #include "handle_return.hpp"
 #include "type_info.hpp"
+#include "callable_traits.hpp"
 
 namespace chaiscript {
 class Type_Conversions;
@@ -67,6 +66,10 @@ namespace chaiscript
         }
 
 
+#ifdef CHAISCRIPT_GCC_4_6 
+      /// \todo REMOVE THIS WHEN WE DROP G++4.6
+
+
       // Forward declaration
       template<typename ... Rest> 
         struct Try_Cast; 
@@ -99,7 +102,7 @@ namespace chaiscript
       template<typename Ret, typename ... Params>
         bool compare_types_cast(Ret (*)(Params...),
              const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
-       {
+        {
           try {
             Try_Cast<Params...>::do_try(params, 0, t_conversions);
           } catch (const exception::bad_boxed_cast &) {
@@ -113,8 +116,8 @@ namespace chaiscript
         struct Call_Func
         {
 
-          template<typename ... InnerParams>
-          static Ret do_call(const std::function<Ret (Params...)> &f,
+          template<typename Callable, typename ... InnerParams>
+          static Ret do_call(const Callable &f,
               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]);
@@ -128,8 +131,8 @@ namespace chaiscript
 #pragma warning(push)
 #pragma warning(disable : 4100) /// Disable unreferenced formal parameter warning, which only shows up in MSVC I don't think there's any way around it \todo evaluate this
 #endif
-          template<typename ... InnerParams>
-            static Ret do_call(const std::function<Ret (Params...)> &f,
+          template<typename Callable, typename ... InnerParams>
+            static Ret do_call(const Callable &f,
                 const std::vector<Boxed_Value> &, const Type_Conversions &t_conversions, InnerParams &&... innerparams)
             {
               return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams), &t_conversions)...);
@@ -145,8 +148,8 @@ namespace chaiscript
        * 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,
+      template<typename Callable, typename Ret, typename ... Params>
+        Ret call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &, const Callable &f,
             const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
         {
           if (params.size() == sizeof...(Params))
@@ -157,6 +160,82 @@ namespace chaiscript
           throw exception::arity_error(static_cast<int>(params.size()), sizeof...(Params));
         }
 
+
+
+#else
+
+      template<size_t ... I>
+      struct Indexes
+      {
+      };
+
+      template<size_t S, size_t ... I> 
+      struct Make_Indexes
+      {
+        typedef typename Make_Indexes<S-1, I..., sizeof...(I)>::indexes indexes;
+      };
+
+      template<size_t ... I>
+      struct Make_Indexes<0, I...>
+      {
+        typedef Indexes<I...> indexes;
+      };
+
+
+
+      /**
+       * Used by Proxy_Function_Impl to determine if it is equivalent to another
+       * 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, size_t ... I>
+        bool compare_types_cast(Indexes<I...>, Ret (*)(Params...),
+             const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
+        {
+          try {
+            (void)params; (void)t_conversions;
+            (void)std::initializer_list<int>{(boxed_cast<Params>(params[I], &t_conversions), 0)...};
+            return true;
+          } catch (const exception::bad_boxed_cast &) {
+            return false;
+          }
+
+        }
+
+      template<typename Ret, typename ... Params>
+        bool compare_types_cast(Ret (*f)(Params...),
+             const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
+        {
+          typedef typename Make_Indexes<sizeof...(Params)>::indexes indexes;
+          return compare_types_cast(indexes(), f, params, t_conversions);
+        }
+
+
+      template<typename Callable, typename Ret, typename ... Params, size_t ... I>
+        Ret call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &, Indexes<I...>, const Callable &f,
+            const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
+        {
+          (void)params; (void)t_conversions;
+          return f(boxed_cast<Params>(params[I], &t_conversions)...);
+        }
+
+
+      /**
+       * Used by Proxy_Function_Impl to perform typesafe execution of a function.
+       * 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 Callable, typename Ret, typename ... Params>
+        Ret call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &sig, const Callable &f,
+            const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
+        {
+          typedef typename Make_Indexes<sizeof...(Params)>::indexes indexes;
+          return call_func(sig, indexes(), f, params, t_conversions);
+        }
+
+#endif
+
     }
   }
 
@@ -172,20 +251,20 @@ namespace chaiscript
     template<typename Ret>
       struct Do_Call
       {
-        template<typename Fun>
-          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
+        template<typename Signature, typename Callable>
+          static Boxed_Value go(const Callable &fun, const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
           {
-            return Handle_Return<Ret>::handle(call_func(fun, params, t_conversions));
+            return Handle_Return<Ret>::handle(call_func(Function_Signature<Signature>(), fun, params, t_conversions));
           }
       };
 
     template<>
       struct Do_Call<void>
       {
-        template<typename Fun>
-          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
+        template<typename Signature, typename Callable>
+          static Boxed_Value go(const Callable &fun, const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
           {
-            call_func(fun, params, t_conversions);
+            call_func(Function_Signature<Signature>(), fun, params, t_conversions);
             return Handle_Return<void>::handle();
           }
       };

include/chaiscript/dispatchkit/register_function.hpp

@@ -7,75 +7,13 @@
 #ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_
 #define CHAISCRIPT_REGISTER_FUNCTION_HPP_
 
-#include <functional>
 #include <type_traits>
 
 #include "bind_first.hpp"
-#include "dispatchkit.hpp"
 #include "proxy_functions.hpp"
 
 namespace chaiscript
 {
-  namespace dispatch
-  {
-    namespace detail
-    {
-      template<typename T>
-        struct FunctionSignature
-        {
-        };
-
-      template<typename Sig>
-        struct FunctionSignature<std::function<Sig> >
-        {
-          typedef Sig Signature;
-        };
-
-      template<typename Ret, typename ... Args> 
-        std::function<Ret (Args...) > to_function(Ret (*func)(Args...))
-        {
-          return std::function<Ret (Args...)>(func);
-        }
-
-      template<typename Ret, typename Class, typename ... Args> 
-        std::function<Ret (Class &, Args...) > to_function(Ret (Class::*func)(Args...))
-        {
-          /// \todo this std::mem_fn wrap shouldn't be necessary but type conversions for 
-          ///       std::function for member function pointers seems to be broken in MSVC
-          return std::function<Ret(Class &, Args...)>(std::mem_fn(func));
-        }
-
-      template<typename Ret, typename Class, typename ... Args> 
-        std::function<Ret (const Class &, Args...) > to_function(Ret (Class::*func)(Args...) const)
-        {
-          /// \todo this std::mem_fn wrap shouldn't be necessary but type conversions for 
-          ///       std::function for member function pointers seems to be broken in MSVC
-          return std::function<Ret (const Class &, Args...)>(std::mem_fn(func));
-        }
-
-      template<bool Object>
-        struct Fun_Helper
-        {
-          template<typename T>
-            static Proxy_Function go(T t)
-            {
-              /// \todo is it possible to reduce the number of templates generated here?
-              return Proxy_Function(
-                  new Proxy_Function_Impl<typename FunctionSignature<decltype(to_function(t)) >::Signature>(to_function(t)));
-            }      
-        };
-
-      template<>
-        struct Fun_Helper<true>
-        {
-          template<typename T, typename Class>
-            static Proxy_Function go(T Class::* m)
-            {
-              return Proxy_Function(new Attribute_Access<T, Class>(m));
-            }
-        };
-    }
-  }
 
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member
   /// \param[in] t Function / member to expose
@@ -98,29 +36,52 @@ namespace chaiscript
   /// 
   /// \sa \ref adding_functions
   template<typename T>
-    Proxy_Function fun(T t)
+    Proxy_Function fun(const T &t)
     {
-      return dispatch::detail::Fun_Helper<std::is_member_object_pointer<T>::value>::go(t);
+      typedef typename dispatch::detail::Callable_Traits<T>::Signature Signature;
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Signature, T>>(t));
+    }
+
+  template<typename Ret, typename ... Param>
+    Proxy_Function fun(Ret (*func)(Param...))
+    {
+      auto fun_call = dispatch::detail::Fun_Caller<Ret, Param...>(func);
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Param...), decltype(fun_call)>>(fun_call));
+
+    }
+
+  template<typename Ret, typename Class, typename ... Param>
+    Proxy_Function fun(Ret (Class::*t_func)(Param...) const)
+    {
+      auto call = dispatch::detail::Const_Caller<Ret, Class, Param...>(t_func);
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (const Class &, Param...), decltype(call)>>(call));
+    }
+
+  template<typename Ret, typename Class, typename ... Param>
+    Proxy_Function fun(Ret (Class::*t_func)(Param...))
+    {
+      auto call = dispatch::detail::Caller<Ret, Class, Param...>(t_func);
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Class &, Param...), decltype(call)>>(call));
+
     }
 
 
-  /// \brief Creates a new Proxy_Function object from a std::function object
-  /// \param[in] f std::function to expose to ChaiScript
-  ///
-  /// \b Example:
-  /// \code
-  /// std::function<int (char, float, std::string)> f = get_some_function();
-  /// chaiscript::ChaiScript chai;
-  /// chai.add(fun(f), "some_function");
-  /// \endcode
-  /// 
-  /// \sa \ref adding_functions
-  template<typename T>
-    Proxy_Function fun(const std::function<T> &f)
+  template<typename T, typename Class /*, typename = typename std::enable_if<std::is_member_object_pointer<T>::value>::type*/>
+    Proxy_Function fun(T Class::* m /*, typename std::enable_if<std::is_member_object_pointer<T>::value>::type* = 0*/ )
     {
-      return Proxy_Function(new dispatch::Proxy_Function_Impl<T>(f));
+      return Proxy_Function(chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Attribute_Access<T, Class>>(m));
     }
 
+
+
   
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member and binds the first parameter of it
   /// \param[in] t Function / member to expose
@@ -141,9 +102,9 @@ namespace chaiscript
   /// 
   /// \sa \ref adding_functions
   template<typename T, typename Q>
-    Proxy_Function fun(T t, const Q &q)
+    Proxy_Function fun(T &&t, const Q &q)
     {
-      return fun(detail::bind_first(t, q));
+      return fun(detail::bind_first(std::forward<T>(t), q));
     }
 
   /// \brief Creates a new Proxy_Function object from a free function or member function and binds the first and second parameters of it
@@ -167,11 +128,11 @@ namespace chaiscript
   /// 
   /// \sa \ref adding_functions
   template<typename T, typename Q, typename R>
-    Proxy_Function fun(T t, const Q &q, const R &r)
+    Proxy_Function fun(T &&t, Q &&q, R &&r)
     {
-      return fun(detail::bind_first(detail::bind_first(t, q), r));
+      return fun(detail::bind_first(detail::bind_first(std::forward<T>(t), std::forward<Q>(q)), std::forward<R>(r)));
     }
-   
+
 }
 
 

include/chaiscript/dispatchkit/type_conversions.hpp

@@ -92,13 +92,19 @@ namespace chaiscript
           return m_from;
         }
 
+        virtual bool bidir() const
+        {
+          return true;
+        }
+
+        virtual ~Type_Conversion_Base() {}
+
       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;
@@ -106,6 +112,62 @@ namespace chaiscript
 
     };
 
+    template<typename From, typename To> 
+      class Static_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())
+                {
+                  return Boxed_Value(
+                      [&]()->std::shared_ptr<const To>{
+                        if (auto data = std::static_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr)))
+                        {
+                          return data;
+                        } else {
+                          throw std::bad_cast();
+                        }
+                      }()
+                      );
+                } else {
+                  return Boxed_Value(
+                      [&]()->std::shared_ptr<To>{
+                        if (auto data = std::static_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr)))
+                        {
+                          return data;
+                        } else {
+                          throw std::bad_cast();
+                        }
+                      }()
+                      );
+                }
+              } 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 = static_cast<const To &>(d);
+                  return Boxed_Value(std::cref(data));
+                } else {
+                  From &d = detail::Cast_Helper<From &>::cast(t_from, nullptr);
+                  To &data = static_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 From, typename To> 
       class Dynamic_Caster
       {
@@ -119,24 +181,36 @@ namespace chaiscript
                 // 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);
+                  return Boxed_Value(
+                      [&]()->std::shared_ptr<const To>{
+                        if (auto data = std::dynamic_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr)))
+                        {
+                          return data;
+                        } else {
+                          throw std::bad_cast();
+                        }
+                      }()
+                      );
                 } 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);
+                  return Boxed_Value(
+                      [&]()->std::shared_ptr<To>{
+                        if (auto data = std::dynamic_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr)))
+                        {
+                          return data;
+                        } else {
+#ifdef CHAISCRIPT_LIBCPP
+                          /// \todo fix this someday after libc++ is fixed.
+                          if (std::string(typeid(To).name()).find("Assignable_Proxy_Function") != std::string::npos) {
+                            auto from = detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr);
+                            if (std::string(typeid(*from).name()).find("Assignable_Proxy_Function_Impl") != std::string::npos) {
+                              return std::static_pointer_cast<To>(from);
+                            }
+                          }
+#endif
+                          throw std::bad_cast();
+                        }
+                      }()
+                      );
                 }
               } else {
                 // Pull the reference out of the contained boxed value, which we know is the type we want
@@ -155,8 +229,10 @@ namespace chaiscript
               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
     {
@@ -173,10 +249,36 @@ namespace chaiscript
 
         virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
         {
-          return Dynamic_Caster<Derived, Base>::cast(t_derived);
+          return Static_Caster<Derived, Base>::cast(t_derived);
         }
     };
 
+    template<typename Base, typename Derived>
+      class Static_Conversion_Impl : public Type_Conversion_Base
+    {
+      public:
+        Static_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
+        {
+          throw chaiscript::exception::bad_boxed_dynamic_cast(t_base.get_type_info(), typeid(Derived), "Unable to cast down inheritance hierarchy with non-polymorphic types");
+        }
+
+        virtual bool bidir() const CHAISCRIPT_OVERRIDE
+        {
+          return false;
+        }
+
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
+        {
+          return Static_Caster<Derived, Base>::cast(t_derived);
+        }
+    };
+
+
 
     template<typename Callable>
     class Type_Conversion_Impl : public Type_Conversion_Base
@@ -199,6 +301,12 @@ namespace chaiscript
           return m_func(t_from);
         }
 
+        virtual bool bidir() const CHAISCRIPT_OVERRIDE
+        {
+          return false;
+        }
+
+
       private:
         Callable m_func;
     };
@@ -229,7 +337,7 @@ namespace chaiscript
       Type_Conversions(const Type_Conversions &t_other)
         : m_mutex(),
           m_conversions(t_other.get_conversions()),
-          m_convertableTypes(),
+          m_convertableTypes(t_other.m_convertableTypes),
           m_num_types(m_conversions.size()),
           m_thread_cache(this),
           m_conversion_saves(this)
@@ -275,7 +383,7 @@ namespace chaiscript
         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);
+          return has_conversion(to, from);
         } else {
           return false;
         }
@@ -325,7 +433,7 @@ namespace chaiscript
       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();
+        return find_bidir(to, from) != m_conversions.end();
       }
 
       std::shared_ptr<detail::Type_Conversion_Base> get_conversion(const Type_Info &to, const Type_Info &from) const
@@ -343,6 +451,19 @@ namespace chaiscript
       }
 
     private:
+      std::set<std::shared_ptr<detail::Type_Conversion_Base> >::const_iterator find_bidir(
+          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) -> bool
+              {
+                return  (conversion->to().bare_equal(to) && conversion->from().bare_equal(from))
+                     || (conversion->bidir() && conversion->from().bare_equal(to) && conversion->to().bare_equal(from));
+;
+              }
+        );
+      }
+
       std::set<std::shared_ptr<detail::Type_Conversion_Base> >::const_iterator find(
           const Type_Info &to, const Type_Info &from) const
       {
@@ -404,22 +525,31 @@ namespace chaiscript
   /// \endcode
   /// 
   template<typename Base, typename Derived>
-  Type_Conversion base_class()
+  Type_Conversion base_class(typename std::enable_if<std::is_polymorphic<Base>::value && std::is_polymorphic<Derived>::value>::type* = nullptr)
   {
     //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>>();
+    return chaiscript::make_shared<detail::Type_Conversion_Base, detail::Dynamic_Conversion_Impl<Base, Derived>>();
   }
 
+  template<typename Base, typename Derived>
+  Type_Conversion base_class(typename std::enable_if<!std::is_polymorphic<Base>::value || !std::is_polymorphic<Derived>::value>::type* = nullptr)
+  {
+    //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");
+
+    return chaiscript::make_shared<detail::Type_Conversion_Base, detail::Static_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);
+      return chaiscript::make_shared<detail::Type_Conversion_Base, detail::Type_Conversion_Impl<Callable>>(t_from, t_to, t_func);
     }
 
   template<typename From, typename To, typename Callable>
@@ -430,7 +560,7 @@ namespace chaiscript
             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);
+      return chaiscript::make_shared<detail::Type_Conversion_Base, detail::Type_Conversion_Impl<decltype(func)>>(user_type<From>(), user_type<To>(), func);
     }
 
   template<typename From, typename To>
@@ -439,12 +569,28 @@ namespace chaiscript
       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 chaiscript::Boxed_Value(To(detail::Cast_Helper<From>::cast(t_bv, nullptr)));
           };
 
-      return std::make_shared<detail::Type_Conversion_Impl<decltype(func)>>(user_type<From>(), user_type<To>(), func);
+      return chaiscript::make_shared<detail::Type_Conversion_Base, detail::Type_Conversion_Impl<decltype(func)>>(user_type<From>(), user_type<To>(), func);
+    }
+
+  template<typename To>
+    Type_Conversion vector_conversion()
+    {
+      auto func = [](const Boxed_Value &t_bv) -> Boxed_Value {
+        const std::vector<Boxed_Value> &from_vec = detail::Cast_Helper<const std::vector<Boxed_Value> &>::cast(t_bv, nullptr);
+
+        To vec;
+
+        for (const Boxed_Value &bv : from_vec) {
+          vec.push_back(detail::Cast_Helper<typename To::value_type>::cast(bv, nullptr));
+        }
+
+        return Boxed_Value(std::move(vec));
+      };
+
+      return chaiscript::make_shared<detail::Type_Conversion_Base, detail::Type_Conversion_Impl<decltype(func)>>(user_type<std::vector<Boxed_Value>>(), user_type<To>(), func);
     }
 
 }

include/chaiscript/dispatchkit/type_info.hpp

@@ -7,11 +7,10 @@
 #ifndef CHAISCRIPT_TYPE_INFO_HPP_
 #define CHAISCRIPT_TYPE_INFO_HPP_
 
-#include <functional>
 #include <memory>
-#include <string>
 #include <type_traits>
 #include <typeinfo>
+#include <string>
 
 namespace chaiscript
 {
@@ -31,8 +30,8 @@ namespace chaiscript
   {
     public:
       CHAISCRIPT_CONSTEXPR Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
-          bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
-        : m_type_info(t_ti), m_bare_type_info(t_bareti),
+          bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bare_ti)
+        : m_type_info(t_ti), m_bare_type_info(t_bare_ti),
         m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
         m_is_void(t_is_void), m_is_arithmetic(t_is_arithmetic),
         m_is_undef(false)
@@ -63,7 +62,7 @@ namespace chaiscript
 
       CHAISCRIPT_CONSTEXPR bool operator==(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
-        return ti.m_type_info == m_type_info 
+        return ti.m_type_info == m_type_info
           || (ti.m_type_info && m_type_info && *ti.m_type_info == *m_type_info);
       }
 
@@ -88,7 +87,7 @@ namespace chaiscript
       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_undef() const CHAISCRIPT_NOEXCEPT { return m_is_undef; }
       CHAISCRIPT_CONSTEXPR bool is_pointer() const CHAISCRIPT_NOEXCEPT { return m_is_pointer; }
 
       std::string name() const
@@ -101,7 +100,7 @@ namespace chaiscript
         }
       }
 
-      std::string bare_name() const 
+      std::string bare_name() const
       {
         if (m_bare_type_info)
         {
@@ -129,20 +128,20 @@ namespace chaiscript
 
   namespace detail
   {
-    /**
-     * Helper used to create a Type_Info object
-     */
+    /// Helper used to create a Type_Info object
     template<typename T>
       struct Get_Type_Info
       {
         typedef T type;
 
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static Type_Info get()
         {
-          return Type_Info(std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+          return Type_Info(std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value, 
+              std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
-              &typeid(T), 
+              (std::is_arithmetic<T>::value || std::is_arithmetic<typename std::remove_reference<T>::type>::value)
+                && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
+              &typeid(T),
               &typeid(typename Bare_Type<T>::type));
         }
       };
@@ -152,11 +151,11 @@ namespace chaiscript
       {
         typedef T type;
 
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
               &typeid(std::shared_ptr<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -167,11 +166,11 @@ namespace chaiscript
       {
         typedef T type;
 
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
               &typeid(const std::shared_ptr<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -182,11 +181,11 @@ namespace chaiscript
       {
         typedef T type;
 
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
               &typeid(std::reference_wrapper<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -197,11 +196,11 @@ namespace chaiscript
       {
         typedef T type;
 
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
               &typeid(const std::reference_wrapper<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -219,7 +218,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type(i);
   /// \endcode
   template<typename T>
-  CHAISCRIPT_CONSTEXPR Type_Info user_type(const T &/*t*/)
+   Type_Info user_type(const T &/*t*/)
   {
     return detail::Get_Type_Info<T>::get();
   }
@@ -234,7 +233,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
   /// \endcode
   template<typename T>
-  CHAISCRIPT_CONSTEXPR Type_Info user_type()
+   Type_Info user_type()
   {
     return detail::Get_Type_Info<T>::get();
   }

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -9,8 +9,6 @@
 
 #include <string>
 
-#include "../dispatchkit/dispatchkit.hpp"
-
 namespace chaiscript
 {
 

include/chaiscript/language/chaiscript_common.hpp

@@ -26,6 +26,7 @@ struct AST_Node;
 
 namespace chaiscript
 {
+
   /// Signature of module entry point that all binary loadable modules must implement.
   typedef ModulePtr (*Create_Module_Func)();
 
@@ -33,11 +34,11 @@ namespace chaiscript
   /// Types of AST nodes available to the parser and eval
   class AST_Node_Type {
   public:
-    enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
+    enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Arg_List, Variable, Equation, Var_Decl,
                 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, Class, Binary, Arg
+                Logical_And, Logical_Or, Reference, Switch, Case, Default, Ternary_Cond, Noop, Class, Binary, Arg, Global_Decl
     };
   };
 
@@ -46,7 +47,7 @@ namespace chaiscript
 
     /// Helper lookup to get the name of each node type
     const char *ast_node_type_to_string(int ast_node_type) {
-      const char *ast_node_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Inplace_Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
+      const char *ast_node_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
                                     "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", 
@@ -67,6 +68,31 @@ namespace chaiscript
     File_Position() : line(0), column(0) { }
   };
 
+  struct Parse_Location {
+    Parse_Location(std::string t_fname="", const int t_start_line=0, const int t_start_col=0,
+        const int t_end_line=0, const int t_end_col=0)
+      : start(t_start_line, t_start_col), 
+        end(t_end_line, t_end_col),
+        filename(std::make_shared<std::string>(std::move(t_fname)))
+    {
+    }
+
+    Parse_Location(std::shared_ptr<std::string> t_fname, const int t_start_line=0, const int t_start_col=0,
+        const int t_end_line=0, const int t_end_col=0)
+      : start(t_start_line, t_start_col), 
+        end(t_end_line, t_end_col),
+        filename(std::move(t_fname))
+    {
+    }
+
+
+
+    File_Position start;
+    File_Position end;
+    std::shared_ptr<std::string> filename;
+  };
+
+
   /// \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;
@@ -77,10 +103,9 @@ namespace chaiscript
   {
 
     /// Errors generated during parsing or evaluation
-    struct eval_error : public std::runtime_error {
+    struct eval_error : std::runtime_error {
       std::string reason;
       File_Position start_position;
-      File_Position end_position;
       std::string filename;
       std::string detail;
       std::vector<AST_NodePtr_Const> call_stack;
@@ -90,7 +115,7 @@ namespace chaiscript
           bool t_dot_notation,
           const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_NOEXCEPT :
         std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_dot_notation, t_ss)),
-        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss)) 
+        reason(t_why), start_position(t_where), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss)) 
       {}
 
       eval_error(const std::string &t_why, 
@@ -104,7 +129,7 @@ namespace chaiscript
 
       eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) CHAISCRIPT_NOEXCEPT :
         std::runtime_error(format(t_why, t_where, t_fname)),
-        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
+        reason(t_why), start_position(t_where), filename(t_fname)
       {}
 
       eval_error(const std::string &t_why) CHAISCRIPT_NOEXCEPT
@@ -153,16 +178,16 @@ namespace chaiscript
         }
 
       template<typename T>
-        static std::string fname(const T& t)
+        static const std::string &fname(const T& t)
         {
-          return *t->filename;
+          return t->filename();
         }
 
       template<typename T>
         static std::string startpos(const T& t)
         {
           std::ostringstream oss;
-          oss << t->start.line << ", " << t->start.column;
+          oss << t->start().line << ", " << t->start().column;
           return oss.str();
         }
 
@@ -229,8 +254,7 @@ namespace chaiscript
 
           if (f)
           {
-            std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfunguard 
-              = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(f);
+            auto dynfunguard = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(f);
             if (dynfunguard)
             {
               retval += " : " + format_guard(dynfunguard->get_parse_tree());
@@ -252,10 +276,13 @@ namespace chaiscript
       template<typename T>
         static std::string format_location(const T &t)
         {
-          std::ostringstream oss;
-          oss << "(" << *t->filename << " " << t->start.line << ", " << t->start.column << ")"; 
-
-          return oss.str();
+          if (t) {
+            std::ostringstream oss;
+            oss << "(" << t->filename() << " " << t->start().line << ", " << t->start().column << ")"; 
+            return oss.str();
+          } else {
+            return "(internal)";
+          }
 
         }
 
@@ -392,7 +419,7 @@ namespace chaiscript
 
 
     /// Errors generated when loading a file
-    struct file_not_found_error : public std::runtime_error {
+    struct file_not_found_error : std::runtime_error {
       file_not_found_error(const std::string &t_filename) CHAISCRIPT_NOEXCEPT
         : std::runtime_error("File Not Found: " + t_filename)
       { }
@@ -407,13 +434,24 @@ namespace chaiscript
   /// \brief Struct that doubles as both a parser ast_node and an AST node.
   struct AST_Node : std::enable_shared_from_this<AST_Node> {
     public:
-      const std::string text;
       const int identifier; //< \todo shouldn't this be a strongly typed enum value?
-      std::shared_ptr<const std::string> filename;
-      File_Position start, end;
+      const std::string text;
+      Parse_Location location;
       std::vector<AST_NodePtr> children;
       AST_NodePtr annotation;
 
+      const std::string &filename() const {
+        return *location.filename;
+      }
+
+      const File_Position &start() const {
+        return location.start;
+      }
+
+      const File_Position &end() const {
+        return location.end;
+      }
+
       virtual std::string pretty_print() const
       {
         std::ostringstream oss;
@@ -433,15 +471,15 @@ namespace chaiscript
         std::ostringstream oss;
 
         oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
-            << this->text << " : " << this->start.line << ", " << this->start.column << '\n';
+            << this->text << " : " << this->location.start.line << ", " << this->location.start.column << '\n';
 
-        for (size_t j = 0; j < this->children.size(); ++j) {
-          oss << this->children[j]->to_string(t_prepend + "  ");
+        for (auto & elem : this->children) {
+          oss << elem->to_string(t_prepend + "  ");
         }
         return oss.str();
       }
 
-      Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) const
+      Boxed_Value eval(const chaiscript::detail::Dispatch_State &t_e) const
       {
         try {
           return eval_internal(t_e);
@@ -451,34 +489,41 @@ namespace chaiscript
         }
       }
 
+      static bool get_bool_condition(const Boxed_Value &t_bv) {
+        try {
+          return boxed_cast<bool>(t_bv);
+        }
+        catch (const exception::bad_boxed_cast &) {
+          throw exception::eval_error("Condition not boolean");
+        }
+      }
+
 
       void replace_child(const AST_NodePtr &t_child, const AST_NodePtr &t_new_child)
       {
         std::replace(children.begin(), children.end(), t_child, t_new_child);
       }
 
+      virtual ~AST_Node() {}
+
     protected:
-      AST_Node(std::string t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname, 
-          int t_start_line, int t_start_col, int t_end_line, int t_end_col) :
-        text(std::move(t_ast_node_text)), identifier(t_id), filename(t_fname),
-        start(t_start_line, t_start_col), end(t_end_line, t_end_col)
+      AST_Node(std::string t_ast_node_text, int t_id, Parse_Location t_loc, 
+               std::vector<AST_NodePtr> t_children = std::vector<AST_NodePtr>()) :
+        identifier(t_id), text(std::move(t_ast_node_text)),
+        location(std::move(t_loc)),
+        children(std::move(t_children))
       {
       }
 
-      AST_Node(std::string t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname) :
-        text(std::move(t_ast_node_text)), identifier(t_id), filename(t_fname) {}
-
-      virtual ~AST_Node() {}
-
-      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &) const
+      virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &) const
       {
         throw std::runtime_error("Undispatched ast_node (internal error)");
       }
 
     private:
       // Copy and assignment explicitly unimplemented
-      AST_Node(const AST_Node &);
-      AST_Node& operator=(const AST_Node &);
+      AST_Node(const AST_Node &) = delete;
+      AST_Node& operator=(const AST_Node &) = delete;
   };
 
 
@@ -486,12 +531,11 @@ namespace chaiscript
   {
     namespace detail
     {
-
       /// Special type for returned values
       struct Return_Value {
         Boxed_Value retval;
 
-        Return_Value(const Boxed_Value &t_return_value) : retval(t_return_value) { }
+        Return_Value(Boxed_Value t_return_value) : retval(std::move(t_return_value)) { }
       };
 
 
@@ -513,21 +557,20 @@ namespace chaiscript
         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)
+        Scope_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
+          : m_ds(t_ds)
         {
-          m_de.new_scope();
+          m_ds.get()->new_scope(m_ds.get().stack_holder());
         }
 
         ~Scope_Push_Pop()
         {
-          m_de.pop_scope();
+          m_ds.get()->pop_scope(m_ds.get().stack_holder());
         }
 
 
         private:
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+        std::reference_wrapper<const chaiscript::detail::Dispatch_State> m_ds;
       };
 
       /// Creates a new function call and pops it on destruction
@@ -536,31 +579,30 @@ namespace chaiscript
         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)
+        Function_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
+          : m_ds(t_ds)
         {
-          m_de.new_function_call();
+          m_ds.get()->new_function_call(m_ds.get().stack_holder());
         }
 
         ~Function_Push_Pop()
         {
-          m_de.pop_function_call();
+          m_ds.get()->pop_function_call(m_ds.get().stack_holder());
         }
 
         void save_params(const std::vector<Boxed_Value> &t_params)
         {
-          m_de.save_function_params(t_params);
+          m_ds.get()->save_function_params(t_params);
         }
 
         void save_params(std::initializer_list<Boxed_Value> t_params)
         {
-          m_de.save_function_params(std::move(t_params));
+          m_ds.get()->save_function_params(std::move(t_params));
         }
 
 
         private:
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          std::reference_wrapper<const chaiscript::detail::Dispatch_State> m_ds;
       };
 
       /// Creates a new scope then pops it on destruction
@@ -569,21 +611,20 @@ namespace chaiscript
         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)
+        Stack_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
+          : m_ds(t_ds)
         {
-          m_de.new_stack();
+          m_ds.get()->new_stack(m_ds.get().stack_holder());
         }
 
         ~Stack_Push_Pop()
         {
-          m_de.pop_stack();
+          m_ds.get()->pop_stack(m_ds.get().stack_holder());
         }
 
 
         private:
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          std::reference_wrapper<const chaiscript::detail::Dispatch_State> m_ds;
       };
     }
   }

include/chaiscript/language/chaiscript_engine.hpp

@@ -8,8 +8,6 @@
 #define CHAISCRIPT_ENGINE_HPP_
 
 #include <cassert>
-#include <cstring>
-#include <algorithm>
 #include <exception>
 #include <fstream>
 #include <functional>
@@ -18,7 +16,6 @@
 #include <mutex>
 #include <set>
 #include <stdexcept>
-#include <string>
 #include <vector>
 
 #include "../chaiscript_defines.hpp"
@@ -39,15 +36,16 @@
 #else
 #ifdef CHAISCRIPT_WINDOWS
 #define VC_EXTRA_LEAN
+#if !defined(WIN32_LEAN_AND_MEAN)
 #define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
+#endif
+#include <windows.h>
 #endif
 #endif
 
 
 #include "../dispatchkit/exception_specification.hpp"
 #include "chaiscript_parser.hpp"
-#include "chaiscript_prelude.chai"
 
 namespace chaiscript
 {
@@ -150,8 +148,8 @@ namespace chaiscript
           return std::string(t_str.begin(), t_str.end());
         }
 
-#ifdef _UNICODE
-      template<typename T>
+#if defined(_UNICODE) || defined(UNICODE)
+        template<typename T>
         static std::wstring to_proper_string(const T &t_str)
         {
           return to_wstring(t_str);
@@ -166,11 +164,11 @@ namespace chaiscript
 
       static std::string get_error_message(DWORD t_err)
       {
-#ifdef _UNICODE
-        typedef LPWSTR StringType;
+        typedef LPTSTR StringType;
+
+#if defined(_UNICODE) || defined(UNICODE)
         std::wstring retval = L"Unknown Error";
 #else
-        typedef LPSTR StringType;
         std::string retval = "Unknown Error";
 #endif
         StringType lpMsgBuf = nullptr;
@@ -182,7 +180,7 @@ namespace chaiscript
             NULL,
             t_err,
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-            (StringType)&lpMsgBuf,
+            reinterpret_cast<StringType>(&lpMsgBuf),
             0, NULL ) != 0 && lpMsgBuf)
         {
           retval = lpMsgBuf;
@@ -264,8 +262,8 @@ namespace chaiscript
     std::map<std::string, detail::Loadable_Module_Ptr> m_loaded_modules;
     std::set<std::string> m_active_loaded_modules;
 
-    std::vector<std::string> m_modulepaths;
-    std::vector<std::string> m_usepaths;
+    std::vector<std::string> m_module_paths;
+    std::vector<std::string> m_use_paths;
 
     chaiscript::detail::Dispatch_Engine m_engine;
 
@@ -276,7 +274,7 @@ namespace chaiscript
         parser::ChaiScript_Parser parser;
         if (parser.parse(t_input, t_filename)) {
           //parser.show_match_stack();
-          return parser.ast()->eval(m_engine);
+          return parser.optimized_ast()->eval(m_engine);
         } else {
           return Boxed_Value();
         }
@@ -288,13 +286,25 @@ namespace chaiscript
 
 
 
-    const Boxed_Value internal_eval_ast(const AST_NodePtr &t_ast)
-    {
-      try {
-        return t_ast->eval(m_engine);
-      } catch (const exception::eval_error &t_ee) {
-        throw Boxed_Value(t_ee);
+
+
+    /// Evaluates the given file and looks in the 'use' paths
+    const Boxed_Value internal_eval_file(const std::string &t_filename) {
+      for (const auto &path : m_use_paths)
+      {
+        try {
+          const auto appendedpath = path + t_filename;
+          return do_eval(load_file(appendedpath), appendedpath, true);
+        } catch (const exception::file_not_found_error &) {
+          // failed to load, try the next path
+        } catch (const exception::eval_error &t_ee) {
+          throw Boxed_Value(t_ee);
+        }
       }
+
+      // failed to load by any name
+      throw exception::file_not_found_error(t_filename);
+
     }
 
 
@@ -330,6 +340,9 @@ namespace chaiscript
       m_engine.add_reserved_word("true");
       m_engine.add_reserved_word("false");
       m_engine.add_reserved_word("class");
+      m_engine.add_reserved_word("attr");
+      m_engine.add_reserved_word("var");
+      m_engine.add_reserved_word("GLOBAL");
       m_engine.add_reserved_word("_");
 
       if (t_lib)
@@ -337,48 +350,58 @@ namespace chaiscript
         add(t_lib);
       }
 
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_system, std::ref(m_engine)), "dump_system");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_object, std::ref(m_engine)), "dump_object");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::is_type, std::ref(m_engine)), "is_type");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::type_name, std::ref(m_engine)), "type_name");
-      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(
+      m_engine.add(fun([this](){ m_engine.dump_system(); }), "dump_system");
+      m_engine.add(fun([this](const Boxed_Value &t_bv){ m_engine.dump_object(t_bv); }), "dump_object");
+      m_engine.add(fun([this](const Boxed_Value &t_bv, const std::string &t_type){ return m_engine.is_type(t_bv, t_type); }), "is_type");
+      m_engine.add(fun([this](const Boxed_Value &t_bv){ return m_engine.type_name(t_bv); }), "type_name");
+      m_engine.add(fun([this](const std::string &t_f){ return m_engine.function_exists(t_f); }), "function_exists");
+      m_engine.add(fun([this](){ return m_engine.get_function_objects(); }), "get_functions");
+      m_engine.add(fun([this](){ return m_engine.get_scripting_objects(); }), "get_objects");
+
+      m_engine.add(
+          dispatch::make_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");
+              })
+          , "call_exists");
 
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::ref(m_engine)), "name");
+//      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(
+            [=](const dispatch::Proxy_Function_Base &t_fun, const std::vector<Boxed_Value> &t_params) {
+              return t_fun(t_params, this->m_engine.conversions());
+            }), "call");
 
-      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 &)> &)> ( 
+      m_engine.add(fun([this](const Type_Info &t_ti){ return m_engine.get_type_name(t_ti); }), "name");
+
+      m_engine.add(fun([this](const std::string &t_type_name, bool t_throw){ return m_engine.get_type(t_type_name, t_throw); }), "type");
+      m_engine.add(fun([this](const std::string &t_type_name){ return m_engine.get_type(t_type_name, true); }), "type");
+
+      m_engine.add(fun(
             [=](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&);
 
-      m_engine.add(fun(static_cast<load_mod_1>(&ChaiScript::load_module), this), "load_module");
-      m_engine.add(fun(static_cast<load_mod_2>(&ChaiScript::load_module), this), "load_module");
+      m_engine.add(fun([this](const std::string &t_module, const std::string &t_file){ return load_module(t_module, t_file); }), "load_module");
+      m_engine.add(fun([this](const std::string &t_module){ return load_module(t_module); }), "load_module");
 
-      m_engine.add(fun(&ChaiScript::use, this), "use");
-      m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
-      m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
+      m_engine.add(fun([this](const std::string &t_file){ return use(t_file); }), "use");
+      m_engine.add(fun([this](const std::string &t_file){ return internal_eval_file(t_file); }), "eval_file");
+      m_engine.add(fun([this](const std::string &t_str){ return internal_eval(t_str); }), "eval");
+      m_engine.add(fun([this](const AST_NodePtr &t_ast){ return eval(t_ast); }), "eval");
+      m_engine.add(fun(&parse), "parse");
 
       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");
+      m_engine.add(fun([this](const Boxed_Value &t_bv, const std::string &t_name){ add_global_const(t_bv, t_name); }), "add_global_const");
+      m_engine.add(fun([this](const Boxed_Value &t_bv, const std::string &t_name){ add_global(t_bv, t_name); }), "add_global");
 
-      do_eval(ChaiScript_Prelude::chaiscript_prelude(), "standard prelude");
     }
 
 
@@ -413,16 +436,16 @@ namespace chaiscript
     ChaiScript(const ModulePtr &t_lib,
                std::vector<std::string> t_modulepaths = std::vector<std::string>(),
                       std::vector<std::string> t_usepaths = std::vector<std::string>())
-      : m_modulepaths(std::move(t_modulepaths)), m_usepaths(std::move(t_usepaths)) 
+      : m_module_paths(std::move(t_modulepaths)), m_use_paths(std::move(t_usepaths))
     {
-      if (m_modulepaths.empty())
+      if (m_module_paths.empty())
       {
-        m_modulepaths.push_back("");
+        m_module_paths.push_back("");
       }
 
-      if (m_usepaths.empty())
+      if (m_use_paths.empty())
       {
-        m_usepaths.push_back("");
+        m_use_paths.push_back("");
       }
 
       build_eval_system(t_lib);
@@ -437,16 +460,16 @@ namespace chaiscript
     /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
     ChaiScript( std::vector<std::string> t_modulepaths = std::vector<std::string>(),
                       std::vector<std::string> t_usepaths = std::vector<std::string>())
-      : m_modulepaths(std::move(t_modulepaths)), m_usepaths(std::move(t_usepaths)) 
+      : m_module_paths(std::move(t_modulepaths)), m_use_paths(std::move(t_usepaths))
     {
-      if (m_modulepaths.empty())
+      if (m_module_paths.empty())
       {
-        m_modulepaths.push_back("");
+        m_module_paths.push_back("");
       }
 
-      if (m_usepaths.empty())
+      if (m_use_paths.empty())
       {
-        m_usepaths.push_back("");
+        m_use_paths.push_back("");
       }
 
 #if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
@@ -455,7 +478,7 @@ namespace chaiscript
 
       union cast_union
       {
-        void (ChaiScript::*in_ptr)(const std::string&);
+        Boxed_Value (ChaiScript::*in_ptr)(const std::string&);
         void *out_ptr;
       };
 
@@ -479,7 +502,7 @@ namespace chaiscript
           dllpath = std::string(&buf.front(), pathlen);
         }
 
-        m_modulepaths.insert(m_modulepaths.begin(), dllpath+"/");
+        m_module_paths.insert(m_module_paths.begin(), dllpath+"/");
       }
 #endif
 
@@ -490,6 +513,28 @@ namespace chaiscript
       build_eval_system(ModulePtr());
     }
 
+
+    const Boxed_Value eval(const AST_NodePtr &t_ast)
+    {
+      try {
+        return t_ast->eval(m_engine);
+      } catch (const exception::eval_error &t_ee) {
+        throw Boxed_Value(t_ee);
+      }
+    }
+
+    static AST_NodePtr parse(const std::string &t_input)
+    {
+      parser::ChaiScript_Parser parser;
+      if (parser.parse(t_input, "PARSE")) {
+        //parser.show_match_stack();
+        return parser.optimized_ast();
+      } else {
+        throw chaiscript::exception::eval_error("Unknown error while parsing");
+      }
+    }
+
+
     static int version_major()
     {
       return chaiscript::version_major;
@@ -529,9 +574,9 @@ namespace chaiscript
     /// requested file.
     ///
     /// \param[in] t_filename Filename to load and evaluate
-    void use(const std::string &t_filename)
+    Boxed_Value use(const std::string &t_filename)
     {
-      for (const auto &path : m_usepaths)
+      for (const auto &path : m_use_paths)
       {
         try {
           const auto appendedpath = path + t_filename;
@@ -539,15 +584,17 @@ namespace chaiscript
           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);
 
+          Boxed_Value retval;
+
           if (m_used_files.count(appendedpath) == 0)
           {
             l2.unlock();
-            eval_file(appendedpath);
+            retval = eval_file(appendedpath);
             l2.lock();
             m_used_files.insert(appendedpath);
-           }
+          }
 
-          return; // return, we loaded it, or it was already loaded
+          return retval; // return, we loaded it, or it was already loaded
         } catch (const exception::file_not_found_error &) {
           // failed to load, try the next path
         }
@@ -728,7 +775,7 @@ namespace chaiscript
 
       std::vector<std::string> postfixes{".dll", ".so", ".bundle", ""};
 
-      for (auto & elem : m_modulepaths) 
+      for (auto & elem : m_module_paths)
       {
         for (auto & prefix : prefixes)
         {

include/chaiscript/language/chaiscript_prelude.chai

@@ -38,11 +38,28 @@ def eq(l, r) {
 
 def new(x) { 
   eval(type_name(x))(); 
-} 
+}
+
+def clone(double x) {
+  double(x).clone_var_attrs(x)
+}
+
+def clone(string x) {
+  string(x).clone_var_attrs(x)
+}
+
+def clone(vector x) {
+  vector(x).clone_var_attrs(x)
+}
+
+
+def clone(int x) {
+  int(x).clone_var_attrs(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);
+  eval(type_name(x))(x).clone_var_attrs(x);
 }
 
 
@@ -110,18 +127,6 @@ def even(x)
 } 
 
 
-# Pushes the second value onto the container first value while making a clone of the value
-def push_back(container, x) : call_exists(push_back_ref, container, x) 
-{ 
-  container.push_back_ref(clone(x))
-} 
-
-# Pushes the second value onto the front of the container first value while making a clone of the value
-def push_front(container, x) : call_exists(push_front_ref, container, x) 
-{ 
-  container.push_front_ref(clone(x)) 
-} 
-
 # Inserts the third value at the position of the second value into the container of the first
 # while making a clone. 
 def insert_at(container, pos, x) 
@@ -140,11 +145,6 @@ def reverse(container) {
   retval; 
 }
 
-# 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) 
-{
-  clone(r);
-}
 
 def range(r) : call_exists(range_internal, r)
 {
@@ -153,6 +153,13 @@ def range(r) : call_exists(range_internal, r)
   ri;
 }
 
+# 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) 
+{
+  clone(r);
+}
+
+
 # The retro attribute that contains the underlying range 
 attr retro::m_range; 
 

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -309,7 +309,7 @@ class Range
 
     /// \brief Moves the front pointer forward one
     /// 
-    /// \post front() returne the element at front() + 1;
+    /// \post front() returns the element at front() + 1;
     void pop_front();
 
 };
@@ -340,7 +340,7 @@ class Const_Range
 
     /// \brief Moves the front pointer forward one
     /// 
-    /// \post front() returne the element at front() + 1;
+    /// \post front() returns the element at front() + 1;
     void pop_front();
 
 };
@@ -718,14 +718,14 @@ Object drop_while(Range c, Function f);
 Object reduce(Range c, Function f);
 
 
-/// \brief Takes elements from Range c that match function f, return them.
+/// \brief Takes elements from Container c that match function f, return them.
 ///
 /// Example:
 /// \code
 /// eval> filter([1, 2, 3, 4], odd)
 /// [1, 3]
 /// \endcode
-Object filter(Range c, Function f);
+Object filter(Container c, Function f);
 
 
 /// \brief Joins the elements of the Range c into a string, delimiting each with the delim string.

include/chaiscript/utility/json.hpp

@@ -0,0 +1,647 @@
+// From github.com/nbsdx/SimpleJSON. 
+// Released under the DWTFYW PL
+//
+
+
+#pragma once
+
+#ifndef SIMPLEJSON_HPP
+#define SIMPLEJSON_HPP
+
+
+#include <cstdint>
+#include <cmath>
+#include <cctype>
+#include <string>
+#include <deque>
+#include <map>
+#include <type_traits>
+#include <initializer_list>
+#include <ostream>
+#include <iostream>
+
+namespace json {
+
+using std::map;
+using std::deque;
+using std::string;
+using std::enable_if;
+using std::initializer_list;
+using std::is_same;
+using std::is_convertible;
+using std::is_integral;
+using std::is_floating_point;
+
+namespace {
+    string json_escape( const string &str ) {
+        string output;
+        for( unsigned i = 0; i < str.length(); ++i )
+            switch( str[i] ) {
+                case '\"': output += "\\\""; break;
+                case '\\': output += "\\\\"; break;
+                case '\b': output += "\\b";  break;
+                case '\f': output += "\\f";  break;
+                case '\n': output += "\\n";  break;
+                case '\r': output += "\\r";  break;
+                case '\t': output += "\\t";  break;
+                default  : output += str[i]; break;
+            }
+        return output;
+    }
+}
+
+class JSON
+{
+    union BackingData {
+        BackingData( double d ) : Float( d ){}
+        BackingData( long   l ) : Int( l ){}
+        BackingData( bool   b ) : Bool( b ){}
+        BackingData( string s ) : String( new string( s ) ){}
+        BackingData()           : Int( 0 ){}
+
+        deque<JSON>        *List;
+        map<string,JSON>   *Map;
+        string             *String;
+        double              Float;
+        long                Int;
+        bool                Bool;
+    } Internal;
+
+    public:
+        enum class Class {
+            Null,
+            Object,
+            Array,
+            String,
+            Floating,
+            Integral,
+            Boolean
+        };
+
+        template <typename Container>
+        class JSONWrapper {
+            Container *object;
+
+            public:
+                JSONWrapper( Container *val ) : object( val ) {}
+                JSONWrapper( std::nullptr_t )  : object( nullptr ) {}
+
+                typename Container::iterator begin() { return object ? object->begin() : typename Container::iterator(); }
+                typename Container::iterator end() { return object ? object->end() : typename Container::iterator(); }
+                typename Container::const_iterator begin() const { return object ? object->begin() : typename Container::iterator(); }
+                typename Container::const_iterator end() const { return object ? object->end() : typename Container::iterator(); }
+        };
+
+        template <typename Container>
+        class JSONConstWrapper {
+            const Container *object;
+
+            public:
+                JSONConstWrapper( const Container *val ) : object( val ) {}
+                JSONConstWrapper( std::nullptr_t )  : object( nullptr ) {}
+
+                typename Container::const_iterator begin() const { return object ? object->begin() : typename Container::const_iterator(); }
+                typename Container::const_iterator end() const { return object ? object->end() : typename Container::const_iterator(); }
+        };
+
+        JSON() : Internal(), Type( Class::Null ){}
+
+        explicit JSON(Class type)
+            : Internal(), Type(Class::Null)
+        {
+            SetType( type );
+        }
+
+        JSON( initializer_list<JSON> list ) 
+            : Internal(), Type(Class::Null)
+        {
+            SetType( Class::Object );
+            for( auto i = list.begin(), e = list.end(); i != e; ++i, ++i )
+                operator[]( i->ToString() ) = *std::next( i );
+        }
+
+        JSON( JSON&& other )
+            : Internal( other.Internal )
+            , Type( other.Type )
+        { other.Type = Class::Null; other.Internal.Map = nullptr; }
+
+        JSON& operator=( JSON&& other ) {
+            Internal = other.Internal;
+            Type = other.Type;
+            other.Internal.Map = nullptr;
+            other.Type = Class::Null;
+            return *this;
+        }
+
+        JSON( const JSON &other ) {
+            switch( other.Type ) {
+            case Class::Object:
+                Internal.Map = 
+                    new map<string,JSON>( other.Internal.Map->begin(),
+                                          other.Internal.Map->end() );
+                break;
+            case Class::Array:
+                Internal.List = 
+                    new deque<JSON>( other.Internal.List->begin(),
+                                      other.Internal.List->end() );
+                break;
+            case Class::String:
+                Internal.String = 
+                    new string( *other.Internal.String );
+                break;
+            default:
+                Internal = other.Internal;
+            }
+            Type = other.Type;
+        }
+
+        JSON& operator=( const JSON &other ) {
+            if (&other == this) return *this;
+
+            switch( other.Type ) {
+            case Class::Object:
+                Internal.Map = 
+                    new map<string,JSON>( other.Internal.Map->begin(),
+                                          other.Internal.Map->end() );
+                break;
+            case Class::Array:
+                Internal.List = 
+                    new deque<JSON>( other.Internal.List->begin(),
+                                      other.Internal.List->end() );
+                break;
+            case Class::String:
+                Internal.String = 
+                    new string( *other.Internal.String );
+                break;
+            default:
+                Internal = other.Internal;
+            }
+            Type = other.Type;
+            return *this;
+        }
+
+        ~JSON() {
+            switch( Type ) {
+            case Class::Array:
+                delete Internal.List;
+                break;
+            case Class::Object:
+                delete Internal.Map;
+                break;
+            case Class::String:
+                delete Internal.String;
+                break;
+            default:;
+            }
+        }
+
+        template <typename T>
+        JSON( T b, typename enable_if<is_same<T,bool>::value>::type* = 0 ) : Internal( b ), Type( Class::Boolean ){}
+
+        template <typename T>
+        JSON( T i, typename enable_if<is_integral<T>::value && !is_same<T,bool>::value>::type* = 0 ) : Internal( long(i) ), Type( Class::Integral ){}
+
+        template <typename T>
+        JSON( T f, typename enable_if<is_floating_point<T>::value>::type* = 0 ) : Internal( double(f) ), Type( Class::Floating ){}
+
+        template <typename T>
+        JSON( T s, typename enable_if<is_convertible<T,string>::value>::type* = 0 ) : Internal( string( s ) ), Type( Class::String ){}
+
+        JSON( std::nullptr_t ) : Internal(), Type( Class::Null ){}
+
+        static JSON Make( Class type ) {
+            return JSON(type);
+        }
+
+        static JSON Load( const string & );
+
+        template <typename T>
+        void append( T arg ) {
+            SetType( Class::Array ); Internal.List->emplace_back( arg );
+        }
+
+        template <typename T, typename... U>
+        void append( T arg, U... args ) {
+            append( arg ); append( args... );
+        }
+
+        template <typename T>
+            typename enable_if<is_same<T,bool>::value, JSON&>::type operator=( T b ) {
+                SetType( Class::Boolean ); Internal.Bool = b; return *this;
+            }
+
+        template <typename T>
+            typename enable_if<is_integral<T>::value && !is_same<T,bool>::value, JSON&>::type operator=( T i ) {
+                SetType( Class::Integral ); Internal.Int = i; return *this;
+            }
+
+        template <typename T>
+            typename enable_if<is_floating_point<T>::value, JSON&>::type operator=( T f ) {
+                SetType( Class::Floating ); Internal.Float = f; return *this;
+            }
+
+        template <typename T>
+            typename enable_if<is_convertible<T,string>::value, JSON&>::type operator=( T s ) {
+                SetType( Class::String ); *Internal.String = string( s ); return *this;
+            }
+
+        JSON& operator[]( const string &key ) {
+            SetType( Class::Object ); return Internal.Map->operator[]( key );
+        }
+
+        JSON& operator[]( const size_t index ) {
+            SetType( Class::Array );
+            if( index >= Internal.List->size() ) Internal.List->resize( index + 1 );
+            return Internal.List->operator[]( index );
+        }
+
+        JSON &at( const string &key ) {
+            return operator[]( key );
+        }
+
+        const JSON &at( const string &key ) const {
+            return Internal.Map->at( key );
+        }
+
+        JSON &at( unsigned index ) {
+            return operator[]( index );
+        }
+
+        const JSON &at( unsigned index ) const {
+            return Internal.List->at( index );
+        }
+
+        int length() const {
+            if( Type == Class::Array )
+                return static_cast<int>(Internal.List->size());
+            else
+                return -1;
+        }
+
+        bool hasKey( const string &key ) const {
+            if( Type == Class::Object )
+                return Internal.Map->find( key ) != Internal.Map->end();
+            return false;
+        }
+
+        int size() const {
+            if( Type == Class::Object )
+                return static_cast<int>(Internal.Map->size());
+            else if( Type == Class::Array )
+                return static_cast<int>(Internal.List->size());
+            else
+                return -1;
+        }
+
+        Class JSONType() const { return Type; }
+
+        /// Functions for getting primitives from the JSON object.
+        bool IsNull() const { return Type == Class::Null; }
+
+        string ToString() const { bool b; return ToString( b ); }
+        string ToString( bool &ok ) const {
+            ok = (Type == Class::String);
+            return ok ? *Internal.String : string("");
+        }
+
+        double ToFloat() const { bool b; return ToFloat( b ); }
+        double ToFloat( bool &ok ) const {
+            ok = (Type == Class::Floating);
+            return ok ? Internal.Float : 0.0;
+        }
+
+        long ToInt() const { bool b; return ToInt( b ); }
+        long ToInt( bool &ok ) const {
+            ok = (Type == Class::Integral);
+            return ok ? Internal.Int : 0;
+        }
+
+        bool ToBool() const { bool b; return ToBool( b ); }
+        bool ToBool( bool &ok ) const {
+            ok = (Type == Class::Boolean);
+            return ok ? Internal.Bool : false;
+        }
+
+        JSONWrapper<map<string,JSON>> ObjectRange() {
+            if( Type == Class::Object )
+                return JSONWrapper<map<string,JSON>>( Internal.Map );
+            return JSONWrapper<map<string,JSON>>( nullptr );
+        }
+
+        JSONWrapper<deque<JSON>> ArrayRange() {
+            if( Type == Class::Array )
+                return JSONWrapper<deque<JSON>>( Internal.List );
+            return JSONWrapper<deque<JSON>>( nullptr );
+        }
+
+        JSONConstWrapper<map<string,JSON>> ObjectRange() const {
+            if( Type == Class::Object )
+                return JSONConstWrapper<map<string,JSON>>( Internal.Map );
+            return JSONConstWrapper<map<string,JSON>>( nullptr );
+        }
+
+
+        JSONConstWrapper<deque<JSON>> ArrayRange() const { 
+            if( Type == Class::Array )
+                return JSONConstWrapper<deque<JSON>>( Internal.List );
+            return JSONConstWrapper<deque<JSON>>( nullptr );
+        }
+
+        string dump( int depth = 1, string tab = "  ") const {
+            switch( Type ) {
+                case Class::Null:
+                    return "null";
+                case Class::Object: {
+                    string pad = "";
+                    for( int i = 0; i < depth; ++i, pad += tab );
+
+                    string s = "{\n";
+                    bool skip = true;
+                    for( auto &p : *Internal.Map ) {
+                        if( !skip ) s += ",\n";
+                        s += ( pad + "\"" + p.first + "\" : " + p.second.dump( depth + 1, tab ) );
+                        skip = false;
+                    }
+                    s += ( "\n" + pad.erase( 0, 2 ) + "}" ) ;
+                    return s;
+                }
+                case Class::Array: {
+                    string s = "[";
+                    bool skip = true;
+                    for( auto &p : *Internal.List ) {
+                        if( !skip ) s += ", ";
+                        s += p.dump( depth + 1, tab );
+                        skip = false;
+                    }
+                    s += "]";
+                    return s;
+                }
+                case Class::String:
+                    return "\"" + json_escape( *Internal.String ) + "\"";
+                case Class::Floating:
+                    return std::to_string( Internal.Float );
+                case Class::Integral:
+                    return std::to_string( Internal.Int );
+                case Class::Boolean:
+                    return Internal.Bool ? "true" : "false";
+            }
+
+            throw std::runtime_error("Unhandled JSON type");
+        }
+
+        friend std::ostream& operator<<( std::ostream&, const JSON & );
+
+    private:
+        void SetType( Class type ) {
+            if( type == Type )
+                return;
+
+            switch( Type ) {
+            case Class::Object: delete Internal.Map;    break;
+            case Class::Array:  delete Internal.List;   break;
+            case Class::String: delete Internal.String; break;
+            default:;
+            }
+
+            switch( type ) {
+            case Class::Null:      Internal.Map    = nullptr;                break;
+            case Class::Object:    Internal.Map    = new map<string,JSON>(); break;
+            case Class::Array:     Internal.List   = new deque<JSON>();     break;
+            case Class::String:    Internal.String = new string();           break;
+            case Class::Floating:  Internal.Float  = 0.0;                    break;
+            case Class::Integral:  Internal.Int    = 0;                      break;
+            case Class::Boolean:   Internal.Bool   = false;                  break;
+            }
+
+            Type = type;
+        }
+
+    private:
+
+        Class Type;
+};
+
+JSON Array() {
+    return JSON::Make( JSON::Class::Array );
+}
+
+template <typename... T>
+JSON Array( T... args ) {
+    JSON arr = JSON::Make( JSON::Class::Array );
+    arr.append( args... );
+    return arr;
+}
+
+JSON Object() {
+    return JSON::Make( JSON::Class::Object );
+}
+
+std::ostream& operator<<( std::ostream &os, const JSON &json ) {
+    os << json.dump();
+    return os;
+}
+
+namespace {
+    JSON parse_next( const string &, size_t & );
+
+    void consume_ws( const string &str, size_t &offset ) {
+        while( isspace( str[offset] ) ) ++offset;
+    }
+
+    JSON parse_object( const string &str, size_t &offset ) {
+        JSON Object = JSON::Make( JSON::Class::Object );
+
+        ++offset;
+        consume_ws( str, offset );
+        if( str[offset] == '}' ) {
+            ++offset; return Object;
+        }
+
+        for (;offset<str.size();) {
+            JSON Key = parse_next( str, offset );
+            consume_ws( str, offset );
+            if( str[offset] != ':' ) {
+                throw std::runtime_error(std::string("JSON ERROR: Object: Expected colon, found '") + str[offset] + "'\n");
+            }
+            consume_ws( str, ++offset );
+            JSON Value = parse_next( str, offset );
+            Object[Key.ToString()] = Value;
+
+            consume_ws( str, offset );
+            if( str[offset] == ',' ) {
+                ++offset; continue;
+            }
+            else if( str[offset] == '}' ) {
+                ++offset; break;
+            }
+            else {
+                throw std::runtime_error(std::string("JSON ERROR: Object: Expected comma, found '") + str[offset] + "'\n");
+            }
+        }
+
+        return Object;
+    }
+
+    JSON parse_array( const string &str, size_t &offset ) {
+        JSON Array = JSON::Make( JSON::Class::Array );
+        unsigned index = 0;
+
+        ++offset;
+        consume_ws( str, offset );
+        if( str[offset] == ']' ) {
+            ++offset; return Array;
+        }
+
+        for (;offset < str.size();) {
+            Array[index++] = parse_next( str, offset );
+            consume_ws( str, offset );
+
+            if( str[offset] == ',' ) {
+                ++offset; continue;
+            }
+            else if( str[offset] == ']' ) {
+                ++offset; break;
+            }
+            else {
+              throw std::runtime_error(std::string("JSON ERROR: Array: Expected ',' or ']', found '") + str[offset] + "'\n");
+            }
+        }
+
+        return Array;
+    }
+
+    JSON parse_string( const string &str, size_t &offset ) {
+        string val;
+        for( char c = str[++offset]; c != '\"' ; c = str[++offset] ) {
+            if( c == '\\' ) {
+                switch( str[ ++offset ] ) {
+                case '\"': val += '\"'; break;
+                case '\\': val += '\\'; break;
+                case '/' : val += '/' ; break;
+                case 'b' : val += '\b'; break;
+                case 'f' : val += '\f'; break;
+                case 'n' : val += '\n'; break;
+                case 'r' : val += '\r'; break;
+                case 't' : val += '\t'; break;
+                case 'u' : {
+                    val += "\\u" ;
+                    for( unsigned i = 1; i <= 4; ++i ) {
+                        c = str[offset+i];
+                        if( (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') )
+                            val += c;
+                        else {
+                            throw std::runtime_error(std::string("JSON ERROR: String: Expected hex character in unicode escape, found '") + c + "'");
+                        }
+                    }
+                    offset += 4;
+                } break;
+                default  : val += '\\'; break;
+                }
+            }
+            else
+                val += c;
+        }
+        ++offset;
+        return JSON(val);
+    }
+
+    JSON parse_number( const string &str, size_t &offset ) {
+        JSON Number;
+        string val, exp_str;
+        char c = '\0';
+        bool isDouble = false;
+        long exp = 0;
+        for (; offset < str.size() ;) {
+            c = str[offset++];
+            if( (c == '-') || (c >= '0' && c <= '9') )
+                val += c;
+            else if( c == '.' ) {
+                val += c; 
+                isDouble = true;
+            }
+            else
+                break;
+        }
+        if( offset < str.size() && (c == 'E' || c == 'e' )) {
+            c = str[ offset++ ];
+            if( c == '-' ) { exp_str += '-';}
+            else if( c == '+' ) { }
+            else --offset;
+
+            for (; offset < str.size() ;) {
+                c = str[ offset++ ];
+                if( c >= '0' && c <= '9' )
+                    exp_str += c;
+                else if( !isspace( c ) && c != ',' && c != ']' && c != '}' ) {
+                    throw std::runtime_error(std::string("JSON ERROR: Number: Expected a number for exponent, found '") + c + "'");
+                }
+                else
+                    break;
+            }
+            exp = std::stol( exp_str );
+        }
+        else if( offset < str.size() && (!isspace( c ) && c != ',' && c != ']' && c != '}' )) {
+            throw std::runtime_error(std::string("JSON ERROR: Number: unexpected character '") + c + "'");
+        }
+        --offset;
+
+        if( isDouble )
+            Number = std::stod( val ) * std::pow( 10, exp );
+        else {
+            if( !exp_str.empty() )
+                Number = std::stol( val ) * std::pow( 10, exp );
+            else
+                Number = std::stol( val );
+        }
+        return Number;
+    }
+
+    JSON parse_bool( const string &str, size_t &offset ) {
+        JSON Bool;
+        if( str.substr( offset, 4 ) == "true" ) {
+            offset += 4;
+            Bool = true;
+        } else if( str.substr( offset, 5 ) == "false" ) {
+            offset += 5;
+            Bool = false;
+        } else {
+            throw std::runtime_error(std::string("JSON ERROR: Bool: Expected 'true' or 'false', found '") + str.substr( offset, 5 ) + "'");
+        }
+        return Bool;
+    }
+
+    JSON parse_null( const string &str, size_t &offset ) {
+        if( str.substr( offset, 4 ) != "null" ) {
+            throw std::runtime_error(std::string("JSON ERROR: Null: Expected 'null', found '") + str.substr( offset, 4 ) + "'");
+        }
+        offset += 4;
+        return JSON();
+    }
+
+    JSON parse_next( const string &str, size_t &offset ) {
+        char value;
+        consume_ws( str, offset );
+        value = str[offset];
+        switch( value ) {
+            case '[' : return parse_array( str, offset );
+            case '{' : return parse_object( str, offset );
+            case '\"': return parse_string( str, offset );
+            case 't' :
+            case 'f' : return parse_bool( str, offset );
+            case 'n' : return parse_null( str, offset );
+            default  : if( ( value <= '9' && value >= '0' ) || value == '-' )
+                           return parse_number( str, offset );
+        }
+        throw std::runtime_error(std::string("JSON ERROR: Parse: Unexpected starting character '") + value + "'");
+    }
+}
+
+JSON JSON::Load( const string &str ) {
+    size_t offset = 0;
+    return parse_next( str, offset );
+}
+
+} // End Namespace json
+
+
+#endif 

include/chaiscript/utility/json_wrap.hpp

@@ -0,0 +1,158 @@
+#ifndef CHAISCRIPT_SIMPLEJSON_WRAP_HPP
+#define CHAISCRIPT_SIMPLEJSON_WRAP_HPP
+
+#include "json.hpp"
+
+namespace chaiscript
+{
+  class json_wrap
+  {
+    public:
+
+      static ModulePtr library(ModulePtr m = std::make_shared<Module>())
+      {
+
+        m->add(chaiscript::fun([](const std::string &t_str) { return from_json(t_str); }), "from_json");
+        m->add(chaiscript::fun(&json_wrap::to_json), "to_json");
+
+        return m;
+
+      }
+
+    private:
+
+      static Boxed_Value from_json(const json::JSON &t_json)
+      {
+        switch( t_json.JSONType() ) {
+          case json::JSON::Class::Null:
+            return Boxed_Value();
+          case json::JSON::Class::Object:
+            {
+              std::map<std::string, Boxed_Value> m;
+
+              for (const auto &p : t_json.ObjectRange())
+              {
+                m.insert(std::make_pair(p.first, from_json(p.second)));
+              }
+
+              return Boxed_Value(m);
+            }
+          case json::JSON::Class::Array:
+            {
+              std::vector<Boxed_Value> vec;
+
+              for (const auto &p : t_json.ArrayRange()) 
+              {
+                vec.emplace_back(from_json(p));
+              }
+
+              return Boxed_Value(vec);
+            }
+          case json::JSON::Class::String:
+            return Boxed_Value(t_json.ToString());
+          case json::JSON::Class::Floating:
+            return Boxed_Value(t_json.ToFloat());
+          case json::JSON::Class::Integral:
+            return Boxed_Value(t_json.ToInt());
+          case json::JSON::Class::Boolean:
+            return Boxed_Value(t_json.ToBool());
+        }
+
+        throw std::runtime_error("Unknown JSON type");
+      }
+
+      static Boxed_Value from_json(const std::string &t_json)
+      {
+        return from_json( json::JSON::Load(t_json) );
+      }
+
+      static std::string to_json(const Boxed_Value &t_bv)
+      {
+        return to_json_object(t_bv).dump();
+      }
+
+      static json::JSON to_json_object(const Boxed_Value &t_bv)
+      {
+        try {
+          const std::map<std::string, Boxed_Value> m = chaiscript::boxed_cast<const std::map<std::string, Boxed_Value> &>(t_bv);
+
+          json::JSON obj;
+          for (const auto &o : m)
+          {
+            obj[o.first] = to_json_object(o.second);
+          }
+          return obj;
+        } catch (const chaiscript::exception::bad_boxed_cast &) {
+          // not a map
+        }
+
+        try {
+          const std::vector<Boxed_Value> v = chaiscript::boxed_cast<const std::vector<Boxed_Value> &>(t_bv);
+
+          json::JSON obj;
+          for (size_t i = 0; i < v.size(); ++i)
+          {
+            obj[i] = to_json_object(v[i]);
+          }
+          return obj;
+        } catch (const chaiscript::exception::bad_boxed_cast &) {
+          // not a vector
+        }
+
+
+        try {
+          Boxed_Number bn(t_bv);
+          json::JSON obj;
+          if (Boxed_Number::is_floating_point(t_bv))
+          {
+            obj = bn.get_as<double>();
+          } else {
+            obj = bn.get_as<long>();
+          }
+          return obj;
+        } catch (const chaiscript::detail::exception::bad_any_cast &) {
+          // not a number
+        }
+
+        try {
+          bool b = boxed_cast<bool>(t_bv);
+          json::JSON obj;
+          obj = b;
+          return obj;
+        } catch (const chaiscript::exception::bad_boxed_cast &) {
+          // not a bool
+        }
+
+        try {
+          std::string s = boxed_cast<std::string>(t_bv);
+          json::JSON obj;
+          obj = s;
+          return obj;
+        } catch (const chaiscript::exception::bad_boxed_cast &) {
+          // not a string
+        }
+
+
+        try {
+          const chaiscript::dispatch::Dynamic_Object &o = boxed_cast<const dispatch::Dynamic_Object &>(t_bv);
+
+          json::JSON obj;
+          for (const auto &attr : o.get_attrs())
+          {
+            obj[attr.first] = to_json_object(attr.second);
+          }
+          return obj;
+        } catch (const chaiscript::exception::bad_boxed_cast &) {
+          // not a dynamic object
+        }
+
+        throw std::runtime_error("Unknown object type to convert to JSON");
+      }
+
+
+  };
+
+
+}
+
+#endif

include/chaiscript/utility/utility.hpp

@@ -38,8 +38,8 @@ namespace chaiscript
     ///      { {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<std::string(test::*)(double)>(&test::function_overload)), "function_overload" },
+    ///        {fun(static_cast<std::string(test::*)(int)>(&test::function_overload)), "function_overload" },
     ///        {fun(static_cast<test & (test::*)(const test &)>(&test::operator=)), "=" }
     ///        }
     ///      );

readme.md

@@ -1,7 +1,11 @@
-Master Status: [![Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=master)](https://travis-ci.org/ChaiScript/ChaiScript) [![Coverage Status](https://coveralls.io/repos/ChaiScript/ChaiScript/badge.png?branch=master)](https://coveralls.io/r/ChaiScript/ChaiScript?branch=master)
+Master Status: [![Linux Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=master)](https://travis-ci.org/ChaiScript/ChaiScript) [![Windows Build status](https://ci.appveyor.com/api/projects/status/6u3r4s81kkjqmsqw?svg=true)](https://ci.appveyor.com/project/lefticus/chaiscript) [![codecov.io](http://codecov.io/github/ChaiScript/ChaiScript/coverage.svg?branch=master)](http://codecov.io/github/ChaiScript/ChaiScript?branch=master)
 
-Develop Status: [![Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=develop)](https://travis-ci.org/ChaiScript/ChaiScript) [![Coverage Status](https://coveralls.io/repos/ChaiScript/ChaiScript/badge.png?branch=develop)](https://coveralls.io/r/ChaiScript/ChaiScript?branch=develop)
+Develop Status: [![Linux Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=develop)](https://travis-ci.org/ChaiScript/ChaiScript) [![Windows Build status](https://ci.appveyor.com/api/projects/status/6u3r4s81kkjqmsqw/branch/develop?svg=true)](https://ci.appveyor.com/project/lefticus/chaiscript/branch/develop) [![codecov.io](http://codecov.io/github/ChaiScript/ChaiScript/coverage.svg?branch=develop)](http://codecov.io/github/ChaiScript/ChaiScript?branch=develop)
 
+<a href="https://scan.coverity.com/projects/5297">
+  <img alt="Coverity Scan Build Status"
+       src="https://img.shields.io/coverity/scan/5297.svg"/>
+</a>
 
 ChaiScript
 

releasenotes.md

@@ -1,6 +1,56 @@
 Notes:
 =======
-Current Version: 5.6.0
+Current Version: 5.7.1
+
+### Changes since 5.7.0
+* Build time reduction
+* Build size reduction
+* Performance increases
+* Fixed ~20 crash-bugs found with fuzzy testing #194
+  * Let unhandled exceptions propogate to user
+  * Report eval_error when break statement is not in loop
+  * Fix handling of 0 length scripts closes #193
+  * Don't crash on arity mismatch - Specifically affects the case where no overloads exist for a given function
+  * Fix error printing for `bind` calls
+  * Handle unexpected continue statement
+  * Check arity during bind
+  * Don't allow arith conversion on variadic function
+  * Correct `bind` parameter match count
+  * Add in expected Boxed_Value exception cases
+  * Check access to AST, don't allow `;` in func def
+  * Don't attempt arithmetic unary & call
+  * Don't crash on 0 param call to `bind`
+  * Catch errors during member function dispatch
+  * Properly handle type of const bool &
+* Automatic deduction of lambda type signatures
+* Work with non-polymorphic parent/child conversions
+* Move to codecov for coverage reporting
+* Add `.at` method for Map objects
+* Various corrections for support of move-only objects
+
+
+### Changes since 5.6.0
+
+* Significant code cleanups and reduction
+* Smaller builds
+* Faster compiles
+* Less runtime memory usage
+* ~2x faster runtimes
+* biicode support
+* method_missing feature added #164 @arBmind
+* Generic objects with dynamic properties support
+* Add ability to call functions contained in properties
+* Add lambda captures
+* Create [cheatsheet.md](cheatsheet.md) for all-in-one reference of features
+* Fix support for libc++
+* Eliminate clone of return value stored locally
+* Eliminate 'return' statements when last line of function
+* Reduce number of runtime exceptions occuring
+* Reduce copies / moves of return values. 
+* make `use` statement return value of last statement in file
+* Add ability to access fixed array sizes
+* Add support for scientific notation floating point literals #174  @totalgee
+
 
 ### Changes since 5.5.1
 * Throw exception on integer divide by 0

samples/example.cpp

@@ -69,13 +69,14 @@ int main(int /*argc*/, char * /*argv*/[]) {
   using namespace chaiscript;
 
   ChaiScript chai;
+  
 
   //Create a new system object and share it with the chaiscript engine
   System system;
   chai.add(var(&system), "system");
 
   //Add a bound callback method
-  chai.add(fun(&System::add_callback, system), "add_callback_bound");
+  chai.add(fun(&System::add_callback, std::ref(system)), "add_callback_bound");
 
   //Register the two methods of the System structure.
   chai.add(fun(&System::add_callback), "add_callback");

samples/fun_call_performance.cpp

@@ -247,7 +247,7 @@ void interactive(chaiscript::ChaiScript& chai)
     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 << "during evaluation at (" << ee.call_stack[0]->start().line << ", " << ee.call_stack[0]->start().column << ")";
       }
       std::cout << std::endl;
     }

samples/test_num_exceptions.cpp

@@ -0,0 +1,32 @@
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
+#include <chaiscript/dispatchkit/function_call.hpp>
+
+int main( int /*argc*/ , char * /*argv*/[] )
+{
+  chaiscript::ChaiScript ch( chaiscript::Std_Lib::library( ) );
+
+  static const char script[ ] =
+    R""(
+
+      class Rectangle
+      {
+        def Rectangle() { }
+      }
+
+      var rect = Rectangle( );
+
+    )"";
+
+  try
+  {
+    ch.eval( script );
+  }
+  catch ( std::exception e )
+  {
+    printf( " >>> Exception thrown: %s \n" , e.what( ) );
+  }
+
+  return 1;
+}

src/main.cpp

@@ -24,7 +24,7 @@ char *mystrdup (const char *s) {
   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
+  strcpy_s(d, len+1, s);                        // Copy the characters
 #else
   strncpy(d,s,len);                        // Copy the characters
 #endif
@@ -238,7 +238,7 @@ void interactive(chaiscript::ChaiScript& chai)
     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 << "during evaluation at (" << ee.call_stack[0]->start().line << ", " << ee.call_stack[0]->start().column << ")";
       }
       std::cout << '\n';
     }
@@ -249,6 +249,13 @@ void interactive(chaiscript::ChaiScript& chai)
   }
 }
 
+double now()
+{
+  using namespace std::chrono;
+  auto now = high_resolution_clock::now();
+  return duration_cast<duration<double>>(now.time_since_epoch()).count();
+}
+
 int main(int argc, char *argv[])
 {
 
@@ -288,6 +295,10 @@ int main(int argc, char *argv[])
   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(&now), "now");
+
+  bool eval_error_ok = false;
+  bool boxed_exception_ok = false;
 
   for (int i = 0; i < argc; ++i) {
     if ( i == 0 && argc > 1 ) {
@@ -315,9 +326,15 @@ int main(int argc, char *argv[])
         arg += line + '\n' ;
       }
     } else if ( arg == "-v" || arg == "--version" ) {
-      arg = "version()" ;
+      arg = "print(version())" ;
     } else if ( arg == "-h" || arg == "--help" ) {
       arg = "help(-1)";
+    } else if ( arg == "-e" || arg == "--evalerrorok" ) {
+      eval_error_ok = true;
+      continue;
+    } else if ( arg == "--exception" ) {
+      boxed_exception_ok = true;
+      continue;
     } else if ( arg == "-i" || arg == "--interactive" ) {
       mode = eInteractive ;
     } else if ( arg.find('-') == 0 ) {
@@ -343,12 +360,23 @@ int main(int argc, char *argv[])
     catch (const chaiscript::exception::eval_error &ee) {
       std::cout << ee.pretty_print();
       std::cout << '\n';
-      return EXIT_FAILURE;
+
+      if (!eval_error_ok) {
+        return EXIT_FAILURE;
+      }
     }
-    catch (std::exception &e) {
-      std::cout << e.what() << '\n';
-      return EXIT_FAILURE;
+    catch (const chaiscript::Boxed_Value &e) {
+      std::cout << "Unhandled exception thrown of type " << e.get_type_info().name() << '\n';
+
+      if (!boxed_exception_ok) {
+        return EXIT_FAILURE;
+      }
     }
+
+//    catch (std::exception &e) {
+//      std::cout << e.what() << '\n';
+//      return EXIT_FAILURE;
+//    }
   }
 
   return EXIT_SUCCESS;

src/stl_extra.cpp

@@ -23,7 +23,11 @@
 
 CHAISCRIPT_MODULE_EXPORT chaiscript::ModulePtr create_chaiscript_module_stl_extra()
 {
-  return chaiscript::bootstrap::standard_library::list_type<std::list<chaiscript::Boxed_Value> >("List");
+
+  auto module = chaiscript::bootstrap::standard_library::list_type<std::list<chaiscript::Boxed_Value> >("List");
+  module->add(chaiscript::bootstrap::standard_library::vector_type<std::vector<uint16_t> >("u16vector"));
+  module->add(chaiscript::vector_conversion<std::vector<uint16_t>>());
+  return module;
 }
 
 #ifdef __llvm__

src/test_module.cpp

@@ -1,5 +1,6 @@
 
 #include <chaiscript/chaiscript.hpp>
+#include <chaiscript/dispatchkit/bootstrap.hpp>
 #include <string>
 
 
@@ -7,9 +8,18 @@
 class TestBaseType
 {
   public:
-    TestBaseType() : val(10), const_val(15) { }
-    TestBaseType(int) : val(10), const_val(15) {}
-    TestBaseType(int *) : val(10), const_val(15) { }
+#ifdef CHAISCRIPT_MSVC_12
+#pragma warning(push)
+#pragma warning(disable : 4351)
+#endif
+    // MSVC 12 warns that we are using new (correct) behavior 
+    TestBaseType() : val(10), const_val(15), mdarray{} { }
+    TestBaseType(int) : val(10), const_val(15), mdarray{} { }
+    TestBaseType(int *) : val(10), const_val(15), mdarray{} { }
+#ifdef CHAISCRIPT_MSVC_12
+#pragma warning(pop)
+#endif    
+    
     TestBaseType(const TestBaseType &) = default;
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
@@ -21,8 +31,16 @@ class TestBaseType
     int val;
     const int const_val;
 
+    int mdarray[2][3][5];
+    std::function<int (int)> func_member;
+
+    void set_string_val(std::string &t_str)
+    {
+      t_str = "42";
+    }
+
   private:
-    TestBaseType &operator=(const TestBaseType &);
+    TestBaseType &operator=(const TestBaseType &) = delete;
 };
 
 class Type2
@@ -39,6 +57,7 @@ class Type2
       return m_bt.val;
     }
 
+
     const char *get_str() const
     {
       return m_str.c_str();
@@ -69,7 +88,7 @@ class TestDerivedType : public TestBaseType
     int derived_only_func() { return 19; }
 
   private:
-    TestDerivedType &operator=(const TestDerivedType &);
+    TestDerivedType &operator=(const TestDerivedType &) = delete;
 };
 
 class TestMoreDerivedType : public TestDerivedType
@@ -158,7 +177,21 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::fun(&TestBaseType::val), "val");
   m->add(chaiscript::fun(&TestBaseType::const_val), "const_val");
   m->add(chaiscript::fun(&TestBaseType::base_only_func), "base_only_func");
+  m->add(chaiscript::fun(&TestBaseType::set_string_val), "set_string_val");
 
+#ifndef CHAISCRIPT_MSVC_12
+  // we cannot support these in MSVC_12 because of a bug in the implementation of
+  // std::reference_wrapper
+  // Array types
+  m->add(chaiscript::fun(&TestBaseType::mdarray), "mdarray");
+  m->add(chaiscript::bootstrap::array<int[2][3][5]>("IntArray_2_3_5"));
+  m->add(chaiscript::bootstrap::array<int[3][5]>("IntArray_3_5"));
+  m->add(chaiscript::bootstrap::array<int[5]>("IntArray_5"));
+  // end array types
+#endif
+
+  // member that is a function
+  m->add(chaiscript::fun(&TestBaseType::func_member), "func_member");
   m->add(chaiscript::fun(&get_new_int), "get_new_int");
 
 

unittests/arithmetic_conversions_test.cpp

@@ -1,70 +0,0 @@
-// Tests to make sure that type conversions happen only when they should
-
-#include <chaiscript/chaiscript.hpp>
-
-void f1(int)
-{
-}
-
-void f4(std::string)
-{
-}
-
-void f2(int)
-{
-}
-
-void f3(double)
-{
-}
-
-void f_func_return(const std::function<unsigned int (unsigned long)> &f)
-{
-  // test the ability to return an unsigned with auto conversion
-  f(4);
-}
-
-int main()
-{
-  chaiscript::ChaiScript chai;
-
-  chai.add(chaiscript::fun(&f1), "f1");
-  chai.add(chaiscript::fun(&f2), "f2");
-  chai.add(chaiscript::fun(&f3), "f2");
-  chai.add(chaiscript::fun(&f1), "f3");
-  chai.add(chaiscript::fun(&f4), "f3");
-
-  chai.add(chaiscript::fun(&f_func_return), "func_return");
-
-  // no overloads
-  chai.eval("f1(0)");
-  chai.eval("f1(0l)");
-  chai.eval("f1(0ul)");
-  chai.eval("f1(0ll)");
-  chai.eval("f1(0ull)");
-  chai.eval("f1(0.0)");
-  chai.eval("f1(0.0f)");
-  chai.eval("f1(0.0l)");
-
-  // expected overloads
-  chai.eval("f2(1)");
-  chai.eval("f2(1.0)");
-
-  // 1 non-arithmetic overload
-  chai.eval("f2(1.0)");
-
-  // various options for returning with conversions from chaiscript
-  chai.eval("func_return(fun(x) { return 5u; })");
-  chai.eval("func_return(fun(x) { return 5; })");
-  chai.eval("func_return(fun(x) { return 5.0f; })");
-
-  // this is the one call we expect to fail, ambiguous overloads
-  try {
-    chai.eval("f2(1.0l)");
-  } catch (const std::exception &) {
-    return EXIT_SUCCESS;
-  }
-
-  // if the last one did not throw, we failed
-  return EXIT_FAILURE;
-}

unittests/array_types.chai

@@ -0,0 +1,12 @@
+load_module("test_module")
+
+auto t0 = TestBaseType()
+
+assert_true(t0.mdarray.size() == 2)
+assert_true(t0.mdarray[0].size() == 3)
+assert_true(t0.mdarray[0][0].size() == 5)
+
+t0.mdarray[1][2][4] = 15;
+
+assert_true(t0.mdarray[1][2][4] == 15)
+

unittests/bool_comparisons.chai

@@ -0,0 +1,12 @@
+
+assert_true(true == true)
+assert_false(true == false)
+assert_true(true != false)
+assert_true(false != true)
+assert_true(false || true)
+assert_true(true || false)
+assert_false(true && false)
+assert_false(false && true)
+assert_true(!false)
+assert_false(!true)
+

unittests/boxed_cast_test.cpp

@@ -117,37 +117,37 @@ bool built_in_type_test(const T &initial, bool ispod)
                                  true, true, true, true, true,
                                  true, true, true, true, true,
                                  true, true, true, true, true,
-                                 ispod && true, ispod && true, ispod && true, true, true);
+                                 ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(const_var(i), true, true, false, true, false, 
                                        true, false, true, false, true,
                                        false, true, false, true, false,
                                        true, false, true, false, true,
-                                       ispod && true, ispod && true, ispod && true, false, true);
+                                       ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(var(&i), true, true, true, true, true, 
                                  true, true, true, false, false,
                                  false, false, false, false, true,
                                  true, true, true, true, true,
-                                 ispod && true, ispod && true, ispod && true, true, true);
+                                 ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(const_var(&i), true, true, false, true, false, 
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, ispod && false, true);
+                                 ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(var(std::ref(i)), true, true, true, true, true, 
                                  true, true, true, false, false,
                                  false, false, false, false, true,
                                  true, true, true, true, true,
-                                 ispod && true, ispod && true, ispod && true, true, true);
+                                 ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(var(std::cref(i)), true, true, false, true, false, 
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, false, true);
+                                 ispod, ispod, ispod, false, true);
 
   /** Const Reference Variable tests */
 
@@ -158,33 +158,33 @@ bool built_in_type_test(const T &initial, bool ispod)
                                  true, true, true, true, true,
                                  true, true, true, true, true,
                                  true, true, true, true, true,
-                                 ispod && true, ispod && true, ispod && true, true, true);
+                                 ispod, ispod, ispod, true, true);
 
   // But a pointer or reference to it should be necessarily const
   passed &= do_test<T>(var(&ir), true, true, false, true, false, 
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, false, true);
+                                 ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(var(std::ref(ir)), true, true, false, true, false, 
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, false, true);
+                                 ispod, ispod, ispod, false, true);
 
   // Make sure const of const works too
   passed &= do_test<T>(const_var(&ir), true, true, false, true, false, 
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, false, true);
+                                 ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(const_var(std::ref(ir)), true, true, false, true, false, 
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, false, true);
+                                 ispod, ispod, ispod, false, true);
 
   /** Const Reference Variable tests */
 
@@ -194,14 +194,14 @@ bool built_in_type_test(const T &initial, bool ispod)
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, false, true);
+                                 ispod, ispod, ispod, false, true);
 
   // make sure const of const works
   passed &= do_test<T>(const_var(cip), true, true, false, true, false, 
                                  true, false, true, false, false,
                                  false, false, false, false, false,
                                  true, false, true, false, true,
-                                 ispod && true, ispod && true, ispod && true, false, true);
+                                 ispod, ispod, ispod, false, true);
 
   /** shared_ptr tests **/
 
@@ -211,13 +211,13 @@ bool built_in_type_test(const T &initial, bool ispod)
                                  true, true, true, true, true,
                                  true, true, true, true, true,
                                  true, true, true, true, true,
-                                 ispod && true, ispod && true, ispod && true, true, true);
+                                 ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(const_var(ip), true, true, false, true, false, 
                                        true, false, true, false, true,
                                        false, true, false, true, false,
                                        true, false, true, false, true,
-                                       ispod && true, ispod && true, ispod && true, false, true);
+                                       ispod, ispod, ispod, false, true);
 
   /** const shared_ptr tests **/
   std::shared_ptr<const T> ipc(new T(initial));
@@ -226,14 +226,14 @@ bool built_in_type_test(const T &initial, bool ispod)
                                        true, false, true, false, true,
                                        false, true, false, true, false,
                                        true, false, true, false, true,
-                                       ispod && true, ispod && true, ispod && true, false, true);
+                                       ispod, ispod, ispod, false, true);
 
   // const of this should be the same, making sure it compiles
   passed &= do_test<T>(const_var(ipc), true, true, false, true, false, 
                                        true, false, true, false, true,
                                        false, true, false, true, false,
                                        true, false, true, false, true,
-                                       ispod && true, ispod && true, ispod && true, false, true);
+                                       ispod, ispod, ispod, false, true);
 
 
   /** Double ptr tests **/
@@ -245,7 +245,7 @@ bool built_in_type_test(const T &initial, bool ispod)
                                        true, false, true, false, true,
                                        false, true, false, true, false,
                                        true, false, true, false, true,
-                                       ispod && true, ispod && true, ispod && true, false, true);
+                                       ispod, ispod, ispod, false, true);
 */
 
   return passed;

unittests/compiled_tests.cpp

@@ -0,0 +1,804 @@
+// All of these are necessary because of catch.hpp. It's OK, they'll be
+// caught in other cpp files if chaiscript causes them
+
+#include <chaiscript/utility/utility.hpp>
+
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4190 4640 28251 4702 6330)
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wfloat-equal"
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+
+
+#define CATCH_CONFIG_MAIN
+
+#include "catch.hpp"
+
+// lambda_tests
+TEST_CASE("C++11 Lambdas Can Be Registered")
+{
+
+  // We cannot deduce the type of a lambda expression, you must either wrap it
+  // in an std::function or provide the signature
+  chaiscript::ChaiScript chai;
+
+  chai.add(chaiscript::fun([]()->std::string { return "hello"; } ), "f1");
+
+  // wrap
+  chai.add(chaiscript::fun(std::function<std::string ()>([] { return "world"; } )), "f2");
+
+  CHECK(chai.eval<std::string>("f1()") == "hello");
+  CHECK(chai.eval<std::string>("f2()") == "world");
+}
+
+
+// dynamic_object tests
+TEST_CASE("Dynamic_Object attributes can be shared with C++")
+{
+  chaiscript::ChaiScript chai;
+
+  chai("attr bob::z; def bob::bob() { this.z = 10 }; auto x = bob()");
+
+  chaiscript::dispatch::Dynamic_Object &mydo = chai.eval<chaiscript::dispatch::Dynamic_Object &>("x");
+
+  CHECK(mydo.get_type_name() == "bob");
+
+  CHECK(chaiscript::boxed_cast<int>(mydo.get_attr("z")) == 10);
+
+  chai("x.z = 15");
+
+  CHECK(chaiscript::boxed_cast<int>(mydo.get_attr("z")) == 15);
+
+  int &z = chaiscript::boxed_cast<int&>(mydo.get_attr("z"));
+
+  CHECK(z == 15);
+
+  z = 20;
+  
+  CHECK(z == 20);
+  CHECK(chaiscript::boxed_cast<int>(chai("x.z")) == 20);
+}
+
+
+TEST_CASE("Function objects can be created from chaiscript functions")
+{
+
+  chaiscript::ChaiScript chai;
+
+  chai.eval("def func() { print(\"Hello World\"); } ");
+
+  std::function<void ()> f = chai.eval<std::function<void ()> >("func");
+  f();
+
+  CHECK(chai.eval<std::function<std::string (int)> >("to_string")(6) == "6");
+  CHECK(chai.eval<std::function<std::string (const chaiscript::Boxed_Value &)> >("to_string")(chaiscript::var(6)) == "6");
+}
+
+
+TEST_CASE("ChaiScript can be created and destroyed on heap")
+{
+  chaiscript::ChaiScript *chai = new chaiscript::ChaiScript();
+  delete chai;
+}
+
+
+///////// Arithmetic Conversions
+
+// Tests to make sure that type conversions happen only when they should
+void arithmetic_conversions_f1(int)
+{
+}
+
+void arithmetic_conversions_f4(std::string)
+{
+}
+
+void arithmetic_conversions_f2(int)
+{
+}
+
+void arithmetic_conversions_f3(double)
+{
+}
+
+void arithmetic_conversions_f_func_return(const std::function<unsigned int (unsigned long)> &f)
+{
+  // test the ability to return an unsigned with auto conversion
+  f(4);
+}
+
+TEST_CASE("Test automatic arithmetic conversions")
+{
+  chaiscript::ChaiScript chai;
+
+  chai.add(chaiscript::fun(&arithmetic_conversions_f1), "f1");
+  chai.add(chaiscript::fun(&arithmetic_conversions_f2), "f2");
+  chai.add(chaiscript::fun(&arithmetic_conversions_f3), "f2");
+  chai.add(chaiscript::fun(&arithmetic_conversions_f1), "f3");
+  chai.add(chaiscript::fun(&arithmetic_conversions_f4), "f3");
+
+  chai.add(chaiscript::fun(&arithmetic_conversions_f_func_return), "func_return");
+
+  // no overloads
+  chai.eval("f1(0)");
+  chai.eval("f1(0l)");
+  chai.eval("f1(0ul)");
+  chai.eval("f1(0ll)");
+  chai.eval("f1(0ull)");
+  chai.eval("f1(0.0)");
+  chai.eval("f1(0.0f)");
+  chai.eval("f1(0.0l)");
+
+  // expected overloads
+  chai.eval("f2(1)");
+  chai.eval("f2(1.0)");
+
+  // 1 non-arithmetic overload
+  chai.eval("f2(1.0)");
+
+  // various options for returning with conversions from chaiscript
+  chai.eval("func_return(fun(x) { return 5u; })");
+  chai.eval("func_return(fun(x) { return 5; })");
+  chai.eval("func_return(fun(x) { return 5.0f; })");
+
+  CHECK_THROWS(chai.eval("f2(1.0l)"));
+}
+
+
+/////// Exception handling
+
+
+TEST_CASE("Generic exception handling with C++")
+{
+  chaiscript::ChaiScript chai;
+
+  try {
+    chai.eval("throw(runtime_error(\"error\"));");
+    REQUIRE(false);
+  } catch (const chaiscript::Boxed_Value &bv) {
+    const std::exception &e = chai.boxed_cast<const std::exception &>(bv);
+    CHECK(e.what() == std::string("error"));
+  }
+}
+
+TEST_CASE("Throw an int")
+{
+  chaiscript::ChaiScript chai;
+
+  try {
+    chai.eval("throw(1)", chaiscript::exception_specification<int>());
+    REQUIRE(false);
+  } catch (int e) {
+    CHECK(e == 1);
+  }
+}
+
+TEST_CASE("Throw int or double")
+{
+  chaiscript::ChaiScript chai;
+
+  try {
+    chai.eval("throw(1.0)", chaiscript::exception_specification<int, double>());
+    REQUIRE(false);
+  } catch (const double e) {
+    CHECK(e == 1.0);
+  }
+}
+
+TEST_CASE("Throw a runtime_error")
+{
+  chaiscript::ChaiScript chai;
+
+  try {
+    chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+    REQUIRE(false);
+  } catch (const double) {
+    REQUIRE(false);
+  } catch (int) {
+    REQUIRE(false);
+  } catch (float) {
+    REQUIRE(false);
+  } catch (const std::string &) {
+    REQUIRE(false);
+  } catch (const std::exception &) {
+    REQUIRE(true);
+  }
+}
+
+TEST_CASE("Throw unhandled type")
+{
+  chaiscript::ChaiScript chai;
+
+  try {
+    chai.eval("throw(\"error\")", chaiscript::exception_specification<int, double, float, const std::exception &>());
+    REQUIRE(false);
+  } catch (double) {
+    REQUIRE(false);
+  } catch (int) {
+    REQUIRE(false);
+  } catch (float) {
+    REQUIRE(false);
+  } catch (const std::exception &) {
+    REQUIRE(false);
+  } catch (const chaiscript::Boxed_Value &) {
+    REQUIRE(true);
+  }
+}
+
+
+///////////// Tests to make sure no arity, dispatch or guard errors leak up past eval
+
+
+int expected_eval_errors_test_one(const int &)
+{
+  return 1;
+}
+
+TEST_CASE("No unexpected exceptions leak")
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::fun(&expected_eval_errors_test_one), "test_fun");
+
+  chai.eval("def guard_fun(i) : i.get_type_info().is_type_arithmetic() {} ");
+
+  //// Dot notation
+
+  // non-existent function
+  CHECK_THROWS_AS(chai.eval("\"test\".test_one()"), chaiscript::exception::eval_error);
+  // wrong parameter type
+  CHECK_THROWS_AS(chai.eval("\"test\".test_fun()"), chaiscript::exception::eval_error);
+
+  // wrong number of parameters
+  CHECK_THROWS_AS(chai.eval("\"test\".test_fun(1)"), chaiscript::exception::eval_error);
+
+  // guard failure
+  CHECK_THROWS_AS(chai.eval("\"test\".guard_fun()"), chaiscript::exception::eval_error);
+
+
+  // regular notation
+
+  // non-existent function
+  CHECK_THROWS_AS(chai.eval("test_one(\"test\")"), chaiscript::exception::eval_error);
+
+  // wrong parameter type
+  CHECK_THROWS_AS(chai.eval("test_fun(\"test\")"), chaiscript::exception::eval_error);
+
+  // wrong number of parameters
+  CHECK_THROWS_AS(chai.eval("test_fun(\"test\")"), chaiscript::exception::eval_error);
+
+  // guard failure
+  CHECK_THROWS_AS(chai.eval("guard_fun(\"test\")"), chaiscript::exception::eval_error);
+
+
+  // index operator
+  CHECK_THROWS_AS(chai.eval("var a = [1,2,3]; a[\"bob\"];"), chaiscript::exception::eval_error);
+
+  // unary operator
+  CHECK_THROWS_AS(chai.eval("++\"bob\""), chaiscript::exception::eval_error);
+
+  // binary operator
+  CHECK_THROWS_AS(chai.eval("\"bob\" + 1"), chaiscript::exception::eval_error);
+
+
+}
+
+
+//////// Tests to make sure that the order in which function dispatches occur is correct
+
+#include <chaiscript/utility/utility.hpp>
+
+int function_ordering_test_one(const int &)
+{
+  return 1;
+}
+
+int function_ordering_test_two(int &)
+{
+  return 2;
+}
+
+TEST_CASE("Function ordering")
+{
+  chaiscript::ChaiScript chai;
+  chai.eval("def test_fun(x) { return 3; }");
+  chai.eval("def test_fun(x) : x == \"hi\" { return 4; }");
+//  chai.eval("def test_fun(x) { return 5; }");
+  chai.add(chaiscript::fun(&function_ordering_test_one), "test_fun");
+  chai.add(chaiscript::fun(&function_ordering_test_two), "test_fun");
+
+  CHECK(chai.eval<int>("test_fun(1)") == 1);
+  CHECK(chai.eval<int>("auto i = 1; test_fun(i)") == 2);
+  CHECK(chai.eval<int>("test_fun(\"bob\")") == 3);
+  CHECK(chai.eval<int>("test_fun(\"hi\")") == 4);
+}
+
+
+
+
+int functor_cast_test_call(const std::function<int (int)> &f, int val)
+{
+  return f(val);
+}
+
+TEST_CASE("Functor cast")
+{
+
+  chaiscript::ChaiScript chai;
+
+  chai.add(chaiscript::fun(&functor_cast_test_call), "test_call");
+
+  chai.eval("def func(i) { return i * 6; };");
+  int d = chai.eval<int>("test_call(func, 3)");
+
+  CHECK(d == 3 * 6);
+}
+
+
+
+int set_state_test_myfun()
+{
+  return 2;
+}
+
+TEST_CASE("Set and restore chai state")
+{
+  chaiscript::ChaiScript chai;
+
+  // save the initial state of globals and locals
+  chaiscript::ChaiScript::State firststate = chai.get_state();
+  std::map<std::string, chaiscript::Boxed_Value> locals = chai.get_locals();
+
+  // add some new globals and locals
+  chai.add(chaiscript::var(1), "i");
+
+  chai.add(chaiscript::fun(&set_state_test_myfun), "myfun");
+
+
+  CHECK(chai.eval<int>("myfun()") == 2);
+
+  CHECK(chai.eval<int>("i") == 1);
+
+  chai.set_state(firststate);
+
+  // set state should have reverted the state of the functions and dropped
+  // the 'myfun'
+
+  CHECK_THROWS_AS(chai.eval<int>("myfun()"), chaiscript::exception::eval_error &);
+
+  // set state should not affect the local variables
+  CHECK(chai.eval<int>("i") == 1);
+
+  // After resetting the locals we expect the 'i' to be gone
+  chai.set_locals(locals);
+
+  CHECK_THROWS_AS(chai.eval<int>("i"), chaiscript::exception::eval_error &);
+}
+
+
+//// Short comparisons
+
+class Short_Comparison_Test {
+ public:
+  Short_Comparison_Test() : value_(5) {}
+
+  short get_value() { return value_; }
+
+  short value_;
+};
+
+TEST_CASE("Short comparison with int")
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::user_type<Short_Comparison_Test>(), "Test");
+  chai.add(chaiscript::constructor<Short_Comparison_Test()>(), "Test");
+
+  chai.add(chaiscript::fun(&Short_Comparison_Test::get_value), "get_value");
+
+  chai.eval("auto &t = Test();");
+
+  CHECK(chai.eval<bool>("t.get_value() == 5"));
+}
+
+
+
+
+///// Test lookup of type names
+
+
+class Type_Name_MyClass
+{
+};
+
+TEST_CASE("Test lookup of type names")
+{
+  chaiscript::ChaiScript chai;
+  auto type = chaiscript::user_type<Type_Name_MyClass>();
+  chai.add(type, "MyClass");
+
+  CHECK(chai.get_type_name(type) == "MyClass");
+  CHECK(chai.get_type_name<Type_Name_MyClass>() == "MyClass");
+}
+
+
+/////// make sure many chaiscript objects can exist simultaneously 
+
+
+int simultaneous_chaiscript_do_something(int i)
+{
+  return i + 2;
+}
+
+int simultaneous_chaiscript_do_something_else(int i)
+{
+  return i * 2;
+}
+
+
+
+TEST_CASE("Simultaneous ChaiScript tests")
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::fun(&simultaneous_chaiscript_do_something), "do_something");
+  chai.add(chaiscript::var(1), "i");
+
+  for (int i = 0; i < 10; ++i)
+  {
+    chaiscript::ChaiScript chai2;
+    chai2.add(chaiscript::fun(&simultaneous_chaiscript_do_something_else), "do_something_else");
+
+    CHECK(chai.eval<int>("do_something(" + std::to_string(i) + ")") == i + 2);
+    CHECK(chai2.eval<int>("do_something_else(" + std::to_string(i) + ")") == i * 2);
+
+    CHECK_THROWS_AS(chai2.eval("do_something(1)"), chaiscript::exception::eval_error &);
+    CHECK_THROWS_AS(chai2.eval("i"), chaiscript::exception::eval_error &);
+    CHECK_NOTHROW(chai2.eval("do_something_else(1)"));
+  }
+}
+
+
+
+/////////////// test utility functions
+
+class Utility_Test
+{
+  public:
+    void function() {}
+    std::string function2() { return "Function2"; }
+    void function3() {}
+    std::string functionOverload(double) { return "double"; }
+    std::string functionOverload(int) { return "int"; }
+};
+
+TEST_CASE("Utility_Test utility class wrapper")
+{
+
+  chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
+
+  using namespace chaiscript;
+
+  /// \todo fix overload resolution for fun<>
+  chaiscript::utility::add_class<Utility_Test>(*m,
+      "Utility_Test",
+      { constructor<Utility_Test ()>(),
+        constructor<Utility_Test (const Utility_Test &)>() },
+      { {fun(&Utility_Test::function), "function"},
+        {fun(&Utility_Test::function2), "function2"},
+        {fun(&Utility_Test::function3), "function3"},
+        {fun(static_cast<std::string(Utility_Test::*)(double)>(&Utility_Test::functionOverload)), "functionOverload" },
+        {fun(static_cast<std::string(Utility_Test::*)(int)>(&Utility_Test::functionOverload)), "functionOverload" },
+        {fun(static_cast<Utility_Test & (Utility_Test::*)(const Utility_Test &)>(&Utility_Test::operator=)), "=" }
+ 
+        }
+      );
+
+
+  chaiscript::ChaiScript chai;
+  chai.add(m);
+
+  CHECK(chai.eval<std::string>("auto t = Utility_Test(); t.function2(); ") == "Function2");
+  CHECK(chai.eval<std::string>("auto t2 = Utility_Test(); t2.functionOverload(1); ") == "int");
+  CHECK(chai.eval<std::string>("auto t3 = Utility_Test(); t3.functionOverload(1.1); ") == "double");
+  chai.eval("t = Utility_Test();");
+
+}
+
+
+////// Object copy count test
+
+class Object_Copy_Count_Test
+{
+  public:
+    Object_Copy_Count_Test()
+    {
+      std::cout << "Object_Copy_Count_Test()\n";
+      ++constructcount();
+    }
+
+    Object_Copy_Count_Test(const Object_Copy_Count_Test &)
+    {
+      std::cout << "Object_Copy_Count_Test(const Object_Copy_Count_Test &)\n";
+      ++copycount();
+    }
+
+    Object_Copy_Count_Test(Object_Copy_Count_Test &&)
+    {
+      std::cout << "Object_Copy_Count_Test(Object_Copy_Count_Test &&)\n";
+      ++movecount();
+    }
+
+    ~Object_Copy_Count_Test()
+    {
+      std::cout << "~Object_Copy_Count_Test()\n";
+      ++destructcount();
+    }
+
+    static int& constructcount()
+    {
+      static int c = 0;
+      return c;
+    }
+
+    static int& copycount()
+    {
+      static int c = 0;
+      return c;
+    }
+
+    static int& movecount()
+    {
+      static int c = 0;
+      return c;
+    }
+
+    static int& destructcount()
+    {
+      static int c = 0;
+      return c;
+    }
+};
+
+Object_Copy_Count_Test object_copy_count_create()
+{
+  return Object_Copy_Count_Test();
+}
+
+TEST_CASE("Object copy counts")
+{
+  chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
+
+  m->add(chaiscript::user_type<Object_Copy_Count_Test>(), "Object_Copy_Count_Test");
+  m->add(chaiscript::constructor<Object_Copy_Count_Test()>(), "Object_Copy_Count_Test");
+  m->add(chaiscript::constructor<Object_Copy_Count_Test(const Object_Copy_Count_Test &)>(), "Object_Copy_Count_Test");
+  m->add(chaiscript::fun(&object_copy_count_create), "create");
+
+  chaiscript::ChaiScript chai;
+  chai.add(m);
+
+  chai.eval(" { auto i = create(); } ");
+
+  CHECK(Object_Copy_Count_Test::copycount() == 0);
+  CHECK(Object_Copy_Count_Test::constructcount() == 1);
+
+
+#ifdef CHAISCRIPT_MSVC
+  CHECK(Object_Copy_Count_Test::destructcount() == 3);
+  CHECK(Object_Copy_Count_Test::movecount() == 2);
+#else
+  CHECK(Object_Copy_Count_Test::destructcount() == 2);
+  CHECK(Object_Copy_Count_Test::movecount() == 1);
+#endif
+}
+
+
+///////////////////// Object lifetime test 1
+
+
+class Object_Lifetime_Test
+{
+  public:
+    Object_Lifetime_Test()
+    {
+      ++count();
+    }
+
+    Object_Lifetime_Test(const Object_Lifetime_Test &)
+    {
+      ++count();
+    }
+
+    ~Object_Lifetime_Test()
+    {
+      --count();
+    }
+
+    static int& count()
+    {
+      static int c = 0;
+      return c;
+    }
+};
+
+TEST_CASE("Object lifetime tests")
+{
+  chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
+
+  m->add(chaiscript::user_type<Object_Lifetime_Test>(), "Object_Lifetime_Test");
+  m->add(chaiscript::constructor<Object_Lifetime_Test()>(), "Object_Lifetime_Test");
+  m->add(chaiscript::constructor<Object_Lifetime_Test(const Object_Lifetime_Test &)>(), "Object_Lifetime_Test");
+  m->add(chaiscript::fun(&Object_Lifetime_Test::count), "count");
+
+  chaiscript::ChaiScript chai;
+  chai.add(m);
+
+  CHECK(chai.eval<int>("count()") == 0);
+  CHECK(chai.eval<int>("auto i = 0; { auto t = Object_Lifetime_Test(); } return i;") == 0);
+  CHECK(chai.eval<int>("i = 0; { auto t = Object_Lifetime_Test(); i = count(); } return i;") == 1);
+  CHECK(chai.eval<int>("i = 0; { auto t = Object_Lifetime_Test(); { auto t2 = Object_Lifetime_Test(); i = count(); } } return i;") == 2);
+  CHECK(chai.eval<int>("i = 0; { auto t = Object_Lifetime_Test(); { auto t2 = Object_Lifetime_Test(); } i = count(); } return i;") == 1);
+  CHECK(chai.eval<int>("i = 0; { auto t = Object_Lifetime_Test(); { auto t2 = Object_Lifetime_Test(); }  } i = count(); return i;") == 0);
+}
+
+
+
+//// Object lifetime tests 2
+
+template<typename T>
+struct Object_Lifetime_Vector2
+{
+  Object_Lifetime_Vector2() : x(0), y(0) {}
+  Object_Lifetime_Vector2(T px, T py) : x(px), y(py) {}
+  Object_Lifetime_Vector2(const Object_Lifetime_Vector2& cp) : x(cp.x), y(cp.y) {}
+
+  Object_Lifetime_Vector2& operator+=(const Object_Lifetime_Vector2& vec_r)
+  {
+    x += vec_r.x;
+    y += vec_r.y;
+    return *this;
+  }
+
+  Object_Lifetime_Vector2 operator+(const Object_Lifetime_Vector2& vec_r)
+  {
+    return Object_Lifetime_Vector2(*this += vec_r);
+  }
+
+  Object_Lifetime_Vector2 &operator=(const Object_Lifetime_Vector2& ver_r)
+  {
+    x = ver_r.x;
+    y = ver_r.y;
+    return *this;
+  }
+
+
+  T x;
+  T y;
+};
+
+Object_Lifetime_Vector2<float> Object_Lifetime_Vector2_GetValue()
+{
+  return Object_Lifetime_Vector2<float>(10,15);
+}
+
+TEST_CASE("Object lifetime test 2")
+{
+  chaiscript::ChaiScript _script;
+
+  //Registering stuff
+  _script.add(chaiscript::user_type<Object_Lifetime_Vector2<float>>(), "Object_Lifetime_Vector2f");
+  _script.add(chaiscript::constructor<Object_Lifetime_Vector2<float> ()>(), "Object_Lifetime_Vector2f");
+  _script.add(chaiscript::constructor<Object_Lifetime_Vector2<float> (float, float)>(), "Object_Lifetime_Vector2f");
+  _script.add(chaiscript::constructor<Object_Lifetime_Vector2<float> (const Object_Lifetime_Vector2<float>&)>(), "Object_Lifetime_Vector2f");
+  _script.add(chaiscript::fun(&Object_Lifetime_Vector2<float>::x), "x");
+  _script.add(chaiscript::fun(&Object_Lifetime_Vector2<float>::y), "y");
+  _script.add(chaiscript::fun(&Object_Lifetime_Vector2<float>::operator +), "+");
+  _script.add(chaiscript::fun(&Object_Lifetime_Vector2<float>::operator +=), "+=");
+  _script.add(chaiscript::fun(&Object_Lifetime_Vector2<float>::operator =), "=");
+  _script.add(chaiscript::fun(&Object_Lifetime_Vector2_GetValue), "getValue");
+
+  _script.eval(R"(
+    var test = 0.0
+    var test2 = Object_Lifetime_Vector2f(10,10)
+
+    test = getValue().x
+    print(test)
+    print(test2.x)
+    )");
+
+  CHECK(_script.eval<std::string>("to_string(test)") == "10");
+  CHECK(_script.eval<std::string>("to_string(test2.x)") == "10");
+
+}
+
+
+
+
+///// Non-polymorphic base class conversions
+class Non_Poly_Base {};
+class Non_Poly_Derived : public Non_Poly_Base {};
+int myfunction(Non_Poly_Base *)
+{
+  return 2;
+}
+
+TEST_CASE("Test Derived->Base with non-polymorphic classes")
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::base_class<Non_Poly_Base, Non_Poly_Derived>());
+  Non_Poly_Derived d;
+  chai.add(chaiscript::var(&d), "d");
+  chai.add(chaiscript::fun(&myfunction), "myfunction");
+  CHECK(chai.eval<int>("myfunction(d)") == 2);
+}
+
+
+struct TestCppVariableScope
+{
+  void print()
+  {
+    std::cout << "Printed" << std::endl;
+  }
+};
+
+TEST_CASE("Variable Scope When Calling From C++")
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::user_type<TestCppVariableScope>(), "Test");
+  chai.add(chaiscript::constructor<TestCppVariableScope()>(), "Test");
+  chai.add(chaiscript::fun(&TestCppVariableScope::print), "print");
+  chai.eval(R"(var t := Test();
+
+      def func()
+      {
+        t.print();
+      }
+
+      )");
+
+  CHECK_THROWS(chai.eval("func()"));
+
+  chai.eval("dump_object(t)");
+
+  auto func = chai.eval<std::function<void()>>("func");
+  CHECK_THROWS(func());
+}
+
+TEST_CASE("Variable Scope When Calling From C++ 2")
+{
+  chaiscript::ChaiScript chai;
+  chai.eval("var obj = 2;");
+  auto func = chai.eval<std::function<void()>>("fun(){ return obj; }");
+  CHECK_THROWS(func());
+}
+
+void ulonglong(unsigned long long i) {
+  std::cout << i << '\n';
+}
+
+
+void longlong(long long i) {
+  std::cout << i << '\n';
+}
+
+TEST_CASE("Test long long dispatch")
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::fun(&longlong), "longlong");
+  chai.add(chaiscript::fun(&ulonglong), "ulonglong");
+  chai.eval("longlong(15)");
+  chai.eval("ulonglong(15)");
+}
+

unittests/cpp_lambda_test.cpp

@@ -1,29 +0,0 @@
-#include <chaiscript/utility/utility.hpp>
-
-
-int main()
-{
-
-  // We cannot deduce the type of a lambda expression, you must either wrap it
-  // in an std::function or provide the signature
-  
-
-  chaiscript::ChaiScript chai;
-
-  // provide the signature
-  chai.add(chaiscript::fun<std::string ()>([] { return "hello"; } ), "f1");
-
-  // wrap
-  chai.add(chaiscript::fun(std::function<std::string ()>([] { return "world"; } )), "f2");
-
-  if (chai.eval<std::string>("f1()") == "hello"
-      && chai.eval<std::string>("f2()") == "world")
-  {
-    return EXIT_SUCCESS;
-  } else {
-    return EXIT_FAILURE;
-  }
-
-
-
-}

unittests/dynamic_object_dynamic_attrs.chai

@@ -0,0 +1,30 @@
+
+class MyClass {
+  def MyClass()
+  {
+  }
+
+  def mult(double d) {
+    this.y * d
+  }
+};
+
+var o = MyClass();
+o.f = fun(x,y) { x * y; }
+assert_true(o.f(3,4) == 12);
+
+o.f2 = fun(x) { x * 3; }
+assert_true(o.f2(3) == 9);
+
+o.y = 15;
+o.f3 = fun(x) { x * this.y; }
+assert_true(o.f3(4) == 60);
+
+assert_true(o.mult(3.0) == 45.0);
+
+
+var o2 = Dynamic_Object();
+o2.a = 15
+assert_true(o2.a == 15)
+
+assert_true(o2["a"] == 15)

unittests/dynamic_object_dynamic_attrs_explicit.chai

@@ -0,0 +1,14 @@
+
+class MyClass {
+  def MyClass()
+  {
+    this.set_explicit(true);
+  }
+};
+
+var o = MyClass();
+
+assert_true(o.is_explicit());
+
+assert_throws("error", fun[o](){o.x = 2})
+

unittests/dynamic_object_test.cpp

@@ -1,44 +0,0 @@
-
-#include <chaiscript/utility/utility.hpp>
-
-template<typename LHS, typename RHS>
-void assert_equal(const LHS &lhs, const RHS &rhs)
-{
-  if (lhs==rhs)
-  {
-    return;
-  } else {
-    std::cout << "Got: " << lhs << " expected " << rhs << '\n';
-    exit(EXIT_FAILURE);
-  }
-}
-
-int main()
-{
-  chaiscript::ChaiScript chai;
-
-  chai("attr bob::z; def bob::bob() { this.z = 10 }; auto x = bob()");
-
-  chaiscript::dispatch::Dynamic_Object &mydo = chai.eval<chaiscript::dispatch::Dynamic_Object &>("x");
-
-  assert_equal(mydo.get_type_name(), "bob");
-
-  assert_equal(chaiscript::boxed_cast<int>(mydo.get_attr("z")), 10);
-
-  chai("x.z = 15");
-
-  assert_equal(chaiscript::boxed_cast<int>(mydo.get_attr("z")), 15);
-
-  int &z = chaiscript::boxed_cast<int&>(mydo.get_attr("z"));
-
-  assert_equal(z, 15);
-
-  z = 20;
-  
-  assert_equal(z, 20);
-
-  assert_equal(chaiscript::boxed_cast<int>(chai("x.z")), 20);
-  
-  return EXIT_SUCCESS;
-
-}

unittests/eval.chai

@@ -1 +1,3 @@
 assert_equal(7, eval("3 + 4"))
+
+

unittests/eval_catch_exception_test.cpp

@@ -1,122 +0,0 @@
-// Tests to make sure that the order in which function dispatches occur is correct
-
-#include <chaiscript/chaiscript.hpp>
-
-int test_generic()
-{
-  chaiscript::ChaiScript chai;
-  
-  try {
-    chai.eval("throw(runtime_error(\"error\"));");
-  } catch (const chaiscript::Boxed_Value &bv) {
-    const std::exception &e = chai.boxed_cast<const std::exception &>(bv);
-    if (e.what() == std::string("error"))
-    {
-      return EXIT_SUCCESS;
-    }
-  }
-
-  std::cout << "test_generic failed\n";
-  return EXIT_FAILURE;
-}
-
-int test_1()
-{
-  chaiscript::ChaiScript chai;
-  
-  try {
-    chai.eval("throw(1)", chaiscript::exception_specification<int>());
-  } catch (int e) {
-    if (e == 1)
-    {
-      return EXIT_SUCCESS;
-    }
-  }
-
-  std::cout << "test_1 failed\n";
-  return EXIT_FAILURE;
-}
-
-int test_2()
-{
-  chaiscript::ChaiScript chai;
-  
-  try {
-    chai.eval("throw(1.0)", chaiscript::exception_specification<int, double>());
-  } catch (const double e) {
-    if (e == 1.0)
-    {
-      return EXIT_SUCCESS;
-    }
-  }
-
-  std::cout << "test_2 failed\n";
-  return EXIT_FAILURE;
-}
-
-int test_5()
-{
-  chaiscript::ChaiScript chai;
-
-  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\n";
-    return EXIT_FAILURE;
-  } catch (int) {
-    std::cout << "test_5 failed with int\n";
-    return EXIT_FAILURE;
-  } catch (float) {
-    std::cout << "test_5 failed with float\n";
-    return EXIT_FAILURE;
-  } catch (const std::string &) {
-    std::cout << "test_5 failed with string\n";
-    return EXIT_FAILURE;
-  } catch (const std::exception &) {
-    return EXIT_SUCCESS;
-  }
-
-  std::cout << "test_5 failed\n";
-  return EXIT_FAILURE;
-}
-
-int test_unhandled()
-{
-  chaiscript::ChaiScript chai;
-
-  try {
-    chai.eval("throw(\"error\")", chaiscript::exception_specification<int, double, float, const std::exception &>());
-  } catch (double) {
-    std::cout << "test_unhandled failed with double\n";
-    return EXIT_FAILURE;
-  } catch (int) {
-    std::cout << "test_unhandled failed with int\n";
-    return EXIT_FAILURE;
-  } catch (float) {
-    std::cout << "test_unhandled failed with float\n";
-    return EXIT_FAILURE;
-  } catch (const std::exception &) {
-    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\n";
-  return EXIT_FAILURE;
-}
-
-
-int main()
-{
-  if (test_generic() == EXIT_SUCCESS
-    && test_1() == EXIT_SUCCESS
-    && test_2() == EXIT_SUCCESS
-    && test_5() == EXIT_SUCCESS
-    && test_unhandled() == EXIT_SUCCESS) 
-  {
-    return EXIT_SUCCESS;
-  } else {
-    return EXIT_FAILURE;
-  }
-}

unittests/eval_file.chai

@@ -0,0 +1,19 @@
+
+try {
+  eval_file("use.inc")
+  assert_true(true)
+  print("used use.inc")
+} catch (e) {
+  print("error: " + e.what())
+  assert_true(false)
+}
+
+
+try {
+  //we expect this second eval_file to fail because of a function redefinition
+  eval_file("use.inc")
+  assert_true(false)
+  print("used use.inc x2")
+} catch (e) {
+  assert_true(true)
+}

unittests/expected_eval_errors_test.cpp

@@ -1,111 +0,0 @@
-// Tests to make sure no arity, dispatch or guard errors leak up past eval
-
-#include <chaiscript/utility/utility.hpp>
-
-int test_one(const int &)
-{
-  return 1;
-}
-
-int main()
-{
-  chaiscript::ChaiScript chai;
-  chai.add(chaiscript::fun(&test_one), "test_fun");
-
-  chai.eval("def guard_fun(i) : i.get_type_info().is_type_arithmetic() {} ");
-
-  bool eval_error = true;
-
-  // Dot notation
-
-  try {
-    // non-existent function
-    chai.eval("\"test\".test_one()");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  try {
-    // wrong parameter type
-    chai.eval("\"test\".test_fun()");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  try {
-    // wrong number of parameters
-    chai.eval("\"test\".test_fun(1)");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  try {
-    // guard failure
-    chai.eval("\"test\".guard_fun(1)");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-
-
-  // regular notation
-
-  try {
-    // non-existent function
-    chai.eval("test_one(\"test\")");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  try {
-    // wrong parameter type
-    chai.eval("test_fun(\"test\")");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  try {
-    // wrong number of parameters
-    chai.eval("test_fun(\"test\")");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  try {
-    // guard failure
-    chai.eval("guard_fun(\"test\")");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-
-  // index operator
-  try {
-    chai.eval("var a = [1,2,3]; a[\"bob\"];");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  // unary operator
-  try {
-    chai.eval("++\"bob\"");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-  // binary operator
-  try {
-    chai.eval("\"bob\" + 1");
-    eval_error = false;
-  } catch (const chaiscript::exception::eval_error &) {
-  }
-
-
-  if (eval_error)
-  {
-    return EXIT_SUCCESS;
-  } else {
-    return EXIT_FAILURE;
-  }
-
-}

unittests/float.chai

@@ -5,3 +5,15 @@ assert_equal(1.2, 1.2)
 assert_equal(true, .5 > 0)
 assert_equal(true, .5 < 1)
 assert_equal(0.5, .5)
+
+// Scientific notation tests
+assert_true(to_string(-1.7e30f) == "-1.7e+30" || to_string(-1.7e30f) == "-1.7e+030")
+assert_equal(to_string(+17.9E04), "179000")
+assert_equal(to_string(-1.7e+300), "-1.7e+300")
+assert_equal(to_string(-1.7e-300), "-1.7e-300")
+assert_true(to_string(17.5e30l) == "1.75e+31" || to_string(17.5e30l) == "1.75e+031")
+assert_equal(to_string(1/3.14159e300L), "3.1831e-301")
+assert_true(to_string(1.0 / 12345) == "8.10045e-05" || to_string(1.0 / 12345) == "8.10045e-005")
+assert_true(to_string(3e8F) == "3e+08" || to_string(3e8F) == "3e+008" )
+assert_equal(to_string(-15E-8*3e8), "-45")
+assert_equal(to_string(-0.5e+3+20e-01), "-498")

unittests/function_attributes.chai

@@ -0,0 +1,23 @@
+// Test attributes/members that are functions
+
+load_module("test_module")
+
+class MyClass
+{
+  var func_member;
+
+  def MyClass() {}
+
+}
+
+auto t0 = MyClass();
+
+t0.func_member = fun(int i){ i * 3; };
+
+assert_true(func_member(t0)(2) == 6)
+assert_true((func_member(t0))(2) == 6)
+assert_true(t0.func_member(2) == 6)
+
+t0.func_member = fun() { 12; };
+
+assert_true(t0.func_member() == 12);

unittests/function_members.chai

@@ -0,0 +1,12 @@
+// Test attributes/members that are functions
+
+load_module("test_module")
+
+auto t0 = TestBaseType()
+
+t0.func_member = fun(int i){ i * 3; };
+
+assert_true(func_member(t0)(2) == 6)
+assert_true((func_member(t0))(2) == 6)
+assert_true(t0.func_member(2) == 6)
+

unittests/function_ordering_test.cpp

@@ -1,38 +0,0 @@
-// Tests to make sure that the order in which function dispatches occur is correct
-
-#include <chaiscript/utility/utility.hpp>
-
-int test_one(const int &)
-{
-  return 1;
-}
-
-int test_two(int &)
-{
-  return 2;
-}
-
-int main()
-{
-  chaiscript::ChaiScript chai;
-  chai.eval("def test_fun(x) { return 3; }");
-  chai.eval("def test_fun(x) : x == \"hi\" { return 4; }");
-//  chai.eval("def test_fun(x) { return 5; }");
-  chai.add(chaiscript::fun(&test_one), "test_fun");
-  chai.add(chaiscript::fun(&test_two), "test_fun");
-
-  int res1 = chai.eval<int>("test_fun(1)");
-  int res2 = chai.eval<int>("auto i = 1; test_fun(i)");
-  int res3 = chai.eval<int>("test_fun(\"bob\")");
-  int res4 = chai.eval<int>("test_fun(\"hi\")");
-
-  if (res1 == 1
-      && res2 == 2 
-      && res3 == 3
-      && res4 == 4 )
-  {
-    return EXIT_SUCCESS;
-  } else {
-    return EXIT_FAILURE;
-  }
-}

unittests/functor_cast_test.cpp

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

unittests/functor_creation_test.cpp

@@ -1,27 +0,0 @@
-#include <chaiscript/utility/utility.hpp>
-
-
-int main()
-{
-
-  chaiscript::ChaiScript chai;
-
-  chai.eval("def func() { print(\"Hello World\"); } ");
-
-  std::function<void ()> f = chai.eval<std::function<void ()> >("func");
-  f();
-
-  if (chai.eval<std::function<std::string (int)> >("to_string")(6) != "6")
-  {
-    return EXIT_FAILURE;
-  }
-
-  if (chai.eval<std::function<std::string (const chaiscript::Boxed_Value &)> >("to_string")(chaiscript::var(6)) == "6")
-  {
-    return EXIT_SUCCESS;
-  } else {
-    return EXIT_FAILURE;
-  }
-
-
-}

unittests/future.chai

@@ -7,8 +7,8 @@ var func = fun(){
 }
 
 
-var fut1 := async(func);
-var fut2 := async(func);
+var fut1 = async(func);
+var fut2 = async(func);
 
 // simply executing without crashing is good enough for this test
 

unittests/global.chai

@@ -0,0 +1,18 @@
+// Test global 
+
+GLOBAL g = 3;
+assert_true(g == 3);
+
+var v := g;
+assert_true(v == 3);
+
+GLOBAL g = 2;
+assert_true(g == 2);
+assert_true(v == 2);
+
+def f() {
+  assert_true(g == 2);
+}
+
+f();
+

unittests/heap_allocated_chaiscript_test.cpp

@@ -1,10 +0,0 @@
-#include <chaiscript/chaiscript.hpp>
-
-
-int main()
-{
-  chaiscript::ChaiScript *chai = new chaiscript::ChaiScript();
-  delete chai;
-
-  return EXIT_SUCCESS;
-}

unittests/hex_escapes.chai

@@ -0,0 +1,6 @@
+
+assert_equal("\x39", "9")
+assert_equal("\x039", "9")
+assert_equal("\x39g", "9g")
+assert_equal("b\x39g", "b9g")
+

unittests/integer_literal_test.cpp

@@ -5,9 +5,10 @@
 template<typename T>
 bool test_literal(T val, const std::string &str)
 {
+  std::cout << "Comparing : " << val;
   chaiscript::ChaiScript chai;
   T val2 = chai.eval<T>(str);
-  std::cout << "Comparing : " << val << " " << val2 << '\n';
+  std::cout << " " << val2 << '\n';
   return val == val2;
 }
 
@@ -74,6 +75,39 @@ int main()
  && TEST_LITERAL(177777777777777777)
  && TEST_LITERAL(1777777777777777777)
 
+ && test_literal(0xF, "0b1111")
+ && test_literal(0xFF, "0b11111111")
+ && test_literal(0xFFF, "0b111111111111")
+ && test_literal(0xFFFF, "0b1111111111111111")
+ && test_literal(0xFFFFF, "0b11111111111111111111")
+ && test_literal(0xFFFFFF, "0b111111111111111111111111")
+ && test_literal(0xFFFFFFF, "0b1111111111111111111111111111")
+ && test_literal(0xFFFFFFFF, "0b11111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFF, "0b111111111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFFF, "0b1111111111111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFFFF, "0b11111111111111111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFFFFF, "0b111111111111111111111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFFFFFF, "0b1111111111111111111111111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFFFFFFF, "0b11111111111111111111111111111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFFFFFFFF, "0b111111111111111111111111111111111111111111111111111111111111")
+ && test_literal(0xFFFFFFFFFFFFFFFF, "0b1111111111111111111111111111111111111111111111111111111111111111")
+
+ && test_literal(0x7, "0b111")
+ && test_literal(0x7F, "0b1111111")
+ && test_literal(0x7FF, "0b11111111111")
+ && test_literal(0x7FFF, "0b111111111111111")
+ && test_literal(0x7FFFF, "0b1111111111111111111")
+ && test_literal(0x7FFFFF, "0b11111111111111111111111")
+ && test_literal(0x7FFFFFF, "0b111111111111111111111111111")
+ && test_literal(0x7FFFFFFF, "0b1111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFF, "0b11111111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFFF, "0b111111111111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFFFF, "0b1111111111111111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFFFFF, "0b11111111111111111111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFFFFFF, "0b111111111111111111111111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFFFFFFF, "0b1111111111111111111111111111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFFFFFFFF, "0b11111111111111111111111111111111111111111111111111111111111")
+ && test_literal(0x7FFFFFFFFFFFFFFF, "0b111111111111111111111111111111111111111111111111111111111111111")
 )
   {
     return EXIT_SUCCESS;

unittests/json_1.chai

@@ -0,0 +1,3 @@
+
+
+assert_true(from_json("null").is_var_null())

unittests/json_10.chai

@@ -0,0 +1 @@
+assert_equal(from_json("\"This is a\\n\\nMultiline string\""), "This is a\n\nMultiline string")

unittests/json_11.chai

@@ -0,0 +1,14 @@
+assert_equal(from_json(
+"{\n" +
+"    \"T1\" : \"Value With a Quote : \\\"\",\n" +
+"    \"T2\" : \"Value With a Rev Solidus : \\/\",\n" +
+"    \"T3\" : \"Value with a Solidus : \\\\\",\n" +
+"    \"T4\" : \"Value with a Backspace : \\b\",\n" +
+"    \"T5\" : \"Value with a Formfeed : \\f\",\n" +
+"    \"T6\" : \"Value with a Newline : \\n\",\n" +
+"    \"T7\" : \"Value with a Carriage Return : \\r\",\n" +
+"    \"T8\" : \"Value with a Horizontal Tab : \\t\"\n" +
+"}"), [ "T1" : "Value With a Quote : \"", "T2" : "Value With a Rev Solidus : /", "T3" : "Value with a Solidus : \\", "T4" : "Value with a Backspace : \b", "T5" : "Value with a Formfeed : \f", "T6" : "Value with a Newline : \n", "T7" : "Value with a Carriage Return : \r", "T8" : "Value with a Horizontal Tab : \t" ]);
+
+
+