Merge pull request #332 from ftk/develop

Ability to disable module loading support at compile time

.decent_ci-Linux.yaml

@@ -1,30 +1,53 @@
 compilers:
   - name: "clang"
-    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
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=OFF -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DRUN_PERFORMANCE_TESTS:BOOL=ON
+    collect_performance_results: true
   - name: "clang"
     build_tag: "LibC++"
-    version: "3.5"
+    version: "3.6"
     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.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_ADDRESS_SANITIZER:BOOL=ON
+    cmake_extra_flags: -DRUN_FUZZY_TESTS:BOOL=TRUE -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"
-    version: "4.8"
-    cmake_extra_flags: -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DBUILD_TESTING:BOOL=ON
-  - name: "gcc"
-    version: "4.6"
+  - name: "clang"
+    version: "3.7"
     skip_packaging: true
-    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=OFF -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DRUN_PERFORMANCE_TESTS:BOOL=ON
+    collect_performance_results: true
+  - name: "clang"
+    build_tag: "LibC++"
+    version: "3.7"
+    skip_packaging: true
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=ON -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: "gcc"
+    version: "4.9"
+    cmake_extra_flags: -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DBUILD_TESTING:BOOL=ON -DRUN_PERFORMANCE_TESTS:BOOL=ON
+    collect_performance_results: true
+  - name: "gcc"
+    version: "4.9"
+    skip_packaging: true
+    build_tag: "NoThreads"
+    cmake_extra_flags: -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DBUILD_TESTING:BOOL=ON -DRUN_PERFORMANCE_TESTS:BOOL=ON -DMULTITHREAD_SUPPORT_ENABLED:BOOL=OFF
+    collect_performance_results: true
+  - name: "gcc"
+    version: "5"
+    skip_packaging: true
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DRUN_PERFORMANCE_TESTS:BOOL=ON
+    collect_performance_results: true
   - name: cppcheck
-    compiler_extra_flags: --enable=all -I include --inline-suppr -Umax  --suppress="*:cmake*" --suppress="*:unittests/catch.hpp" --force
+    compiler_extra_flags: --enable=all -I include --inline-suppr -Umax  --suppress="*:unittests/catch.hpp" --force --suppress="unusedFunction:*"
+  - name: custom_check
+    commands:
+       - ./contrib/check_for_tabs.rb
+       - ./contrib/check_for_todos.rb
 

.decent_ci-MacOS.yaml

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

.decent_ci-Windows.yaml

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

.github/CONTRIBUTING.md

@@ -0,0 +1,41 @@
+# Contributing to ChaiScript
+
+Thank you for contributing!
+
+# Pull Requests
+
+Please follow the existing style in the code you are patching.
+
+ - two space indent
+ - no tabs EVER
+ - match the existing indentation level
+ 
+All ChaiScript commits are run through a large set of builds and analysis on all supported platforms. Those results are posted on the 
+[build dashboard](http://chaiscript.com/ChaiScript-BuildResults/index.html). No PR will be accepted until all tests pass.
+
+The build system has full integration with GitHub and you will be notified automatically if all tests have passed.
+
+# Issues
+
+Please do not post a "chaiscript is too slow", "chaiscript compiles too slowly", or "chaiscript needs more documentation" issue
+without first reading the following notes.
+
+## ChaiScript is Too Slow
+
+We are actively working on constently improving the runtime performance of ChaiScript. With the performance being
+[monitored with each commit](http://chaiscript.com/ChaiScript-BuildResults/performance.html).
+
+If you feel you *must* post an issue about performance, please post a complete example that illustrates the exact case you
+feel should be better optimized.
+
+Any issue request regarding performance without a complete example of the issue experienced will be closed.
+
+## ChaiScript Compiles Too Slowly
+
+This is also something we are actively working on. If you need highly optimized build times, please see [this discussion
+on the discourse site](http://discourse.chaiscript.com/t/slow-build-times/94).
+
+## ChaiScript Needs More Documentation
+
+If you have a question that is not addressed in the [cheatsheet](https://github.com/ChaiScript/ChaiScript/blob/develop/cheatsheet.md) 
+please open an issue so we can get the Cheatsheet updated.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,10 @@
+ * Compiler Used:
+ * Operating System:
+ * Architecture (ARM/x86/32bit/64bit/etc): 
+ 
+
+### Expected Behavior 
+
+### Actual Behavior 
+
+### Minimal Example to Reproduce Behavior

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,8 @@
+Issue this pull request references: #
+
+Changes proposed in this pull request
+
+ -
+ -
+ -
+ 

.travis.yml

@@ -1,25 +1,64 @@
 language: cpp
-compiler:
-  - gcc
+
+
+addons:
+  apt:
+    sources: 
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.9
+      - g++-5
+  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
+      
+matrix:
+  include:
+    - os: linux
+      sudo: false
+      env: GCC_VER="4.9"
+      compiler: gcc
+    - os: linux
+      sudo: false
+      env: GCC_VER="4.9" CMAKE_OPTIONS="-D DYNLOAD_ENABLED:BOOL=FALSE -D MULTITHREAD_SUPPORT_ENABLED:BOOL=FALSE -D USE_STD_MAKE_SHARED:BOOL=TRUE" BUILD_ONLY=1
+      compiler: gcc
+    - os: linux
+      sudo: false
+      env: GCC_VER="5" CPPCHECK=1 COVERAGE=1 CMAKE_OPTIONS="-D RUN_FUZZY_TESTS:BOOL=TRUE"
+      compiler: gcc
+    - os: osx
+      compiler: clang
+      osx_image: xcode8
+    - os: osx
+      compiler: clang
+      osx_image: xcode8
+      env: CMAKE_OPTIONS="-D DYNLOAD_ENABLED:BOOL=FALSE -D MULTITHREAD_SUPPORT_ENABLED:BOOL=FALSE -D USE_STD_MAKE_SHARED:BOOL=TRUE" BUILD_ONLY=1
+  
 env:
-  - 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:
-  - 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
+  - if [ "${GCC_VER}" != "" ]; then export CXX="g++-$GCC_VER" CC="gcc-$GCC_VER" GCOV="gcov-$GCC_VER" ; fi
+  - pip install --user cpp-coveralls
+
 script: 
-  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug .
-  - make -j2
-  - make test
-  - mkdir gcov
-  - find CMakeFiles/ -name "*.gc*" -exec mv {} gcov/ \;
-  - $GCOV -d -o gcov gcov/*.gcda
-  - coveralls -n -E ".*\.cpp"
-after_script:
-  - contrib/codeanalysis/runcppcheck.sh
+  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug $CMAKE_OPTIONS . 
+  - cmake --build . -- -j2
+  - if [ "${BUILD_ONLY}" != "1" ]; then ctest; fi
+  - if [ "${COVERAGE}" = "1" ]; then bash <(curl -s https://raw.githubusercontent.com/codecov/codecov-bash/master/codecov) -x $GCOV -a "-s `pwd`" ; fi
+
+#after_script:
+#  - if [ ${CPPCHECK} = 1 ]; then contrib/codeanalysis/runcppcheck.sh ; fi
+
+
 notifications:
   email:
     recipients:
@@ -32,8 +71,3 @@ notifications:
     on_success: change  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
     on_start: false     # default: false
-env:
-  global:
-    secure: eiaR6pXiiEpyB8+LLQ1NvZdl0Yylru1BLy9lMoHl+IpUNGGQGywmW/2WAn77rFfmR1OPA2qWQLfgPwgK0HxUA9HHlot9tre5QhiN2Lw8NOT8tCZ6tTm2+QntDBjBGJyal/knRvQkn/6qs6GxlXRerz4ArnnuPL1vESt3zwB0YtU=
-
-

CMakeLists.txt

@@ -14,11 +14,14 @@ ELSE()
 project(chaiscript)
 
 option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
+option(DYNLOAD_ENABLED "Dynamic Loading 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)
+option(RUN_PERFORMANCE_TESTS "Run Performance Tests" FALSE)
 
 mark_as_advanced(USE_STD_MAKE_SHARED)
 
@@ -67,6 +70,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)
@@ -92,8 +102,8 @@ set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt")
 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 7)
+set(CPACK_PACKAGE_VERSION_MAJOR 6)
+set(CPACK_PACKAGE_VERSION_MINOR 0)
 set(CPACK_PACKAGE_VERSION_PATCH 0)
 
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
@@ -114,16 +124,12 @@ configure_file(Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile)
 include(CTest)
 include(CPack)
 
-include(cmake/CheckCXX11Features.cmake)
-
 if(NOT MINGW)
   find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
 endif()
 
-if(HAS_CXX11_VARIADIC_TEMPLATES)
-  message(STATUS "Variadic Template support detected")
-else()
-  message(SEND_ERROR "The selected compiler does not support the C++11 feature Variadic Templates.")
+if (UNIX AND NOT APPLE)
+  find_program(VALGRIND NAMES valgrind PATH /usr/bin /usr/local/bin)
 endif()
 
 enable_testing()
@@ -143,21 +149,24 @@ endif()
 if(CMAKE_COMPILER_IS_GNUCC)
   execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
 
-  if(GCC_VERSION VERSION_LESS 4.8)
-    set(CPP11_FLAG "-std=c++0x")
+  if(GCC_VERSION VERSION_LESS 4.9)
+    set(CPP11_FLAG "-std=c++1y")
   else()
-    set(CPP11_FLAG "-std=c++11")
+    set(CPP11_FLAG "-std=c++14")
   endif()
 else()
-  set(CPP11_FLAG "-std=c++11")
+  set(CPP11_FLAG "-std=c++14")
 endif()
 
 if(MSVC)
-  add_definitions(/W4)
+  add_definitions(/W4 /w14545 /w34242 /w34254 /w34287 /w44263 /w44265 /w44296 /w44311 /w44826 /we4289 /w14546 /w14547 /w14549 /w14555 /w14619 /w14905 /w14906 /w14928)
 
-  # VS2013 doesn't have magic statics
   if (MSVC_VERSION STREQUAL "1800")
+    # VS2013 doesn't have magic statics
     add_definitions(/w44640)
+  else()
+    # enum warnings are too noisy on MSVC2013
+    add_definitions(/w34062)
   endif()
 
   add_definitions(/bigobj)
@@ -170,10 +179,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 -Wunused -Woverloaded-virtual  -pedantic ${CPP11_FLAG})
+  add_definitions(-Wall -Wextra -Wconversion -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 -Wno-exit-time-destructors)
+    add_definitions(-Weverything -Wno-c++98-compat-pedantic  -Wno-c++98-compat -Wno-documentation -Wno-switch-enum -Wno-weak-vtables -Wno-missing-prototypes -Wno-padded -Wno-missing-noreturn -Wno-exit-time-destructors -Wno-documentation-unknown-command)
   else()
     add_definitions(-Wnoexcept)
   endif()
@@ -205,7 +214,7 @@ endif()
 include_directories(include)
 
 
-set(Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/type_conversions.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.chai include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
+set(Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/type_conversions.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.hpp include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp include/chaiscript/utility/json.hpp include/chaiscript/utility/json_wrap.hpp)
 
 set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
 
@@ -213,10 +222,16 @@ if(NOT MULTITHREAD_SUPPORT_ENABLED)
   add_definitions(-DCHAISCRIPT_NO_THREADS)
 endif()
 
+if(NOT DYNLOAD_ENABLED)
+  add_definitions(-DCHAISCRIPT_NO_DYNLOAD)
+endif()
+
 if(CMAKE_HOST_UNIX)
+  if(DYNLOAD_ENABLED)
     if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
       list(APPEND LIBS "dl")
     endif()
+  endif()
 
   if(MULTITHREAD_SUPPORT_ENABLED)
     if(CMAKE_COMPILER_IS_GNUCC)
@@ -241,27 +256,37 @@ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
 
+add_library(stdlib STATIC static_libs/chaiscript_stdlib.cpp)
+add_library(parser STATIC static_libs/chaiscript_parser.cpp)
 
-add_library(chaiscript_stdlib-${CHAI_VERSION} MODULE src/chaiscript_stdlib.cpp)
+add_library(chaiscript_stdlib-${CHAI_VERSION} MODULE src/chaiscript_stdlib_module.cpp)
 target_link_libraries(chaiscript_stdlib-${CHAI_VERSION} ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
 
+set(CHAISCRIPT_LIBS stdlib parser)
+
 add_executable(chai src/main.cpp ${Chai_INCLUDES})
-target_link_libraries(chai ${LIBS})
-add_dependencies(chai chaiscript_stdlib-${CHAI_VERSION})
+target_link_libraries(chai ${LIBS} ${CHAISCRIPT_LIBS})
 
 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} ${CHAISCRIPT_LIBS})
   add_executable(memory_leak_test samples/memory_leak_test.cpp)
-  target_link_libraries(memory_leak_test ${LIBS})
+  target_link_libraries(memory_leak_test ${LIBS} ${CHAISCRIPT_LIBS})
   add_executable(inheritance samples/inheritance.cpp)
-  target_link_libraries(inheritance ${LIBS})
+  target_link_libraries(inheritance ${LIBS} ${CHAISCRIPT_LIBS})
+  add_executable(factory samples/factory.cpp)
+  target_link_libraries(factory ${LIBS} ${CHAISCRIPT_LIBS})
   add_executable(fun_call_performance samples/fun_call_performance.cpp)
-  target_link_libraries(fun_call_performance ${LIBS})
+  target_link_libraries(fun_call_performance ${LIBS} ${CHAISCRIPT_LIBS})
 endif()
 
 
 if(BUILD_MODULES)
+  add_library(test_module MODULE src/test_module.cpp)
+  target_link_libraries(test_module ${LIBS})
+
   add_library(stl_extra MODULE src/stl_extra.cpp)
   target_link_libraries(stl_extra ${LIBS})
 
@@ -269,9 +294,54 @@ 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)
 
+file(GLOB PERFORMANCE_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/performance_tests/ ${CMAKE_CURRENT_SOURCE_DIR}/performance_tests/*.chai)
+list(SORT PERFORMANCE_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-2016-06-29.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
@@ -293,8 +363,8 @@ if(BUILD_TESTING)
           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}")
+            add_test(compiled.${test_name} "${executable}" ${test_name})
+            set_tests_properties(compiled.${test_name} PROPERTIES TIMEOUT 660 ENVIRONMENT "PATH=${NEWPATH}")
           endforeach()
         endif()
       endif()
@@ -314,13 +384,46 @@ 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}/"
+  )
+
+
+  set(TESTS "")
 
   foreach(filename ${UNIT_TESTS})
-    message(STATUS "Adding test ${filename}")
-    add_test(${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
+    message(STATUS "Adding unit test ${filename}")
+    add_test(unit.${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
+    list(APPEND TESTS unit.${filename})
   endforeach()
 
-  set_property(TEST ${UNIT_TESTS}
+  if (RUN_PERFORMANCE_TESTS)
+    foreach(filename ${PERFORMANCE_TESTS})
+      message(STATUS "Adding performance test ${filename}")
+
+      add_test(NAME performance.${filename} COMMAND ${VALGRIND} --tool=callgrind --callgrind-out-file=callgrind.performance.${filename} $<TARGET_FILE:chai> ${CMAKE_CURRENT_SOURCE_DIR}/performance_tests/${filename})
+      list(APPEND TESTS performance.${filename})
+    endforeach()
+
+    add_executable(profile_cpp_calls_2 performance_tests/profile_cpp_calls_2.cpp)
+    target_link_libraries(profile_cpp_calls_2 ${LIBS})
+    add_test(NAME performance.profile_cpp_calls_2 COMMAND ${VALGRIND} --tool=callgrind --callgrind-out-file=callgrind.performance.profile_cpp_calls_2 $<TARGET_FILE:profile_cpp_calls_2>)
+
+    add_executable(profile_fun_wrappers performance_tests/profile_fun_wrappers.cpp)
+    target_link_libraries(profile_fun_wrappers ${LIBS})
+    add_test(NAME performance.profile_fun_wrappers COMMAND ${VALGRIND} --tool=callgrind --callgrind-out-file=callgrind.performance.profile_fun_wrappers $<TARGET_FILE:profile_fun_wrappers>)
+  endif()
+
+  set_property(TEST ${TESTS}
     PROPERTY ENVIRONMENT
     "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
     "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
@@ -328,9 +431,12 @@ if(BUILD_TESTING)
 
   if(NOT UNIT_TEST_LIGHT)
     add_executable(compiled_tests unittests/compiled_tests.cpp)
-    target_link_libraries(compiled_tests ${LIBS})
+    target_link_libraries(compiled_tests ${LIBS} ${CHAISCRIPT_LIBS})
     ADD_CATCH_TESTS(compiled_tests)
 
+    add_executable(static_chaiscript_test unittests/static_chaiscript.cpp)
+    target_link_libraries(static_chaiscript_test ${LIBS})
+    add_test(NAME Static_ChaiScript_Test COMMAND static_chaiscript_test)
 
     add_executable(boxed_cast_test unittests/boxed_cast_test.cpp)
     target_link_libraries(boxed_cast_test ${LIBS})
@@ -341,11 +447,11 @@ if(BUILD_TESTING)
     add_test(NAME Type_Info_Test COMMAND type_info_test)
 
     add_executable(c_linkage_test unittests/c_linkage_test.cpp)
-    target_link_libraries(c_linkage_test ${LIBS})
+    target_link_libraries(c_linkage_test ${LIBS} ${CHAISCRIPT_LIBS})
     add_test(NAME C_Linkage_Test COMMAND c_linkage_test)
 
     add_executable(integer_literal_test unittests/integer_literal_test.cpp)
-    target_link_libraries(integer_literal_test ${LIBS})
+    target_link_libraries(integer_literal_test ${LIBS} ${CHAISCRIPT_LIBS})
     add_test(NAME Integer_Literal_Test COMMAND integer_literal_test)
 
     if(MULTITHREAD_SUPPORT_ENABLED)
@@ -369,9 +475,6 @@ if(BUILD_TESTING)
     target_link_libraries(multifile_test ${LIBS})
     add_test(NAME MultiFile_Test COMMAND multifile_test)
 
-    add_library(test_module MODULE src/test_module.cpp)
-    target_link_libraries(test_module ${LIBS})
-
     install(TARGETS test_module RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
   endif()
 endif()

DesignGoals.md

@@ -0,0 +1,28 @@
+# Introduction
+
+This document outlines the principles that drive the development of ChaiScript. ChaiScript does not intent to be the perfect tool for *every* situation, but it does intend to be a good general purpose tool for *most* situations.
+
+# Goals
+
+1. Trivially easy to integrate with C++ projects
+2. 0 external depenencies
+3. "Perfect" integration with C++
+   * Direct mapping between ChaiScript objects and C++ objects
+   * Direct mapping between ChaiScript functions and C++ functions
+   * Direct mapping between ChaiScript exceptions and C++ exceptions
+3. Never surprise the C++ developer
+   * Object lifetimes managed by the stack
+   * Familiar syntax to C++ developers
+4. Perform "well enough" to not get in the way
+
+
+# Alternatives
+
+## Sol2
+
+If you are looking for the fastest performing scripting language and don't mind Lua, you might want to consider [sol2](https://github.com/ThePhD/sol2).
+
+## SWIG
+
+If you are looking for the most flexible solution to be able to support multiple target languages, consider [SWIG](http://swig.org)
+

LICENSE

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

appveyor.yml

@@ -0,0 +1,22 @@
+version: 5.8.x.{build}
+os: Visual Studio 2015
+environment:
+  matrix:
+  - {}
+build_script:
+- cmd: >-
+    mkdir build
+
+    cd build
+
+    cmake c:\Projects\chaiscript -G "Visual Studio 14"
+
+    cmake --build . --config Debug
+test_script:
+- cmd: ctest -C Debug
+notifications:
+- provider: Webhook
+  url: https://webhooks.gitter.im/e/9ff725a985b5679d1d5d
+  on_build_success: true
+  on_build_failure: true
+  on_build_status_changed: false

cheatsheet.md

@@ -1,3 +1,13 @@
+# 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
 
 ```
@@ -17,6 +27,13 @@ chai.add(chaiscript::fun(&Class::method_name), "method_name");
 chai.add(chaiscript::fun(&Class::member_name), "member_name");
 ```
 
+### Bound Member Functions
+
+```
+chai.add(chaiscript::fun(&Class::method_name, Class_instance_ptr), "method_name");
+chai.add(chaiscript::fun(&Class::member_name, Class_instance_ptr), "member_name");
+```
+
 ### With Overloads 
 
 #### Preferred
@@ -30,6 +47,19 @@ chai.add(chaiscript::fun<ReturnType (ParamType1, ParamType2)>(&function_with_ove
 ```
 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
 
@@ -54,9 +84,72 @@ chai.add(chaiscript::constructor<MyType (const MyType &)>(), "MyType");
 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");
+chai.add(chaiscript::user_type<MyClass>(), "MyClass");
 ```
 
+## Adding Type Conversions
+
+User defined type conversions are possible, defined in either script or in C++.
+
+
+
+### ChaiScript Defined Conversions
+
+Function objects (including lambdas) can be used to add type conversions
+from inside of ChaiScript:
+
+```
+add_type_conversion(type("string"), type("Type_Info"), fun(s) { return type(s); });
+```
+
+### C++ Defined Conversions
+
+Invoking a C++ type conversion possible with `static_cast`
+
+```
+chai.add(chaiscript::type_conversion<T, bool>());
+```
+
+Calling a user defined type conversion that takes a lambda
+
+```
+chai.add(chaiscript::type_conversion<TestBaseType, Type2>([](const TestBaseType &t_bt) { /* return converted thing */ }));
+```
+
+### Class Hierarchies
+
+If you want objects to be convertable between base and derived classes, you must tell ChaiScritp about the relationship.
+
+```
+chai.add(chaiscript::base_class<Base, Derived>());
+```
+
+If you have multiple classes in your inheritance graph, you will probably want to tell ChaiScript about all relationships.
+
+```
+chai.add(chaiscript::base_class<Base, Derived>());
+chai.add(chaiscript::base_class<Derived, MoreDerived>());
+chai.add(chaiscript::base_class<Base, MoreDerived>());
+```
+
+### Helpers
+
+A helper function exists for strongly typed and ChaiScript `Vector` function conversion definition:
+
+```
+chai.add(chaiscript::vector_conversion<std::vector<int>>());
+```
+
+A helper function also exists for strongly typed and ChaiScript `Map` function conversion definition:
+
+```
+chai.add(chaiscript::map_conversion<std::map<std::string, int>>());
+```
+
+
+
+This allows you to pass a ChaiScript function to a function requiring `std::vector<int>`
+
 ## Adding Objects
 
 ```
@@ -65,8 +158,26 @@ chai.add(chaiscript::var(std::ref(somevar), "somevar"); // by reference, shared
 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
+chai.add_global_const(chaiscript::const_var(somevar), "somevar"); // global const. Throws if value is non-const, throws if object exists
+chai.add_global(chaiscript::var(somevar), "somevar"); // global non-const, throws if object exists
+chai.set_global(chaiscript::var(somevar), "somevar"); // global non-const, overwrites existing object
+```
+
+# 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
@@ -80,6 +191,8 @@ 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
 
 ```
@@ -102,6 +215,28 @@ chaiscript::Boxed_Number(chai.eval("5.3 + 2.1")).get_as<int>(); // works with an
 static_cast<int>(chai.eval<double>("5.3+2.1")); // this version only works if we know that it's a double
 ```
 
+### Conversion Caveats
+
+Conversion to `std::shared_ptr<T> &` is supported for function calls, but if you attempt to keep a reference to a `shared_ptr<>` you might invoke undefined behavior
+
+```cpp
+// ok this is supported, you can register it with chaiscript engine
+void nullify_shared_ptr(std::shared_ptr<int> &t) {
+  t = nullptr
+}
+```
+
+```cpp
+int main()
+{
+  // do some stuff and create a chaiscript instance
+  std::shared_ptr<int> &ptr = chai.eval<std::shared_ptr<int> &>(somevalue);
+  // DO NOT do this. Taking a non-const reference to a shared_ptr is not 
+  // supported and causes undefined behavior in the chaiscript engine
+}
+```
+
+
 ## Sharing Values
 
 ```
@@ -152,7 +287,7 @@ 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); });
+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++
 ```
 
@@ -168,11 +303,51 @@ 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 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
+global g2;
+if (g2.is_var_undef()) { g2 = 4; } // only initialize g2 once, if global decl hit more than once
+
+GLOBAL g3; // all upper case version also accepted
+```
+
+## Looping
+
+```
+// c-style for loops
+for (var i = 0; i < 100; ++i) { print(i); }
+```
+
+```
+// while
+while (some_condition()) { /* do something */ }
+```
+
+```
+// ranged for
+for (x : [1,2,3]) { print(i); }
+```
+
+Each of the loop styles can be broken using the `break` statement. For example:
+
+```
+while (some_condition()) {
+  /* do something */
+  if (another_condition()) { break; }
+}
+```
+
+## Conditionals
+
+```
+if (expression) { }
+```
+
+```
+// C++17-style init-if blocks
+// Value of 'statement' is scoped for entire `if` block
+if (statement; expression) { }
 ```
 
 ## Built in Types
@@ -183,7 +358,7 @@ 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 notion is supported
+such as `f`, `ll`, `u` as well as scientific notation are supported
 
 ```
 1.0 // double
@@ -201,6 +376,9 @@ 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 
 
 ```
@@ -298,6 +476,19 @@ 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
@@ -317,9 +508,33 @@ the contained function.
 
 If both a 2 parameter and a 3 parameter signature match, the 3 parameter function always wins.
 
+## Context
+
+ * `__LINE__` Current file line number
+ * `__FILE__` Full path of current file
+ * `__CLASS__` Name of current class
+ * `__FUNC__` Mame of current function
+
 
 # Built In Functions
 
+## Disabling Built-Ins
+
+When constructing a ChaiScript object, a vector of parameters can be passed in to disable or enable various built-in methods.
+
+Current options:
+
+```
+enum class Options
+{
+  Load_Modules,
+  No_Load_Modules,
+  External_Scripts,
+  No_External_Scripts
+};
+```
+
+
 ## Evaluation
 
 ```
@@ -331,4 +546,7 @@ use("filename") // evals file exactly once and returns value of last statement
 
 Both `use` and `eval_file` search the 'usepaths' passed to the ChaiScript constructor
 
+## JSON
 
+ * `from_json` converts a JSON string into its strongly typed (map, vector, int, double, string) representations
+ * `to_json` converts a ChaiScript object (either a `Object` or one of map, vector, int, double, string) tree into its JSON string representation

cmake/CheckCXX11Features.cmake

@@ -1,103 +0,0 @@
-# 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 +0,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 +0,0 @@
-
-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 +0,0 @@
-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 +0,0 @@
-#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 +0,0 @@
-
-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 +0,0 @@
-int main()
-{
-	int ret = 0;
-	return ([&ret]() -> int { return ret; })();
-}

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

@@ -1,7 +0,0 @@
-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 +0,0 @@
-int main()
-{
-	int* test = nullptr;
-	return test ? 1 : 0;
-}

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

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

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

@@ -1,15 +0,0 @@
-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 +0,0 @@
-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 +0,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 +0,0 @@
-int main()
-{
-	static_assert(1 < 0, "this should fail");
-	return 0;
-}

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

@@ -1,23 +0,0 @@
-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/check_for_tabs.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'json'
+
+`grep -rPIHn '\t' src/* include/* samples/*`.lines { |line|
+  if /(?<filename>.+(hpp|cpp|chai)):(?<linenumber>[0-9]+):(?<restofline>.+)/ =~ line 
+    puts(JSON.dump({:line => linenumber, :filename => filename, :tool => "tab_checker", :message => "Source Code Line Contains Tabs", :messagetype => "warning"}))
+  end
+}
+
+

contrib/check_for_todos.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'json'
+
+`grep -rPIHni 'todo' src/* include/* samples/*`.lines { |line|
+  if /(?<filename>.+(hpp|cpp|chai)):(?<linenumber>[0-9]+):(?<restofline>.+)/ =~ line 
+    puts(JSON.dump({:line => linenumber, :filename => filename, :tool => "todo_checker", :message => "todo: #{restofline.strip}", :messagetype => "info"}))
+  end
+}
+
+

contrib/codeanalysis/fuzzy_tests/chaiscript.dict

@@ -0,0 +1,61 @@
+# My dict
+
+
+for="for"
+while="while"
+def="def"
+fun="fun"
+if="if"
+else="else"
+and="&&"
+or="||"
+auto="auto"
+var="var"
+begin_block="{"
+end_block="}"
+empty_vec="[]"
+string="string"
+vector="Vector"
+map="Map"
+return="return"
+break="break"
+true="true"
+false="false"
+class="class"
+attr="attr"
+var="var"
+global="global"
+empty_lambda=" fun(){} "
+empty_fun=" def empty_fun() {} "
+continue="continue"
+float=" 1.1f "
+double=" 2.2 "
+long_double=" 2.2ll "
+unsigned=" 3u "
+unsigned_long=" 4ul "
+unsigned_long_long=" 4ull "
+long_long=" 5ll "
+attr="attr"
+reference_del="auto &"
+int8=" int8_t(1) "
+int16=" int16_t(2) "
+int32=" int32_t(3) "
+int64=" int64_t(4) "
+uint8=" uint8_t(1) "
+uint16=" uint16_t(2) "
+uint32=" uint32_t(3) "
+uint64=" uint64_t(4) "
+int8t="int8_t"
+int16t="int16_t"
+int32t="int32_t"
+int64t="int64_t"
+uint8t="uint8_t"
+uint16t="uint16_t"
+uint32t="uint32_t"
+uint64t="uint64_t"
+
+
+
+
+
+

contrib/codeanalysis/fuzzy_tests/notes.txt

@@ -0,0 +1,17 @@
+Command line used to find this crash:
+
+../../Downloads/afl-1.80b/afl-fuzz -i- -o findings -x chaiscript.dict -- ../a.out unit_test.inc @@
+
+If you can't reproduce a bug outside of afl-fuzz, be sure to set the same
+memory limit. The limit used for this fuzzing session was 50.0 MB.
+
+Need a tool to minimize test cases before investigating the crashes or sending
+them to a vendor? Check out the afl-tmin that comes with the fuzzer!
+
+Found any cool bugs in open-source tools using afl-fuzz? If yes, please drop
+me a mail at <lcamtuf@coredump.cx> once the issues are fixed - I'd love to
+add your finds to the gallery at:
+
+  http://lcamtuf.coredump.cx/afl/
+
+Thanks :-)

contrib/codeanalysis/fuzzy_tests/use.inc

@@ -0,0 +1,5 @@
+def greet {
+  return("hello")
+}
+
+fun(){ "world" }

contrib/codeanalysis/runcppcheck.sh

@@ -4,7 +4,7 @@ pushd ..
 wget http://sourceforge.net/projects/cppcheck/files/cppcheck/1.66/cppcheck-1.66.tar.bz2
 tar -xvf cppcheck-1.66.tar.bz2
 cd cppcheck-1.66
-CXX=g++-4.8 make -j2
+make -j2
 popd
 ../cppcheck-1.66/cppcheck --enable=all -I include --inline-suppr --suppress=missingIncludeSystem --std=c++11 --platform=unix64 src/main.cpp src/chai*.cpp --template ' - __{severity}__: [{file}:{line}](../blob/TRAVIS_COMMIT/{file}#L{line}) {message} ({id})'  2>output
 sed -i "s/TRAVIS_COMMIT/${TRAVIS_COMMIT}/g" output

contrib/sublimetext/ChaiScript.YAML-tmLanguage

@@ -1,93 +0,0 @@
-# [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

@@ -1,333 +0,0 @@
-<?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

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_HPP_
 #define CHAISCRIPT_HPP_
 
@@ -65,7 +69,7 @@
 /// int main()
 /// {
 ///   chaiscript::ChaiScript chai;
-///   chai.add(&function, "function");
+///   chai.add(chaiscript::fun(&function), "function");
 ///
 ///   double d = chai.eval<double>("function(3, 4.75);");
 /// } 
@@ -695,11 +699,10 @@
 /// Begins a function or method definition
 ///
 /// ~~~~~~~~
-/// 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
+/// Function Definition ::= "def" identifier "(" [[type] arg ("," [type] arg)*] ")" [":" guard] block
+/// Method Definition ::= "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 with optional type specifiers. Optional.
 /// guards: guarding statement that act as a prerequisite for the function. Optional.
@@ -817,16 +820,26 @@
 /// @namespace chaiscript::detail
 /// @brief Classes and functions reserved for internal use. Items in this namespace are not supported.
 
-#include "chaiscript_defines.hpp"
-
-#include "dispatchkit/dispatchkit.hpp"
-#include "dispatchkit/function_call.hpp"
-#include "dispatchkit/dynamic_object.hpp"
-#include "dispatchkit/boxed_number.hpp"
-
-#include "language/chaiscript_eval.hpp"
-#include "language/chaiscript_engine.hpp"
+#include "chaiscript_basic.hpp"
+#include "language/chaiscript_parser.hpp"
+#include "chaiscript_stdlib.hpp"
 
 
+namespace chaiscript 
+{
+  class ChaiScript : public ChaiScript_Basic
+  {
+    public:
+      ChaiScript(std::vector<std::string> t_modulepaths = {},
+          std::vector<std::string> t_usepaths = {},
+          const std::vector<Options> &t_opts = {})
+        : ChaiScript_Basic(
+            chaiscript::Std_Lib::library(),
+            std::make_unique<parser::ChaiScript_Parser<eval::Noop_Tracer, optimizer::Optimizer_Default>>(),
+            t_modulepaths, t_usepaths, t_opts)
+        {
+        }
+  };
+}
 
 #endif /* CHAISCRIPT_HPP_ */

include/chaiscript/chaiscript_basic.hpp

@@ -0,0 +1,39 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_BASIC_HPP_
+#define CHAISCRIPT_BASIC_HPP_
+
+#include "chaiscript_defines.hpp"
+
+#include "dispatchkit/dispatchkit.hpp"
+#include "dispatchkit/function_call.hpp"
+#include "dispatchkit/dynamic_object.hpp"
+#include "dispatchkit/boxed_number.hpp"
+
+#include "language/chaiscript_eval.hpp"
+#include "language/chaiscript_engine.hpp"
+
+// This file includes all of the basic requirements for ChaiScript,
+// to use, you might do something like:
+//
+
+/*
+
+#include "chaiscript_stdlib.hpp"
+#include "language/chaiscript_parser.hpp"
+
+ChaiScript_Basic chai(
+          chaiscript::Std_Lib::library(),
+          std::make_unique<parser::ChaiScript_Parser<eval::Noop_Tracer, optimizer::Optimizer_Default>>());
+
+*/
+
+// If you want a fully packaged ready to go ChaiScript, use chaiscript.hpp
+
+
+
+#endif /* CHAISCRIPT_BASIC_HPP_ */

include/chaiscript/chaiscript_defines.hpp

@@ -1,22 +1,23 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DEFINES_HPP_
 #define CHAISCRIPT_DEFINES_HPP_
 
 #ifdef _MSC_VER
+#define CHAISCRIPT_STRINGIZE(x) "" #x
+#define CHAISCRIPT_STRINGIZE_EXPANDED(x) CHAISCRIPT_STRINGIZE(x)
+#define CHAISCRIPT_COMPILER_VERSION CHAISCRIPT_STRINGIZE_EXPANDED(_MSC_FULL_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
+static_assert(_MSC_FULL_VER >= 190024210, "Visual C++ 2015 Update 3 or later required");
+
+#else
+#define CHAISCRIPT_COMPILER_VERSION __VERSION__
 #endif
 
 #include <vector>
@@ -29,16 +30,27 @@
 #define CHAISCRIPT_WINDOWS
 #endif
 
-#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
+#if defined(_WIN32)
+#if defined(__llvm__)
+#define CHAISCRIPT_COMPILER_NAME "clang(windows)"
+#elif defined(__GNUC__)
+#define CHAISCRIPT_COMPILER_NAME "gcc(mingw)"
+#else
+#define CHAISCRIPT_COMPILER_NAME "msvc"
+#endif
+#else
+#if defined(__llvm__)
+#define CHAISCRIPT_COMPILER_NAME "clang"
+#elif defined(__GNUC__)
+#define CHAISCRIPT_COMPILER_NAME "gcc"
+#else
+#define CHAISCRIPT_COMPILER_NAME "unknown"
+#endif
 #endif
 
-#if (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) || defined(CHAISCRIPT_MSVC) || defined(__llvm__)
-#define CHAISCRIPT_OVERRIDE override
-#else
-#define CHAISCRIPT_OVERRIDE
+
+#if defined(__llvm__)
+#define CHAISCRIPT_CLANG
 #endif
 
 
@@ -48,21 +60,29 @@
 #define CHAISCRIPT_MODULE_EXPORT extern "C" 
 #endif
 
-#ifdef CHAISCRIPT_MSVC
-#define CHAISCRIPT_NOEXCEPT throw()
-#define CHAISCRIPT_CONSTEXPR 
+#if defined(CHAISCRIPT_MSVC) || (defined(__GNUC__) && __GNUC__ >= 5) || defined(CHAISCRIPT_CLANG)
+#define CHAISCRIPT_UTF16_UTF32
+#endif
+
+#ifdef _DEBUG
+#define CHAISCRIPT_DEBUG true
 #else
-#define CHAISCRIPT_NOEXCEPT noexcept
-#define CHAISCRIPT_CONSTEXPR constexpr
+#define CHAISCRIPT_DEBUG false
 #endif
 
 #include <memory>
+#include <string>
+#include <cmath>
 
 namespace chaiscript {
-  static const int version_major = 5;
-  static const int version_minor = 7;
+  static const int version_major = 6;
+  static const int version_minor = 0;
   static const int version_patch = 0;
 
+  static const char *compiler_version = CHAISCRIPT_COMPILER_VERSION;
+  static const char *compiler_name = CHAISCRIPT_COMPILER_NAME;
+  static const bool debug_build = CHAISCRIPT_DEBUG;
+
   template<typename B, typename D, typename ...Arg>
   inline std::shared_ptr<B> make_shared(Arg && ... arg)
   {
@@ -73,6 +93,135 @@ namespace chaiscript {
 #endif
   }
 
+  struct Build_Info {
+    static int version_major()
+    {
+      return chaiscript::version_major;
+    }
+
+    static int version_minor()
+    {
+      return chaiscript::version_minor;
+    }
+
+    static int version_patch()
+    {
+      return chaiscript::version_patch;
+    }
+
+    static std::string version()
+    {
+      return std::to_string(version_major()) + '.' + std::to_string(version_minor()) + '.' + std::to_string(version_patch());
+    }
+
+    static std::string compiler_id()
+    {
+      return compiler_name() + '-' + compiler_version();
+    }
+
+    static std::string build_id()
+    {
+      return compiler_id() + (debug_build()?"-Debug":"-Release");
+    }
+
+    static std::string compiler_version()
+    {
+      return chaiscript::compiler_version;
+    }
+
+    static std::string compiler_name()
+    {
+      return chaiscript::compiler_name;
+    }
+
+    static bool debug_build()
+    {
+      return chaiscript::debug_build;
+    }
+  };
+
+
+  template<typename T>
+    auto parse_num(const char *t_str) -> typename std::enable_if<std::is_integral<T>::value, T>::type
+    {
+      T t = 0;
+      for (char c = *t_str; (c = *t_str) != 0; ++t_str) {
+        if (c < '0' || c > '9') {
+          return t;
+        }
+        t *= 10;
+        t += c - '0';
+      }
+      return t;
+    }
+
+
+  template<typename T>
+    auto parse_num(const char *t_str) -> typename std::enable_if<!std::is_integral<T>::value, T>::type
+    {
+      T t = 0;
+      T base = 0;
+      T decimal_place = 0;
+      bool exponent = false;
+      bool neg_exponent = false;
+
+      const auto final_value = [](const T val, const T baseval, const bool hasexp, const bool negexp) -> T {
+        if (!hasexp) {
+          return val;
+        } else {
+          return baseval * std::pow(T(10), val*T(negexp?-1:1));
+        }
+      };
+
+      for(; *t_str != '\0'; ++t_str) {
+        char c = *t_str;
+        if (c == '.') {
+          decimal_place = 10;
+        } else if (c == 'e' || c == 'E') {
+          exponent = true;
+          decimal_place = 0;
+          base = t;
+          t = 0;
+        } else if (c == '-' && exponent) {
+          neg_exponent = true;
+        } else if (c == '+' && exponent) {
+          neg_exponent = false;
+        } else if (c < '0' || c > '9') {
+          return final_value(t, base, exponent, neg_exponent);
+        } else if (decimal_place < T(10)) {
+          t *= T(10);
+          t += T(c - '0');
+        } else {
+          t += (T(c - '0') / (T(decimal_place)));
+          decimal_place *= 10;
+        }
+      }
+
+      return final_value(t, base, exponent, neg_exponent);
+    }
+
+  template<typename T>
+    T parse_num(const std::string &t_str)
+    {
+      return parse_num<T>(t_str.c_str());
+    }
+
+  enum class Options
+  {
+    No_Load_Modules,
+    Load_Modules,
+    No_External_Scripts,
+    External_Scripts
+  };
+
+  static inline std::vector<Options> default_options()
+  {
+#ifdef CHAISCRIPT_NO_DYNLOAD
+    return {Options::No_Load_Modules, Options::External_Scripts};
+#else
+    return {Options::Load_Modules, Options::External_Scripts};
+#endif
+  }
 }
 #endif
 

include/chaiscript/chaiscript_stdlib.hpp

@@ -14,10 +14,18 @@
 #include <vector>
 
 #include "chaiscript_defines.hpp"
-#include "dispatchkit/dispatchkit.hpp"
+#include "language/chaiscript_common.hpp"
+
+#include "dispatchkit/function_call.hpp"
+
+//#include "dispatchkit/dispatchkit.hpp"
+#include "dispatchkit/operators.hpp"
 #include "dispatchkit/bootstrap.hpp"
 #include "dispatchkit/bootstrap_stl.hpp"
-#include "dispatchkit/boxed_value.hpp"
+//#include "dispatchkit/boxed_value.hpp"
+#include "language/chaiscript_prelude.hpp"
+#include "dispatchkit/register_function.hpp"
+#include "utility/json_wrap.hpp"
 
 #ifndef CHAISCRIPT_NO_THREADS
 #include <future>
@@ -36,20 +44,23 @@ namespace chaiscript
 
       static ModulePtr library()
       {
-        using namespace bootstrap;
+        auto lib = std::make_shared<Module>();
+        bootstrap::Bootstrap::bootstrap(*lib);
 
-        ModulePtr lib = Bootstrap::bootstrap();
-
-        lib->add(standard_library::vector_type<std::vector<Boxed_Value> >("Vector"));
-        lib->add(standard_library::string_type<std::string>("string"));
-        lib->add(standard_library::map_type<std::map<std::string, Boxed_Value> >("Map"));
-        lib->add(standard_library::pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair"));
+        bootstrap::standard_library::vector_type<std::vector<Boxed_Value> >("Vector", *lib);
+        bootstrap::standard_library::string_type<std::string>("string", *lib);
+        bootstrap::standard_library::map_type<std::map<std::string, Boxed_Value> >("Map", *lib);
+        bootstrap::standard_library::pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair", *lib);
 
 #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");
+        bootstrap::standard_library::future_type<std::future<chaiscript::Boxed_Value>>("future", *lib);
+        lib->add(chaiscript::fun([](const std::function<chaiscript::Boxed_Value ()> &t_func){ return std::async(std::launch::async, t_func);}), "async");
 #endif
 
+        json_wrap::library(*lib);
+
+        lib->eval(ChaiScript_Prelude::chaiscript_prelude() /*, "standard prelude"*/ );
+
         return lib;
       }
 

include/chaiscript/chaiscript_threading.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_THREADING_HPP_
 #define CHAISCRIPT_THREADING_HPP_
 
@@ -14,8 +18,10 @@
 #include <thread>
 #include <mutex>
 #else
+#ifndef CHAISCRIPT_NO_THREADS_WARNING
 #pragma message ("ChaiScript is compiling without thread safety.")
 #endif
+#endif
 
 #include "chaiscript_defines.hpp"
 
@@ -40,146 +46,92 @@ namespace chaiscript
 #ifndef CHAISCRIPT_NO_THREADS
 
       template<typename T>
-      class unique_lock : public std::unique_lock<T>
-      {
-        public:
-          unique_lock(T &t) : std::unique_lock<T>(t) {}
-      };
+        using unique_lock = std::unique_lock<T>;
 
       template<typename T>
-      class shared_lock : public std::unique_lock<T>
-      {
-        public:
-          shared_lock(T &t) : std::unique_lock<T>(t) {}
-          void unlock() {}
-      };
+        using shared_lock = std::unique_lock<T>;
 
       template<typename T>
-      class lock_guard : public std::lock_guard<T>
-      {
-        public:
-          lock_guard(T &t) : std::lock_guard<T>(t) {}
-      };
+        using lock_guard = std::lock_guard<T>;
 
-      class shared_mutex : public std::mutex { };
+
+      using shared_mutex = std::mutex;
 
       using std::mutex;
 
       using std::recursive_mutex;
 
-#ifdef CHAISCRIPT_HAS_THREAD_LOCAL
       /// Typesafe thread specific storage. If threading is enabled, this class uses a mutex protected map. If
       /// threading is not enabled, the class always returns the same data, regardless of which thread it is called from.
       template<typename T>
         class Thread_Storage
         {
           public:
-
-            Thread_Storage(void *t_key)
-              : m_key(t_key)
-            {
-            }
+            Thread_Storage() = default;
+            Thread_Storage(const Thread_Storage &) = delete;
+            Thread_Storage(Thread_Storage &&) = delete;
+            Thread_Storage &operator=(const Thread_Storage &) = delete;
+            Thread_Storage &operator=(Thread_Storage &&) = delete;
 
             ~Thread_Storage()
             {
-              t().erase(m_key);
+              if (!destroyed) {
+                t().erase(this);
+              }
             }
 
             inline const T *operator->() const
             {
-              return &(t()[m_key]);
+              return &(t()[const_cast<Thread_Storage *>(this)]);
             }
 
             inline const T &operator*() const
             {
-              return t()[m_key];
+              return t()[const_cast<Thread_Storage *>(this)];
             }
 
             inline T *operator->()
             {
-              return &(t()[m_key]);
+              return &(t()[this]);
             }
 
             inline T &operator*()
             {
-              return t()[m_key];
+              return t()[this];
             }
 
-
-            void *m_key;
-
           private:
-            static std::unordered_map<void*, T> &t()
-            {
-              thread_local static std::unordered_map<void *, T> my_t;
-              return my_t;
+            struct Map_Holder {
+              std::unordered_map<Thread_Storage<T> *, T> map;
+
+              Map_Holder() = default;
+              Map_Holder(const Map_Holder &) = delete;
+              Map_Holder(Map_Holder &&) = delete;
+              Map_Holder& operator=(Map_Holder &&) = delete;
+              Map_Holder& operator=(const Map_Holder &&) = delete;
+              ~Map_Holder() {
+                // here is the theory:
+                //   * If the Map_Holder is destroyed before the Thread_Storage, a flag will get set
+                //   * If destroyed after the Thread_Storage, the * will have been removed from `map` and nothing will happen
+                for(auto &elem : map) { elem.first->destroyed = true; }
               }
             };
 
-#else
-
-      /// Typesafe thread specific storage. If threading is enabled, this class uses a mutex protected map. If
-      /// threading is not enabled, the class always returns the same data, regardless of which thread it is called from.
-      /// 
-      /// This version is used if the compiler does not support thread_local
-      template<typename T>
-        class Thread_Storage
-        {
-          public:
-
-            Thread_Storage(void *)
+            static std::unordered_map<Thread_Storage<T> *, T> &t()
             {
+              thread_local Map_Holder my_map;
+              return my_map.map;
             }
 
-            inline const T *operator->() const
-            {
-              return get_tls().get();
-            }
-
-            inline const T &operator*() const
-            {
-              return *get_tls();
-            }
-
-            inline T *operator->()
-            {
-              return get_tls().get();
-            }
-
-            inline T &operator*()
-            {
-              return *get_tls();
-            }
-
-
-          private:
-            std::shared_ptr<T> get_tls() const
-            {
-              unique_lock<mutex> lock(m_mutex);
-
-              auto itr = m_instances.find(std::this_thread::get_id());
-
-              if (itr != m_instances.end()) { return itr->second; }
-
-              std::shared_ptr<T> new_instance(std::make_shared<T>());
-
-              m_instances.insert(std::make_pair(std::this_thread::get_id(), new_instance));
-
-              return new_instance;
-            }
-
-
-            mutable mutex m_mutex;
-            mutable std::unordered_map<std::thread::id, std::shared_ptr<T> > m_instances;
+            bool destroyed{false};
         };
-#endif // threading enabled but no tls
 
 #else // threading disabled
       template<typename T>
       class unique_lock 
       {
         public:
-          unique_lock(T &) {}
+          explicit unique_lock(T &) {}
           void lock() {}
           void unlock() {}
       };
@@ -188,7 +140,7 @@ namespace chaiscript
       class shared_lock 
       {
         public:
-          shared_lock(T &) {}
+          explicit shared_lock(T &) {}
           void lock() {}
           void unlock() {}
       };
@@ -197,7 +149,7 @@ namespace chaiscript
       class lock_guard 
       {
         public:
-          lock_guard(T &) {}
+          explicit lock_guard(T &) {}
       };
 
       class shared_mutex { };
@@ -209,7 +161,7 @@ namespace chaiscript
         class Thread_Storage
         {
           public:
-            Thread_Storage(void *)
+            explicit Thread_Storage(void *)
             {
             }
 

include/chaiscript/dispatchkit/any.hpp

@@ -21,23 +21,20 @@ namespace chaiscript {
       class bad_any_cast : public std::bad_cast
       {
         public:
-          bad_any_cast() CHAISCRIPT_NOEXCEPT
-            : m_what("bad any cast")
-          {
-          }
+          bad_any_cast() = default;
 
           bad_any_cast(const bad_any_cast &) = default;
 
-          virtual ~bad_any_cast() CHAISCRIPT_NOEXCEPT {}
+          ~bad_any_cast() noexcept override = default;
 
           /// \brief Description of what error occurred
-          virtual const char * what() const CHAISCRIPT_NOEXCEPT CHAISCRIPT_OVERRIDE
+          const char * what() const noexcept override
           {
             return m_what.c_str();
           }
 
         private:
-          std::string m_what;
+          std::string m_what = "bad any cast";
       };
     }
   
@@ -46,16 +43,17 @@ namespace chaiscript {
       private:
         struct Data
         {
-          Data(const std::type_info &t_type) 
+          explicit Data(const std::type_info &t_type) 
             : m_type(t_type)
           {
           }
 
           Data &operator=(const Data &) = delete;
 
-          virtual ~Data() {}
+          virtual ~Data() = default;
 
           virtual void *data() = 0;
+
           const std::type_info &type() const
           {
             return m_type;
@@ -74,14 +72,12 @@ namespace chaiscript {
             {
             }
 
-            virtual ~Data_Impl() {}
-
-            virtual void *data() CHAISCRIPT_OVERRIDE
+            void *data() override
             {
               return &m_data;
             }
 
-            std::unique_ptr<Data> clone() const CHAISCRIPT_OVERRIDE
+            std::unique_ptr<Data> clone() const override
             {
               return std::unique_ptr<Data>(new Data_Impl<T>(m_data));
             }
@@ -96,6 +92,8 @@ namespace chaiscript {
       public:
         // construct/copy/destruct
         Any() = default;
+        Any(Any &&) = default;
+        Any &operator=(Any &&t_any) = default;
 
         Any(const Any &t_any) 
         { 
@@ -107,10 +105,6 @@ namespace chaiscript {
           }
         }
 
-#if !defined(_MSC_VER) || _MSC_VER  != 1800
-        Any(Any &&) = default;
-        Any &operator=(Any &&t_any) = default;
-#endif
 
         template<typename ValueType,
           typename = typename std::enable_if<!std::is_same<Any, typename std::decay<ValueType>::type>::value>::type>
@@ -139,10 +133,6 @@ namespace chaiscript {
           }
 
 
-        ~Any()
-        {
-        }
-
         // modifiers
         Any & swap(Any &t_other)
         {
@@ -158,8 +148,7 @@ namespace chaiscript {
 
         const std::type_info & type() const
         {
-          if (m_data)
-          {
+          if (m_data) {
             return m_data->type();
           } else {
             return typeid(void);

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
 #define CHAISCRIPT_BAD_BOXED_CAST_HPP_
 
@@ -30,32 +34,32 @@ namespace chaiscript
     {
       public:
         bad_boxed_cast(Type_Info t_from, const std::type_info &t_to,
-            std::string t_what) CHAISCRIPT_NOEXCEPT
-          : from(std::move(t_from)), to(&t_to), m_what(std::move(t_what))
+            std::string t_what) noexcept
+          : from(t_from), to(&t_to), m_what(std::move(t_what))
         {
         }
 
         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(t_from), to(&t_to), m_what("Cannot perform boxed_cast: " + t_from.name() + " to: " + t_to.name())
         {
         }
 
-        bad_boxed_cast(std::string t_what) CHAISCRIPT_NOEXCEPT
-          : to(nullptr), m_what(std::move(t_what))
+        explicit bad_boxed_cast(std::string t_what) noexcept
+          : m_what(std::move(t_what))
         {
         }
 
         bad_boxed_cast(const bad_boxed_cast &) = default;
-        virtual ~bad_boxed_cast() CHAISCRIPT_NOEXCEPT {}
+        ~bad_boxed_cast() noexcept override = default;
 
         /// \brief Description of what error occurred
-        virtual const char * what() const CHAISCRIPT_NOEXCEPT CHAISCRIPT_OVERRIDE
+        const char * what() const noexcept override
         {
           return m_what.c_str();
         }
 
         Type_Info from; ///< Type_Info contained in the Boxed_Value
-        const std::type_info *to; ///< std::type_info of the desired (but failed) result type
+        const std::type_info *to = nullptr; ///< std::type_info of the desired (but failed) result type
 
       private:
         std::string m_what;

include/chaiscript/dispatchkit/bind_first.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_BIND_FIRST_HPP_
 #define CHAISCRIPT_BIND_FIRST_HPP_
 
@@ -27,45 +31,52 @@ namespace chaiscript
       }
 
     template<typename O, typename Ret, typename P1, typename ... Param>
-      std::function<Ret (Param...)> bind_first(Ret (*f)(P1, Param...), O&& o)
+      auto bind_first(Ret (*f)(P1, Param...), O&& o)
       {
-        return std::function<Ret (Param...)>(
-            [f, o](Param...param) -> Ret {
+        return [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)
+      auto bind_first(Ret (Class::*f)(Param...), O&& o)
       {
-        return std::function<Ret (Param...)>(
-            [f, o](Param...param) -> Ret {
+        return [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)
+      auto bind_first(Ret (Class::*f)(Param...) const, O&& o)
       {
-        return std::function<Ret (Param...)>(
-            [f, o](Param...param) -> Ret {
+        return [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)
+      auto bind_first(const std::function<Ret (P1, Param...)> &f, O&& o)
       {
-        return std::function<Ret (Param...)>(
-            [f, o](Param...param) -> Ret {
+        return [f, o](Param...param) -> Ret {
           return f(o, std::forward<Param>(param)...);
-            });
+        };
       }
 
+    template<typename F, typename O, typename Ret, typename Class, typename P1, typename ... Param>
+      auto bind_first(const F &fo, O&& o, Ret (Class::*f)(P1, Param...) const)
+      {
+        return [fo, o, f](Param ...param) -> Ret {
+          return (fo.*f)(o, std::forward<Param>(param)...);
+        };
+
+      }
+
+    template<typename F, typename O>
+      auto bind_first(const F &f, O&& o)
+      {
+        return bind_first(f, std::forward<O>(o), &F::operator());
+      }
 
   }
 }

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,63 +1,31 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
 #define CHAISCRIPT_BOOTSTRAP_HPP_
 
-#include <cstdint>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-#include <vector>
-#include <iterator>
-
-#include "bad_boxed_cast.hpp"
-#include "boxed_cast.hpp"
-#include "boxed_number.hpp"
-#include "boxed_value.hpp"
-#include "dispatchkit.hpp"
-#include "type_conversions.hpp"
-#include "dynamic_object.hpp"
-#include "operators.hpp"
-#include "proxy_constructors.hpp"
-#include "proxy_functions.hpp"
-#include "proxy_functions_detail.hpp"
-#include "register_function.hpp"
-#include "type_info.hpp"
 #include "../utility/utility.hpp"
-#include "../language/chaiscript_common.hpp"
+#include "register_function.hpp"
 
 namespace chaiscript 
 {
   /// \brief Classes and functions useful for bootstrapping of ChaiScript and adding of new types
   namespace bootstrap
   {
-    namespace detail
-    {
-      /// \brief Constructs a new POD value object from a Boxed_Number
-      /// \param[in] v Boxed_Number to copy into the new object
-      /// \returns The newly created object.
-      template<typename P1>
-      std::shared_ptr<P1> construct_pod(const Boxed_Number &v)
-      {
-        return std::make_shared<P1>(v.get_as<P1>());
-      }
-    }
-
     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>())
+      void array(const std::string &type, Module& m)
       {
         typedef typename std::remove_extent<T>::type ReturnType;
         const auto extent = std::extent<T>::value;
-        m->add(user_type<T>(), type);
-        m->add(fun<ReturnType& (T &, size_t)>(
+        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));
@@ -68,7 +36,7 @@ namespace chaiscript
               ), "[]"
             );
 
-        m->add(fun<const ReturnType& (const T &, size_t)>(
+        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));
@@ -79,33 +47,29 @@ namespace chaiscript
               ), "[]"
             );
 
-        m->add(fun<size_t (const T &)>(
+        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
+    /// \returns The passed in Module
     template<typename T>
-    ModulePtr copy_constructor(const std::string &type, ModulePtr m = std::make_shared<Module>())
+    void copy_constructor(const std::string &type, Module& m)
     {
-      m->add(constructor<T (const T &)>(), type);
-      return m;
+      m.add(constructor<T (const T &)>(), type);
     }
 
     /// \brief Add all comparison operators for the templated type. Used during bootstrap, also available to users.
     /// \tparam T Type to create comparison operators for
     /// \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.
+    /// \returns the passed in Module.
     template<typename T>
-    ModulePtr opers_comparison(ModulePtr m = std::make_shared<Module>())
+    void opers_comparison(Module& m)
     {
       operators::equal<T>(m);
       operators::greater_than<T>(m);
@@ -113,7 +77,6 @@ namespace chaiscript
       operators::less_than<T>(m);
       operators::less_than_equal<T>(m);
       operators::not_equal<T>(m);
-      return m;
     }
 
 
@@ -122,15 +85,14 @@ namespace chaiscript
     /// \param[in] type The name of the type to add the constructors for.
     /// \param[in,out] m The Module to add the basic constructors to
     /// \tparam T Type to generate basic constructors for
-    /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
+    /// \returns The passed in Module
     /// \sa copy_constructor
     /// \sa constructor
     template<typename T>
-    ModulePtr basic_constructors(const std::string &type, ModulePtr m = std::make_shared<Module>())
+    void basic_constructors(const std::string &type, Module& m)
     {
-      m->add(constructor<T ()>(), type);
+      m.add(constructor<T ()>(), type);
       copy_constructor<T>(type, m);
-      return m;
     }
 
     /// \brief Adds a constructor for a POD type 
@@ -138,26 +100,21 @@ 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 = std::make_shared<Module>())
+    void construct_pod(const std::string &type, Module& m)
     {
-      m->add(fun(&detail::construct_pod<T>), type);
-      return m;
+      m.add(fun([](const Boxed_Number &bn){ return bn.get_as<T>(); }), type);
     }
 
 
-    /// to_string function for internal use. Uses ostream operator<<
-    template<typename Input>
-    std::string to_string(Input i)
-    {
-      std::stringstream ss;
-      ss << i;
-      return ss.str();
-    }
-
     /// 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;
@@ -165,23 +122,28 @@ 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 = std::make_shared<Module>())
+    void bootstrap_pod_type(const std::string &name, Module& m)
     {
-      m->add(user_type<T>(), name);
-      m->add(constructor<T()>(), name);
+      m.add(user_type<T>(), name);
+      m.add(constructor<T()>(), name);
       construct_pod<T>(name, m);
 
-      auto to_s = fun(&to_string<T>);
-
-      if (!m->has_function(to_s, "to_string")) {
-        m->add(to_s, "to_string");
-      }
-      m->add(fun(&parse_string<T>), "to_" + name);
-      return m;
+      m.add(fun(&parse_string<T>), "to_" + name);
     }
 
 
@@ -191,15 +153,14 @@ namespace chaiscript
     /// for handling of Proxy_Function object (that is,
     /// function variables.
     template<typename Type>
-    std::shared_ptr<Type> shared_ptr_clone(const std::shared_ptr<Type> &p)
+    auto shared_ptr_clone(const std::shared_ptr<Type> &p)
     {
       return p;
     }
 
     /// Specific version of shared_ptr_clone just for Proxy_Functions
     template<typename Type>
-    std::shared_ptr<typename std::remove_const<Type>::type> 
-        shared_ptr_unconst_clone(const std::shared_ptr<typename std::add_const<Type>::type> &p)
+    std::shared_ptr<typename std::remove_const<Type>::type> shared_ptr_unconst_clone(const std::shared_ptr<typename std::add_const<Type>::type> &p)
     {
       return std::const_pointer_cast<typename std::remove_const<Type>::type>(p);
     }
@@ -250,56 +211,58 @@ namespace chaiscript
 
 
       /// Add all arithmetic operators for PODs
-      static void opers_arithmetic_pod(ModulePtr m = std::make_shared<Module>())
+      static void opers_arithmetic_pod(Module& m)
       {
-        m->add(fun(&Boxed_Number::equals), "==");
-        m->add(fun(&Boxed_Number::less_than), "<");
-        m->add(fun(&Boxed_Number::greater_than), ">");
-        m->add(fun(&Boxed_Number::greater_than_equal), ">=");
-        m->add(fun(&Boxed_Number::less_than_equal), "<=");
-        m->add(fun(&Boxed_Number::not_equal), "!=");
-
-        m->add(fun(&Boxed_Number::pre_decrement), "--");
-        m->add(fun(&Boxed_Number::pre_increment), "++");
-        m->add(fun(&Boxed_Number::sum), "+");
-        m->add(fun(&Boxed_Number::unary_plus), "+");
-        m->add(fun(&Boxed_Number::unary_minus), "-");
-        m->add(fun(&Boxed_Number::difference), "-");
-        m->add(fun(&Boxed_Number::assign_bitwise_and), "&=");
-        m->add(fun(&Boxed_Number::assign), "=");
-        m->add(fun(&Boxed_Number::assign_bitwise_or), "|=");
-        m->add(fun(&Boxed_Number::assign_bitwise_xor), "^=");
-        m->add(fun(&Boxed_Number::assign_remainder), "%=");
-        m->add(fun(&Boxed_Number::assign_shift_left), "<<=");
-        m->add(fun(&Boxed_Number::assign_shift_right), ">>=");
-        m->add(fun(&Boxed_Number::bitwise_and), "&");
-        m->add(fun(&Boxed_Number::bitwise_complement), "~");
-        m->add(fun(&Boxed_Number::bitwise_xor), "^");
-        m->add(fun(&Boxed_Number::bitwise_or), "|");
-        m->add(fun(&Boxed_Number::assign_product), "*=");
-        m->add(fun(&Boxed_Number::assign_quotient), "/=");
-        m->add(fun(&Boxed_Number::assign_sum), "+=");
-        m->add(fun(&Boxed_Number::assign_difference), "-=");
-        m->add(fun(&Boxed_Number::quotient), "/");
-        m->add(fun(&Boxed_Number::shift_left), "<<");
-        m->add(fun(&Boxed_Number::product), "*");
-        m->add(fun(&Boxed_Number::remainder), "%");
-        m->add(fun(&Boxed_Number::shift_right), ">>");
-
+        m.add(fun(&Boxed_Number::equals), "==");
+        m.add(fun(&Boxed_Number::less_than), "<");
+        m.add(fun(&Boxed_Number::greater_than), ">");
+        m.add(fun(&Boxed_Number::greater_than_equal), ">=");
+        m.add(fun(&Boxed_Number::less_than_equal), "<=");
+        m.add(fun(&Boxed_Number::not_equal), "!=");
 
+        m.add(fun(&Boxed_Number::pre_decrement), "--");
+        m.add(fun(&Boxed_Number::pre_increment), "++");
+        m.add(fun(&Boxed_Number::sum), "+");
+        m.add(fun(&Boxed_Number::unary_plus), "+");
+        m.add(fun(&Boxed_Number::unary_minus), "-");
+        m.add(fun(&Boxed_Number::difference), "-");
+        m.add(fun(&Boxed_Number::assign_bitwise_and), "&=");
+        m.add(fun(&Boxed_Number::assign), "=");
+        m.add(fun(&Boxed_Number::assign_bitwise_or), "|=");
+        m.add(fun(&Boxed_Number::assign_bitwise_xor), "^=");
+        m.add(fun(&Boxed_Number::assign_remainder), "%=");
+        m.add(fun(&Boxed_Number::assign_shift_left), "<<=");
+        m.add(fun(&Boxed_Number::assign_shift_right), ">>=");
+        m.add(fun(&Boxed_Number::bitwise_and), "&");
+        m.add(fun(&Boxed_Number::bitwise_complement), "~");
+        m.add(fun(&Boxed_Number::bitwise_xor), "^");
+        m.add(fun(&Boxed_Number::bitwise_or), "|");
+        m.add(fun(&Boxed_Number::assign_product), "*=");
+        m.add(fun(&Boxed_Number::assign_quotient), "/=");
+        m.add(fun(&Boxed_Number::assign_sum), "+=");
+        m.add(fun(&Boxed_Number::assign_difference), "-=");
+        m.add(fun(&Boxed_Number::quotient), "/");
+        m.add(fun(&Boxed_Number::shift_left), "<<");
+        m.add(fun(&Boxed_Number::product), "*");
+        m.add(fun(&Boxed_Number::remainder), "%");
+        m.add(fun(&Boxed_Number::shift_right), ">>");
      }
 
       /// Create a bound function object. The first param is the function to bind
       /// the remaining parameters are the args to bind into the result
       static Boxed_Value bind_function(const std::vector<Boxed_Value> &params)
       {
-        if (params.size() < 2)
-        {
-          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]);
 
+        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()))));
       }
@@ -322,26 +285,6 @@ namespace chaiscript
         }
       }
 
-      static void throw_exception(const Boxed_Value &bv) {
-        throw bv;
-      }
-
-      static std::string what(const std::exception &e)
-      {
-        return e.what();
-      }
-
-      /// Boolean specialization of internal to_string function
-      static std::string bool_to_string(bool b)
-      {
-        if (b)
-        {
-          return "true";
-        } else {
-          return "false";
-        }
-      }
-
       template<typename FunctionType>
         static std::vector<Boxed_Value> do_return_boxed_value_vector(FunctionType f,
             const dispatch::Proxy_Function_Base *b)
@@ -377,7 +320,7 @@ namespace chaiscript
       }
 
       template<typename Function>
-      static std::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
+      static auto return_boxed_value_vector(const Function &f)
       {
         return [f](const dispatch::Proxy_Function_Base *b) {
           return do_return_boxed_value_vector(f, b);
@@ -388,88 +331,138 @@ namespace chaiscript
     public:
       /// \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 = std::make_shared<Module>())
+      /// \returns passed in Module
+      static void bootstrap(Module& m)
       {
-        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(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");
-        m->add(fun(&dispatch::Proxy_Function_Base::annotation), "get_annotation");
-        m->add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
+        m.add(fun(&dispatch::Proxy_Function_Base::get_arity), "get_arity");
+        m.add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
 
 
-        m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_param_types)), "get_param_types");
-        m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_contained_functions)), "get_contained_functions");
+        m.add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_param_types)), "get_param_types");
+        m.add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_contained_functions)), "get_contained_functions");
 
+        m.add(fun([](const std::exception &e){ return std::string(e.what()); }), "what");
 
-        m->add(user_type<std::runtime_error>(), "runtime_error");
-        m->add(chaiscript::base_class<std::exception, std::runtime_error>());
+        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(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
-        m->add(fun(std::function<std::string (const std::runtime_error &)>(&what)), "what");
+        m.add(user_type<std::runtime_error>(), "runtime_error");
+        m.add(chaiscript::base_class<std::exception, std::runtime_error>());
 
-        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(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
 
-        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(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::set_explicit), "set_explicit");
+        m.add(fun(&dispatch::Dynamic_Object::is_explicit), "is_explicit");
+        m.add(fun(&dispatch::Dynamic_Object::has_attr), "has_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)), "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::get_attr)), "[]");
-        m->add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::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->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)), "[]");
+        m.add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::get_attr)), "[]");
 
-        m->add(fun(&has_guard), "has_guard");
-        m->add(fun(&get_guard), "get_guard");
+        m.eval(R"chaiscript(
+          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(&Boxed_Value::is_undef), "is_var_undef");
-        m->add(fun(&Boxed_Value::is_null), "is_var_null");
-        m->add(fun(&Boxed_Value::is_const), "is_var_const");
-        m->add(fun(&Boxed_Value::is_ref), "is_var_reference");
-        m->add(fun(&Boxed_Value::is_pointer), "is_var_pointer");
-        m->add(fun(&Boxed_Value::is_type), "is_type");
-        m->add(fun(&Boxed_Value::get_attr), "get_var_attr");
-        m->add(fun(&Boxed_Value::copy_attrs), "copy_var_attrs");
+          def `=`(Dynamic_Object lhs, Dynamic_Object rhs) : lhs.get_type_name() == rhs.get_type_name()
+          {
+            for_each(rhs.get_attrs(), fun[lhs](x) { lhs.get_attr(x.first) = clone(x.second); } ); 
+          }
 
-        m->add(fun(&Boxed_Value::get_type_info), "get_type_info");
-        m->add(user_type<Type_Info>(), "Type_Info");
-        m->add(constructor<Type_Info (const Type_Info &)>(), "Type_Info");
+          def `!=`(Dynamic_Object lhs, Dynamic_Object rhs) : lhs.get_type_name() == rhs.get_type_name()
+          {
+            var rhs_attrs := rhs.get_attrs();
+            var lhs_attrs := lhs.get_attrs();
+
+            if (rhs_attrs.size() != lhs_attrs.size()) {
+              true;
+            } else {
+              return any_of(rhs_attrs, fun[lhs](x) { !lhs.has_attr(x.first) || lhs.get_attr(x.first) != x.second; } );
+            }
+          }
+
+          def `==`(Dynamic_Object lhs, Dynamic_Object rhs) : lhs.get_type_name() == rhs.get_type_name()
+          {
+            var rhs_attrs := rhs.get_attrs();
+            var lhs_attrs := lhs.get_attrs();
+
+            if (rhs_attrs.size() != lhs_attrs.size()) {
+              false;
+            } else {
+              return all_of(rhs_attrs, fun[lhs](x) { lhs.has_attr(x.first) && lhs.get_attr(x.first) == x.second; } );
+            }
+          }
+        )chaiscript");
+
+        m.add(fun(&has_guard), "has_guard");
+        m.add(fun(&get_guard), "get_guard");
+
+        m.add(fun(&Boxed_Value::is_undef), "is_var_undef");
+        m.add(fun(&Boxed_Value::is_null), "is_var_null");
+        m.add(fun(&Boxed_Value::is_const), "is_var_const");
+        m.add(fun(&Boxed_Value::is_ref), "is_var_reference");
+        m.add(fun(&Boxed_Value::is_pointer), "is_var_pointer");
+        m.add(fun(&Boxed_Value::is_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");
+        m.add(constructor<Type_Info (const Type_Info &)>(), "Type_Info");
 
 
         operators::equal<Type_Info>(m);
 
-        m->add(fun(&Type_Info::is_const), "is_type_const");
-        m->add(fun(&Type_Info::is_reference), "is_type_reference");
-        m->add(fun(&Type_Info::is_void), "is_type_void");
-        m->add(fun(&Type_Info::is_undef), "is_type_undef");
-        m->add(fun(&Type_Info::is_pointer), "is_type_pointer");
-        m->add(fun(&Type_Info::is_arithmetic), "is_type_arithmetic");
-        m->add(fun(&Type_Info::name), "cpp_name");
-        m->add(fun(&Type_Info::bare_name), "cpp_bare_name");
-        m->add(fun(&Type_Info::bare_equal), "bare_equal");
+        m.add(fun(&Type_Info::is_const), "is_type_const");
+        m.add(fun(&Type_Info::is_reference), "is_type_reference");
+        m.add(fun(&Type_Info::is_void), "is_type_void");
+        m.add(fun(&Type_Info::is_undef), "is_type_undef");
+        m.add(fun(&Type_Info::is_pointer), "is_type_pointer");
+        m.add(fun(&Type_Info::is_arithmetic), "is_type_arithmetic");
+        m.add(fun(&Type_Info::name), "cpp_name");
+        m.add(fun(&Type_Info::bare_name), "cpp_bare_name");
+        m.add(fun(&Type_Info::bare_equal), "bare_equal");
 
 
         basic_constructors<bool>("bool", m);
         operators::assign<bool>(m);
         operators::equal<bool>(m);
+        operators::not_equal<bool>(m);
+
+        m.add(fun([](const std::string &s) { return s; }), "to_string");
+        m.add(fun([](const bool b) { return std::string(b?"true":"false"); }), "to_string");
+        m.add(fun(&unknown_assign), "=");
+        m.add(fun([](const Boxed_Value &bv) { throw bv; }), "throw");
+
+        m.add(fun([](const char c) { return std::string(1, c); }), "to_string");
+        m.add(fun(&Boxed_Number::to_string), "to_string");
 
-        m->add(fun<std::string (const std::string &t_ss)>([](const std::string &s) -> std::string { return s; }), "to_string");
-        m->add(fun(&Bootstrap::bool_to_string), "to_string");
-        m->add(fun(&unknown_assign), "=");
-        m->add(fun(&throw_exception), "throw");
-        m->add(fun(&what), "what");
         
         bootstrap_pod_type<double>("double", m);
         bootstrap_pod_type<long double>("long_double", m);
@@ -478,8 +471,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);
@@ -489,57 +487,71 @@ namespace chaiscript
         bootstrap_pod_type<std::uint32_t>("uint32_t", m);
         bootstrap_pod_type<std::uint64_t>("uint64_t", m);
 
+
         operators::logical_compliment<bool>(m);
 
         opers_arithmetic_pod(m);
 
         
-        m->add(fun(&print), "print_string");
-        m->add(fun(&println), "println_string");
+        m.add(fun(&Build_Info::version_major), "version_major");
+        m.add(fun(&Build_Info::version_minor), "version_minor");
+        m.add(fun(&Build_Info::version_patch), "version_patch");
+        m.add(fun(&Build_Info::version), "version");
+        m.add(fun(&Build_Info::compiler_version), "compiler_version");
+        m.add(fun(&Build_Info::compiler_name), "compiler_name");
+        m.add(fun(&Build_Info::compiler_id), "compiler_id");
+        m.add(fun(&Build_Info::debug_build), "debug_build");
 
-        m->add(chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Dynamic_Proxy_Function>(&bind_function), "bind");
 
-        m->add(fun(&shared_ptr_unconst_clone<dispatch::Proxy_Function_Base>), "clone");
-        m->add(fun(&ptr_assign<std::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
-        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<void (dispatch::Assignable_Proxy_Function &, const std::shared_ptr<const dispatch::Proxy_Function_Base> &)>(
+        m.add(fun(&print), "print_string");
+        m.add(fun(&println), "println_string");
+
+        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");
+        m.add(fun(&Boxed_Value::type_match), "type_match");
 
 
-        m->add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
-        m->add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
+        m.add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
+        m.add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
 
-        m->add(chaiscript::base_class<std::runtime_error, chaiscript::exception::eval_error>());
+        m.add(chaiscript::base_class<std::runtime_error, chaiscript::exception::eval_error>());
+        m.add(chaiscript::base_class<std::exception, chaiscript::exception::eval_error>());
 
-        m->add(chaiscript::user_type<chaiscript::exception::arithmetic_error>(), "arithmetic_error");
-        m->add(chaiscript::base_class<std::runtime_error, chaiscript::exception::arithmetic_error>());
+        m.add(chaiscript::user_type<chaiscript::exception::arithmetic_error>(), "arithmetic_error");
+        m.add(chaiscript::base_class<std::runtime_error, chaiscript::exception::arithmetic_error>());
+        m.add(chaiscript::base_class<std::exception, chaiscript::exception::arithmetic_error>());
 
 
 //        chaiscript::bootstrap::standard_library::vector_type<std::vector<std::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
 
 
-        chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
+        chaiscript::utility::add_class<chaiscript::exception::eval_error>(m,
             "eval_error",
             { },
             { {fun(&chaiscript::exception::eval_error::reason), "reason"},
-            {fun(std::function<std::vector<Boxed_Value> (const chaiscript::exception::eval_error &t_eval_error)>([](const chaiscript::exception::eval_error &t_eval_error) -> std::vector<Boxed_Value> { 
+              {fun(&chaiscript::exception::eval_error::pretty_print), "pretty_print"},
+              {fun([](const chaiscript::exception::eval_error &t_eval_error) { 
                   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>>);
+                                 &chaiscript::var<const std::shared_ptr<const chaiscript::AST_Node> &>);
                   return retval;
-              })), "call_stack"} }
+                }), "call_stack"} }
             );
 
 
-        chaiscript::utility::add_class<chaiscript::File_Position>(*m,
+        chaiscript::utility::add_class<chaiscript::File_Position>(m,
             "File_Position",
             { constructor<File_Position()>(),
               constructor<File_Position(int, int)>() },
@@ -548,7 +560,7 @@ namespace chaiscript
             );
 
 
-        chaiscript::utility::add_class<AST_Node>(*m, 
+        chaiscript::utility::add_class<AST_Node>(m,
             "AST_Node",
             {  },
             { {fun(&AST_Node::text), "text"},
@@ -557,28 +569,17 @@ namespace chaiscript
               {fun(&AST_Node::start), "start"},
               {fun(&AST_Node::end), "end"},
               {fun(&AST_Node::to_string), "to_string"},
-              {fun(std::function<std::vector<Boxed_Value> (const chaiscript::AST_Node &t_node)>([](const chaiscript::AST_Node &t_node) -> std::vector<Boxed_Value> { 
+              {fun([](const chaiscript::AST_Node &t_node) -> std::vector<Boxed_Value> { 
                 std::vector<Boxed_Value> retval;
-                std::transform(t_node.children.begin(), t_node.children.end(),
+                const auto children = t_node.get_children();
+                std::transform(children.begin(), 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"}
+              }), "children"}
             }
             );
 
-
-        chaiscript::utility::add_class<parser::ChaiScript_Parser>(*m,
-            "ChaiScript_Parser",
-            { constructor<parser::ChaiScript_Parser ()>() },
-            { {fun(&parser::ChaiScript_Parser::parse), "parse"},
-              {fun(&parser::ChaiScript_Parser::ast), "ast"} }
-            );
-
-
-
-        return m;
       }
     };
   }

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 /// \file
 /// This file contains utility functions for registration of STL container
 /// classes. The methodology used is based on the SGI STL concepts.
@@ -37,11 +41,10 @@ namespace chaiscript
       /// Bidir_Range, based on the D concept of ranges.
       /// \todo Update the Range code to base its capabilities on
       ///       the user_typetraits of the iterator passed in
-      template<typename Container>
+      template<typename Container, typename IterType>
         struct Bidir_Range
         {
           typedef Container container_type;
-          typedef typename std::iterator_traits<typename Container::iterator>::reference reference_type;
 
           Bidir_Range(Container &c)
             : m_begin(c.begin()), m_end(c.end())
@@ -71,86 +74,28 @@ namespace chaiscript
             --m_end;
           }
 
-          reference_type front() const
+          decltype(auto) front() const
           {
             if (empty())
             {
               throw std::range_error("Range empty");
             }
-            return *m_begin;
+            return (*m_begin);
           }
 
-          reference_type back() const
+          decltype(auto) back() const
           {
             if (empty())
             {
               throw std::range_error("Range empty");
             }
-            typename Container::iterator pos = m_end;
+            auto pos = m_end;
             --pos;
-            return *(pos);
+            return (*(pos));
           }
 
-          typename Container::iterator m_begin;
-          typename Container::iterator m_end;
-        };
-
-      template<typename Container>
-        struct Const_Bidir_Range
-        {
-          typedef const Container container_type;
-          typedef typename std::iterator_traits<typename Container::const_iterator>::reference const_reference_type;
-
-          Const_Bidir_Range(const Container &c)
-            : m_begin(c.begin()), m_end(c.end())
-          {
-          }
-
-          bool empty() const
-          {
-            return m_begin == m_end;
-          }
-
-          void pop_front()
-          {
-            if (empty())
-            {
-              throw std::range_error("Range empty");
-            }
-            ++m_begin;
-          }
-
-          void pop_back()
-          {
-            if (empty())
-            {
-              throw std::range_error("Range empty");
-            }
-            --m_end;
-          }
-
-          const_reference_type front() const
-          {
-            if (empty())
-            {
-              throw std::range_error("Range empty");
-            }
-            return *m_begin;
-          }
-
-          const_reference_type back() const
-          {
-            if (empty())
-            {
-              throw std::range_error("Range empty");
-            }
-            typename Container::const_iterator pos = m_end;
-            --pos;
-            return *(pos);
-          }
-
-          typename Container::const_iterator m_begin;
-          typename Container::const_iterator m_end;
+          IterType m_begin;
+          IterType m_end;
         };
 
       namespace detail {
@@ -177,21 +122,19 @@ 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 = std::make_shared<Module>())
+          void input_range_type_impl(const std::string &type, Module& m)
           {
-            m->add(user_type<Bidir_Type>(), type + "_Range");
+            m.add(user_type<Bidir_Type>(), type + "_Range");
 
             copy_constructor<Bidir_Type>(type + "_Range", m);
 
-            m->add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range_internal");
+            m.add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range_internal");
 
-            m->add(fun(&Bidir_Type::empty), "empty");
-            m->add(fun(&Bidir_Type::pop_front), "pop_front");
-            m->add(fun(&Bidir_Type::front), "front");
-            m->add(fun(&Bidir_Type::pop_back), "pop_back");
-            m->add(fun(&Bidir_Type::back), "back");
-
-            return m;
+            m.add(fun(&Bidir_Type::empty), "empty");
+            m.add(fun(&Bidir_Type::pop_front), "pop_front");
+            m.add(fun(&Bidir_Type::front), "front");
+            m.add(fun(&Bidir_Type::pop_back), "pop_back");
+            m.add(fun(&Bidir_Type::back), "back");
           }
 
 
@@ -230,10 +173,16 @@ namespace chaiscript
       }
 
       template<typename ContainerType>
-        ModulePtr input_range_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
+        void input_range_type(const std::string &type, Module& m)
         {
-          detail::input_range_type_impl<Bidir_Range<ContainerType> >(type,m);
-          detail::input_range_type_impl<Const_Bidir_Range<ContainerType> >("Const_" + type, m);
+          detail::input_range_type_impl<Bidir_Range<ContainerType, typename ContainerType::iterator> >(type,m);
+          detail::input_range_type_impl<Bidir_Range<const ContainerType, typename ContainerType::const_iterator> >("Const_" + type,m);
+        }
+      template<typename ContainerType>
+        ModulePtr input_range_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          input_range_type<ContainerType>(type, *m);
           return m;
         }
 
@@ -241,33 +190,83 @@ 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 = std::make_shared<Module>())
+        void random_access_container_type(const std::string &/*type*/, Module& m)
         {
-          // cppcheck-suppress syntaxError
-          typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
-
           //In the interest of runtime safety for the m, we prefer the at() method for [] access,
           //to throw an exception in an out of bounds condition.
-          m->add(
-              fun(std::function<typename ContainerType::reference (ContainerType *, int)>
-                (std::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
-          m->add(
-              fun<typename ContainerType::const_reference (const ContainerType *, int)>(
-                [](const ContainerType *c, int index) -> typename ContainerType::const_reference {
-                  return c->at(index);
+          m.add(
+              fun(
+                [](ContainerType &c, int index) -> typename ContainerType::reference {
+                  /// \todo we are prefering to keep the key as 'int' to avoid runtime conversions
+                  /// during dispatch. reevaluate
+                  return c.at(static_cast<typename ContainerType::size_type>(index));
                 }), "[]");
 
+          m.add(
+              fun(
+                [](const ContainerType &c, int index) -> typename ContainerType::const_reference {
+                  /// \todo we are prefering to keep the key as 'int' to avoid runtime conversions
+                  /// during dispatch. reevaluate
+                  return c.at(static_cast<typename ContainerType::size_type>(index));
+                }), "[]");
+        }
+      template<typename ContainerType>
+        ModulePtr random_access_container_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          random_access_container_type<ContainerType>(type, *m);
           return m;
         }
 
 
+
       /// 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 = std::make_shared<Module>())
+        void assignable_type(const std::string &type, Module& m)
         {
           copy_constructor<ContainerType>(type, m);
           operators::assign<ContainerType>(m);
+        }
+      template<typename ContainerType>
+        ModulePtr assignable_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          assignable_type<ContainerType>(type, *m);
+          return m;
+        }
+
+
+      /// Add container resize concept to the given ContainerType
+      /// http://www.cplusplus.com/reference/stl/
+      template<typename ContainerType>
+        void resizable_type(const std::string &/*type*/, Module& m)
+        {
+          m.add(fun([](ContainerType *a, typename ContainerType::size_type n, const typename ContainerType::value_type& val) { return a->resize(n, val); } ), "resize");
+          m.add(fun([](ContainerType *a, typename ContainerType::size_type n) { return a->resize(n); } ), "resize");
+        }
+      template<typename ContainerType>
+        ModulePtr resizable_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          resizable_type<ContainerType>(type, *m);
+          return m;
+        }
+
+
+      /// Add container reserve concept to the given ContainerType
+      /// http://www.cplusplus.com/reference/stl/
+      template<typename ContainerType>
+        void reservable_type(const std::string &/*type*/, Module& m)
+        {
+          m.add(fun([](ContainerType *a, typename ContainerType::size_type n) { return a->reserve(n); } ), "reserve");
+          m.add(fun([](const ContainerType *a) { return a->capacity(); } ), "capacity");
+        }
+      template<typename ContainerType>
+        ModulePtr reservable_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          reservable_type<ContainerType>(type, *m);
           return m;
         }
 
@@ -275,11 +274,17 @@ 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 = std::make_shared<Module>())
+        void container_type(const std::string &/*type*/, Module& m)
         {
-          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");
+        }
+      template <typename ContainerType>
+        ModulePtr container_type(const std::string& type)
+      {
+        auto m = std::make_shared<Module>();
+        container_type<ContainerType>(type, *m);
         return m;
       }
 
@@ -287,21 +292,26 @@ 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 = std::make_shared<Module>())
+        void default_constructible_type(const std::string &type, Module& m)
         {
-          m->add(constructor<Type ()>(), type);
+          m.add(constructor<Type ()>(), type);
+        }
+      template <typename Type>
+        ModulePtr default_constructible_type(const std::string& type)
+        {
+          auto m = std::make_shared<Module>();
+          default_constructible_type<Type>(type, *m);
           return m;
         }
 
 
 
-
       /// 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 = std::make_shared<Module>())
+        void sequence_type(const std::string &/*type*/, Module& m)
         {
-          m->add(fun(&detail::insert_at<ContainerType>), 
+          m.add(fun(&detail::insert_at<ContainerType>),
               []()->std::string{
                 if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value)) {
                   return "insert_ref_at";
@@ -310,33 +320,56 @@ namespace chaiscript
                 }
               }());
 
-          m->add(fun(&detail::erase_at<ContainerType>), "erase_at");
-
+          m.add(fun(&detail::erase_at<ContainerType>), "erase_at");
+        }
+      template <typename ContainerType>
+        ModulePtr sequence_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          sequence_type<ContainerType>(type, *m);
           return m;
         }
 
-
       /// 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 = std::make_shared<Module>())
+        void back_insertion_sequence_type(const std::string &type, Module& m)
         {
           typedef typename ContainerType::reference (ContainerType::*backptr)();
 
-          m->add(fun(static_cast<backptr>(&ContainerType::back)), "back");
+          m.add(fun(static_cast<backptr>(&ContainerType::back)), "back");
 
 
           typedef void (ContainerType::*push_back)(const typename ContainerType::value_type &);
-          m->add(fun(static_cast<push_back>(&ContainerType::push_back)),
-              []()->std::string{
+          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");
+          m.add(fun(&ContainerType::pop_back), "pop_back");
+        }
+      template<typename ContainerType>
+        ModulePtr back_insertion_sequence_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          back_insertion_sequence_type<ContainerType>(type, *m);
           return m;
         }
 
@@ -345,26 +378,44 @@ 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 = std::make_shared<Module>())
+        void front_insertion_sequence_type(const std::string &type, Module& m)
         {
           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<front_ptr>(&ContainerType::front)), "front");
-          m->add(fun(static_cast<const_front_ptr>(&ContainerType::front)), "front");
+          m.add(fun(static_cast<front_ptr>(&ContainerType::front)), "front");
+          m.add(fun(static_cast<const_front_ptr>(&ContainerType::front)), "front");
 
-          m->add(fun(static_cast<push_ptr>(&ContainerType::push_front)),
-              []()->std::string{
+          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<pop_ptr>(&ContainerType::pop_front)), "pop_front");
+          m.add(fun(static_cast<pop_ptr>(&ContainerType::pop_front)), "pop_front");
+        }
+      template<typename ContainerType>
+        ModulePtr front_insertion_sequence_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          front_insertion_sequence_type<ContainerType>(type, *m);
           return m;
         }
 
@@ -372,20 +423,21 @@ 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 = std::make_shared<Module>())
+        void pair_type(const std::string &type, Module& m)
         {
-          m->add(user_type<PairType>(), type);
+          m.add(user_type<PairType>(), type);
 
-
-          typename PairType::first_type PairType::* f = &PairType::first;
-          typename PairType::second_type PairType::* s = &PairType::second;
-
-          m->add(fun(f), "first");
-          m->add(fun(s), "second");
+          m.add(fun(&PairType::first), "first");
+          m.add(fun(&PairType::second), "second");
 
           basic_constructors<PairType>(type, m);
-          m->add(constructor<PairType (const typename PairType::first_type &, const typename PairType::second_type &)>(), type);
-
+          m.add(constructor<PairType (const typename PairType::first_type &, const typename PairType::second_type &)>(), type);
+        }
+      template<typename PairType>
+        ModulePtr pair_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          pair_type<PairType>(type, *m);
           return m;
         }
 
@@ -395,10 +447,15 @@ namespace chaiscript
       /// http://www.sgi.com/tech/stl/PairAssociativeContainer.html
 
       template<typename ContainerType>
-        ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
+        void pair_associative_container_type(const std::string &type, Module& m)
         {
           pair_type<typename ContainerType::value_type>(type + "_Pair", m);
-
+        }
+      template<typename ContainerType>
+        ModulePtr pair_associative_container_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          pair_associative_container_type<ContainerType>(type, *m);
           return m;
         }
 
@@ -406,17 +463,17 @@ 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 = std::make_shared<Module>())
+        void unique_associative_container_type(const std::string &/*type*/, Module& m)
         {
-          m->add(fun(detail::count<ContainerType>), "count");
+          m.add(fun(detail::count<ContainerType>), "count");
 
           typedef size_t (ContainerType::*erase_ptr)(const typename ContainerType::key_type &);
 
-          m->add(fun(static_cast<erase_ptr>(&ContainerType::erase)), "erase");
+          m.add(fun(static_cast<erase_ptr>(&ContainerType::erase)), "erase");
 
-          m->add(fun(&detail::insert<ContainerType>), "insert");
+          m.add(fun(&detail::insert<ContainerType>), "insert");
 
-          m->add(fun(&detail::insert_ref<ContainerType>), 
+          m.add(fun(&detail::insert_ref<ContainerType>),
               []()->std::string{
                 if (typeid(typename ContainerType::mapped_type) == typeid(Boxed_Value)) {
                   return "insert_ref";
@@ -424,8 +481,12 @@ namespace chaiscript
                   return "insert";
                 }
               }());
-
-
+        }
+      template<typename ContainerType>
+        ModulePtr unique_associative_container_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          unique_associative_container_type<ContainerType>(type, *m);
           return m;
         }
 
@@ -433,13 +494,41 @@ 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 = std::make_shared<Module>())
+        void map_type(const std::string &type, Module& m)
         {
-          m->add(user_type<MapType>(), type);
+          m.add(user_type<MapType>(), 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<elem_access>(&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);
@@ -447,26 +536,36 @@ namespace chaiscript
           unique_associative_container_type<MapType>(type, m);
           pair_associative_container_type<MapType>(type, m);
           input_range_type<MapType>(type, m);
-
+        }
+      template<typename MapType>
+        ModulePtr map_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          map_type<MapType>(type, *m);
           return m;
         }
 
 
-      /// hopefully working List type
       /// http://www.sgi.com/tech/stl/List.html
       template<typename ListType>
-        ModulePtr list_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
+        void list_type(const std::string &type, Module& m)
         {
-          m->add(user_type<ListType>(), type);
+          m.add(user_type<ListType>(), type);
 
           front_insertion_sequence_type<ListType>(type, m);
           back_insertion_sequence_type<ListType>(type, m);
           sequence_type<ListType>(type, m);
+          resizable_type<ListType>(type, m);
           container_type<ListType>(type, m);
           default_constructible_type<ListType>(type, m);
           assignable_type<ListType>(type, m);
           input_range_type<ListType>(type, m);
-
+        }
+      template<typename ListType>
+        ModulePtr list_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          list_type<ListType>(type, m);
           return m;
         }
 
@@ -474,20 +573,22 @@ 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 = std::make_shared<Module>())
+        void vector_type(const std::string &type, Module& m)
         {
-          m->add(user_type<VectorType>(), type);
+          m.add(user_type<VectorType>(), type);
 
           typedef typename VectorType::reference (VectorType::*frontptr)();
           typedef typename VectorType::const_reference (VectorType::*constfrontptr)() const;
 
-          m->add(fun(static_cast<frontptr>(&VectorType::front)), "front");
-          m->add(fun(static_cast<constfrontptr>(&VectorType::front)), "front");
+          m.add(fun(static_cast<frontptr>(&VectorType::front)), "front");
+          m.add(fun(static_cast<constfrontptr>(&VectorType::front)), "front");
 
 
           back_insertion_sequence_type<VectorType>(type, m);
           sequence_type<VectorType>(type, m);
           random_access_container_type<VectorType>(type, m);
+          resizable_type<VectorType>(type, m);
+          reservable_type<VectorType>(type, m);
           container_type<VectorType>(type, m);
           default_constructible_type<VectorType>(type, m);
           assignable_type<VectorType>(type, m);
@@ -495,8 +596,8 @@ namespace chaiscript
 
           if (typeid(VectorType) == typeid(std::vector<Boxed_Value>))
           {
-            m->eval(R"(
-                    def Vector::`==`(rhs) : type_match(rhs, this) {
+            m.eval(R"(
+                    def Vector::`==`(Vector rhs) {
                        if ( rhs.size() != this.size() ) {
                          return false;
                        } else {
@@ -516,16 +617,21 @@ namespace chaiscript
                    } )"
                  );
           } 
-
+        }
+      template<typename VectorType>
+        ModulePtr vector_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          vector_type<VectorType>(type, *m);
           return m;
         }
 
       /// Add a String container
       /// http://www.sgi.com/tech/stl/basic_string.html
       template<typename String>
-        ModulePtr string_type(const std::string &type, ModulePtr m = std::make_shared<Module>())
+        void string_type(const std::string &type, Module& m)
         {
-          m->add(user_type<String>(), type);
+          m.add(user_type<String>(), type);
           operators::addition<String>(m);
           operators::assign_sum<String>(m);
           opers_comparison<String>(m);
@@ -537,7 +643,7 @@ namespace chaiscript
           input_range_type<String>(type, m);
 
           //Special case: add push_back to string (which doesn't support other back_insertion operations
-          m->add(fun(&String::push_back), 
+          m.add(fun(&String::push_back),
               []()->std::string{
                 if (typeid(typename String::value_type) == typeid(Boxed_Value)) {
                   return "push_back_ref";
@@ -547,24 +653,26 @@ namespace chaiscript
               }());
 
 
-          typedef std::function<size_t (const String *, const String &, size_t)> find_func;
+          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([](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(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( 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( 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");
+        }
+      template<typename String>
+        ModulePtr string_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          string_type<String>(type, *m);
           return m;
         }
 
@@ -573,14 +681,19 @@ 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 = std::make_shared<Module>())
+        void future_type(const std::string &type, Module& m)
         {
-          m->add(user_type<FutureType>(), type);
-
-          m->add(fun<bool (const FutureType &)>([](const FutureType &t) { return t.valid(); }), "valid");
-          m->add(fun(&FutureType::get), "get");
-          m->add(fun(&FutureType::wait), "wait");
+          m.add(user_type<FutureType>(), type);
 
+          m.add(fun([](const FutureType &t) { return t.valid(); }), "valid");
+          m.add(fun(&FutureType::get), "get");
+          m.add(fun(&FutureType::wait), "wait");
+        }
+      template<typename FutureType>
+        ModulePtr future_type(const std::string &type)
+        {
+          auto m = std::make_shared<Module>();
+          future_type<FutureType>(type, *m);
           return m;
         }
     }

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_BOXED_CAST_HPP_
 #define CHAISCRIPT_BOXED_CAST_HPP_
 
@@ -69,49 +73,36 @@ namespace chaiscript
   /// assert(i == 5);
   /// \endcode
   template<typename Type>
-  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv, const Type_Conversions *t_conversions = nullptr)
+  decltype(auto) boxed_cast(const Boxed_Value &bv, const Type_Conversions_State *t_conversions = nullptr)
   {
-    if (!t_conversions || bv.get_type_info().bare_equal(user_type<Type>()) || (t_conversions && !t_conversions->convertable_type<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);
+        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>())
+    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);
+        return(detail::Cast_Helper<Type>::cast((*t_conversions)->boxed_type_conversion<Type>(t_conversions->saves(), 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);
+          // try going the other way
+          return(detail::Cast_Helper<Type>::cast((*t_conversions)->boxed_type_down_conversion<Type>(t_conversions->saves(), 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 
+      // If it's not convertable, 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));
     }
 
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(pop)
-#endif
-
   }
 
 }

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 #define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 
@@ -16,7 +20,7 @@
 
 namespace chaiscript 
 {
-  class Type_Conversions;
+  class Type_Conversions_State;
 
   namespace detail
   {
@@ -25,25 +29,54 @@ namespace chaiscript
     template<typename T>
       T* throw_if_null(T *t)
       {
-        if (t) return t;
+        if (t) { return t; }
         throw std::runtime_error("Attempted to dereference null Boxed_Value");
       }
 
+    template<typename T>
+    static const T *verify_type_no_throw(const Boxed_Value &ob, const std::type_info &ti, const T *ptr) {
+      if (ob.get_type_info() == ti) {
+        return ptr;
+      } else {
+        throw chaiscript::detail::exception::bad_any_cast();
+      }
+    }
+
+    template<typename T>
+    static T *verify_type_no_throw(const Boxed_Value &ob, const std::type_info &ti, T *ptr) {
+      if (!ob.is_const() && ob.get_type_info() == ti) {
+        return ptr;
+      } else {
+        throw chaiscript::detail::exception::bad_any_cast();
+      }
+    }
+
+
+    template<typename T>
+    static const T *verify_type(const Boxed_Value &ob, const std::type_info &ti, const T *ptr) {
+      if (ob.get_type_info().bare_equal_type_info(ti)) {
+        return throw_if_null(ptr);
+      } else {
+        throw chaiscript::detail::exception::bad_any_cast();
+      }
+    }
+
+    template<typename T>
+    static T *verify_type(const Boxed_Value &ob, const std::type_info &ti, T *ptr) {
+      if (!ob.is_const() && ob.get_type_info().bare_equal_type_info(ti)) {
+        return throw_if_null(ptr);
+      } else {
+        throw chaiscript::detail::exception::bad_any_cast();
+      }
+    }
+
     /// Generic Cast_Helper_Inner, for casting to any type
     template<typename Result>
       struct Cast_Helper_Inner
       {
-        typedef std::reference_wrapper<typename std::add_const<Result>::type > Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static Result cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (ob.get_type_info().bare_equal_type_info(typeid(Result)))
-          {
-            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();
-          }
+          return *static_cast<const Result *>(verify_type(ob, typeid(Result), ob.get_const_ptr()));
         }
       };
 
@@ -52,25 +85,14 @@ namespace chaiscript
       {
       };
 
-    /// Cast_Helper_Inner for casting to a const & type
-    template<typename Result>
-      struct Cast_Helper_Inner<const Result &> : Cast_Helper_Inner<Result>
-      {
-      };
 
     /// Cast_Helper_Inner for casting to a const * type
     template<typename Result>
       struct Cast_Helper_Inner<const Result *>
       {
-        typedef const Result * Result_Type;
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static const Result * cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (ob.get_type_info().bare_equal_type_info(typeid(Result)))
-          {
-            return static_cast<const Result *>(throw_if_null(ob.get_const_ptr()));
-          } else {
-            throw chaiscript::detail::exception::bad_any_cast();
-          }
+          return static_cast<const Result *>(verify_type_no_throw(ob, typeid(Result), ob.get_const_ptr()));
         }
       };
 
@@ -78,15 +100,30 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner<Result *>
       {
-        typedef Result * Result_Type;
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static Result * cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (ob.is_ref())
-          {
-            return &(ob.get().cast<std::reference_wrapper<Result> >()).get();
-          } else {
-            return (ob.get().cast<std::shared_ptr<Result> >()).get();
+          return static_cast<Result *>(verify_type_no_throw(ob, typeid(Result), ob.get_ptr()));
         }
+      };
+
+    template<typename Result>
+    struct Cast_Helper_Inner<Result * const &> : public Cast_Helper_Inner<Result *>
+    {
+    };
+
+    template<typename Result>
+    struct Cast_Helper_Inner<const Result * const &> : public Cast_Helper_Inner<const Result *>
+    {
+    };
+
+
+    /// Cast_Helper_Inner for casting to a & type
+    template<typename Result>
+      struct Cast_Helper_Inner<const Result &>
+      {
+        static const Result & cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return *static_cast<const Result *>(verify_type(ob, typeid(Result), ob.get_const_ptr()));
         }
       };
 
@@ -96,26 +133,61 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner<Result &>
       {
-        typedef Result& Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static Result& cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (!ob.get_type_info().is_const() && ob.get_type_info().bare_equal_type_info(typeid(Result)))
-          {
-            return *(static_cast<Result *>(throw_if_null(ob.get_ptr())));
-          } else {
-            throw chaiscript::detail::exception::bad_any_cast();
-          }
+          return *static_cast<Result *>(verify_type(ob, typeid(Result), ob.get_ptr()));
         }
       };
 
+    /// Cast_Helper_Inner for casting to a && type
+    template<typename Result>
+      struct Cast_Helper_Inner<Result &&>
+      {
+        static Result&& cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return std::move(*static_cast<Result *>(verify_type(ob, typeid(Result), ob.get_ptr())));
+        }
+      };
+
+    /// Cast_Helper_Inner for casting to a std::unique_ptr<> && type
+    /// \todo Fix the fact that this has to be in a shared_ptr for now
+    template<typename Result>
+      struct Cast_Helper_Inner<std::unique_ptr<Result> &&>
+      {
+        static std::unique_ptr<Result> &&cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return std::move(*(ob.get().cast<std::shared_ptr<std::unique_ptr<Result>>>()));
+        }
+      };
+
+    /// Cast_Helper_Inner for casting to a std::unique_ptr<> & type
+    /// \todo Fix the fact that this has to be in a shared_ptr for now
+    template<typename Result>
+      struct Cast_Helper_Inner<std::unique_ptr<Result> &>
+      {
+        static std::unique_ptr<Result> &cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return *(ob.get().cast<std::shared_ptr<std::unique_ptr<Result>>>());
+        }
+      };
+
+    /// Cast_Helper_Inner for casting to a std::unique_ptr<> & type
+    /// \todo Fix the fact that this has to be in a shared_ptr for now
+    template<typename Result>
+      struct Cast_Helper_Inner<const std::unique_ptr<Result> &>
+      {
+        static std::unique_ptr<Result> &cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return *(ob.get().cast<std::shared_ptr<std::unique_ptr<Result>>>());
+        }
+      };
+
+
     /// Cast_Helper_Inner for casting to a std::shared_ptr<> type
     template<typename Result>
       struct Cast_Helper_Inner<std::shared_ptr<Result> >
       {
-        typedef std::shared_ptr<Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static auto cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
           return ob.get().cast<std::shared_ptr<Result> >();
         }
@@ -125,9 +197,7 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner<std::shared_ptr<const Result> >
       {
-        typedef std::shared_ptr<const Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static auto cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
           if (!ob.get_type_info().is_const())
           {
@@ -149,6 +219,17 @@ namespace chaiscript
       {
       };
 
+    template<typename Result>
+      struct Cast_Helper_Inner<std::shared_ptr<Result> &>
+      {
+        static_assert(!std::is_const<Result>::value, "Non-const reference to std::shared_ptr<const T> is not supported");
+        static auto cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          std::shared_ptr<Result> &res = ob.get().cast<std::shared_ptr<Result> >();
+          return ob.pointer_sentinel(res);
+        }
+      };
+
 
     /// Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
     template<typename Result>
@@ -162,14 +243,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;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static Boxed_Value cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
           return ob;
         }
@@ -179,11 +257,9 @@ namespace chaiscript
     template<>
       struct Cast_Helper_Inner<Boxed_Value &>
       {
-        typedef Boxed_Value& Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        static std::reference_wrapper<Boxed_Value> cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          return const_cast<Boxed_Value &>(ob);
+          return std::ref(const_cast<Boxed_Value &>(ob));
         }
       };
 
@@ -235,11 +311,9 @@ namespace chaiscript
     template<typename T>
       struct Cast_Helper
       {
-        typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
+        static decltype(auto) cast(const Boxed_Value &ob, const Type_Conversions_State *t_conversions)
         {
-          return Cast_Helper_Inner<T>::cast(ob, t_conversions);
+          return(Cast_Helper_Inner<T>::cast(ob, t_conversions));
         }
       };
   }

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
 #define CHAISCRIPT_BOXED_VALUE_HPP_
 
@@ -35,11 +39,11 @@ namespace chaiscript
       {
         Data(const Type_Info &ti,
             chaiscript::detail::Any to,
-            bool tr,
+            bool is_ref,
             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_return_value(t_return_value)
+            m_is_ref(is_ref), m_return_value(t_return_value)
         {
         }
 
@@ -54,7 +58,7 @@ namespace chaiscript
 
           if (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));
+            m_attrs = std::make_unique<std::map<std::string, std::shared_ptr<Data>>>(*rhs.m_attrs);
           }
 
           return *this;
@@ -62,10 +66,8 @@ namespace chaiscript
 
         Data(const Data &) = delete;
 
-#if !defined(__APPLE__) && (!defined(_MSC_VER) || _MSC_VER != 1800)
         Data(Data &&) = default;
         Data &operator=(Data &&rhs) = default;
-#endif
 
 
         Type_Info m_type_info;
@@ -79,7 +81,7 @@ namespace chaiscript
 
       struct Object_Data
       {
-        static std::shared_ptr<Data> get(Boxed_Value::Void_Type, bool t_return_value)
+        static auto get(Boxed_Value::Void_Type, bool t_return_value)
         {
           return std::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
@@ -91,13 +93,13 @@ namespace chaiscript
         }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const std::shared_ptr<T> *obj, bool t_return_value)
+          static auto get(const std::shared_ptr<T> *obj, bool t_return_value)
           {
             return get(*obj, t_return_value);
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const std::shared_ptr<T> &obj, bool t_return_value)
+          static auto get(const std::shared_ptr<T> &obj, bool t_return_value)
           {
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
@@ -109,7 +111,7 @@ namespace chaiscript
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(std::shared_ptr<T> &&obj, bool t_return_value)
+          static auto get(std::shared_ptr<T> &&obj, bool t_return_value)
           {
             auto ptr = obj.get();
             return std::make_shared<Data>(
@@ -121,21 +123,23 @@ namespace chaiscript
                 );
           }
 
+
+
         template<typename T>
-          static std::shared_ptr<Data> get(T *t, bool t_return_value)
+          static auto get(T *t, bool t_return_value)
           {
             return get(std::ref(*t), t_return_value);
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const T *t, bool t_return_value)
+          static auto get(const T *t, bool t_return_value)
           {
             return get(std::cref(*t), t_return_value);
           }
 
 
         template<typename T>
-          static std::shared_ptr<Data> get(std::reference_wrapper<T> obj, bool t_return_value)
+          static auto get(std::reference_wrapper<T> obj, bool t_return_value)
           {
             auto p = &obj.get();
             return std::make_shared<Data>(
@@ -148,7 +152,20 @@ namespace chaiscript
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(T t, bool t_return_value)
+          static auto get(std::unique_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::make_shared<std::unique_ptr<T>>(std::move(obj))), 
+                  true,
+                  ptr,
+                  t_return_value
+                );
+          }
+
+        template<typename T>
+          static auto get(T t, bool t_return_value)
           {
             auto p = std::make_shared<T>(std::move(t));
             auto ptr = p.get();
@@ -184,16 +201,10 @@ namespace chaiscript
         }
 
       /// Unknown-type constructor
-      Boxed_Value()
-        : m_data(Object_Data::get())
-      {
-      }
+      Boxed_Value() = default;
 
-#if !defined(_MSC_VER) || _MSC_VER != 1800
       Boxed_Value(Boxed_Value&&) = default;
       Boxed_Value& operator=(Boxed_Value&&) = default;
-#endif
-
       Boxed_Value(const Boxed_Value&) = default;
       Boxed_Value& operator=(const Boxed_Value&) = default;
 
@@ -210,63 +221,99 @@ namespace chaiscript
         return *this;
       }
 
-      const Type_Info &get_type_info() const CHAISCRIPT_NOEXCEPT
+      const Type_Info &get_type_info() const noexcept
       {
         return m_data->m_type_info;
       }
 
       /// return true if the object is uninitialized
-      bool is_undef() const CHAISCRIPT_NOEXCEPT
+      bool is_undef() const noexcept
       {
         return m_data->m_type_info.is_undef();
       }
 
-      bool is_const() const CHAISCRIPT_NOEXCEPT
+      bool is_const() const noexcept
       {
         return m_data->m_type_info.is_const();
       }
 
-      bool is_type(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
+      bool is_type(const Type_Info &ti) const noexcept
       {
         return m_data->m_type_info.bare_equal(ti);
       }
 
-      bool is_null() const CHAISCRIPT_NOEXCEPT
+
+      template<typename T>
+      auto pointer_sentinel(std::shared_ptr<T> &ptr) const
+      {
+        struct Sentinel {
+          Sentinel(std::shared_ptr<T> &t_ptr, Data &data)
+            : m_ptr(t_ptr), m_data(data)
+          {
+          }
+
+          ~Sentinel()
+          {
+            // save new pointer data
+            const auto ptr_ = m_ptr.get().get();
+            m_data.get().m_data_ptr = ptr_;
+            m_data.get().m_const_data_ptr = ptr_;
+          }
+
+          Sentinel& operator=(Sentinel&&s) = default;
+          Sentinel(Sentinel &&s) = default;
+
+          operator std::shared_ptr<T>&() const
+          {
+            return m_ptr.get();
+          }
+
+          Sentinel &operator=(const Sentinel &) = delete;
+          Sentinel(Sentinel&) = delete;
+
+          std::reference_wrapper<std::shared_ptr<T>> m_ptr;
+          std::reference_wrapper<Data> m_data;
+        };
+
+        return Sentinel(ptr, *(m_data.get()));
+      }
+
+      bool is_null() const noexcept
       {
         return (m_data->m_data_ptr == nullptr && m_data->m_const_data_ptr == nullptr);
       }
 
-      const chaiscript::detail::Any & get() const CHAISCRIPT_NOEXCEPT
+      const chaiscript::detail::Any & get() const noexcept
       {
         return m_data->m_obj;
       }
 
-      bool is_ref() const CHAISCRIPT_NOEXCEPT
+      bool is_ref() const noexcept
       {
         return m_data->m_is_ref;
       }
 
-      bool is_return_value() const CHAISCRIPT_NOEXCEPT
+      bool is_return_value() const noexcept
       {
         return m_data->m_return_value;
       }
 
-      void reset_return_value() const CHAISCRIPT_NOEXCEPT
+      void reset_return_value() const noexcept
       {
         m_data->m_return_value = false;
       }
 
-      bool is_pointer() const CHAISCRIPT_NOEXCEPT
+      bool is_pointer() const noexcept
       {
         return !is_ref();
       }
 
-      void *get_ptr() const CHAISCRIPT_NOEXCEPT
+      void *get_ptr() const noexcept
       {
         return m_data->m_data_ptr;
       }
 
-      const void *get_const_ptr() const CHAISCRIPT_NOEXCEPT
+      const void *get_const_ptr() const noexcept
       {
         return m_data->m_const_data_ptr;
       }
@@ -275,7 +322,7 @@ namespace chaiscript
       {
         if (!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>>());
+          m_data->m_attrs = std::make_unique<std::map<std::string, std::shared_ptr<Data>>>();
         }
 
         auto &attr = (*m_data->m_attrs)[t_name];
@@ -292,14 +339,21 @@ namespace chaiscript
       {
         if (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));
+          m_data->m_attrs = std::make_unique<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
+      static bool type_match(const Boxed_Value &l, const Boxed_Value &r) noexcept
       {
         return l.get_type_info() == r.get_type_info();
       }
@@ -308,11 +362,11 @@ namespace chaiscript
       // 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) {
+      Boxed_Value(std::shared_ptr<Data> t_data, Internal_Construction)
+        : m_data(std::move(t_data)) {
       }
 
-      std::shared_ptr<Data> m_data;
+      std::shared_ptr<Data> m_data = Object_Data::get();
   };
 
   /// @brief Creates a Boxed_Value. If the object passed in is a value type, it is copied. If it is a pointer, std::shared_ptr, or std::reference_type
@@ -330,9 +384,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 {
@@ -409,10 +463,14 @@ namespace chaiscript
       return detail::const_var_impl(t);
     }
 
-#ifdef CHAISCRIPT_HAS_MAGIC_STATICS
+  inline Boxed_Value void_var() {
+    static const auto v = Boxed_Value(Boxed_Value::Void_Type());
+    return v;
+  }
+
   inline Boxed_Value const_var(bool b) {
-    static auto t = detail::const_var_impl(true);
-    static auto f = detail::const_var_impl(false);
+    static const auto t = detail::const_var_impl(true);
+    static const auto f = detail::const_var_impl(false);
 
     if (b) {
       return t;
@@ -420,7 +478,6 @@ namespace chaiscript
       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-2017, 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
+      {
+        explicit 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
+      {
+        explicit 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
+      {
+        explicit 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

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 #define CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 
@@ -24,16 +28,36 @@ namespace chaiscript
 {
   namespace dispatch
   {
+    struct option_explicit_set : std::runtime_error {
+      explicit option_explicit_set(const std::string &t_param_name)
+        : std::runtime_error("option explicit set and parameter '" + t_param_name + "' does not exist")
+      {
+
+      }
+
+      option_explicit_set(const option_explicit_set &) = default;
+
+      ~option_explicit_set() noexcept override = default;
+    };
+
     class Dynamic_Object
     {
       public:
-        Dynamic_Object(std::string t_type_name)
-          : m_type_name(std::move(t_type_name))
+        explicit Dynamic_Object(std::string t_type_name)
+          : m_type_name(std::move(t_type_name)), m_option_explicit(false)
         {
         }
 
-        Dynamic_Object() : m_type_name("")
+        Dynamic_Object() = default;
+
+        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
@@ -41,6 +65,16 @@ namespace chaiscript
           return m_type_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);
@@ -52,6 +86,10 @@ namespace chaiscript
           }
         }
 
+        bool has_attr(const std::string &t_attr_name) const {
+          return m_attrs.find(t_attr_name) != m_attrs.end();
+        }
+
         Boxed_Value &get_attr(const std::string &t_attr_name)
         {
           return m_attrs[t_attr_name];
@@ -59,14 +97,21 @@ namespace chaiscript
 
         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
         {
-          return get_attr(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);
+        }
 
         std::map<std::string, Boxed_Value> get_attrs() const
         {
@@ -74,7 +119,8 @@ namespace chaiscript
         }
 
       private:
-        std::string m_type_name;
+        const std::string m_type_name = "";
+        bool m_option_explicit = false;
 
         std::map<std::string, Boxed_Value> m_attrs;
     };

include/chaiscript/dispatchkit/dynamic_object_detail.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_DETAIL_HPP_
@@ -39,7 +39,7 @@ namespace chaiscript
       /// A Proxy_Function implementation designed for calling a function
       /// that is automatically guarded based on the first param based on the
       /// param's type name
-      class Dynamic_Object_Function : public Proxy_Function_Base
+      class Dynamic_Object_Function final : public Proxy_Function_Base
       {
         public:
           Dynamic_Object_Function(
@@ -67,12 +67,11 @@ namespace chaiscript
                 && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
           }
 
-          virtual ~Dynamic_Object_Function() {}
 
           Dynamic_Object_Function &operator=(const Dynamic_Object_Function) = delete;
           Dynamic_Object_Function(Dynamic_Object_Function &) = delete;
 
-          virtual bool operator==(const Proxy_Function_Base &f) const CHAISCRIPT_OVERRIDE
+          bool operator==(const Proxy_Function_Base &f) const override
           {
             if (const auto *df = dynamic_cast<const Dynamic_Object_Function *>(&f))
             {
@@ -82,9 +81,9 @@ namespace chaiscript
             }
           }
 
-          virtual bool is_attribute_function() const CHAISCRIPT_OVERRIDE { return m_is_attribute; } 
+          bool is_attribute_function() const override { return m_is_attribute; } 
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const override
           {
             if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
             {
@@ -94,19 +93,13 @@ namespace chaiscript
             }
           }
 
-          virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
+          std::vector<Const_Proxy_Function> get_contained_functions() const override
           {
             return {m_func};
           }
 
-          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-          {
-            return m_func->annotation();
-          }
-
-
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
           {
             if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
             {
@@ -116,7 +109,7 @@ namespace chaiscript
             } 
           }
 
-          virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          bool compare_first_type(const Boxed_Value &bv, const Type_Conversions_State &t_conversions) const override
           {
             return dynamic_object_typename_match(bv, m_type_name, m_ti, t_conversions);
           }
@@ -134,7 +127,7 @@ namespace chaiscript
           }
 
           bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const std::unique_ptr<Type_Info> &ti, const Type_Conversions &t_conversions) const
+              const std::unique_ptr<Type_Info> &ti, const Type_Conversions_State &t_conversions) const
           {
             if (bv.get_type_info().bare_equal(m_doti))
             {
@@ -156,9 +149,9 @@ namespace chaiscript
           }
 
           bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const std::unique_ptr<Type_Info> &ti, const Type_Conversions &t_conversions) const
+              const std::unique_ptr<Type_Info> &ti, const Type_Conversions_State &t_conversions) const
           {
-            if (bvs.size() > 0)
+            if (!bvs.empty())
             {
               return dynamic_object_typename_match(bvs[0], name, ti, t_conversions);
             } else {
@@ -170,9 +163,7 @@ namespace chaiscript
           Proxy_Function m_func;
           std::unique_ptr<Type_Info> m_ti;
           const Type_Info m_doti;
-          bool m_is_attribute;
-
-
+          const bool m_is_attribute;
       };
 
 
@@ -182,7 +173,7 @@ namespace chaiscript
        * that is automatically guarded based on the first param based on the
        * param's type name
        */
-      class Dynamic_Object_Constructor : public Proxy_Function_Base
+      class Dynamic_Object_Constructor final : public Proxy_Function_Base
       {
         public:
           Dynamic_Object_Constructor(
@@ -208,15 +199,13 @@ namespace chaiscript
             return std::vector<Type_Info>(begin, end);
           }
 
-          virtual ~Dynamic_Object_Constructor() {}
-
-          virtual bool operator==(const Proxy_Function_Base &f) const CHAISCRIPT_OVERRIDE
+          bool operator==(const Proxy_Function_Base &f) const override
           {
             const Dynamic_Object_Constructor *dc = dynamic_cast<const Dynamic_Object_Constructor*>(&f);
-            return dc && dc->m_type_name == m_type_name && (*dc->m_func) == (*m_func);
+            return (dc != nullptr) && 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
+          bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const override
           {
             std::vector<Boxed_Value> new_vals{Boxed_Value(Dynamic_Object(m_type_name))};
             new_vals.insert(new_vals.end(), vals.begin(), vals.end());
@@ -224,15 +213,10 @@ namespace chaiscript
             return m_func->call_match(new_vals, t_conversions);
           }
 
-          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-          {
-            return m_func->annotation();
-          }
-
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const 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());
 
@@ -242,8 +226,8 @@ namespace chaiscript
           }
 
         private:
-          std::string m_type_name;
-          Proxy_Function m_func;
+          const std::string m_type_name;
+          const Proxy_Function m_func;
 
       };
     }

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
 #define CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
 
@@ -23,80 +27,26 @@ namespace chaiscript
 {
   namespace detail
   {
-    /// \todo make this a variadic template
     struct Exception_Handler_Base
     {
       virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) = 0;
 
-      virtual ~Exception_Handler_Base() {}
+      virtual ~Exception_Handler_Base() = default;
 
       protected:
         template<typename T>
-        void throw_type(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        static void throw_type(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
           try { T t = t_engine.boxed_cast<T>(bv); throw t; } catch (const chaiscript::exception::bad_boxed_cast &) {}
         }
     };
 
-    template<typename T1>
-      struct Exception_Handler_Impl1 : Exception_Handler_Base
+    template<typename ... T>
+      struct Exception_Handler_Impl : Exception_Handler_Base
       {
-        virtual ~Exception_Handler_Impl1() {}
-
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
+        void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) override
         {
-          throw_type<T1>(bv, t_engine);
-        }
-      };
-    template<typename T1, typename T2>
-      struct Exception_Handler_Impl2 : Exception_Handler_Base
-      {
-        virtual ~Exception_Handler_Impl2() {}
-
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
-        {
-          throw_type<T1>(bv, t_engine);
-          throw_type<T2>(bv, t_engine);
-        }
-      };
-
-    template<typename T1, typename T2, typename T3>
-      struct Exception_Handler_Impl3 : Exception_Handler_Base
-      {
-        virtual ~Exception_Handler_Impl3() {}
-
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
-        {
-          throw_type<T1>(bv, t_engine);
-          throw_type<T2>(bv, t_engine);
-          throw_type<T3>(bv, t_engine);
-        }
-      };
-    template<typename T1, typename T2, typename T3, typename T4>
-      struct Exception_Handler_Impl4 : Exception_Handler_Base
-      {
-        virtual ~Exception_Handler_Impl4() {}
-
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
-        {
-          throw_type<T1>(bv, t_engine);
-          throw_type<T2>(bv, t_engine);
-          throw_type<T3>(bv, t_engine);
-          throw_type<T4>(bv, t_engine);
-        }
-      };
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-      struct Exception_Handler_Impl5 : Exception_Handler_Base
-      {
-        virtual ~Exception_Handler_Impl5() {}
-
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
-        {
-          throw_type<T1>(bv, t_engine);
-          throw_type<T2>(bv, t_engine);
-          throw_type<T3>(bv, t_engine);
-          throw_type<T4>(bv, t_engine);
-          throw_type<T5>(bv, t_engine);
+          (void)std::initializer_list<int>{(throw_type<T>(bv, t_engine), 0)...};
         }
       };
   }
@@ -155,42 +105,10 @@ namespace chaiscript
 
   /// \brief creates a chaiscript::Exception_Handler which handles one type of exception unboxing
   /// \sa \ref exceptions
-  template<typename T1>
+  template<typename ... T>
   Exception_Handler exception_specification()
   {
-    return Exception_Handler(new detail::Exception_Handler_Impl1<T1>());
-  }
-
-  /// \brief creates a chaiscript::Exception_Handler which handles two types of exception unboxing
-  /// \sa \ref exceptions
-  template<typename T1, typename T2>
-  Exception_Handler exception_specification()
-  {
-    return Exception_Handler(new detail::Exception_Handler_Impl2<T1, T2>());
-  }
-
-  /// \brief creates a chaiscript::Exception_Handler which handles three types of exception unboxing
-  /// \sa \ref exceptions
-  template<typename T1, typename T2, typename T3>
-  Exception_Handler exception_specification()
-  {
-    return Exception_Handler(new detail::Exception_Handler_Impl3<T1, T2, T3>());
-  }
-
-  /// \brief creates a chaiscript::Exception_Handler which handles four types of exception unboxing
-  /// \sa \ref exceptions
-  template<typename T1, typename T2, typename T3, typename T4>
-  Exception_Handler exception_specification()
-  {
-    return Exception_Handler(new detail::Exception_Handler_Impl4<T1, T2, T3, T4>());
-  }
-
-  /// \brief creates a chaiscript::Exception_Handler which handles five types of exception unboxing
-  /// \sa \ref exceptions
-  template<typename T1, typename T2, typename T3, typename T4, typename T5>
-  Exception_Handler exception_specification()
-  {
-    return Exception_Handler(new detail::Exception_Handler_Impl5<T1, T2, T3, T4, T5>());
+    return std::make_shared<detail::Exception_Handler_Impl<T...>>();
   }
 }
 

include/chaiscript/dispatchkit/function_call.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_HPP_
 
@@ -14,10 +18,11 @@
 #include "boxed_cast.hpp"
 #include "function_call_detail.hpp"
 #include "proxy_functions.hpp"
+#include "callable_traits.hpp"
 
 namespace chaiscript {
 class Boxed_Value;
-class Type_Conversions;
+class Type_Conversions_State;
 namespace detail {
 template <typename T> struct Cast_Helper;
 }  // namespace detail
@@ -34,9 +39,17 @@ namespace chaiscript
     /// \returns A std::function object for dispatching
     /// \param[in] funcs the set of functions to dispatch on.
     template<typename FunctionType>
-      std::function<FunctionType>
-      functor(const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions *t_conversions)
+      std::function<FunctionType> functor(const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions_State *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);
       }
@@ -53,8 +66,7 @@ namespace chaiscript
     /// \returns A std::function object for dispatching
     /// \param[in] func A function to execute.
     template<typename FunctionType>
-      std::function<FunctionType>
-      functor(Const_Proxy_Function func, const Type_Conversions *t_conversions)
+      std::function<FunctionType> functor(Const_Proxy_Function func, const Type_Conversions_State *t_conversions)
       {
         return functor<FunctionType>(std::vector<Const_Proxy_Function>({std::move(func)}), t_conversions);
       }
@@ -62,8 +74,7 @@ namespace chaiscript
     /// Helper for automatically unboxing a Boxed_Value that contains a function object
     /// and creating a typesafe C++ function caller from it.
     template<typename FunctionType>
-      std::function<FunctionType>
-      functor(const Boxed_Value &bv, const Type_Conversions *t_conversions)
+      std::function<FunctionType> functor(const Boxed_Value &bv, const Type_Conversions_State *t_conversions)
       {
         return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
       }
@@ -74,9 +85,7 @@ namespace chaiscript
     template<typename Signature>
       struct Cast_Helper<const std::function<Signature> &>
       {
-        typedef std::function<Signature> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
+        static std::function<Signature> cast(const Boxed_Value &ob, const Type_Conversions_State *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
@@ -91,9 +100,7 @@ namespace chaiscript
     template<typename Signature>
       struct Cast_Helper<std::function<Signature> >
       {
-        typedef std::function<Signature> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
+        static std::function<Signature> cast(const Boxed_Value &ob, const Type_Conversions_State *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
@@ -108,9 +115,7 @@ namespace chaiscript
     template<typename Signature>
       struct Cast_Helper<const std::function<Signature> >
       {
-        typedef std::function<Signature> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
+        static std::function<Signature> cast(const Boxed_Value &ob, const Type_Conversions_State *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 
@@ -31,9 +35,15 @@ 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_State *t_conversions)
           {
-            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, t_conversions));
+            if (t_conversions != nullptr) {
+              return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, *t_conversions), t_conversions);
+            } else {
+              Type_Conversions conv;
+              Type_Conversions_State state(conv, conv.conversion_saves());
+              return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, state), t_conversions);
+            }
           }
         };
 
@@ -44,9 +54,15 @@ 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_State *t_conversions)
           {
-            return Boxed_Number(dispatch::dispatch(t_funcs, params, t_conversions)).get_as<Ret>();
+            if (t_conversions != nullptr) {
+              return Boxed_Number(dispatch::dispatch(t_funcs, params, *t_conversions)).get_as<Ret>();
+            } else {
+              Type_Conversions conv;
+              Type_Conversions_State state(conv, conv.conversion_saves());
+              return Boxed_Number(dispatch::dispatch(t_funcs, params, state)).get_as<Ret>();
+            }
           }
         };
 
@@ -58,9 +74,15 @@ 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_State *t_conversions)
           {
-            dispatch::dispatch(t_funcs, params, t_conversions);
+            if (t_conversions != nullptr) {
+              dispatch::dispatch(t_funcs, params, *t_conversions);
+            } else {
+              Type_Conversions conv;
+              Type_Conversions_State state(conv, conv.conversion_saves());
+              dispatch::dispatch(t_funcs, params, state);
+            }
           }
         };
 
@@ -70,31 +92,60 @@ 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)
           {
+            if (m_conversions) {
+              Type_Conversions_State state(*m_conversions, m_conversions->conversion_saves());
               return Function_Caller_Ret<Ret, std::is_arithmetic<Ret>::value && !std::is_same<Ret, bool>::value>::call(m_funcs, { 
-                (std::is_reference<Param>::value&&!(std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<Param>::type>::type>::value))?Boxed_Value(std::ref(param)):Boxed_Value(param)... 
-                }, m_conversions
-
+                  box<P>(std::forward<P>(param))...
+                  }, &state
                   );
+            } else {
+              return Function_Caller_Ret<Ret, std::is_arithmetic<Ret>::value && !std::is_same<Ret, bool>::value>::call(m_funcs, { 
+                  box<P>(std::forward<P>(param))...
+                  }, nullptr
+                  );
+            }
 
           }
 
+          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)
+        std::function<Ret (Params...)> build_function_caller_helper(Ret (Params...), const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions_State *t_conversions)
         {
+          /*
           if (funcs.size() == 1)
           {
             std::shared_ptr<const Proxy_Function_Impl<Ret (Params...)>> pfi = 
@@ -108,8 +159,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?t_conversions->get():nullptr));
         }
     }
   }

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,15 +1,18 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
 #define CHAISCRIPT_HANDLE_RETURN_HPP_
 
 #include <functional>
 #include <memory>
-#include <string>
 #include <type_traits>
 
 #include "boxed_number.hpp"
@@ -23,14 +26,12 @@ namespace chaiscript
 {
   namespace dispatch
   {
-    template<class T> class Proxy_Function_Impl;
+    template<class T, class U> class Proxy_Function_Callable_Impl;
     template<class T> class Assignable_Proxy_Function_Impl;
 
     namespace detail
     {
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
+      /// Used internally for handling a return value from a Proxy_Function call
       template<typename Ret>
         struct Handle_Return
         {
@@ -54,23 +55,14 @@ namespace chaiscript
         {
           static Boxed_Value handle(const std::function<Ret> &f) {
             return Boxed_Value(
-                std::shared_ptr<dispatch::Proxy_Function_Base>(
-                  new dispatch::Proxy_Function_Impl<Ret>(f)
-                )
+                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>>
+        struct Handle_Return<std::function<Ret>> : Handle_Return<const std::function<Ret> &>
         {
-          static Boxed_Value handle(const std::function<Ret> &f) {
-            return Boxed_Value(
-                std::shared_ptr<dispatch::Proxy_Function_Base>(
-                  new Proxy_Function_Impl<Ret>(f)
-                  )
-                );
-          }
         };
 
       template<typename Ret>
@@ -78,44 +70,19 @@ namespace chaiscript
         {
           static Boxed_Value handle(const std::shared_ptr<std::function<Ret>> &f) {
             return Boxed_Value(
-                std::shared_ptr<Proxy_Function_Base>(
-                  new Assignable_Proxy_Function_Impl<Ret>(
-                    std::ref(*f),
-                    f
-                    )
-                  )
+                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>> &>
+        struct Handle_Return<const std::shared_ptr<std::function<Ret>> &> : Handle_Return<const std::shared_ptr<std::function<Ret>>>
         {
-          static Boxed_Value handle(const std::shared_ptr<std::function<Ret>> &f) {
-            return Boxed_Value(
-                std::shared_ptr<Proxy_Function_Base>(
-                  new Assignable_Proxy_Function_Impl<Ret>(
-                    std::ref(*f),
-                    f
-                    )
-                  )
-                );
-          }
         };
 
       template<typename Ret>
-        struct Handle_Return<std::shared_ptr<std::function<Ret>>>
+        struct Handle_Return<std::shared_ptr<std::function<Ret>>> : Handle_Return<const std::shared_ptr<std::function<Ret>>>
         {
-          static Boxed_Value handle(const std::shared_ptr<std::function<Ret>> &f) {
-            return Boxed_Value(
-                std::shared_ptr<Proxy_Function_Base>(
-                  new Assignable_Proxy_Function_Impl<Ret>(
-                    std::ref(*f),
-                    f
-                    )
-                  )
-                );
-          }
         };
 
       template<typename Ret>
@@ -123,24 +90,36 @@ namespace chaiscript
         {
           static Boxed_Value handle(std::function<Ret> &f) {
             return Boxed_Value(
-                std::shared_ptr<Proxy_Function_Base>(
-                  new Assignable_Proxy_Function_Impl<Ret>(
-                    std::ref(f),
-                    std::shared_ptr<std::function<Ret>>()
-                    )
-                  )
+                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(
-                std::shared_ptr<dispatch::Proxy_Function_Base>(
-                  new dispatch::Proxy_Function_Impl<Ret>(f)
-                )
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret, std::function<Ret>>>(f)
               );
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<Ret *&>
+        {
+          static Boxed_Value handle(Ret *p)
+          {
+            return Boxed_Value(p, true);
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const Ret *&>
+        {
+          static Boxed_Value handle(const Ret *p)
+          {
+            return Boxed_Value(p, true);
+          }
+        };
+
       template<typename Ret>
         struct Handle_Return<Ret *>
         {
@@ -169,23 +148,27 @@ namespace chaiscript
         };
 
       template<typename Ret>
-        struct Handle_Return<std::shared_ptr<Ret> >
+        struct Handle_Return<std::shared_ptr<Ret>> : Handle_Return<std::shared_ptr<Ret> &>
         {
-          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
-          {
-            return Boxed_Value(r, true);
-          }
         };
 
       template<typename Ret>
-        struct Handle_Return<const std::shared_ptr<Ret> &>
+        struct Handle_Return<const std::shared_ptr<Ret> &> : Handle_Return<std::shared_ptr<Ret> &>
         {
-          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
+        };
+
+
+      template<typename Ret>
+        struct Handle_Return<std::unique_ptr<Ret>> : Handle_Return<std::unique_ptr<Ret> &>
         {
-            return Boxed_Value(r, true);
+          static Boxed_Value handle(std::unique_ptr<Ret> &&r)
+          {
+            return Boxed_Value(std::move(r), true);
           }
         };
 
+
+
       template<typename Ret>
         struct Handle_Return<const Ret &>
         {
@@ -195,10 +178,15 @@ namespace chaiscript
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<const Ret>
+        {
+          static Boxed_Value handle(const Ret &r)
+          {
+            return Boxed_Value(std::cref(r));
+          }
+        };
 
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
       template<typename Ret>
         struct Handle_Return<Ret &>
         {
@@ -206,16 +194,8 @@ namespace chaiscript
           {
             return Boxed_Value(std::ref(r));
           }
-
-          static Boxed_Value handle(const Ret &r)
-          {
-            return Boxed_Value(std::cref(r));
-          }
         };
 
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
       template<>
         struct Handle_Return<Boxed_Value>
         {
@@ -225,40 +205,19 @@ namespace chaiscript
           }
         };
 
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
       template<>
-        struct Handle_Return<const Boxed_Value>
+        struct Handle_Return<const Boxed_Value> : Handle_Return<Boxed_Value>
         {
-          static Boxed_Value handle(const Boxed_Value &r)
-          {
-            return r;
-          }
         };
 
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
       template<>
-        struct Handle_Return<Boxed_Value &>
+        struct Handle_Return<Boxed_Value &> : Handle_Return<Boxed_Value>
         {
-          static Boxed_Value handle(const Boxed_Value &r)
-          {
-            return r;
-          }
         };
 
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
       template<>
-        struct Handle_Return<const Boxed_Value &>
+        struct Handle_Return<const Boxed_Value &> : Handle_Return<Boxed_Value>
         {
-          static Boxed_Value handle(const Boxed_Value &r)
-          {
-            return r;
-          }
         };
 
       /**
@@ -273,16 +232,9 @@ namespace chaiscript
           }
         };
 
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
       template<>
-        struct Handle_Return<const Boxed_Number>
+        struct Handle_Return<const Boxed_Number> : Handle_Return<Boxed_Number>
         {
-          static Boxed_Value handle(const Boxed_Number &r)
-          {
-            return r.bv;
-          }
         };
 
 
@@ -294,7 +246,7 @@ namespace chaiscript
         {
           static Boxed_Value handle()
           {
-            return Boxed_Value(Boxed_Value::Void_Type());
+            return void_var();
           }
         };
     }

include/chaiscript/dispatchkit/operators.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_OPERATORS_HPP_
 #define CHAISCRIPT_OPERATORS_HPP_
 
@@ -16,447 +20,202 @@ namespace chaiscript
   {
     namespace operators
     {
-      namespace detail
-      {
-        /// \todo make this return a decltype once we drop gcc 4.6
-        template<typename L, typename R>
-          auto assign(L l, R r) -> L&
-          {
-            return (l = r);
-          }
-
-        template<typename L, typename R>
-          auto assign_bitwise_and(L l, R r) -> decltype((l &= r))
-          {
-            return (l &= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_xor(L l, R r) -> decltype((l^=r))
-          {
-            return (l ^= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_bitwise_or(L l, R r) -> decltype((l |= r))
-          {
-            return (l |= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_difference(L l, R r) -> decltype(( l -= r))
-          {
-            return (l -= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_left_shift(L l, R r) -> decltype(( l <<= r))
-          {
-            return (l <<= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_product(L l, R r) -> decltype(( l *= r ))
-          {
-            return (l *= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_quotient(L l, R r) -> decltype(( l /= r ))
-          {
-            return (l /= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_remainder(L l, R r) -> decltype(( l %= r ))
-          {
-            return (l %= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_right_shift(L l, R r) -> decltype(( l >>= r))
-          {
-            return (l >>= r);
-          }
-
-        /// \todo make this return a decltype once we drop gcc 4.6
-        template<typename L, typename R>
-          auto assign_sum(L l, R r) -> L&
-          {
-            return (l += r);
-          }
-
-        template<typename L>
-          auto prefix_decrement(L l) -> decltype(( --l ))
-          {
-            return (--l);
-          }
-
-        template<typename L>
-          auto prefix_increment(L l) -> decltype(( ++l ))
-          {
-            return (++l);
-          }
-
-        template<typename L, typename R>
-          auto equal(L l, R r) -> decltype(( l == r ))
-          {
-            return (l == r);
-          }
-
-        template<typename L, typename R>
-          auto greater_than(L l, R r) -> decltype(( l > r ))
-          {
-            return (l > r);
-          }
-
-        template<typename L, typename R>
-          auto greater_than_equal(L l, R r) -> decltype(( l >= r ))
-          {
-            return (l >= r);
-          }
-
-        template<typename L, typename R>
-          auto less_than(L l, R r) -> decltype(( l < r ))
-          {
-            return (l < r);
-          }
-
-        template<typename L, typename R>
-          auto less_than_equal(L l, R r) -> decltype(( l <= r ))
-          {
-            return (l <= r);
-          }
-
-        template<typename L>
-          auto logical_compliment(L l) -> decltype(( !l ))
-          {
-            return (!l);
-          }
-
-        template<typename L, typename R>
-          auto not_equal(L l, R r) -> decltype(( l != r ))
-          {
-            return (l != r);
-          }
-
-        template<typename L, typename R>
-          auto addition(L l, R r) -> decltype(( l + r ))
-          {
-            return (l + r);
-          }
-
-        template<typename L>
-          auto unary_plus(L l) -> decltype(( +l ))
-          {
-            return (+l);
-          }
-
-        template<typename L, typename R>
-          auto subtraction(L l, R r) -> decltype(( l - r ))
-          {
-            return (l - r);
-          }
-
-        template<typename L>
-          auto unary_minus(L l) -> decltype(( -l ))
-          {
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4146)
-            return (-l);
-#pragma warning(pop)
-#else
-            return (-l);
-#endif
-          }
-
-        template<typename L, typename R>
-          auto bitwise_and(L l, R r) -> decltype(( l & r ))
-          {
-            return (l & r);
-          }
-
-        template<typename L>
-          auto bitwise_compliment(L l) -> decltype(( ~l ))
-          {
-            return (~l);
-          }
-
-        template<typename L, typename R>
-          auto bitwise_xor(L l, R r) -> decltype(( l ^ r ))
-          {
-            return (l ^ r);
-          }
-
-        template<typename L, typename R>
-          auto bitwise_or(L l, R r) -> decltype(( l | r ))
-          {
-            return (l | r);
-          }
-
-        template<typename L, typename R>
-          auto division(L l, R r) -> decltype(( l / r ))
-          {
-            return (l / r);
-          }
-
-        template<typename L, typename R>
-          auto left_shift(L l, R r) -> decltype(( l << r ))
-          {
-            return l << r;
-          }
-
-        template<typename L, typename R>
-          auto multiplication(L l, R r) -> decltype(( l * r ))
-          {
-            return l * r;
-          }
-
-        template<typename L, typename R>
-          auto remainder(L l, R r) -> decltype(( l % r ))
-          {
-            return (l % r);
-          }
-
-        template<typename L, typename R>
-          auto right_shift(L l, R r) -> decltype(( l >> r ))
-          {
-            return (l >> r);
-          }
-      }
-
-
-
       template<typename T>
-        ModulePtr assign(ModulePtr m = std::make_shared<Module>())
+        void assign(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign<T &, const T&>), "=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs = rhs;}), "=");
         }
 
       template<typename T>
-        ModulePtr assign_bitwise_and(ModulePtr m = std::make_shared<Module>())
+        void assign_bitwise_and(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_bitwise_and<T &, const T&>), "&=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs &= rhs;}), "&=");
         }
 
       template<typename T>
-        ModulePtr assign_xor(ModulePtr m = std::make_shared<Module>())
+        void assign_xor(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_xor<T &, const T&>), "^=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs ^= rhs;}), "^=");
         }
 
       template<typename T>
-        ModulePtr assign_bitwise_or(ModulePtr m = std::make_shared<Module>())
+        void assign_bitwise_or(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_bitwise_or<T &, const T&>), "|=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs |= rhs;}), "|=");
         }
 
       template<typename T>
-        ModulePtr assign_difference(ModulePtr m = std::make_shared<Module>())
+        void assign_difference(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_difference<T &, const T&>), "-=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs -= rhs;}), "-=");
         }
 
       template<typename T>
-        ModulePtr assign_left_shift(ModulePtr m = std::make_shared<Module>())
+        void assign_left_shift(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_left_shift<T &, const T&>), "<<=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs <<= rhs;}), "<<=");
         }
 
       template<typename T>
-        ModulePtr assign_product(ModulePtr m = std::make_shared<Module>())
+        void assign_product(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_product<T &, const T&>), "*=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs <<= rhs;}), "*=");
         }
 
       template<typename T>
-        ModulePtr assign_quotient(ModulePtr m = std::make_shared<Module>())
+        void assign_quotient(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_quotient<T &, const T&>), "/=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs /= rhs;}), "/=");
         }
 
       template<typename T>
-        ModulePtr assign_remainder(ModulePtr m = std::make_shared<Module>())
+        void assign_remainder(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_remainder<T &, const T&>), "%=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs %= rhs;}), "%=");
         }
 
       template<typename T>
-        ModulePtr assign_right_shift(ModulePtr m = std::make_shared<Module>())
+        void assign_right_shift(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_right_shift<T &, const T&>), ">>=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs >>= rhs;}), ">>=");
         }
 
       template<typename T>
-        ModulePtr assign_sum(ModulePtr m = std::make_shared<Module>())
+        void assign_sum(Module& m)
         {
-          m->add(chaiscript::fun(&detail::assign_sum<T &, const T&>), "+=");
-          return m;
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs += rhs;}), "+=");
         }
 
       template<typename T>
-        ModulePtr prefix_decrement(ModulePtr m = std::make_shared<Module>())
+        void prefix_decrement(Module& m)
         {
-          m->add(chaiscript::fun(&detail::prefix_decrement<T &>), "--");
-          return m;
+          m.add(chaiscript::fun([](T &lhs)->T&{return --lhs;}), "--");
         }
 
       template<typename T>
-        ModulePtr prefix_increment(ModulePtr m = std::make_shared<Module>())
+        void prefix_increment(Module& m)
         {
-          m->add(chaiscript::fun(&detail::prefix_increment<T &>), "++");
-          return m;
+          m.add(chaiscript::fun([](T &lhs)->T&{return ++lhs;}), "++");
         }
 
       template<typename T>
-        ModulePtr equal(ModulePtr m = std::make_shared<Module>())
+        void equal(Module& m)
         {
-          m->add(chaiscript::fun(&detail::equal<const T&, const T&>), "==");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs==rhs;}), "==");
         }
 
       template<typename T>
-        ModulePtr greater_than(ModulePtr m = std::make_shared<Module>())
+        void greater_than(Module& m)
         {
-          m->add(chaiscript::fun(&detail::greater_than<const T&, const T&>), ">");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>rhs;}), ">");
         }
 
       template<typename T>
-        ModulePtr greater_than_equal(ModulePtr m = std::make_shared<Module>())
+        void greater_than_equal(Module& m)
         {
-          m->add(chaiscript::fun(&detail::greater_than_equal<const T&, const T&>), ">=");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>=rhs;}), ">=");
         }
 
       template<typename T>
-        ModulePtr less_than(ModulePtr m = std::make_shared<Module>())
+        void less_than(Module& m)
         {
-          m->add(chaiscript::fun(&detail::less_than<const T&, const T&>), "<");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<rhs;}), "<");
         }
 
       template<typename T>
-        ModulePtr less_than_equal(ModulePtr m = std::make_shared<Module>())
+        void less_than_equal(Module& m)
         {
-          m->add(chaiscript::fun(&detail::less_than_equal<const T&, const T&>), "<=");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<=rhs;}), "<=");
         }
 
       template<typename T>
-        ModulePtr logical_compliment(ModulePtr m = std::make_shared<Module>())
+        void logical_compliment(Module& m)
         {
-          m->add(chaiscript::fun(&detail::logical_compliment<const T &>), "!");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return !lhs;}), "!");
         }
 
       template<typename T>
-        ModulePtr not_equal(ModulePtr m = std::make_shared<Module>())
+        void not_equal(Module& m)
         {
-          m->add(chaiscript::fun(&detail::not_equal<const T &, const T &>), "!=");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs!=rhs;}), "!=");
         }
 
       template<typename T>
-        ModulePtr addition(ModulePtr m = std::make_shared<Module>())
+        void addition(Module& m)
         {
-          m->add(chaiscript::fun(&detail::addition<const T &, const T &>), "+");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs+rhs;}), "+");
         }
 
       template<typename T>
-        ModulePtr unary_plus(ModulePtr m = std::make_shared<Module>())
+        void unary_plus(Module& m)
         {
-          m->add(chaiscript::fun(&detail::unary_plus<const T &>), "+");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return +lhs;}), "+");
         }
 
       template<typename T>
-        ModulePtr subtraction(ModulePtr m = std::make_shared<Module>())
+        void subtraction(Module& m)
         {
-          m->add(chaiscript::fun(&detail::subtraction<const T &, const T &>), "-");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs-rhs;}), "-");
         }
 
       template<typename T>
-        ModulePtr unary_minus(ModulePtr m = std::make_shared<Module>())
+        void unary_minus(Module& m)
         {
-          m->add(chaiscript::fun(&detail::unary_minus<const T &>), "-");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return -lhs;}), "-");
         }
 
       template<typename T>
-        ModulePtr bitwise_and(ModulePtr m = std::make_shared<Module>())
+        void bitwise_and(Module& m)
         {
-          m->add(chaiscript::fun(&detail::bitwise_and<const T &, const T &>), "&");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs&rhs;}), "&");
         }
 
       template<typename T>
-        ModulePtr bitwise_compliment(ModulePtr m = std::make_shared<Module>())
+        void bitwise_compliment(Module& m)
         {
-          m->add(chaiscript::fun(&detail::bitwise_compliment<const T &>), "~");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return ~lhs;}), "~");
         }
 
       template<typename T>
-        ModulePtr bitwise_xor(ModulePtr m = std::make_shared<Module>())
+        void bitwise_xor(Module& m)
         {
-          m->add(chaiscript::fun(&detail::bitwise_xor<const T &, const T &>), "^");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs^rhs;}), "^");
         }
 
       template<typename T>
-        ModulePtr bitwise_or(ModulePtr m = std::make_shared<Module>())
+        void bitwise_or(Module& m)
         {
-          m->add(chaiscript::fun(&detail::bitwise_or<const T &, const T &>), "|");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs|rhs;}), "|");
         }
 
       template<typename T>
-        ModulePtr division(ModulePtr m = std::make_shared<Module>())
+        void division(Module& m)
         {
-          m->add(chaiscript::fun(&detail::division<const T &, const T &>), "/");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs/rhs;}), "/");
         }
 
       template<typename T>
-        ModulePtr left_shift(ModulePtr m = std::make_shared<Module>())
+        void left_shift(Module& m)
         {
-          m->add(chaiscript::fun(&detail::left_shift<const T &, const T &>), "<<");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<<rhs;}), "<<");
         }
 
       template<typename T>
-        ModulePtr multiplication(ModulePtr m = std::make_shared<Module>())
+        void multiplication(Module& m)
         {
-          m->add(chaiscript::fun(&detail::multiplication<const T &, const T &>), "*");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs*rhs;}), "*");
         }
 
       template<typename T>
-        ModulePtr remainder(ModulePtr m = std::make_shared<Module>())
+        void remainder(Module& m)
         {
-          m->add(chaiscript::fun(&detail::remainder<const T &, const T &>), "%");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs%rhs;}), "%");
         }
 
       template<typename T>
-        ModulePtr right_shift(ModulePtr m = std::make_shared<Module>())
+        void right_shift(Module& m)
         {
-          m->add(chaiscript::fun(&detail::right_shift<const T &, const T &>), ">>");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>>rhs;}), ">>");
         }
     }
   }

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -1,9 +1,12 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 
 #ifndef CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 #define CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
@@ -16,21 +19,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(static_cast<Proxy_Function_Impl_Base *>(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

@@ -1,9 +1,12 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_HPP_
@@ -16,6 +19,7 @@
 #include <string>
 #include <type_traits>
 #include <vector>
+#include <iterator>
 
 #include "../chaiscript_defines.hpp"
 #include "boxed_cast.hpp"
@@ -42,7 +46,7 @@ namespace chaiscript
   namespace dispatch
   {
     template<typename FunctionType>
-      std::function<FunctionType> functor(std::shared_ptr<const Proxy_Function_Base> func, const Type_Conversions *t_conversions);
+      std::function<FunctionType> functor(std::shared_ptr<const Proxy_Function_Base> func, const Type_Conversions_State *t_conversions);
 
     class Param_Types
     {
@@ -52,7 +56,7 @@ namespace chaiscript
             m_doti(user_type<Dynamic_Object>())
         {}
 
-        Param_Types(std::vector<std::pair<std::string, Type_Info>> t_types)
+        explicit Param_Types(std::vector<std::pair<std::string, Type_Info>> t_types)
           : m_types(std::move(t_types)),
             m_has_types(false),
             m_doti(user_type<Dynamic_Object>())
@@ -62,7 +66,7 @@ namespace chaiscript
 
         void push_front(std::string t_name, Type_Info t_ti)
         {
-          m_types.emplace(m_types.begin(), std::move(t_name), std::move(t_ti));
+          m_types.emplace(m_types.begin(), std::move(t_name), t_ti);
           update_has_types();
         }
 
@@ -71,10 +75,51 @@ namespace chaiscript
           return m_types == t_rhs.m_types;
         }
 
-        bool match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const
+        std::vector<Boxed_Value> convert(std::vector<Boxed_Value> vals, const Type_Conversions_State &t_conversions) const
         {
-          if (!m_has_types) return true;
-          if (vals.size() != m_types.size()) return false;
+          for (size_t i = 0; i < vals.size(); ++i)
+          {
+            const auto &name = m_types[i].first;
+            if (!name.empty()) {
+              const auto &bv = vals[i];
+
+              if (!bv.get_type_info().bare_equal(m_doti))
+              {
+                const auto &ti = m_types[i].second;
+                if (!ti.is_undef())
+                {
+                  if (!bv.get_type_info().bare_equal(ti)) {
+                    if (t_conversions->converts(ti, bv.get_type_info())) {
+                      try {
+                        // 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
+                        vals[i] = t_conversions->boxed_type_conversion(m_types[i].second, t_conversions.saves(), vals[i]);
+                      } catch (...) {
+                        try {
+                          // try going the other way
+                          vals[i] = t_conversions->boxed_type_down_conversion(m_types[i].second, t_conversions.saves(), vals[i]);
+                        } catch (const chaiscript::detail::exception::bad_any_cast &) {
+                          throw exception::bad_boxed_cast(bv.get_type_info(), *m_types[i].second.bare_type_info());
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          return vals;
+        }
+
+        // first result: is a match
+        // second result: needs conversions
+        std::pair<bool, bool> match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const
+        {
+          bool needs_conversion = false;
+
+          if (!m_has_types) { return std::make_pair(true, needs_conversion); }
+          if (vals.size() != m_types.size()) { return std::make_pair(false, needs_conversion); }
 
           for (size_t i = 0; i < vals.size(); ++i)
           {
@@ -86,25 +131,31 @@ namespace chaiscript
               {
                 try {
                   const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
-                  return name == "Dynamic_Object" || d.get_type_name() == name;
+                  if (!(name == "Dynamic_Object" || d.get_type_name() == name)) {
+                    return std::make_pair(false, false);
+                  }
                 } catch (const std::bad_cast &) {
-                  return false;
+                  return std::make_pair(false, false);
                 } 
               } else {
                 const auto &ti = m_types[i].second;
                 if (!ti.is_undef())
                 {
                   if (!bv.get_type_info().bare_equal(ti)) {
-                    return false;
+                    if (!t_conversions->converts(ti, bv.get_type_info())) {
+                      return std::make_pair(false, false);
+                    } else {
+                      needs_conversion = true;
+                    }
                   }
                 } else {
-                  return false;
+                  return std::make_pair(false, false);
                 }
               }
             }
           }
 
-          return true;
+          return std::make_pair(true, needs_conversion);
         }
 
         const std::vector<std::pair<std::string, Type_Info>> &types() const
@@ -144,11 +195,15 @@ namespace chaiscript
     class Proxy_Function_Base
     {
       public:
-        virtual ~Proxy_Function_Base() {}
+        virtual ~Proxy_Function_Base() = default;
 
-        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Type_Conversions &t_conversions) const
+        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Type_Conversions_State &t_conversions) const
         {
+          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
@@ -158,7 +213,7 @@ namespace chaiscript
         const std::vector<Type_Info> &get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const = 0;
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const = 0;
 
         virtual bool is_attribute_function() const { return false; }
 
@@ -174,22 +229,17 @@ namespace chaiscript
 
         //! Return true if the function is a possible match
         //! to the passed in values
-        bool filter(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const
+        bool filter(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const
         {
+          assert(m_arity == -1 || (m_arity > 0 && static_cast<int>(vals.size()) == m_arity));
+
           if (m_arity < 0)
           {
             return true;
-          } else if (static_cast<size_t>(m_arity) == vals.size()) {
-            if (m_arity == 0)
-            {
-              return true;
-            } else if (m_arity > 1 && m_types.size() > 1) {
-              return compare_first_type(vals[0], t_conversions) && compare_type_to_param(m_types[2], vals[1], t_conversions);
+          } 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);
-            }
-          } else {
-            return false;
+            return compare_type_to_param(m_types[1], vals[0], t_conversions);
           }
         }
 
@@ -199,17 +249,15 @@ namespace chaiscript
           return m_arity;
         }
 
-        virtual std::string annotation() const = 0;
-
-        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Type_Conversions &t_conversions)
+        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Type_Conversions_State &t_conversions)
         {
           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()) 
+                  || t_conversions->converts(ti, bv.get_type_info()) 
                   )
                 )
              )
@@ -220,13 +268,13 @@ namespace chaiscript
           }
         }
 
-        virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions &t_conversions) const
+        virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions_State &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;
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const = 0;
 
         Proxy_Function_Base(std::vector<Type_Info> t_types, int t_arity)
           : m_types(std::move(t_types)), m_arity(t_arity), m_has_arithmetic_param(false)
@@ -243,7 +291,8 @@ namespace chaiscript
         }
 
 
-        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_State &t_conversions)
         {
           if (tis.size() - 1 != bvs.size())
           {
@@ -252,10 +301,7 @@ namespace chaiscript
             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;
@@ -280,14 +326,13 @@ namespace chaiscript
     class guard_error : public std::runtime_error
     {
       public:
-        guard_error() CHAISCRIPT_NOEXCEPT
+        guard_error() noexcept
           : std::runtime_error("Guard evaluation failed")
         { }
 
         guard_error(const guard_error &) = default;
 
-        virtual ~guard_error() CHAISCRIPT_NOEXCEPT
-        { }
+        ~guard_error() noexcept override = default;
     };
   }
 
@@ -301,36 +346,31 @@ 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(),
-            std::string t_description = "",
             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))
         {
         }
 
-        virtual ~Dynamic_Proxy_Function() {}
 
-        virtual bool operator==(const Proxy_Function_Base &rhs) const CHAISCRIPT_OVERRIDE
+        bool operator==(const Proxy_Function_Base &rhs) const override
         {
           const Dynamic_Proxy_Function *prhs = dynamic_cast<const Dynamic_Proxy_Function *>(&rhs);
 
           return this == &rhs
-            || (prhs
+            || ((prhs != nullptr)
                 && this->m_arity == prhs->m_arity
                 && !this->m_guard && !prhs->m_guard
                 && this->m_param_types == prhs->m_param_types);
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const override
         {
-          return (m_arity < 0 || (vals.size() == size_t(m_arity) && m_param_types.match(vals, t_conversions)))
-            && test_guard(vals, t_conversions);
+          return call_match_internal(vals, t_conversions).first;
         }
 
 
@@ -344,30 +384,9 @@ namespace chaiscript
           return m_parsenode;
         }
 
-        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-        {
-          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
+        bool test_guard(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const
         {
           if (m_guard)
           {
@@ -383,12 +402,31 @@ namespace chaiscript
           }
         }
 
+        // first result: is a match
+        // second result: needs conversions
+        std::pair<bool, bool> call_match_internal(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const
+        {
+          const auto comparison_result = [&](){
+            if (m_arity < 0) {
+              return std::make_pair(true, false);
+            } else if (vals.size() == size_t(m_arity)) {
+              return m_param_types.match(vals, t_conversions);
+            } else {
+              return std::make_pair(false, false);
+            }
+          }();
+
+          return std::make_pair(
+              comparison_result.first && test_guard(vals, t_conversions), 
+              comparison_result.second
+              );
+        }
+
+      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())
           {
@@ -402,13 +440,64 @@ namespace chaiscript
           return types;
         }
 
+      protected:
         Param_Types m_param_types;
+
+      private:
         Proxy_Function m_guard;
         AST_NodePtr m_parsenode;
-        std::string m_description;
-        std::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
     };
 
+
+
+    template<typename Callable>
+    class Dynamic_Proxy_Function_Impl final : 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(),
+            Proxy_Function t_guard = Proxy_Function())
+          : Dynamic_Proxy_Function(
+                t_arity,
+                std::move(t_parsenode),
+                std::move(t_param_types),
+                std::move(t_guard)
+              ),
+            m_f(std::move(t_f))
+        {
+        }
+
+
+      protected:
+        Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
+        {
+          const auto match_results = call_match_internal(params, t_conversions);
+          if (match_results.first)
+          {
+            if (match_results.second) {
+              return m_f(m_param_types.convert(params, t_conversions));
+            } else {
+              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
@@ -419,7 +508,7 @@ namespace chaiscript
     /// 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
+    class Bound_Function final : public Proxy_Function_Base
     {
       public:
         Bound_Function(const Const_Proxy_Function &t_f, 
@@ -430,19 +519,18 @@ namespace chaiscript
           assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
         }
 
-        virtual bool operator==(const Proxy_Function_Base &t_f) const CHAISCRIPT_OVERRIDE
+        bool operator==(const Proxy_Function_Base &t_f) const override
         {
           return &t_f == this;
         }
 
-        virtual ~Bound_Function() {}
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const override
         {
           return m_f->call_match(build_param_list(vals), t_conversions);
         }
 
-        virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
+        std::vector<Const_Proxy_Function> get_contained_functions() const override
         {
           return std::vector<Const_Proxy_Function>{m_f};
         }
@@ -479,10 +567,6 @@ namespace chaiscript
           return args;
         }
 
-        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-        {
-          return "Bound: " + m_f->annotation();
-        }
 
       protected:
         static std::vector<Type_Info> build_param_type_info(const Const_Proxy_Function &t_f, 
@@ -492,18 +576,11 @@ namespace chaiscript
 
           if (t_f->get_arity() < 0) { return std::vector<Type_Info>(); }
 
-          std::vector<Type_Info> types = t_f->get_param_types();
+          const auto types = t_f->get_param_types();
           assert(types.size() == t_args.size() + 1);
 
-#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)
           {
@@ -516,7 +593,7 @@ namespace chaiscript
           return retval;
         }
 
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
         {
           return (*m_f)(build_param_list(params), t_conversions);
         }
@@ -529,104 +606,83 @@ namespace chaiscript
     class Proxy_Function_Impl_Base : public Proxy_Function_Base
     {
       public:
-        Proxy_Function_Impl_Base(const std::vector<Type_Info> &t_types)
+        explicit Proxy_Function_Impl_Base(const std::vector<Type_Info> &t_types)
           : Proxy_Function_Base(t_types, static_cast<int>(t_types.size()) - 1)
         {
         }
 
-        virtual ~Proxy_Function_Impl_Base() {}
-
-        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
+        bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const override
         {
-          return "";
+          return static_cast<int>(vals.size()) == get_arity() 
+            && (compare_types(m_types, vals, t_conversions) && compare_types_with_cast(vals, t_conversions));
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-        {
-          return static_cast<int>(vals.size()) == get_arity() && (compare_types(m_types, vals) || compare_types_with_cast(vals, t_conversions));
-        }
-
-        virtual bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const = 0;
+        virtual bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &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 final : public Proxy_Function_Impl_Base
     {
       public:
-        Proxy_Function_Impl(std::function<Func> f)
+        explicit 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 bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const 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
+        bool operator==(const Proxy_Function_Base &t_func) const 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;
         }
 
-        std::function<Func> internal_function() const
-        {
-          return m_f;
-        }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
         {
-          return detail::Do_Call<typename std::function<Func>::result_type>::go(m_f, params, t_conversions);
+          return detail::call_func(detail::Function_Signature<Func>(), m_f, params, t_conversions);
         }
 
-
       private:
-        std::function<Func> m_f;
-        Func *m_dummy_func;
+        Callable m_f;
     };
 
+
     class Assignable_Proxy_Function : public Proxy_Function_Impl_Base
     {
       public:
-        Assignable_Proxy_Function(const std::vector<Type_Info> &t_types)
+        explicit 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
+      class Assignable_Proxy_Function_Impl final : 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)), m_dummy_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
+        bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &t_conversions) const 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
+        bool operator==(const Proxy_Function_Base &t_func) const override
         {
           return dynamic_cast<const Assignable_Proxy_Function_Impl<Func> *>(&t_func) != nullptr;
         }
@@ -636,38 +692,37 @@ namespace chaiscript
           return m_f.get();
         }
 
-        virtual void assign(const std::shared_ptr<const Proxy_Function_Base> &t_rhs) CHAISCRIPT_OVERRIDE {
+        void assign(const std::shared_ptr<const Proxy_Function_Base> &t_rhs) 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 CHAISCRIPT_OVERRIDE
+        Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
         {
-          return detail::Do_Call<typename std::function<Func>::result_type>::go(m_f.get(), params, t_conversions);
+          return detail::call_func(detail::Function_Signature<Func>(), m_f.get(), params, t_conversions);
         }
 
 
       private:
         std::reference_wrapper<std::function<Func>> m_f;
         std::shared_ptr<std::function<Func>> m_shared_ptr_holder;
-        Func *m_dummy_func;
     };
+
+
     /// Attribute getter Proxy_Function implementation
     template<typename T, typename Class>
-      class Attribute_Access : public Proxy_Function_Base
+      class Attribute_Access final : public Proxy_Function_Base
     {
       public:
-        Attribute_Access(T Class::* t_attr)
+        explicit Attribute_Access(T Class::* t_attr)
           : Proxy_Function_Base(param_types(), 1),
             m_attr(t_attr)
         {
         }
 
-        virtual ~Attribute_Access() {}
+        bool is_attribute_function() const override { return true; } 
 
-        virtual bool is_attribute_function() const CHAISCRIPT_OVERRIDE { return true; } 
-
-        virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
+        bool operator==(const Proxy_Function_Base &t_func) const override
         {
           const Attribute_Access<T, Class> * aa 
             = dynamic_cast<const Attribute_Access<T, Class> *>(&t_func);
@@ -679,7 +734,7 @@ namespace chaiscript
           }
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &) const CHAISCRIPT_OVERRIDE
+        bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions_State &) const override
         {
           if (vals.size() != 1)
           {
@@ -689,31 +744,47 @@ namespace chaiscript
           return vals[0].get_type_info().bare_equal(user_type<Class>());
         }
 
-        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-        {
-          return "";
-        }
-
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-        {
-          if (params.size() == 1)
+        Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
         {
           const Boxed_Value &bv = params[0];
           if (bv.is_const())
           {
             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);
+            return do_call_impl<T>(o);
           } else {
             Class *o = boxed_cast<Class *>(bv, &t_conversions);
-              return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
-            }
-          } else {
-            throw exception::arity_error(static_cast<int>(params.size()), 1);
+            return do_call_impl<T>(o);
           }
         }
 
       private:
+        template<typename Type>
+        auto do_call_impl(Class *o) const -> std::enable_if_t<std::is_pointer<Type>::value, Boxed_Value>
+        {
+          return detail::Handle_Return<Type>::handle(o->*m_attr);
+        }
+
+        template<typename Type>
+        auto do_call_impl(const Class *o) const -> std::enable_if_t<std::is_pointer<Type>::value, Boxed_Value>
+        {
+          return detail::Handle_Return<const Type>::handle(o->*m_attr);
+        }
+
+        template<typename Type>
+        auto do_call_impl(Class *o) const -> std::enable_if_t<!std::is_pointer<Type>::value, Boxed_Value>
+        {
+          return detail::Handle_Return<typename std::add_lvalue_reference<Type>::type>::handle(o->*m_attr);
+        }
+
+        template<typename Type>
+        auto do_call_impl(const Class *o) const -> std::enable_if_t<!std::is_pointer<Type>::value, Boxed_Value>
+        {
+          return detail::Handle_Return<typename std::add_lvalue_reference<typename std::add_const<Type>::type>::type>::handle(o->*m_attr);
+        }
+
+
+
         static std::vector<Type_Info> param_types()
         {
           return {user_type<T>(), user_type<Class>()};
@@ -739,8 +810,16 @@ 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 {}
+        ~dispatch_error() noexcept override = default;
 
         std::vector<Boxed_Value> parameters;
         std::vector<Const_Proxy_Function> functions;
@@ -753,51 +832,40 @@ namespace chaiscript
     {
       template<typename FuncType>
         bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
-            const Type_Conversions &t_conversions)
+            const Type_Conversions_State &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;
+          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());
         }
 
-          // all types match
-          return true;
-        }
-
-      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_State &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 {
                 // handle const members vs non-const member, which is not really ambiguous
-                const auto &mat_fun_param_types = (*matching_func)->get_param_types();
-                const auto &next_fun_param_types = (*begin)->get_param_types();
+                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
@@ -805,7 +873,7 @@ namespace chaiscript
                   // 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>(orig, end));
+                  throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(t_funcs.begin(), t_funcs.end()));
                 }
               }
             }
@@ -816,25 +884,29 @@ 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());
 
-          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);
+          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()
+                               && param.get_type_info() != ti) {
+                             return Boxed_Number(param).get_as(ti).bv;
                            } else {
-              newplist.push_back(plist[i]);
+                             return param;
                            }
                          }
+                       );
 
           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 &) {
@@ -843,32 +915,30 @@ 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()));
 
         }
     }
 
-    /**
-     * Take a vector of functions and a vector of parameters. Attempt to execute
-     * each function against the set of parameters, in order, until a matching
-     * function is found or throw dispatch_error if no matching function is found
-     */
+    /// Take a vector of functions and a vector of parameters. Attempt to execute
+    /// each function against the set of parameters, in order, until a matching
+    /// function is found or throw dispatch_error if no matching function is found
     template<typename Funcs>
       Boxed_Value dispatch(const Funcs &funcs,
-          const std::vector<Boxed_Value> &plist, const Type_Conversions &t_conversions)
+          const std::vector<Boxed_Value> &plist, const Type_Conversions_State &t_conversions)
       {
-        //std::cout << "starting dispatch: " << funcs.size() << '\n';
-        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()))
@@ -876,17 +946,17 @@ namespace chaiscript
                 ++numdiffs;
               }
             }
-          } else {
-            continue;
+            ordered_funcs.emplace_back(numdiffs, func.get());
+          }
         }
 
-          ordered_funcs.insert(std::make_pair(numdiffs, func.get()));
-        }
 
+        for (size_t i = 0; i <= plist.size(); ++i)
+        {
           for (const auto &func : ordered_funcs )
           {
             try {
-            if (func.first == 0 || func.second->filter(plist, t_conversions))
+              if (func.first == i && (i == 0 || func.second->filter(plist, t_conversions)))
               {
                 return (*(func.second))(plist, t_conversions);
               }
@@ -899,8 +969,9 @@ namespace chaiscript
               //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

@@ -1,24 +1,30 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
 #include <functional>
 #include <stdexcept>
 #include <vector>
+#include <array>
 
 #include "../chaiscript_defines.hpp"
 #include "boxed_cast.hpp"
 #include "boxed_value.hpp"
 #include "handle_return.hpp"
 #include "type_info.hpp"
+#include "callable_traits.hpp"
 
 namespace chaiscript {
-class Type_Conversions;
+class Type_Conversions_State;
 namespace exception {
 class bad_boxed_cast;
 }  // namespace exception
@@ -42,7 +48,7 @@ namespace chaiscript
 
       arity_error(const arity_error &) = default;
 
-      virtual ~arity_error() CHAISCRIPT_NOEXCEPT {}
+      ~arity_error() noexcept override = default;
 
       int got;
       int expected;
@@ -65,30 +71,6 @@ namespace chaiscript
         }
 
 
-      // Forward declaration
-      template<typename ... Rest> 
-        struct Try_Cast; 
-
-      template<typename Param, typename ... Rest>
-        struct Try_Cast<Param, Rest...>
-        {
-          static void do_try(const std::vector<Boxed_Value> &params, size_t generation, const Type_Conversions &t_conversions)
-          {
-            boxed_cast<Param>(params[generation], &t_conversions);
-            Try_Cast<Rest...>::do_try(params, generation+1, t_conversions);
-          }
-        };
-
-      // 0th case
-      template<>
-        struct Try_Cast<>
-        {
-          static void do_try(const std::vector<Boxed_Value> &, size_t, const Type_Conversions &)
-          {
-          }
-        };
-
-
       /**
        * Used by Proxy_Function_Impl to determine if it is equivalent to another
        * Proxy_Function_Impl object. This function is primarily used to prevent
@@ -96,63 +78,56 @@ namespace chaiscript
        */
       template<typename Ret, typename ... Params>
         bool compare_types_cast(Ret (*)(Params...),
-             const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
+             const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
         {
           try {
-            Try_Cast<Params...>::do_try(params, 0, t_conversions);
+            std::vector<Boxed_Value>::size_type i = 0;
+            (void)i;
+            (void)params; (void)t_conversions;
+            // this is ok because the order of evaluation of initializer lists is well defined
+            (void)std::initializer_list<int>{(boxed_cast<Params>(params[i++], &t_conversions), 0)...};
+            return true;
           } catch (const exception::bad_boxed_cast &) {
             return false;
           }
-
-          return true;
         }
 
-      template<typename Ret, int count, typename ... Params>
-        struct Call_Func
-        {
 
-          template<typename ... InnerParams>
-          static Ret do_call(const std::function<Ret (Params...)> &f,
-              const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions, InnerParams &&... innerparams)
+      template<typename Callable, typename Ret, typename ... Params, size_t ... I>
+        Ret call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &, 
+                      std::index_sequence<I...>, const Callable &f,
+                      const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
         {
-            return Call_Func<Ret, count - 1, Params...>::do_call(f, params, t_conversions, std::forward<InnerParams>(innerparams)..., params[sizeof...(Params) - count]);
+          (void)params; (void)t_conversions;
+          return f(boxed_cast<Params>(params[I], &t_conversions)...);
         }
-        };
 
-      template<typename Ret, typename ... Params>
-        struct Call_Func<Ret, 0, Params...>
+
+      /// 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>
+        Boxed_Value call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &sig, const Callable &f,
+            const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
         {
+          return Handle_Return<Ret>::handle(call_func(sig, std::index_sequence_for<Params...>{}, f, params, t_conversions));
+        }
+
+      template<typename Callable, typename ... Params>
+        Boxed_Value call_func(const chaiscript::dispatch::detail::Function_Signature<void (Params...)> &sig, const Callable &f,
+            const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
+        {
+          call_func(sig, std::index_sequence_for<Params...>{}, f, params, t_conversions);
 #ifdef CHAISCRIPT_MSVC
 #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
+#pragma warning(disable : 4702)
 #endif
-          template<typename ... InnerParams>
-            static Ret do_call(const std::function<Ret (Params...)> &f,
-                const std::vector<Boxed_Value> &, const Type_Conversions &t_conversions, InnerParams &&... innerparams)
-            {
-              return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams), &t_conversions)...);
-            }
+          // MSVC is reporting that this is unreachable code - and it's wrong.
+          return Handle_Return<void>::handle();
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
-        };
-
-      /**
-       * 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 Ret, typename ... Params>
-        Ret call_func(const std::function<Ret (Params...)> &f,
-            const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
-        {
-          if (params.size() == sizeof...(Params))
-          {
-            return Call_Func<Ret, sizeof...(Params), Params...>::do_call(f, params, t_conversions);
-          }
-
-          throw exception::arity_error(static_cast<int>(params.size()), sizeof...(Params));
         }
 
     }
@@ -161,34 +136,4 @@ namespace chaiscript
 }
 
 
-namespace chaiscript
-{
-  namespace dispatch
-  {
-    namespace detail
-    {
-    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)
-          {
-            return Handle_Return<Ret>::handle(call_func(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)
-          {
-            call_func(fun, params, t_conversions);
-            return Handle_Return<void>::handle();
-          }
-      };
-    }
-  }
-}
-
 #endif

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,13 +1,16 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_
 #define CHAISCRIPT_REGISTER_FUNCTION_HPP_
 
-#include <functional>
 #include <type_traits>
 
 #include "bind_first.hpp"
@@ -15,55 +18,6 @@
 
 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...))
-        {
-#ifdef CHAISCRIPT_MSVC
-          /// \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));
-#else
-          return std::function<Ret(Class &, Args...)>(func);
-#endif
-        }
-
-      template<typename Ret, typename Class, typename ... Args> 
-        std::function<Ret (const Class &, Args...) > to_function(Ret (Class::*func)(Args...) const)
-        {
-#if defined(CHAISCRIPT_MSVC) || defined(CHAISCRIPT_LIBCPP)
-          /// \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...)>([func](const Class &o, Args... args)->Ret {
-                return (o.*func)(std::forward<Args>(args)...);
-              });
-#else
-          return std::function<Ret(const Class &, Args...)>(func);
-#endif
-        }
-
-    }
-  }
 
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member
   /// \param[in] t Function / member to expose
@@ -88,22 +42,39 @@ namespace chaiscript
   template<typename T>
     Proxy_Function fun(const T &t)
     {
+      typedef typename dispatch::detail::Callable_Traits<T>::Signature Signature;
+
       return Proxy_Function(
-          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Impl<typename dispatch::detail::FunctionSignature<decltype(dispatch::detail::to_function(t)) >::Signature>>(dispatch::detail::to_function(t)));
+          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::*func)(Param...) const)
+    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_Impl<typename dispatch::detail::FunctionSignature<decltype(dispatch::detail::to_function(func)) >::Signature>>(dispatch::detail::to_function(func)));
+          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::*func)(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_Impl<typename dispatch::detail::FunctionSignature<decltype(dispatch::detail::to_function(func)) >::Signature>>(dispatch::detail::to_function(func)));
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Class &, Param...), decltype(call)>>(call));
+
     }
 
 
@@ -114,22 +85,6 @@ namespace chaiscript
     }
 
 
-  /// \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)
-    {
-      return Proxy_Function(chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Impl<T>>(f));
-    }
 
   
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member and binds the first parameter of it
@@ -156,31 +111,6 @@ namespace chaiscript
       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
-  /// \param[in] t Function / member to expose
-  /// \param[in] q Value to bind to first parameter
-  /// \param[in] r Value to bind to second parameter
-  ///
-  /// \b Example:
-  /// \code
-  /// struct MyClass
-  /// {
-  ///   void memberfunction(int);
-  /// };
-  /// 
-  /// MyClass obj;
-  /// chaiscript::ChaiScript chai;
-  /// // Add function taking only no arguments, and permanently bound to "obj" and "1"
-  /// // memberfunction() will be equivalent to obj.memberfunction(1)
-  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj), 1), "memberfunction"); 
-  /// \endcode
-  /// 
-  /// \sa \ref adding_functions
-  template<typename T, typename Q, typename R>
-    Proxy_Function fun(T &&t, Q &&q, R &&r)
-    {
-      return fun(detail::bind_first(detail::bind_first(std::forward<T>(t), std::forward<Q>(q)), std::forward<R>(r)));
-    }
 
 }
 

include/chaiscript/dispatchkit/short_alloc.hpp

@@ -0,0 +1,159 @@
+#ifndef SHORT_ALLOC_H
+#define SHORT_ALLOC_H
+
+// The MIT License (MIT)
+// 
+// Copyright (c) 2015 Howard Hinnant
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <cstddef>
+#include <cassert>
+
+template <std::size_t N, std::size_t alignment = alignof(std::max_align_t)>
+class arena
+{
+    alignas(alignment) char buf_[N];
+    char* ptr_;
+
+public:
+    ~arena() {ptr_ = nullptr;}
+    arena() noexcept : ptr_(buf_) {}
+    arena(const arena&) = delete;
+    arena& operator=(const arena&) = delete;
+
+    template <std::size_t ReqAlign> char* allocate(std::size_t n);
+    void deallocate(char* p, std::size_t n) noexcept;
+
+    static constexpr std::size_t size() noexcept {return N;}
+    std::size_t used() const noexcept {return static_cast<std::size_t>(ptr_ - buf_);}
+    void reset() noexcept {ptr_ = buf_;}
+
+private:
+    static
+    std::size_t 
+    align_up(std::size_t n) noexcept
+        {return (n + (alignment-1)) & ~(alignment-1);}
+
+    bool
+    pointer_in_buffer(char* p) noexcept
+        {return buf_ <= p && p <= buf_ + N;}
+};
+
+template <std::size_t N, std::size_t alignment>
+template <std::size_t ReqAlign>
+char*
+arena<N, alignment>::allocate(std::size_t n)
+{
+    static_assert(ReqAlign <= alignment, "alignment is too small for this arena");
+    assert(pointer_in_buffer(ptr_) && "short_alloc has outlived arena");
+    auto const aligned_n = align_up(n);
+    if (static_cast<decltype(aligned_n)>(buf_ + N - ptr_) >= aligned_n)
+    {
+        char* r = ptr_;
+        ptr_ += aligned_n;
+        return r;
+    }
+
+    static_assert(alignment <= alignof(std::max_align_t), "you've chosen an "
+                  "alignment that is larger than alignof(std::max_align_t), and "
+                  "cannot be guaranteed by normal operator new");
+    return static_cast<char*>(::operator new(n));
+}
+
+template <std::size_t N, std::size_t alignment>
+void
+arena<N, alignment>::deallocate(char* p, std::size_t n) noexcept
+{
+    assert(pointer_in_buffer(ptr_) && "short_alloc has outlived arena");
+    if (pointer_in_buffer(p))
+    {
+      n = align_up(n);
+      if (p + n == ptr_) {
+        ptr_ = p;
+      }
+    }
+    else {
+      ::operator delete(p);
+    }
+}
+
+template <class T, std::size_t N, std::size_t Align = alignof(std::max_align_t)>
+class short_alloc
+{
+public:
+    using value_type = T;
+    static auto constexpr alignment = Align;
+    static auto constexpr size = N;
+    using arena_type = arena<size, alignment>;
+
+private:
+    arena_type& a_;
+
+public:
+    short_alloc(const short_alloc&) = default;
+    short_alloc& operator=(const short_alloc&) = delete;
+
+    explicit short_alloc(arena_type& a) noexcept : a_(a)
+    {
+        static_assert(size % alignment == 0,
+                      "size N needs to be a multiple of alignment Align");
+    }
+    template <class U>
+        explicit short_alloc(const short_alloc<U, N, alignment>& a) noexcept
+            : a_(a.a_) {}
+
+    template <class _Up> struct rebind {using other = short_alloc<_Up, N, alignment>;};
+
+    T* allocate(std::size_t n)
+    {
+        return reinterpret_cast<T*>(a_.template allocate<alignof(T)>(n*sizeof(T)));
+    }
+    void deallocate(T* p, std::size_t n) noexcept
+    {
+        a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T));
+    }
+
+    template <class T1, std::size_t N1, std::size_t A1, 
+              class U, std::size_t M, std::size_t A2>
+    friend
+    bool
+    operator==(const short_alloc<T1, N1, A1>& x, const short_alloc<U, M, A2>& y) noexcept;
+
+    template <class U, std::size_t M, std::size_t A> friend class short_alloc;
+};
+
+template <class T, std::size_t N, std::size_t A1, class U, std::size_t M, std::size_t A2>
+inline
+bool
+operator==(const short_alloc<T, N, A1>& x, const short_alloc<U, M, A2>& y) noexcept
+{
+    return N == M && A1 == A2 && &x.a_ == &y.a_;
+}
+
+template <class T, std::size_t N, std::size_t A1, class U, std::size_t M, std::size_t A2>
+inline
+bool
+operator!=(const short_alloc<T, N, A1>& x, const short_alloc<U, M, A2>& y) noexcept
+{
+    return !(x == y);
+}
+
+#endif  // SHORT_ALLOC_HPP
+

include/chaiscript/dispatchkit/type_conversions.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
 #define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
 
@@ -29,48 +33,48 @@ namespace chaiscript
     {
       public:
         bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) CHAISCRIPT_NOEXCEPT
+            const std::string &t_what) noexcept
           : bad_boxed_cast(t_from, t_to, t_what)
         {
         }
 
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) noexcept
           : bad_boxed_cast(t_from, t_to)
         {
         }
 
-        bad_boxed_dynamic_cast(const std::string &w) CHAISCRIPT_NOEXCEPT
+        explicit bad_boxed_dynamic_cast(const std::string &w) noexcept
           : bad_boxed_cast(w)
         {
         }
 
         bad_boxed_dynamic_cast(const bad_boxed_dynamic_cast &) = default;
 
-        virtual ~bad_boxed_dynamic_cast() CHAISCRIPT_NOEXCEPT {}
+        ~bad_boxed_dynamic_cast() noexcept override = default;
     };
 
     class bad_boxed_type_cast : public bad_boxed_cast
     {
       public:
         bad_boxed_type_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) CHAISCRIPT_NOEXCEPT
+            const std::string &t_what) noexcept
           : bad_boxed_cast(t_from, t_to, t_what)
         {
         }
 
-        bad_boxed_type_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
+        bad_boxed_type_cast(const Type_Info &t_from, const std::type_info &t_to) noexcept
           : bad_boxed_cast(t_from, t_to)
         {
         }
 
-        bad_boxed_type_cast(const std::string &w) CHAISCRIPT_NOEXCEPT
+        explicit bad_boxed_type_cast(const std::string &w) noexcept
           : bad_boxed_cast(w)
         {
         }
 
         bad_boxed_type_cast(const bad_boxed_type_cast &) = default;
 
-        virtual ~bad_boxed_type_cast() CHAISCRIPT_NOEXCEPT {}
+        ~bad_boxed_type_cast() noexcept override = default;
     };
   }
 
@@ -92,21 +96,82 @@ namespace chaiscript
           return m_from;
         }
 
-        virtual ~Type_Conversion_Base() {}
+        virtual bool bidir() const
+        {
+          return true;
+        }
+
+        virtual ~Type_Conversion_Base() = default;
 
       protected:
-        Type_Conversion_Base(const Type_Info &t_to, const Type_Info &t_from)
-          : m_to(t_to), m_from(t_from)
+        Type_Conversion_Base(Type_Info t_to, Type_Info t_from)
+          : m_to(std::move(t_to)), m_from(std::move(t_from))
         {
         }
 
 
       private:
-        Type_Info m_to;
-        Type_Info m_from;
+        const Type_Info m_to;
+        const Type_Info m_from;
 
     };
 
+    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(
+                      [&](){
+                        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(
+                      [&](){
+                        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
       {
@@ -121,7 +186,7 @@ namespace chaiscript
                 if (t_from.is_const())
                 {
                   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;
@@ -132,7 +197,7 @@ namespace chaiscript
                       );
                 } else {
                   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;
@@ -168,8 +233,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
     {
@@ -179,48 +246,86 @@ namespace chaiscript
         {
         }
 
-        virtual Boxed_Value convert_down(const Boxed_Value &t_base) const CHAISCRIPT_OVERRIDE
+        Boxed_Value convert_down(const Boxed_Value &t_base) const override
         {
           return Dynamic_Caster<Base, Derived>::cast(t_base);
         }
 
-        virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
+        Boxed_Value convert(const Boxed_Value &t_derived) const 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>())
+        {
+        }
+
+        Boxed_Value convert_down(const Boxed_Value &t_base) const 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");
+        }
+
+        bool bidir() const override
+        {
+          return false;
+        }
+
+        Boxed_Value convert(const Boxed_Value &t_derived) const override
+        {
+          return Static_Caster<Derived, Base>::cast(t_derived);
+        }
+    };
+
+
 
     template<typename Callable>
     class Type_Conversion_Impl : public Type_Conversion_Base
     {
       public:
         Type_Conversion_Impl(Type_Info t_from, Type_Info t_to, Callable t_func)
-          : Type_Conversion_Base(std::move(t_to), std::move(t_from)),
+          : Type_Conversion_Base(t_to, t_from),
             m_func(std::move(t_func))
         {
         }
 
-        virtual Boxed_Value convert_down(const Boxed_Value &) const CHAISCRIPT_OVERRIDE
+        Boxed_Value convert_down(const Boxed_Value &) const override
         {
           throw chaiscript::exception::bad_boxed_type_cast("No conversion exists");
         }
 
-        virtual Boxed_Value convert(const Boxed_Value &t_from) const CHAISCRIPT_OVERRIDE
+        Boxed_Value convert(const Boxed_Value &t_from) const override
         {
           /// \todo better handling of errors from the conversion function
           return m_func(t_from);
         }
 
+        bool bidir() const override
+        {
+          return false;
+        }
+
+
       private:
         Callable m_func;
     };
-
   }
 
   class Type_Conversions
   {
     public:
+      struct Conversion_Saves
+      {
+        bool enabled = false;
+        std::vector<Boxed_Value> saves;
+      };
+
       struct Less_Than
       {
         bool operator()(const std::type_info *t_lhs, const std::type_info *t_rhs) const
@@ -233,22 +338,15 @@ namespace chaiscript
         : m_mutex(),
           m_conversions(),
           m_convertableTypes(),
-          m_num_types(0),
-          m_thread_cache(this),
-          m_conversion_saves(this)
+          m_num_types(0)
       {
       }
 
-      Type_Conversions(const Type_Conversions &t_other)
-        : m_mutex(),
-          m_conversions(t_other.get_conversions()),
-          m_convertableTypes(),
-          m_num_types(m_conversions.size()),
-          m_thread_cache(this),
-          m_conversion_saves(this)
+      Type_Conversions(const Type_Conversions &t_other) = delete;
+      Type_Conversions(Type_Conversions &&) = default;
 
-      {
-      }
+      Type_Conversions &operator=(const Type_Conversions &) = delete;
+      Type_Conversions &operator=(Type_Conversions &&) = default;
 
       const std::set<const std::type_info *, Less_Than> &thread_cache() const
       {
@@ -288,64 +386,74 @@ 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;
         }
-
       }
 
       template<typename To>
-        Boxed_Value boxed_type_conversion(const Boxed_Value &from) const
+        Boxed_Value boxed_type_conversion(Conversion_Saves &t_saves, const Boxed_Value &from) const
         {
-          try {
-            Boxed_Value ret = get_conversion(user_type<To>(), from.get_type_info())->convert(from);
-            if (m_conversion_saves->enabled) m_conversion_saves->saves.push_back(ret);
-            return ret;
-          } catch (const std::out_of_range &) {
-            throw exception::bad_boxed_dynamic_cast(from.get_type_info(), typeid(To), "No known conversion");
-          } catch (const std::bad_cast &) {
-            throw exception::bad_boxed_dynamic_cast(from.get_type_info(), typeid(To), "Unable to perform dynamic_cast operation");
-          }
+          return boxed_type_conversion(user_type<To>(), t_saves, from);
         }
 
       template<typename From>
-        Boxed_Value boxed_type_down_conversion(const Boxed_Value &to) const
+        Boxed_Value boxed_type_down_conversion(Conversion_Saves &t_saves, const Boxed_Value &to) const
+        {
+          return boxed_type_down_conversion(user_type<From>(), t_saves, to);
+        }
+
+
+        Boxed_Value boxed_type_conversion(const Type_Info &to, Conversion_Saves &t_saves, const Boxed_Value &from) const
         {
           try {
-            Boxed_Value ret = get_conversion(to.get_type_info(), user_type<From>())->convert_down(to);
-            if (m_conversion_saves->enabled) m_conversion_saves->saves.push_back(ret);
+            Boxed_Value ret = get_conversion(to, from.get_type_info())->convert(from);
+            if (t_saves.enabled) { t_saves.saves.push_back(ret); }
             return ret;
           } catch (const std::out_of_range &) {
-            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), typeid(From), "No known conversion");
+            throw exception::bad_boxed_dynamic_cast(from.get_type_info(), *to.bare_type_info(), "No known conversion");
           } catch (const std::bad_cast &) {
-            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), typeid(From), "Unable to perform dynamic_cast operation");
+            throw exception::bad_boxed_dynamic_cast(from.get_type_info(), *to.bare_type_info(), "Unable to perform dynamic_cast operation");
           }
         }
 
-      void enable_conversion_saves(bool t_val) 
+        Boxed_Value boxed_type_down_conversion(const Type_Info &from, Conversion_Saves &t_saves, const Boxed_Value &to) const
         {
-        m_conversion_saves->enabled = t_val;
+          try {
+            Boxed_Value ret = get_conversion(to.get_type_info(), from)->convert_down(to);
+            if (t_saves.enabled) { t_saves.saves.push_back(ret); }
+            return ret;
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), *from.bare_type_info(), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), *from.bare_type_info(), "Unable to perform dynamic_cast operation");
+          }
         }
 
-      std::vector<Boxed_Value> take_saves()
+      static void enable_conversion_saves(Conversion_Saves &t_saves, bool t_val) 
+      {
+        t_saves.enabled = t_val;
+      }
+
+      std::vector<Boxed_Value> take_saves(Conversion_Saves &t_saves)
       {
         std::vector<Boxed_Value> ret;
-        std::swap(ret, m_conversion_saves->saves);
+        std::swap(ret, t_saves.saves);
         return ret;
       }
 
       bool has_conversion(const Type_Info &to, const Type_Info &from) const
       {
         chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-        return find(to, from) != m_conversions.end();
+        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
       {
         chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
-        auto itr = find(to, from);
+        const auto itr = find(to, from);
 
         if (itr != m_conversions.end())
         {
@@ -355,7 +463,23 @@ namespace chaiscript
         }
       }
 
+      Conversion_Saves &conversion_saves() const {
+        return *m_conversion_saves;
+      }
+
     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
       {
@@ -375,15 +499,6 @@ namespace chaiscript
       }
 
 
-      struct Conversion_Saves
-      {
-        Conversion_Saves()
-          : enabled(false)
-        {}
-
-        bool enabled;
-        std::vector<Boxed_Value> saves;
-      };
 
       mutable chaiscript::detail::threading::shared_mutex m_mutex;
       std::set<std::shared_ptr<detail::Type_Conversion_Base>> m_conversions;
@@ -393,6 +508,33 @@ namespace chaiscript
       mutable chaiscript::detail::threading::Thread_Storage<Conversion_Saves> m_conversion_saves;
   };
 
+  class Type_Conversions_State
+  {
+    public:
+      Type_Conversions_State(const Type_Conversions &t_conversions,
+          Type_Conversions::Conversion_Saves &t_saves)
+        : m_conversions(t_conversions),
+          m_saves(t_saves)
+      {
+      }
+
+      const Type_Conversions *operator->() const {
+        return &m_conversions.get();
+      }
+
+      const Type_Conversions *get() const {
+        return &m_conversions.get();
+      }
+
+      Type_Conversions::Conversion_Saves &saves() const {
+        return m_saves;
+      }
+
+    private:
+      std::reference_wrapper<const Type_Conversions> m_conversions;
+      std::reference_wrapper<Type_Conversions::Conversion_Saves> m_saves;
+  };
+
   typedef std::shared_ptr<chaiscript::detail::Type_Conversion_Base> Type_Conversion;
 
   /// \brief Used to register a to / parent class relationship with ChaiScript. Necessary if you
@@ -417,17 +559,26 @@ 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 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)
@@ -458,6 +609,40 @@ namespace chaiscript
       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;
+        vec.reserve(from_vec.size());
+        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);
+    }
+
+  template<typename To>
+    Type_Conversion map_conversion()
+    {
+      auto func = [](const Boxed_Value &t_bv) -> Boxed_Value {
+        const std::map<std::string, Boxed_Value> &from_map = detail::Cast_Helper<const std::map<std::string, Boxed_Value> &>::cast(t_bv, nullptr);
+
+        To map;
+        for (const std::pair<std::string, Boxed_Value> &p : from_map) {
+          map.insert(std::make_pair(p.first, detail::Cast_Helper<typename To::mapped_type>::cast(p.second, nullptr)));
+        }
+
+        return Boxed_Value(std::move(map));
+      };
+
+      return chaiscript::make_shared<detail::Type_Conversion_Base, detail::Type_Conversion_Impl<decltype(func)>>(user_type<std::map<std::string, Boxed_Value>>(), user_type<To>(), func);
+    }
 }
 
 

include/chaiscript/dispatchkit/type_info.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_TYPE_INFO_HPP_
 #define CHAISCRIPT_TYPE_INFO_HPP_
 
@@ -29,70 +33,66 @@ namespace chaiscript
   class Type_Info
   {
     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_bare_ti)
+      constexpr Type_Info(const bool t_is_const, const bool t_is_reference, const bool t_is_pointer, const bool t_is_void, 
+          const 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)
+          m_flags((static_cast<unsigned int>(t_is_const) << is_const_flag)
+                + (static_cast<unsigned int>(t_is_reference) << is_reference_flag)
+                + (static_cast<unsigned int>(t_is_pointer) << is_pointer_flag)
+                + (static_cast<unsigned int>(t_is_void) << is_void_flag)
+                + (static_cast<unsigned int>(t_is_arithmetic) << is_arithmetic_flag))
       {
       }
 
-      CHAISCRIPT_CONSTEXPR Type_Info()
-        : m_type_info(nullptr), m_bare_type_info(nullptr),
-        m_is_const(false), m_is_reference(false), m_is_pointer(false),
-        m_is_void(false), m_is_arithmetic(false), 
-        m_is_undef(true)
-      {
-      }
+      constexpr Type_Info() = default;
 
-#if !defined(_MSC_VER) || _MSC_VER != 1800
-      Type_Info(Type_Info&&) = default;
-      Type_Info& operator=(Type_Info&&) = default;
-#endif
-
-      Type_Info(const Type_Info&) = default;
-      Type_Info& operator=(const Type_Info&) = default;
-
-
-      CHAISCRIPT_CONSTEXPR bool operator<(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
+      constexpr bool operator<(const Type_Info &ti) const noexcept
       {
         return m_type_info < ti.m_type_info;
       }
 
-      CHAISCRIPT_CONSTEXPR bool operator==(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
+      constexpr bool operator!=(const Type_Info &ti) const noexcept
+      {
+        return !(operator==(ti));
+      }
+
+      constexpr bool operator!=(const std::type_info &ti) const noexcept
+      {
+        return !(operator==(ti));
+      }
+
+      constexpr bool operator==(const Type_Info &ti) const noexcept
       {
         return ti.m_type_info == m_type_info
-          || (ti.m_type_info && m_type_info && *ti.m_type_info == *m_type_info);
+           || *ti.m_type_info == *m_type_info;
       }
 
-      CHAISCRIPT_CONSTEXPR bool operator==(const std::type_info &ti) const CHAISCRIPT_NOEXCEPT
+      constexpr bool operator==(const std::type_info &ti) const noexcept
       {
-        return m_type_info != nullptr && (*m_type_info) == ti;
+        return !is_undef() && (*m_type_info) == ti;
       }
 
-      CHAISCRIPT_CONSTEXPR bool bare_equal(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
+      constexpr bool bare_equal(const Type_Info &ti) const noexcept
       {
         return ti.m_bare_type_info == m_bare_type_info
-          || (ti.m_bare_type_info && m_bare_type_info && *ti.m_bare_type_info == *m_bare_type_info);
+           || *ti.m_bare_type_info == *m_bare_type_info;
       }
 
-      CHAISCRIPT_CONSTEXPR bool bare_equal_type_info(const std::type_info &ti) const CHAISCRIPT_NOEXCEPT
+      constexpr bool bare_equal_type_info(const std::type_info &ti) const noexcept
       {
-        return m_bare_type_info != nullptr 
-          && (*m_bare_type_info) == ti;
+        return !is_undef() && (*m_bare_type_info) == ti;
       }
 
-      CHAISCRIPT_CONSTEXPR bool is_const() const CHAISCRIPT_NOEXCEPT { return m_is_const; }
-      CHAISCRIPT_CONSTEXPR bool is_reference() const CHAISCRIPT_NOEXCEPT { return m_is_reference; }
-      CHAISCRIPT_CONSTEXPR bool is_void() const CHAISCRIPT_NOEXCEPT { return m_is_void; }
-      CHAISCRIPT_CONSTEXPR bool is_arithmetic() const CHAISCRIPT_NOEXCEPT { return m_is_arithmetic; }
-      CHAISCRIPT_CONSTEXPR bool is_undef() const CHAISCRIPT_NOEXCEPT { return m_is_undef || m_bare_type_info == nullptr; }
-      CHAISCRIPT_CONSTEXPR bool is_pointer() const CHAISCRIPT_NOEXCEPT { return m_is_pointer; }
+      constexpr bool is_const() const noexcept { return (m_flags & (1 << is_const_flag)) != 0; }
+      constexpr bool is_reference() const noexcept { return (m_flags & (1 << is_reference_flag)) != 0; }
+      constexpr bool is_void() const noexcept { return (m_flags & (1 << is_void_flag)) != 0; }
+      constexpr bool is_arithmetic() const noexcept { return (m_flags & (1 << is_arithmetic_flag)) != 0; }
+      constexpr bool is_undef() const noexcept { return (m_flags & (1 << is_undef_flag)) != 0; }
+      constexpr bool is_pointer() const noexcept { return (m_flags & (1 << is_pointer_flag)) != 0; }
 
       std::string name() const
       {
-        if (m_type_info)
+        if (!is_undef())
         {
           return m_type_info->name();
         } else {
@@ -102,7 +102,7 @@ namespace chaiscript
 
       std::string bare_name() const
       {
-        if (m_bare_type_info)
+        if (!is_undef())
         {
           return m_bare_type_info->name();
         } else {
@@ -110,20 +110,23 @@ namespace chaiscript
         }
       }
 
-      CHAISCRIPT_CONSTEXPR const std::type_info *bare_type_info() const
+      constexpr const std::type_info *bare_type_info() const
       {
         return m_bare_type_info;
       }
 
     private:
-      const std::type_info *m_type_info;
-      const std::type_info *m_bare_type_info;
-      bool m_is_const;
-      bool m_is_reference;
-      bool m_is_pointer;
-      bool m_is_void;
-      bool m_is_arithmetic;
-      bool m_is_undef;
+      struct Unknown_Type {};
+
+      const std::type_info *m_type_info = &typeid(Unknown_Type);
+      const std::type_info *m_bare_type_info = &typeid(Unknown_Type);
+      static const int is_const_flag = 0;
+      static const int is_reference_flag = 1;
+      static const int is_pointer_flag = 2;
+      static const int is_void_flag = 3;
+      static const int is_arithmetic_flag = 4;
+      static const int is_undef_flag = 5;
+      unsigned int m_flags = (1 << is_undef_flag);
   };
 
   namespace detail
@@ -132,13 +135,13 @@ namespace chaiscript
     template<typename T>
       struct Get_Type_Info
       {
-        typedef T type;
-
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static constexpr 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,
+              (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));
         }
@@ -147,28 +150,31 @@ namespace chaiscript
     template<typename T>
       struct Get_Type_Info<std::shared_ptr<T> >
       {
-        typedef T type;
+//        typedef T type;
 
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static constexpr 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));
         }
       };
 
+    template<typename T>
+      struct Get_Type_Info<std::shared_ptr<T> &> : Get_Type_Info<std::shared_ptr<T>>
+      {
+      };
+
     template<typename T>
       struct Get_Type_Info<const std::shared_ptr<T> &>
       {
-        typedef T type;
-
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static constexpr 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));
         }
@@ -177,13 +183,11 @@ namespace chaiscript
     template<typename T>
       struct Get_Type_Info<std::reference_wrapper<T> >
       {
-        typedef T type;
-
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static constexpr 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));
         }
@@ -192,13 +196,11 @@ namespace chaiscript
     template<typename T>
       struct Get_Type_Info<const std::reference_wrapper<T> &>
       {
-        typedef T type;
-
-        CHAISCRIPT_CONSTEXPR static Type_Info get()
+        static constexpr 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));
         }
@@ -216,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*/)
+  constexpr Type_Info user_type(const T &/*t*/)
   {
     return detail::Get_Type_Info<T>::get();
   }
@@ -231,7 +233,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
   /// \endcode
   template<typename T>
-  CHAISCRIPT_CONSTEXPR Type_Info user_type()
+  constexpr Type_Info user_type()
   {
     return detail::Get_Type_Info<T>::get();
   }

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -1,19 +1,25 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_ALGEBRAIC_HPP_
 #define CHAISCRIPT_ALGEBRAIC_HPP_
 
+#include "../utility/fnv1a.hpp"
+
 #include <string>
 
 namespace chaiscript
 {
 
   struct Operators {
-    enum Opers
+    enum class Opers
     {
       boolean_flag,
       equals, less_than, greater_than, less_than_equal, greater_than_equal, not_equal, 
@@ -31,7 +37,7 @@ namespace chaiscript
     };
 
     static const char *to_string(Opers t_oper) {
-      const char *opers[] = { 
+      static const char *opers[] = { 
         "",
         "==", "<", ">", "<=", ">=", "!=",
         "",
@@ -46,81 +52,53 @@ namespace chaiscript
         "+", "/", "*", "-", "+", "-",
         ""
       };
-      return opers[t_oper];
+      return opers[static_cast<int>(t_oper)];
     }
 
     static Opers to_operator(const std::string &t_str, bool t_is_unary = false)
     {
-      if (t_str == "==")
-      {
-        return equals;
-      } else if (t_str == "<") {
-        return less_than;
-      } else if (t_str == ">") {
-        return greater_than;
-      } else if (t_str == "<=") {
-        return less_than_equal; 
-      } else if (t_str == ">=") {
-        return greater_than_equal;
-      } else if (t_str == "!=") {
-        return not_equal;
-      } else if (t_str == "=") {
-        return assign;
-      } else if (t_str == "++") {
-        return pre_increment;
-      } else if (t_str == "--") {
-        return pre_decrement;
-      } else if (t_str == "*=") {
-        return assign_product;
-      } else if (t_str == "+=") {
-        return assign_sum;
-      } else if (t_str == "-=") {
-        return assign_difference;
-      } else if (t_str == "&=") {
-        return assign_bitwise_and;
-      } else if (t_str == "|=") {
-        return assign_bitwise_or;
-      } else if (t_str == "<<=") {
-        return assign_shift_left;
-      } else if (t_str == ">>=") {
-        return assign_shift_right;
-      } else if (t_str == "%=") {
-        return assign_remainder;
-      } else if (t_str == "^=") {
-        return assign_bitwise_xor;
-      } else if (t_str == "<<") {
-        return shift_left;
-      } else if (t_str == ">>") {
-        return shift_right;
-      } else if (t_str == "%") {
-        return remainder;
-      } else if (t_str == "&") { 
-        return bitwise_and;
-      } else if (t_str == "|") {
-        return bitwise_or;
-      } else if (t_str == "^") {
-        return bitwise_xor;
-      } else if (t_str == "~") {
-        return bitwise_complement;
-      } else if (t_str == "+") {
-        if (t_is_unary) {
-          return unary_plus;
-        } else {
-          return sum;
-        }
-      } else if (t_str == "-") {
-        if (t_is_unary) {
-          return unary_minus;
-        } else {
-          return difference;
-        }
-      } else if (t_str == "/") {
-        return quotient;
-      } else if (t_str == "*") {
-        return product;
-      } else {
-        return invalid;
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4307)
+#endif
+
+      const auto op_hash = utility::fnv1a_32(t_str.c_str());
+      switch (op_hash) {
+        case utility::fnv1a_32("=="): { return Opers::equals; }
+        case utility::fnv1a_32("<"): { return Opers::less_than; }
+        case utility::fnv1a_32(">"): { return Opers::greater_than; }
+        case utility::fnv1a_32("<="): { return Opers::less_than_equal; }
+        case utility::fnv1a_32(">="): { return Opers::greater_than_equal; }
+        case utility::fnv1a_32("!="): { return Opers::not_equal; }
+        case utility::fnv1a_32("="): { return Opers::assign; }
+        case utility::fnv1a_32("++"): { return Opers::pre_increment; }
+        case utility::fnv1a_32("--"): { return Opers::pre_decrement; }
+        case utility::fnv1a_32("*="): { return Opers::assign_product; }
+        case utility::fnv1a_32("+="): { return Opers::assign_sum; }
+        case utility::fnv1a_32("-="): { return Opers::assign_difference; }
+        case utility::fnv1a_32("&="): { return Opers::assign_bitwise_and; }
+        case utility::fnv1a_32("|="): { return Opers::assign_bitwise_or; }
+        case utility::fnv1a_32("<<="): { return Opers::assign_shift_left; }
+        case utility::fnv1a_32(">>="): { return Opers::assign_shift_right; }
+        case utility::fnv1a_32("%="): { return Opers::assign_remainder; }
+        case utility::fnv1a_32("^="): { return Opers::assign_bitwise_xor; }
+        case utility::fnv1a_32("<<"): { return Opers::shift_left; }
+        case utility::fnv1a_32(">>"): { return Opers::shift_right; }
+        case utility::fnv1a_32("%"): { return Opers::remainder; }
+        case utility::fnv1a_32("&"): { return Opers::bitwise_and; }
+        case utility::fnv1a_32("|"): { return Opers::bitwise_or; }
+        case utility::fnv1a_32("^"): { return Opers::bitwise_xor; }
+        case utility::fnv1a_32("~"): { return Opers::bitwise_complement; }
+        case utility::fnv1a_32("+"): { return t_is_unary ? Opers::unary_plus : Opers::sum; }
+        case utility::fnv1a_32("-"): { return t_is_unary ? Opers::unary_minus : Opers::difference; }
+        case utility::fnv1a_32("/"): { return Opers::quotient; }
+        case utility::fnv1a_32("*"): { return Opers::product; }
+        default: { return Opers::invalid; }
       }
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif
+
     }
 
   };

include/chaiscript/language/chaiscript_common.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_COMMON_HPP_
 #define CHAISCRIPT_COMMON_HPP_
 
@@ -26,34 +30,60 @@ struct AST_Node;
 
 namespace chaiscript
 {
+  struct Name_Validator {
+    static bool is_reserved_word(const std::string &name)
+    {
+      static const std::set<std::string> m_reserved_words 
+        = {"def", "fun", "while", "for", "if", "else", "&&", "||", ",", "auto", 
+          "return", "break", "true", "false", "class", "attr", "var", "global", "GLOBAL", "_",
+          "__LINE__", "__FILE__", "__FUNC__", "__CLASS__"};
+      return m_reserved_words.count(name) > 0;
+    }
+
+    static bool valid_object_name(const std::string &name)
+    {
+      return name.find("::") == std::string::npos && !is_reserved_word(name);
+    }
+
+    static void validate_object_name(const std::string &name)
+    {
+      if (is_reserved_word(name)) {
+        throw exception::reserved_word_error(name);
+      }
+
+      if (name.find("::") != std::string::npos) {
+        throw exception::illegal_name_error(name);
+      }
+    }
+  };
 
   /// Signature of module entry point that all binary loadable modules must implement.
   typedef ModulePtr (*Create_Module_Func)();
 
 
   /// 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,
-                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, Global_Decl
-    };
+  enum class AST_Node_Type { Id, Fun_Call, Unused_Return_Fun_Call, Arg_List, Equation, Var_Decl,
+    Array_Call, Dot_Access,
+    Lambda, Block, Scopeless_Block, Def, While, If, For, Ranged_For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Continue, Map_Pair, Value_Range,
+    Inline_Range, Try, Catch, Finally, Method, Attr_Decl,  
+    Logical_And, Logical_Or, Reference, Switch, Case, Default, Noop, Class, Binary, Arg, Global_Decl, Constant, Compiled
   };
 
+  enum class Operator_Precidence { Ternary_Cond, Logical_Or, 
+    Logical_And, Bitwise_Or, Bitwise_Xor, Bitwise_And, 
+    Equality, Comparison, Shift, Addition, Multiplication, Prefix };
+
   namespace
   {
-
     /// 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",
-                                    "Comparison", "Addition", "Subtraction", "Multiplication", "Division", "Modulus", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
-                                    "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Continue", "Map_Pair", "Value_Range",
-                                    "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Shift", "Equality", "Bitwise_And", "Bitwise_Xor", "Bitwise_Or", 
-                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Ternary Condition", "Noop", "Class", "Binary", "Arg"};
+    inline const char *ast_node_type_to_string(AST_Node_Type ast_node_type) {
+      static const char * const ast_node_types[] = { "Id", "Fun_Call", "Unused_Return_Fun_Call", "Arg_List", "Equation", "Var_Decl",
+                                    "Array_Call", "Dot_Access", 
+                                    "Lambda", "Block", "Scopeless_Block", "Def", "While", "If", "For", "Ranged_For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Continue", "Map_Pair", "Value_Range",
+                                    "Inline_Range", "Try", "Catch", "Finally", "Method", "Attr_Decl",
+                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Noop", "Class", "Binary", "Arg", "Global_Decl", "Constant", "Compiled"};
 
-      return ast_node_types[ast_node_type];
+      return ast_node_types[static_cast<int>(ast_node_type)];
     }
   }
 
@@ -101,6 +131,36 @@ namespace chaiscript
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
   namespace exception
   {
+    /// \brief Thrown if an error occurs while attempting to load a binary module
+    struct load_module_error : std::runtime_error
+    {
+      explicit load_module_error(const std::string &t_reason) noexcept
+        : std::runtime_error(t_reason)
+      {
+      }
+
+      load_module_error(const std::string &t_name, const std::vector<load_module_error> &t_errors)
+        : std::runtime_error(format_error(t_name, t_errors))
+      {
+      }
+
+      load_module_error(const load_module_error &) = default;
+      ~load_module_error() noexcept override = default;
+
+      static std::string format_error(const std::string &t_name, const std::vector<load_module_error> &t_errors)
+      {
+        std::stringstream ss;
+        ss << "Error loading module '" << t_name << "'\n"
+           << "  The following locations were searched:\n";
+
+        for (const auto &err : t_errors) {
+          ss << "    " << err.what() << "\n";
+        }
+
+        return ss.str();
+      }
+    };
+
 
     /// Errors generated during parsing or evaluation
     struct eval_error : std::runtime_error {
@@ -113,7 +173,7 @@ namespace chaiscript
       eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
           bool t_dot_notation,
-          const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_NOEXCEPT :
+          const chaiscript::detail::Dispatch_Engine &t_ss) 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), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss)) 
       {}
@@ -121,18 +181,18 @@ namespace chaiscript
       eval_error(const std::string &t_why, 
            const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
            bool t_dot_notation,
-           const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_NOEXCEPT :
+           const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
         std::runtime_error(format(t_why, t_parameters, t_dot_notation, t_ss)),
         reason(t_why), detail(format_detail(t_functions, t_dot_notation, t_ss))
       {}
 
 
-      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) CHAISCRIPT_NOEXCEPT :
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) noexcept :
         std::runtime_error(format(t_why, t_where, t_fname)),
         reason(t_why), start_position(t_where), filename(t_fname)
       {}
 
-      eval_error(const std::string &t_why) CHAISCRIPT_NOEXCEPT
+      explicit eval_error(const std::string &t_why) noexcept
         : std::runtime_error("Error: \"" + t_why + "\" "),
         reason(t_why) 
       {}
@@ -144,7 +204,7 @@ namespace chaiscript
         std::ostringstream ss;
 
         ss << what();
-        if (call_stack.size() > 0) {
+        if (!call_stack.empty()) {
           ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")\n";
           ss << '\n' << detail << '\n';
           ss << "  " << fname(call_stack[0]) << " (" << startpos(call_stack[0]) << ") '" << pretty(call_stack[0]) << "'";
@@ -161,12 +221,12 @@ namespace chaiscript
         return ss.str();
       }
 
-      virtual ~eval_error() CHAISCRIPT_NOEXCEPT {}
+      ~eval_error() noexcept override = default;
 
     private:
 
       template<typename T>
-        static int id(const T& t)
+        static AST_Node_Type id(const T& t)
         {
           return t->identifier;
         }
@@ -276,10 +336,13 @@ namespace chaiscript
       template<typename T>
         static std::string format_location(const T &t)
         {
+          if (t) {
             std::ostringstream oss;
             oss << "(" << t->filename() << " " << t->start().line << ", " << t->start().column << ")"; 
-
             return oss.str();
+          } else {
+            return "(internal)";
+          }
 
         }
 
@@ -417,12 +480,12 @@ namespace chaiscript
 
     /// Errors generated when loading a file
     struct file_not_found_error : std::runtime_error {
-      file_not_found_error(const std::string &t_filename) CHAISCRIPT_NOEXCEPT
+      explicit file_not_found_error(const std::string &t_filename) noexcept
         : std::runtime_error("File Not Found: " + t_filename)
       { }
 
       file_not_found_error(const file_not_found_error &) = default;
-      virtual ~file_not_found_error() CHAISCRIPT_NOEXCEPT {}
+      ~file_not_found_error() noexcept override = default;
     };
 
   }
@@ -431,11 +494,9 @@ 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 int identifier; //< \todo shouldn't this be a strongly typed enum value?
+      const AST_Node_Type identifier;
       const std::string text;
       Parse_Location location;
-      std::vector<AST_NodePtr> children;
-      AST_NodePtr annotation;
 
       const std::string &filename() const {
         return *location.filename;
@@ -449,19 +510,22 @@ namespace chaiscript
         return location.end;
       }
 
-      virtual std::string pretty_print() const
+      std::string pretty_print() const
       {
         std::ostringstream oss;
 
         oss << text;
 
-        for (auto & elem : this->children) {
-          oss << elem->pretty_print();
+        for (auto & elem : this->get_children()) {
+          oss << elem->pretty_print() << ' ';
         }
 
         return oss.str();
       }
 
+      virtual std::vector<AST_NodePtr> get_children() const = 0;
+      virtual Boxed_Value eval(const chaiscript::detail::Dispatch_State &t_e) const = 0;
+
 
       /// Prints the contents of an AST node, including its children, recursively
       std::string to_string(const std::string &t_prepend = "") const {
@@ -470,25 +534,16 @@ namespace chaiscript
         oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
             << 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->get_children()) {
+          oss << elem->to_string(t_prepend + "  ");
         }
         return oss.str();
       }
 
-      Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) const
-      {
-        try {
-          return eval_internal(t_e);
-        } catch (exception::eval_error &ee) {
-          ee.call_stack.push_back(shared_from_this());
-          throw;
-        }
-      }
 
-      static bool get_bool_condition(const Boxed_Value &t_bv) {
+      static bool get_bool_condition(const Boxed_Value &t_bv, const chaiscript::detail::Dispatch_State &t_ss) {
         try {
-          return boxed_cast<bool>(t_bv);
+          return t_ss->boxed_cast<bool>(t_bv);
         }
         catch (const exception::bad_boxed_cast &) {
           throw exception::eval_error("Condition not boolean");
@@ -496,33 +551,47 @@ namespace chaiscript
       }
 
 
-      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, 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))
-      {
-      }
-
-      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &) const
-      {
-        throw std::runtime_error("Undispatched ast_node (internal error)");
-      }
-
-    private:
-      // Copy and assignment explicitly unimplemented
+      virtual ~AST_Node() = default;
+      AST_Node(AST_Node &&) = default;
+      AST_Node &operator=(AST_Node &&) = default;
       AST_Node(const AST_Node &) = delete;
       AST_Node& operator=(const AST_Node &) = delete;
+
+
+    protected:
+      AST_Node(std::string t_ast_node_text, AST_Node_Type t_id, Parse_Location t_loc)
+        : identifier(t_id), text(std::move(t_ast_node_text)),
+          location(std::move(t_loc))
+      {
+      }
+
+
   };
 
+  namespace parser {
+    class ChaiScript_Parser_Base
+    {
+      public:
+        virtual AST_NodePtr parse(const std::string &t_input, const std::string &t_fname) = 0;
+        virtual void debug_print(AST_NodePtr t, std::string prepend = "") const = 0;
+        virtual void *get_tracer_ptr() = 0;
+        virtual ~ChaiScript_Parser_Base() = default;
+        ChaiScript_Parser_Base() = default;
+        ChaiScript_Parser_Base(ChaiScript_Parser_Base &&) = default;
+        ChaiScript_Parser_Base &operator=(ChaiScript_Parser_Base &&) = delete;
+        ChaiScript_Parser_Base &operator=(const ChaiScript_Parser_Base &&) = delete;
+
+        template<typename T>
+        T &get_tracer()
+        {
+          // to do type check this somehow?
+          return *static_cast<T*>(get_tracer_ptr());
+        }
+
+      protected:
+        ChaiScript_Parser_Base(const ChaiScript_Parser_Base &) = default;
+    };
+  }
 
   namespace eval
   {
@@ -532,99 +601,102 @@ namespace chaiscript
       struct Return_Value {
         Boxed_Value retval;
 
-        Return_Value(Boxed_Value t_return_value) : retval(std::move(t_return_value)) { }
+        explicit Return_Value(Boxed_Value t_return_value) : retval(std::move(t_return_value)) { }
       };
 
 
       /// Special type indicating a call to 'break'
       struct Break_Loop {
-        Break_Loop() { }
+        Break_Loop() = default;
       };
 
 
       /// Special type indicating a call to 'continue'
       struct Continue_Loop {
-        Continue_Loop() { }
+        Continue_Loop() = default;
       };
 
 
       /// Creates a new scope then pops it on destruction
       struct Scope_Push_Pop
       {
+        Scope_Push_Pop(Scope_Push_Pop &&) = default;
+        Scope_Push_Pop& operator=(Scope_Push_Pop &&) = default;
         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)
+        explicit Scope_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
+          : m_ds(t_ds)
         {
-          m_de.new_scope();
+          m_ds->new_scope(m_ds.stack_holder());
         }
 
         ~Scope_Push_Pop()
         {
-          m_de.pop_scope();
+          m_ds->pop_scope(m_ds.stack_holder());
         }
 
 
         private:
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          const chaiscript::detail::Dispatch_State &m_ds;
       };
 
       /// Creates a new function call and pops it on destruction
       struct Function_Push_Pop
       {
+        Function_Push_Pop(Function_Push_Pop &&) = default;
+        Function_Push_Pop& operator=(Function_Push_Pop &&) = default;
         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)
+        explicit Function_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
+          : m_ds(t_ds)
         {
-          m_de.new_function_call();
+          m_ds->new_function_call(m_ds.stack_holder(), m_ds.conversion_saves());
         }
 
         ~Function_Push_Pop()
         {
-          m_de.pop_function_call();
+          m_ds->pop_function_call(m_ds.stack_holder(), m_ds.conversion_saves());
         }
 
         void save_params(const std::vector<Boxed_Value> &t_params)
         {
-          m_de.save_function_params(t_params);
+          m_ds->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->save_function_params(t_params);
         }
 
 
         private:
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          const chaiscript::detail::Dispatch_State &m_ds;
       };
 
       /// Creates a new scope then pops it on destruction
       struct Stack_Push_Pop
       {
+        Stack_Push_Pop(Stack_Push_Pop &&) = default;
+        Stack_Push_Pop& operator=(Stack_Push_Pop &&) = default;
         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)
+        explicit Stack_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
+          : m_ds(t_ds)
         {
-          m_de.new_stack();
+          m_ds->new_stack(m_ds.stack_holder());
         }
 
         ~Stack_Push_Pop()
         {
-          m_de.pop_stack();
+          m_ds->pop_stack(m_ds.stack_holder());
         }
 
 
         private:
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          const chaiscript::detail::Dispatch_State &m_ds;
       };
     }
   }

include/chaiscript/language/chaiscript_engine.hpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_ENGINE_HPP_
 #define CHAISCRIPT_ENGINE_HPP_
 
@@ -17,6 +21,7 @@
 #include <set>
 #include <stdexcept>
 #include <vector>
+#include <cstring>
 
 #include "../chaiscript_defines.hpp"
 #include "../chaiscript_threading.hpp"
@@ -31,228 +36,34 @@
 #include <unistd.h>
 #endif
 
-#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
+#if !defined(CHAISCRIPT_NO_DYNLOAD) && defined(_POSIX_VERSION) && !defined(__CYGWIN__)
 #include <dlfcn.h>
-#else
-#ifdef CHAISCRIPT_WINDOWS
-#define VC_EXTRA_LEAN
-#define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
 #endif
+
+#if defined(CHAISCRIPT_NO_DYNLOAD)
+#include "chaiscript_unknown.hpp"
+#elif defined(CHAISCRIPT_WINDOWS)
+#include "chaiscript_windows.hpp"
+#elif _POSIX_VERSION
+#include "chaiscript_posix.hpp"
+#else
+#include "chaiscript_unknown.hpp"
 #endif
 
 
 #include "../dispatchkit/exception_specification.hpp"
-#include "chaiscript_parser.hpp"
-#include "chaiscript_prelude.chai"
 
 namespace chaiscript
 {
-  namespace exception
-  {
-    /// \brief Thrown if an error occurs while attempting to load a binary module
-    struct load_module_error : std::runtime_error
-    {
-      load_module_error(const std::string &t_reason) CHAISCRIPT_NOEXCEPT
-        : std::runtime_error(t_reason)
-      {
-      }
-
-      load_module_error(const load_module_error &) = default;
-      virtual ~load_module_error() CHAISCRIPT_NOEXCEPT {}
-    };
-  }
 
   namespace detail
   {
-#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
-    struct Loadable_Module
-    {
-      struct DLModule
-      {
-        DLModule(const std::string &t_filename)
-          : m_data(dlopen(t_filename.c_str(), RTLD_NOW))
-        {
-          if (!m_data)
-          {
-            throw chaiscript::exception::load_module_error(dlerror());
-          }
-        }
-
-        DLModule(const DLModule &); // Explicitly unimplemented copy constructor
-        DLModule &operator=(const DLModule &); // Explicitly unimplemented assignment operator
-
-        ~DLModule()
-        {
-          dlclose(m_data);
-        }
-
-        void *m_data;
-      };
-
-      template<typename T>
-        struct DLSym
-        {
-          DLSym(DLModule &t_mod, const std::string &t_symbol)
-            : m_symbol(cast_symbol(dlsym(t_mod.m_data, t_symbol.c_str())))
-          {
-            if (!m_symbol)
-            {
-              throw chaiscript::exception::load_module_error(dlerror());
-            }
-          }
-
-          static T cast_symbol(void *p)
-          {
-            union cast_union
-            {
-              T func_ptr;
-              void *in_ptr;
-            };
-
-            cast_union c;
-            c.in_ptr = p;
-            return c.func_ptr;
-          }
-
-          T m_symbol;
-        };
-
-      Loadable_Module(const std::string &t_module_name, const std::string &t_filename)
-        : m_dlmodule(t_filename), m_func(m_dlmodule, "create_chaiscript_module_" + t_module_name),
-        m_moduleptr(m_func.m_symbol())
-      {
-      }
-
-      DLModule m_dlmodule;
-      DLSym<Create_Module_Func> m_func;
-      ModulePtr m_moduleptr;
-    };
-#else
-
-#ifdef WIN32
-
-
-    struct Loadable_Module
-    {
-      template<typename T>
-        static std::wstring to_wstring(const T &t_str) 
-        {
-          return std::wstring(t_str.begin(), t_str.end());
-        }
-
-      template<typename T>
-        static std::string to_string(const T &t_str)
-        {
-          return std::string(t_str.begin(), t_str.end());
-        }
-
-#if defined(_UNICODE) || defined(UNICODE)
-        template<typename T>
-        static std::wstring to_proper_string(const T &t_str)
-        {
-          return to_wstring(t_str);
-        }
-#else
-      template<typename T>
-        static std::string to_proper_string(const T &t_str)
-        {
-          return to_string(t_str);
-        }
-#endif
-
-      static std::string get_error_message(DWORD t_err)
-      {
-        typedef LPTSTR StringType;
-
-#if defined(_UNICODE) || defined(UNICODE)
-        std::wstring retval = L"Unknown Error";
-#else
-        std::string retval = "Unknown Error";
-#endif
-        StringType lpMsgBuf = nullptr;
-
-        if (FormatMessage(
-            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-            FORMAT_MESSAGE_FROM_SYSTEM |
-            FORMAT_MESSAGE_IGNORE_INSERTS,
-            NULL,
-            t_err,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-            reinterpret_cast<StringType>(&lpMsgBuf),
-            0, NULL ) != 0 && lpMsgBuf)
-        {
-          retval = lpMsgBuf;
-          LocalFree(lpMsgBuf);
-        }
-
-        return to_string(retval);
-      }
-
-      struct DLModule
-      {
-        DLModule(const std::string &t_filename)
-          : m_data(LoadLibrary(to_proper_string(t_filename).c_str()))
-        {
-          if (!m_data)
-          {
-            throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
-          }
-        }
-
-        ~DLModule()
-        {
-          FreeLibrary(m_data);
-        }
-
-        HMODULE m_data;
-      };
-
-      template<typename T>
-        struct DLSym
-        {
-          DLSym(DLModule &t_mod, const std::string &t_symbol)
-            : m_symbol(reinterpret_cast<T>(GetProcAddress(t_mod.m_data, t_symbol.c_str())))
-          {
-            if (!m_symbol)
-            {
-              throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
-            }
-          }
-
-          T m_symbol;
-        };
-
-      Loadable_Module(const std::string &t_module_name, const std::string &t_filename)
-        : m_dlmodule(t_filename), m_func(m_dlmodule, "create_chaiscript_module_" + t_module_name),
-        m_moduleptr(m_func.m_symbol())
-      {
-      }
-
-      DLModule m_dlmodule;
-      DLSym<Create_Module_Func> m_func;
-      ModulePtr m_moduleptr;
-    };
-
-#else
-    struct Loadable_Module
-    {
-      Loadable_Module(const std::string &, const std::string &)
-      {
-        throw chaiscript::exception::load_module_error("Loadable module support not available for your platform");
-      }
-
-      ModulePtr m_moduleptr;
-    };
-#endif
-#endif
-
     typedef std::shared_ptr<Loadable_Module> Loadable_Module_Ptr;
   }
 
 
   /// \brief The main object that the ChaiScript user will use.
-  class ChaiScript {
+  class ChaiScript_Basic {
 
     mutable chaiscript::detail::threading::shared_mutex m_mutex;
     mutable chaiscript::detail::threading::recursive_mutex m_use_mutex;
@@ -264,19 +75,16 @@ namespace chaiscript
     std::vector<std::string> m_module_paths;
     std::vector<std::string> m_use_paths;
 
+    std::unique_ptr<parser::ChaiScript_Parser_Base> m_parser;
+
     chaiscript::detail::Dispatch_Engine m_engine;
 
     /// Evaluates the given string in by parsing it and running the results through the evaluator
     Boxed_Value do_eval(const std::string &t_input, const std::string &t_filename = "__EVAL__", bool /* t_internal*/  = false) 
     {
       try {
-        parser::ChaiScript_Parser parser;
-        if (parser.parse(t_input, t_filename)) {
-          //parser.show_match_stack();
-          return parser.optimized_ast()->eval(m_engine);
-        } else {
-          return Boxed_Value();
-        }
+        const auto p = m_parser->parse(t_input, t_filename);
+        return p->eval(chaiscript::detail::Dispatch_State(m_engine));
       }
       catch (chaiscript::eval::detail::Return_Value &rv) {
         return rv.retval;
@@ -285,15 +93,6 @@ 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)
@@ -330,83 +129,72 @@ namespace chaiscript
     }
 
     /// Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
-    void build_eval_system(const ModulePtr &t_lib) {
-      m_engine.add_reserved_word("def");
-      m_engine.add_reserved_word("fun");
-      m_engine.add_reserved_word("while");
-      m_engine.add_reserved_word("for");
-      m_engine.add_reserved_word("if");
-      m_engine.add_reserved_word("else");
-      m_engine.add_reserved_word("&&");
-      m_engine.add_reserved_word("||");
-      m_engine.add_reserved_word(",");
-      m_engine.add_reserved_word("auto");
-      m_engine.add_reserved_word("return");
-      m_engine.add_reserved_word("break");
-      m_engine.add_reserved_word("true");
-      m_engine.add_reserved_word("false");
-      m_engine.add_reserved_word("class");
-      m_engine.add_reserved_word("attr");
-      m_engine.add_reserved_word("var");
-      m_engine.add_reserved_word("GLOBAL");
-      m_engine.add_reserved_word("_");
-
+    void build_eval_system(const ModulePtr &t_lib, const std::vector<Options> &t_opts) {
       if (t_lib)
       {
         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(chaiscript::make_shared<dispatch::Proxy_Function_Base, 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");
+              })
+          , "call_exists");
 
-//      m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base *, const std::vector<Boxed_Value> &)>(std::bind(&chaiscript::dispatch::Proxy_Function_Base::operator(), std::placeholders::_1, std::placeholders::_2, std::ref(m_engine.conversions()))), "call");
-//
-      m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base &, const std::vector<Boxed_Value> &)>(
-            [=](const dispatch::Proxy_Function_Base &t_fun, const std::vector<Boxed_Value> &t_params) {
-              return t_fun(t_params, this->m_engine.conversions());
+
+      m_engine.add(fun(
+            [=](const dispatch::Proxy_Function_Base &t_fun, const std::vector<Boxed_Value> &t_params) -> Boxed_Value {
+              Type_Conversions_State s(this->m_engine.conversions(), this->m_engine.conversions().conversion_saves());
+              return t_fun(t_params, s);
             }), "call");
 
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::ref(m_engine)), "name");
 
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type, std::ref(m_engine)), "type");
-      m_engine.add(fun<chaiscript::Type_Info (const std::string &)>([this](const std::string &t_type_name){ return this->m_engine.get_type(t_type_name, true); }), "type");
+      m_engine.add(fun([this](const Type_Info &t_ti){ return m_engine.get_type_name(t_ti); }), "name");
 
-      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 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");
+      if (std::find(t_opts.begin(), t_opts.end(), Options::No_Load_Modules) == t_opts.end()
+          && std::find(t_opts.begin(), t_opts.end(), Options::Load_Modules) != t_opts.end()) 
+      {
+        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_file, this), "eval_file");
-      m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
-      m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
+      if (std::find(t_opts.begin(), t_opts.end(), Options::No_External_Scripts) == t_opts.end()
+          && std::find(t_opts.begin(), t_opts.end(), Options::External_Scripts) != t_opts.end())
+      {
+        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(&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([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(&ChaiScript::add_global_const, this), "add_global_const");
-      m_engine.add(fun(&ChaiScript::add_global, this), "add_global");
+      m_engine.add(fun([this](const std::string &t_str, const bool t_dump){ return parse(t_str, t_dump); }), "parse");
+      m_engine.add(fun([this](const std::string &t_str){ return parse(t_str); }), "parse");
 
-      do_eval(ChaiScript_Prelude::chaiscript_prelude(), "standard prelude");
+
+      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");
+      m_engine.add(fun([this](const Boxed_Value &t_bv, const std::string &t_name){ set_global(t_bv, t_name); }), "set_global");
     }
 
 
@@ -433,65 +221,43 @@ namespace chaiscript
       }
     }
 
+    std::vector<std::string> ensure_minimum_path_vec(std::vector<std::string> paths)
+    {
+      if (paths.empty()) { return {""}; }
+      else { return paths; }
+    }
+
   public:
+
     /// \brief Constructor for ChaiScript
     /// \param[in] t_lib Standard library to apply to this ChaiScript instance
     /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
     /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
-    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_module_paths(std::move(t_modulepaths)), m_use_paths(std::move(t_usepaths))
+    ChaiScript_Basic(const ModulePtr &t_lib,
+                     std::unique_ptr<parser::ChaiScript_Parser_Base> &&parser,
+                     std::vector<std::string> t_module_paths = {},
+                     std::vector<std::string> t_use_paths = {},
+                     const std::vector<chaiscript::Options> &t_opts = chaiscript::default_options())
+      : m_module_paths(ensure_minimum_path_vec(std::move(t_module_paths))),
+        m_use_paths(ensure_minimum_path_vec(std::move(t_use_paths))),
+        m_parser(std::move(parser)),
+        m_engine(*m_parser)
     {
-      if (m_module_paths.empty())
-      {
-        m_module_paths.push_back("");
-      }
-
-      if (m_use_paths.empty())
-      {
-        m_use_paths.push_back("");
-      }
-
-      build_eval_system(t_lib);
-    }
-
-    /// \brief Constructor for ChaiScript.
-    /// 
-    /// This version of the ChaiScript constructor attempts to find the stdlib module to load
-    /// at runtime generates an error if it cannot be found.
-    ///
-    /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
-    /// \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_module_paths(std::move(t_modulepaths)), m_use_paths(std::move(t_usepaths))
-    {
-      if (m_module_paths.empty())
-      {
-        m_module_paths.push_back("");
-      }
-
-      if (m_use_paths.empty())
-      {
-        m_use_paths.push_back("");
-      }
-
-#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
+#if !defined(CHAISCRIPT_NO_DYNLOAD) && defined(_POSIX_VERSION) && !defined(__CYGWIN__)
       // If on Unix, add the path of the current executable to the module search path
       // as windows would do
 
       union cast_union
       {
-        Boxed_Value (ChaiScript::*in_ptr)(const std::string&);
+        Boxed_Value (ChaiScript_Basic::*in_ptr)(const std::string&);
         void *out_ptr;
       };
 
       Dl_info rInfo; 
       memset( &rInfo, 0, sizeof(rInfo) ); 
       cast_union u;
-      u.in_ptr = &ChaiScript::use;
-      if ( dladdr(static_cast<void*>(u.out_ptr), &rInfo) && rInfo.dli_fname ) { 
+      u.in_ptr = &ChaiScript_Basic::use;
+      if ( (dladdr(static_cast<void*>(u.out_ptr), &rInfo) != 0) && (rInfo.dli_fname != nullptr) ) { 
         std::string dllpath(rInfo.dli_fname);
         const size_t lastslash = dllpath.rfind('/');
         if (lastslash != std::string::npos)
@@ -501,44 +267,78 @@ namespace chaiscript
 
         // Let's see if this is a link that we should expand
         std::vector<char> buf(2048);
-        const size_t pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
-        if (pathlen > 0 && pathlen < buf.size())
+        const auto pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
+        if (pathlen > 0 && static_cast<size_t>(pathlen) < buf.size())
         {
-          dllpath = std::string(&buf.front(), pathlen);
+          dllpath = std::string(&buf.front(), static_cast<size_t>(pathlen));
         }
 
         m_module_paths.insert(m_module_paths.begin(), dllpath+"/");
       }
 #endif
+      build_eval_system(t_lib, t_opts);
+    }
 
-
+#ifndef CHAISCRIPT_NO_DYNLOAD
+    /// \brief Constructor for ChaiScript.
+    /// 
+    /// This version of the ChaiScript constructor attempts to find the stdlib module to load
+    /// at runtime generates an error if it cannot be found.
+    ///
+    /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
+    /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
+    explicit ChaiScript_Basic(std::unique_ptr<parser::ChaiScript_Parser_Base> &&parser,
+                     std::vector<std::string> t_module_paths = {},
+                     std::vector<std::string> t_use_paths = {},
+                     const std::vector<chaiscript::Options> &t_opts = chaiscript::default_options())
+      : ChaiScript_Basic({}, std::move(parser), t_module_paths, t_use_paths, t_opts)
+    {
+      try {
         // attempt to load the stdlib
-      load_module("chaiscript_stdlib-" + version());
-
-      build_eval_system(ModulePtr());
+        load_module("chaiscript_stdlib-" + Build_Info::version());
+      } catch (const exception::load_module_error &t_err) {
+        std::cout << "An error occured while trying to load the chaiscript standard library.\n"
+                  << "\n"
+                  << "You must either provide a standard library, or compile it in.\n"
+                  << "For an example of compiling the standard library in,\n"
+                  << "see: https://gist.github.com/lefticus/9456197\n"
+                  << "Compiling the stdlib in is the recommended and MOST SUPPORTED method.\n"
+                  << "\n"
+                  << "\n"
+                  << t_err.what();
+        throw;
       }
+    }
+#else // CHAISCRIPT_NO_DYNLOAD
+explicit ChaiScript_Basic(std::unique_ptr<parser::ChaiScript_Parser_Base> &&parser,
+                          std::vector<std::string> t_module_paths = {},
+                          std::vector<std::string> t_use_paths = {},
+                          const std::vector<chaiscript::Options> &t_opts = chaiscript::default_options()) = delete;
+#endif
 
-    static int version_major()
+    parser::ChaiScript_Parser_Base &get_parser()
     {
-      return chaiscript::version_major;
+      return *m_parser;
     }
 
-    static int version_minor()
+    const Boxed_Value eval(const AST_NodePtr &t_ast)
     {
-      return chaiscript::version_minor;
+      try {
+        return t_ast->eval(chaiscript::detail::Dispatch_State(m_engine));
+      } catch (const exception::eval_error &t_ee) {
+        throw Boxed_Value(t_ee);
+      }
     }
 
-    static int version_patch()
+    AST_NodePtr parse(const std::string &t_input, const bool t_debug_print = false)
     {
-      return chaiscript::version_patch;
+      const auto ast = m_parser->parse(t_input, "PARSE");
+      if (t_debug_print) {
+        m_parser->debug_print(ast);
+      }
+      return ast;
     }
 
-    static std::string version()
-    {
-      std::stringstream ss;
-      ss << version_major() << "." << version_minor() << "." << version_patch();
-      return ss.str();
-    }
 
     std::string get_type_name(const Type_Info &ti) const
     {
@@ -592,8 +392,9 @@ namespace chaiscript
     /// \param[in] t_name Name of the value to add
     /// \throw chaiscript::exception::global_non_const If t_bv is not a constant object
     /// \sa Boxed_Value::is_const
-    ChaiScript &add_global_const(const Boxed_Value &t_bv, const std::string &t_name)
+    ChaiScript_Basic &add_global_const(const Boxed_Value &t_bv, const std::string &t_name)
     {
+      Name_Validator::validate_object_name(t_name);
       m_engine.add_global_const(t_bv, t_name);
       return *this;
     }
@@ -603,12 +404,20 @@ namespace chaiscript
     /// \param[in] t_name Name of the value to add
     /// \warning The user is responsible for making sure the object is thread-safe if necessary
     ///          ChaiScript is thread-safe but provides no threading locking mechanism to the script
-    ChaiScript &add_global(const Boxed_Value &t_bv, const std::string &t_name)
+    ChaiScript_Basic &add_global(const Boxed_Value &t_bv, const std::string &t_name)
     {
+      Name_Validator::validate_object_name(t_name);
       m_engine.add_global(t_bv, t_name);
       return *this;
     }
 
+    ChaiScript_Basic &set_global(const Boxed_Value &t_bv, const std::string &t_name)
+    {
+      Name_Validator::validate_object_name(t_name);
+      m_engine.set_global(t_bv, t_name);
+      return *this;
+    }
+
     /// \brief Represents the current state of the ChaiScript system. State and be saved and restored
     /// \warning State object does not contain the user defined type conversions of the engine. They
     ///          are left out due to performance considerations involved in tracking the state
@@ -702,8 +511,9 @@ namespace chaiscript
     ///
     /// \sa \ref adding_items
     template<typename T>
-    ChaiScript &add(const T &t_t, const std::string &t_name)
+    ChaiScript_Basic &add(const T &t_t, const std::string &t_name)
     {
+      Name_Validator::validate_object_name(t_name);
       m_engine.add(t_t, t_name);
       return *this;
     }
@@ -717,7 +527,7 @@ namespace chaiscript
     /// chaiscript::ChaiScript chai;
     /// chai.add(chaiscript::base_class<std::runtime_error, chaiscript::dispatch_error>());
     /// \endcode
-    ChaiScript &add(const Type_Conversion &d)
+    ChaiScript_Basic &add(const Type_Conversion &d)
     {
       m_engine.add(d);
       return *this;
@@ -726,7 +536,7 @@ namespace chaiscript
     /// \brief Adds all elements of a module to ChaiScript runtime
     /// \param[in] t_p The module to add.
     /// \sa chaiscript::Module
-    ChaiScript &add(const ModulePtr &t_p)
+    ChaiScript_Basic &add(const ModulePtr &t_p)
     {
       t_p->apply(*this, this->get_eval_engine());
       return *this;
@@ -746,9 +556,13 @@ namespace chaiscript
     /// \throw chaiscript::exception::load_module_error In the event that no matching module can be found.
     std::string load_module(const std::string &t_module_name)
     {
+#ifdef CHAISCRIPT_NO_DYNLOAD
+      (void)t_module_name; // -Wunused-parameter
+      throw chaiscript::exception::load_module_error("Loadable module support was disabled (CHAISCRIPT_NO_DYNLOAD)");
+#else
       std::vector<exception::load_module_error> errors;
       std::string version_stripped_name = t_module_name;
-      size_t version_pos = version_stripped_name.find("-"+version());
+      size_t version_pos = version_stripped_name.find("-" + Build_Info::version());
       if (version_pos != std::string::npos)
       {
         version_stripped_name.erase(version_pos);
@@ -778,21 +592,8 @@ namespace chaiscript
         }
       }
 
-      std::string errstring;
-
-      for (std::vector<exception::load_module_error>::const_iterator itr = errors.begin();
-           itr != errors.end();
-           ++itr)
-      {
-        if (!errstring.empty())
-        {
-          errstring += "; ";
-        }
-
-        errstring += itr->what();
-      }
-
-      throw chaiscript::exception::load_module_error("Unable to find module: " + t_module_name + " Errors: " + errstring);
+      throw chaiscript::exception::load_module_error(t_module_name, errors);
+#endif
     }
 
     /// \brief Load a binary module from a dynamic library. Works on platforms that support
@@ -829,14 +630,7 @@ namespace chaiscript
     /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
     Boxed_Value operator()(const std::string &t_script, const Exception_Handler &t_handler = Exception_Handler())
     {
-      try {
-        return do_eval(t_script);
-      } catch (Boxed_Value &bv) {
-        if (t_handler) {
-          t_handler->handle(bv, m_engine);
-        }
-        throw;
-      }
+      return eval(t_script, t_handler);
     }
 
     /// \brief Evaluates a string and returns a typesafe result.
@@ -855,21 +649,14 @@ namespace chaiscript
     template<typename T>
     T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
     {
-      try {
-        return m_engine.boxed_cast<T>(do_eval(t_input, t_filename));
-      } catch (Boxed_Value &bv) {
-        if (t_handler) {
-          t_handler->handle(bv, m_engine);
-        }
-        throw;
-      }
+      return m_engine.boxed_cast<T>(eval(t_input, t_handler, t_filename));
     }
 
     /// \brief casts an object while applying any Dynamic_Conversion available
     template<typename Type>
-      typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv) const
+      decltype(auto) boxed_cast(const Boxed_Value &bv) const
       {
-        return m_engine.boxed_cast<Type>(bv);
+        return(m_engine.boxed_cast<Type>(bv));
       }
  
 
@@ -901,14 +688,7 @@ namespace chaiscript
     /// \return result of the script execution
     /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
     Boxed_Value eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
-      try {
-        return do_eval(load_file(t_filename), t_filename);
-      } catch (Boxed_Value &bv) {
-        if (t_handler) {
-          t_handler->handle(bv, m_engine);
-        }
-        throw;
-      }
+      return eval(load_file(t_filename), t_handler, t_filename);
     }
 
     /// \brief Loads the file specified by filename, evaluates it, and returns the type safe result.
@@ -921,14 +701,7 @@ namespace chaiscript
     ///        to the requested type.
     template<typename T>
     T eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
-      try {
-        return m_engine.boxed_cast<T>(do_eval(load_file(t_filename), t_filename));
-      } catch (Boxed_Value &bv) {
-        if (t_handler) {
-          t_handler->handle(bv, m_engine);
-        }
-        throw;
-      }
+      return m_engine.boxed_cast<T>(eval_file(t_filename, t_handler));
     }
   };
 

include/chaiscript/language/chaiscript_optimizer.hpp

@@ -0,0 +1,427 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_OPTIMIZER_HPP_
+#define CHAISCRIPT_OPTIMIZER_HPP_
+
+#include "chaiscript_eval.hpp"
+
+
+namespace chaiscript {
+  namespace optimizer {
+
+    template<typename ... T>
+      struct Optimizer : T...
+    {
+      Optimizer() = default;
+      explicit Optimizer(T ... t)
+        : T(std::move(t))...
+      {
+      }
+
+      template<typename Tracer>
+      auto optimize(eval::AST_Node_Impl_Ptr<Tracer> p) {
+        (void)std::initializer_list<int>{ (p = static_cast<T&>(*this).optimize(p), 0)... };
+        return p;
+      }
+    };
+
+    template<typename T>
+      auto child_at(const eval::AST_Node_Impl_Ptr<T> &node, const size_t offset) {
+        if (node->children[offset]->identifier == AST_Node_Type::Compiled) {
+          return dynamic_cast<const eval::Compiled_AST_Node<T>&>(*node->children[offset]).m_original_node;
+        } else {
+          return node->children[offset];
+        }
+
+
+        /*
+        if (node->identifier == AST_Node_Type::Compiled) {
+          return dynamic_cast<const eval::Compiled_AST_Node<T>&>(*node).m_original_node->children[offset];
+        } else {
+          return node->children[offset];
+        }
+        */
+      }
+
+    template<typename T>
+      auto child_count(const eval::AST_Node_Impl_Ptr<T> &node) {
+        if (node->identifier == AST_Node_Type::Compiled) {
+          return dynamic_cast<const eval::Compiled_AST_Node<T>&>(*node).m_original_node->children.size();
+        } else {
+          return node->children.size();
+        }
+      }
+
+    template<typename T, typename Callable>
+      auto make_compiled_node(const eval::AST_Node_Impl_Ptr<T> &original_node, std::vector<eval::AST_Node_Impl_Ptr<T>> children, Callable callable)
+      {
+        return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Compiled_AST_Node<T>>(original_node, std::move(children), std::move(callable));
+      }
+
+
+    struct Return {
+      template<typename T>
+      auto optimize(const eval::AST_Node_Impl_Ptr<T> &p)
+      {
+        if ( (p->identifier == AST_Node_Type::Def || p->identifier == AST_Node_Type::Lambda)
+            && !p->children.empty())
+        {
+          auto &last_child = p->children.back();
+          if (last_child->identifier == AST_Node_Type::Block) {
+            auto &block_last_child = last_child->children.back();
+            if (block_last_child->identifier == AST_Node_Type::Return) {
+              if (block_last_child->children.size() == 1) {
+                last_child->children.back() = block_last_child->children[0];
+              }
+            }
+          }
+        }
+
+        return p;
+      }
+    };
+
+    template<typename T>
+    bool contains_var_decl_in_scope(const T &node)
+    {
+      if (node->identifier == AST_Node_Type::Var_Decl) {
+        return true;
+      }
+
+      const auto num = child_count(node);
+
+      for (size_t i = 0; i < num; ++i) {
+        const auto &child = child_at(node, i);
+        if (child->identifier != AST_Node_Type::Block
+            && child->identifier != AST_Node_Type::For
+            && contains_var_decl_in_scope(child)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    struct Block {
+      template<typename T>
+      auto optimize(const eval::AST_Node_Impl_Ptr<T> &node) {
+        if (node->identifier == AST_Node_Type::Block)
+        {
+          if (!contains_var_decl_in_scope(node))
+          {
+            if (node->children.size() == 1) {
+              return node->children[0];
+            } else {
+              return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Scopeless_Block_AST_Node<T>>(node->text, node->location, node->children);
+            }
+          }
+        }
+
+        return node;
+      }
+    };
+
+    struct Dead_Code {
+      template<typename T>
+        auto optimize(const eval::AST_Node_Impl_Ptr<T> &node) {
+          if (node->identifier == AST_Node_Type::Block)
+          {
+            std::vector<size_t> keepers;
+            const auto num_children = node->children.size();
+            keepers.reserve(num_children);
+
+            for (size_t i = 0; i < num_children; ++i) {
+              auto child = node->children[i];
+              if ( (child->identifier != AST_Node_Type::Id
+                    && child->identifier != AST_Node_Type::Constant
+                    && child->identifier != AST_Node_Type::Noop)
+                  || i == num_children - 1) {
+                keepers.push_back(i);
+              }
+            }
+
+            if (keepers.size() == num_children) {
+              return node;
+            } else {
+              std::vector<eval::AST_Node_Impl_Ptr<T>> new_children;
+              for (const auto x : keepers)
+              {
+                new_children.push_back(node->children[x]);
+              }
+              return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Block_AST_Node<T>>(node->text, node->location, new_children);
+            }
+          } else {
+            return node;
+          }
+        }
+    };
+
+    struct Unused_Return {
+      template<typename T>
+        auto optimize(const eval::AST_Node_Impl_Ptr<T> &node) {
+          if ((node->identifier == AST_Node_Type::Block
+              || node->identifier == AST_Node_Type::Scopeless_Block)
+              && !node->children.empty())
+          {
+            for (size_t i = 0; i < node->children.size()-1; ++i) {
+              auto child = node->children[i];
+              if (child->identifier == AST_Node_Type::Fun_Call) {
+                node->children[i] = chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Unused_Return_Fun_Call_AST_Node<T>>(child->text, child->location, std::move(child->children));
+              }
+            }
+          } else if ((node->identifier == AST_Node_Type::For
+                      || node->identifier == AST_Node_Type::While)
+                     && child_count(node) > 0) {
+            auto child = child_at(node, child_count(node) - 1);
+            if (child->identifier == AST_Node_Type::Block
+                || child->identifier == AST_Node_Type::Scopeless_Block)
+            {
+              auto num_sub_children = child_count(child);
+              for (size_t i = 0; i < num_sub_children; ++i) {
+                auto sub_child = child_at(child, i);
+                if (sub_child->identifier == AST_Node_Type::Fun_Call) {
+                  child->children[i] = chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Unused_Return_Fun_Call_AST_Node<T>>(sub_child->text, sub_child->location, std::move(sub_child->children));
+                }
+              }
+            }
+          }
+          return node;
+        }
+    };
+
+    struct If {
+      template<typename T>
+      auto optimize(const eval::AST_Node_Impl_Ptr<T> &node) {
+        if ((node->identifier == AST_Node_Type::If)
+             && node->children.size() >= 2
+             && node->children[0]->identifier == AST_Node_Type::Constant)
+        {
+          const auto condition = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[0])->m_value;
+          if (condition.get_type_info().bare_equal_type_info(typeid(bool))) {
+            if (boxed_cast<bool>(condition)) {
+              return node->children[1];
+            } else if (node->children.size() == 3) {
+              return node->children[2];
+            }
+          }
+        }
+
+        return node;
+      }
+    };
+
+    struct Partial_Fold {
+      template<typename T>
+      auto optimize(const eval::AST_Node_Impl_Ptr<T> &node) {
+
+        // Fold right side
+        if (node->identifier == AST_Node_Type::Binary
+            && node->children.size() == 2
+            && node->children[0]->identifier != AST_Node_Type::Constant
+            && node->children[1]->identifier == AST_Node_Type::Constant)
+        {
+          try {
+            const auto &oper = node->text;
+            const auto parsed = Operators::to_operator(oper);
+            if (parsed != Operators::Opers::invalid) {
+              const auto rhs = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[1])->m_value;
+              if (rhs.get_type_info().is_arithmetic()) {
+                return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Fold_Right_Binary_Operator_AST_Node<T>>(node->text, node->location, node->children, rhs);
+              }
+            }
+          } catch (const std::exception &) {
+            //failure to fold, that's OK
+          }
+        }
+
+        return node;
+      }
+    };
+
+    struct Constant_Fold {
+      template<typename T>
+      auto optimize(const eval::AST_Node_Impl_Ptr<T> &node) {
+
+        if (node->identifier == AST_Node_Type::Prefix
+            && node->children.size() == 1
+            && node->children[0]->identifier == AST_Node_Type::Constant)
+        {
+          try {
+            const auto &oper = node->text;
+            const auto parsed = Operators::to_operator(oper, true);
+            const auto lhs = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[0])->m_value;
+            const auto match = oper + node->children[0]->text;
+
+            if (parsed != Operators::Opers::invalid && parsed != Operators::Opers::bitwise_and && lhs.get_type_info().is_arithmetic()) {
+              const auto val  = Boxed_Number::do_oper(parsed, lhs);
+              return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Constant_AST_Node<T>>(std::move(match), node->location, std::move(val));
+            } else if (lhs.get_type_info().bare_equal_type_info(typeid(bool)) && oper == "!") {
+              return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Constant_AST_Node<T>>(std::move(match), node->location, Boxed_Value(!boxed_cast<bool>(lhs)));
+            }
+          } catch (const std::exception &) {
+            //failure to fold, that's OK
+          }
+        } else if ((node->identifier == AST_Node_Type::Logical_And || node->identifier == AST_Node_Type::Logical_Or)
+            && node->children.size() == 2
+            && node->children[0]->identifier == AST_Node_Type::Constant
+            && node->children[1]->identifier == AST_Node_Type::Constant)
+        {
+          try {
+            const auto lhs = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[0])->m_value;
+            const auto rhs = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[1])->m_value;
+            if (lhs.get_type_info().bare_equal_type_info(typeid(bool)) && rhs.get_type_info().bare_equal_type_info(typeid(bool))) {
+              const auto match = node->children[0]->text + " " + node->text + " " + node->children[1]->text;
+              const auto val = [lhs_val = boxed_cast<bool>(lhs), rhs_val = boxed_cast<bool>(rhs), id = node->identifier] {
+                if (id == AST_Node_Type::Logical_And) { return Boxed_Value(lhs_val && rhs_val); }
+                else { return Boxed_Value(lhs_val || rhs_val); }
+              }();
+
+              return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Constant_AST_Node<T>>(std::move(match), node->location, std::move(val));
+            }
+          } catch (const std::exception &) {
+            //failure to fold, that's OK
+          }
+        } else if (node->identifier == AST_Node_Type::Binary
+            && node->children.size() == 2
+            && node->children[0]->identifier == AST_Node_Type::Constant
+            && node->children[1]->identifier == AST_Node_Type::Constant)
+        {
+          try {
+            const auto &oper = node->text;
+            const auto parsed = Operators::to_operator(oper);
+            if (parsed != Operators::Opers::invalid) {
+              const auto lhs = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[0])->m_value;
+              const auto rhs = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[1])->m_value;
+              if (lhs.get_type_info().is_arithmetic() && rhs.get_type_info().is_arithmetic()) {
+                const auto val  = Boxed_Number::do_oper(parsed, lhs, rhs);
+                const auto match = node->children[0]->text + " " + oper + " " + node->children[1]->text;
+                return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Constant_AST_Node<T>>(std::move(match), node->location, std::move(val));
+              }
+            }
+          } catch (const std::exception &) {
+            //failure to fold, that's OK
+          }
+        } else if (node->identifier == AST_Node_Type::Fun_Call
+                   && node->children.size() == 2
+                   && node->children[0]->identifier == AST_Node_Type::Id
+                   && node->children[1]->identifier == AST_Node_Type::Arg_List
+                   && node->children[1]->children.size() == 1
+                   && node->children[1]->children[0]->identifier == AST_Node_Type::Constant) {
+
+          const auto arg = std::dynamic_pointer_cast<eval::Constant_AST_Node<T>>(node->children[1]->children[0])->m_value;
+          if (arg.get_type_info().is_arithmetic()) {
+            const auto &fun_name = node->children[0]->text;
+
+            const auto make_constant = [&node, &fun_name](auto val){
+              const auto match = fun_name + "(" + node->children[1]->children[0]->text + ")";
+              return chaiscript::make_shared<eval::AST_Node_Impl<T>, eval::Constant_AST_Node<T>>(std::move(match), node->location, Boxed_Value(val));
+            };
+
+            if (fun_name == "double") {
+              return make_constant(Boxed_Number(arg).get_as<double>());
+            } else if (fun_name == "int") {
+              return make_constant(Boxed_Number(arg).get_as<int>());
+            } else if (fun_name == "float") {
+              return make_constant(Boxed_Number(arg).get_as<float>());
+            } else if (fun_name == "long") {
+              return make_constant(Boxed_Number(arg).get_as<long>());
+            } else if (fun_name == "size_t") {
+              return make_constant(Boxed_Number(arg).get_as<size_t>());
+            }
+
+
+          }
+
+        }
+
+        return node;
+      }
+    };
+
+    struct For_Loop {
+      template<typename T>
+      auto optimize(const eval::AST_Node_Impl_Ptr<T> &for_node) {
+
+        if (for_node->identifier != AST_Node_Type::For) {
+          return for_node;
+        }
+
+        const auto eq_node = child_at(for_node, 0);
+        const auto binary_node = child_at(for_node, 1);
+        const auto prefix_node = child_at(for_node, 2);
+
+        if (eq_node->identifier == AST_Node_Type::Equation
+            && child_count(eq_node) == 2
+            && child_at(eq_node, 0)->identifier == AST_Node_Type::Var_Decl
+            && child_at(eq_node, 1)->identifier == AST_Node_Type::Constant
+            && binary_node->identifier == AST_Node_Type::Binary
+            && binary_node->text == "<"
+            && child_count(binary_node) == 2
+            && child_at(binary_node, 0)->identifier == AST_Node_Type::Id
+            && child_at(binary_node, 0)->text == child_at(child_at(eq_node,0), 0)->text
+            && child_at(binary_node, 1)->identifier == AST_Node_Type::Constant
+            && prefix_node->identifier == AST_Node_Type::Prefix
+            && prefix_node->text == "++"
+            && child_count(prefix_node) == 1
+            && child_at(prefix_node, 0)->identifier == AST_Node_Type::Id
+            && child_at(prefix_node, 0)->text == child_at(child_at(eq_node,0), 0)->text)
+        {
+          const Boxed_Value &begin = std::dynamic_pointer_cast<const eval::Constant_AST_Node<T>>(child_at(eq_node, 1))->m_value;
+          const Boxed_Value &end = std::dynamic_pointer_cast<const eval::Constant_AST_Node<T>>(child_at(binary_node, 1))->m_value;
+          const std::string &id = child_at(prefix_node, 0)->text;
+
+          if (begin.get_type_info().bare_equal(user_type<int>()) 
+              && end.get_type_info().bare_equal(user_type<int>())) {
+
+            const auto start_int = boxed_cast<int>(begin);
+            const auto end_int = boxed_cast<int>(end);
+
+            const auto body = child_at(for_node, 3);
+
+            return make_compiled_node(for_node, {body}, 
+                [id, start_int, end_int](const std::vector<eval::AST_Node_Impl_Ptr<T>> &children, const chaiscript::detail::Dispatch_State &t_ss) {
+                  assert(children.size() == 1);
+                  chaiscript::eval::detail::Scope_Push_Pop spp(t_ss);
+
+                  int i = start_int;
+                  t_ss.add_object(id, var(&i));
+
+                  try {
+                    for (; i < end_int; ++i) {
+                      try {
+                        // Body of Loop
+                        children[0]->eval(t_ss);
+                      } catch (eval::detail::Continue_Loop &) {
+                        // we got a continue exception, which means all of the remaining 
+                        // loop implementation is skipped and we just need to continue to
+                        // the next iteration step
+                      }
+                    }
+                  } catch (eval::detail::Break_Loop &) {
+                    // loop broken
+                  }
+
+                  return void_var();
+                }
+            );
+          } else {
+            return for_node;
+          }
+        } else {
+          return for_node;
+        }
+      }
+    };
+
+    typedef Optimizer<optimizer::Partial_Fold, optimizer::Unused_Return, optimizer::Constant_Fold, 
+      optimizer::If, optimizer::Return, optimizer::Dead_Code, optimizer::Block, optimizer::For_Loop> Optimizer_Default; 
+
+  }
+}
+
+
+#endif

include/chaiscript/language/chaiscript_posix.hpp

@@ -0,0 +1,81 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_POSIX_HPP_
+#define CHAISCRIPT_POSIX_HPP_
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    struct Loadable_Module
+    {
+      struct DLModule
+      {
+        explicit DLModule(const std::string &t_filename)
+          : m_data(dlopen(t_filename.c_str(), RTLD_NOW))
+        {
+          if (m_data == nullptr)
+          {
+            throw chaiscript::exception::load_module_error(dlerror());
+          }
+        }
+
+        DLModule(DLModule &&) = default;
+        DLModule &operator=(DLModule &&) = default;
+        DLModule(const DLModule &) = delete;
+        DLModule &operator=(const DLModule &) = delete;
+
+        ~DLModule()
+        {
+          dlclose(m_data);
+        }
+
+        void *m_data;
+      };
+
+      template<typename T>
+        struct DLSym
+        {
+          DLSym(DLModule &t_mod, const std::string &t_symbol)
+            : m_symbol(cast_symbol(dlsym(t_mod.m_data, t_symbol.c_str())))
+          {
+            if (!m_symbol)
+            {
+              throw chaiscript::exception::load_module_error(dlerror());
+            }
+          }
+
+          static T cast_symbol(void *p)
+          {
+            union cast_union
+            {
+              T func_ptr;
+              void *in_ptr;
+            };
+
+            cast_union c;
+            c.in_ptr = p;
+            return c.func_ptr;
+          }
+
+          T m_symbol;
+        };
+
+      Loadable_Module(const std::string &t_module_name, const std::string &t_filename)
+        : m_dlmodule(t_filename), m_func(m_dlmodule, "create_chaiscript_module_" + t_module_name),
+        m_moduleptr(m_func.m_symbol())
+      {
+      }
+
+      DLModule m_dlmodule;
+      DLSym<Create_Module_Func> m_func;
+      ModulePtr m_moduleptr;
+    };
+  }
+}
+#endif
+

include/chaiscript/language/chaiscript_prelude.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// and 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_PRELUDE_HPP_
@@ -9,7 +9,7 @@
 
 namespace chaiscript {
 struct ChaiScript_Prelude { 
-  static std::string chaiscript_prelude() {  return R""(
+  static std::string chaiscript_prelude() {  return R"chaiscript(
 
 def lt(l, r) { 
   if (call_exists(`<`, l, r)) { 
@@ -41,25 +41,25 @@ def new(x) {
 }
 
 def clone(double x) {
-  double(x).copy_var_attrs(x)
+  double(x).clone_var_attrs(x)
 }
 
 def clone(string x) {
-  string(x).copy_var_attrs(x)
+  string(x).clone_var_attrs(x)
 }
 
 def clone(vector x) {
-  vector(x).copy_var_attrs(x)
+  vector(x).clone_var_attrs(x)
 }
 
 
 def clone(int x) {
-  int(x).copy_var_attrs(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);
 }
 
 
@@ -127,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) 
@@ -157,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)
 {
@@ -170,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; 
 
@@ -225,6 +215,29 @@ def for_each(container, func) : call_exists(range, container) {
   } 
 } 
 
+def any_of(container, func) : call_exists(range, container) { 
+  var t_range := range(container); 
+  while (!t_range.empty()) { 
+    if (func(t_range.front())) {
+      return true;
+    }
+    t_range.pop_front(); 
+  }
+  false;
+}
+
+def all_of(container, func) : call_exists(range, container) { 
+  var t_range := range(container); 
+  while (!t_range.empty()) { 
+    if (!func(t_range.front())) {
+      return false;
+    }
+    t_range.pop_front(); 
+  }
+
+  true;
+}
+
 def back_inserter(container) {
   bind(push_back, container, _);
 }
@@ -540,7 +553,7 @@ def find(container, value) {
 } 
 
 
-)"";
+)chaiscript";
 }
 
 };

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -505,7 +505,7 @@ class Function
     /// \endcode
     Vector get_contained_functions() const;
 
-    /// \brief Returns a vector of the contained functions
+    /// \brief Returns a function guard as function
     /// 
     /// Example:
     /// \code
@@ -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/language/chaiscript_tracer.hpp

@@ -0,0 +1,46 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_TRACER_HPP_
+#define CHAISCRIPT_TRACER_HPP_
+
+namespace chaiscript {
+  namespace eval {
+
+
+    struct Noop_Tracer_Detail
+    {
+      template<typename T>
+        void trace(const chaiscript::detail::Dispatch_State &, const AST_Node_Impl<T> *)
+        {
+        }
+    };
+
+    template<typename ... T>
+      struct Tracer : T...
+    {
+      Tracer() = default;
+      explicit Tracer(T ... t)
+        : T(std::move(t))...
+      {
+      }
+
+      void do_trace(const chaiscript::detail::Dispatch_State &ds, const AST_Node_Impl<Tracer<T...>> *node) {
+        (void)std::initializer_list<int>{ (static_cast<T&>(*this).trace(ds, node), 0)... };
+      }
+
+      static void trace(const chaiscript::detail::Dispatch_State &ds, const AST_Node_Impl<Tracer<T...>> *node) {
+        ds->get_parser().get_tracer<Tracer<T...>>().do_trace(ds, node);
+      }
+    };
+
+    typedef Tracer<Noop_Tracer_Detail> Noop_Tracer;
+
+  }
+}
+
+#endif
+

include/chaiscript/language/chaiscript_unknown.hpp

@@ -0,0 +1,31 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_UNKNOWN_HPP_
+#define CHAISCRIPT_UNKNOWN_HPP_
+
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    struct Loadable_Module
+    {
+      Loadable_Module(const std::string &, const std::string &)
+      {
+#ifdef CHAISCRIPT_NO_DYNLOAD
+        throw chaiscript::exception::load_module_error("Loadable module support was disabled (CHAISCRIPT_NO_DYNLOAD)");
+#else
+        throw chaiscript::exception::load_module_error("Loadable module support not available for your platform");
+#endif
+      }
+
+      ModulePtr m_moduleptr;
+    };
+  }
+}
+#endif
+

include/chaiscript/language/chaiscript_windows.hpp

@@ -0,0 +1,133 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_WINDOWS_HPP_
+#define CHAISCRIPT_WINDOWS_HPP_
+
+#include <string>
+
+#ifdef CHAISCRIPT_WINDOWS
+#define VC_EXTRA_LEAN
+#if !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#endif
+
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    struct Loadable_Module
+    {
+      template<typename T>
+        static std::wstring to_wstring(const T &t_str) 
+        {
+          return std::wstring(t_str.begin(), t_str.end());
+        }
+
+      template<typename T>
+        static std::string to_string(const T &t_str)
+        {
+          return std::string(t_str.begin(), t_str.end());
+        }
+
+#if defined(_UNICODE) || defined(UNICODE)
+        template<typename T>
+        static std::wstring to_proper_string(const T &t_str)
+        {
+          return to_wstring(t_str);
+        }
+#else
+      template<typename T>
+        static std::string to_proper_string(const T &t_str)
+        {
+          return to_string(t_str);
+        }
+#endif
+
+      static std::string get_error_message(DWORD t_err)
+      {
+        typedef LPTSTR StringType;
+
+#if defined(_UNICODE) || defined(UNICODE)
+        std::wstring retval = L"Unknown Error";
+#else
+        std::string retval = "Unknown Error";
+#endif
+        StringType lpMsgBuf = nullptr;
+
+        if (FormatMessage(
+            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+            FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+            nullptr,
+            t_err,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+            reinterpret_cast<StringType>(&lpMsgBuf),
+            0, nullptr ) != 0 && lpMsgBuf)
+        {
+          retval = lpMsgBuf;
+          LocalFree(lpMsgBuf);
+        }
+
+        return to_string(retval);
+      }
+
+      struct DLModule
+      {
+        explicit DLModule(const std::string &t_filename)
+          : m_data(LoadLibrary(to_proper_string(t_filename).c_str()))
+        {
+          if (!m_data)
+          {
+            throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
+          }
+        }
+
+        DLModule(DLModule &&) = default;
+        DLModule &operator=(DLModule &&) = default;
+        DLModule(const DLModule &) = delete;
+        DLModule &operator=(const DLModule &) = delete;
+
+        ~DLModule()
+        {
+          FreeLibrary(m_data);
+        }
+
+        HMODULE m_data;
+      };
+
+      template<typename T>
+        struct DLSym
+        {
+          DLSym(DLModule &t_mod, const std::string &t_symbol)
+            : m_symbol(reinterpret_cast<T>(GetProcAddress(t_mod.m_data, t_symbol.c_str())))
+          {
+            if (!m_symbol)
+            {
+              throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
+            }
+          }
+
+          T m_symbol;
+        };
+
+      Loadable_Module(const std::string &t_module_name, const std::string &t_filename)
+        : m_dlmodule(t_filename), m_func(m_dlmodule, "create_chaiscript_module_" + t_module_name),
+        m_moduleptr(m_func.m_symbol())
+      {
+      }
+
+      DLModule m_dlmodule;
+      DLSym<Create_Module_Func> m_func;
+      ModulePtr m_moduleptr;
+    };
+  }
+}
+#endif 
+

include/chaiscript/utility/fnv1a.hpp

@@ -0,0 +1,50 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_UTILITY_FNV1A_HPP_
+#define CHAISCRIPT_UTILITY_FNV1A_HPP_
+
+
+#include <cstdint>
+#include "../chaiscript_defines.hpp"
+
+
+namespace chaiscript
+{
+
+
+  namespace utility
+  {
+
+
+    static constexpr std::uint32_t fnv1a_32(const char *s, std::uint32_t h = 0x811c9dc5) {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4307)
+#endif
+      return (*s == 0) ? h : fnv1a_32(s+1, ((h ^ (*s)) * 0x01000193));
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    }
+
+
+  }
+
+
+}
+
+#endif

include/chaiscript/utility/json.hpp

@@ -0,0 +1,674 @@
+// 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 <vector>
+#include <map>
+#include <type_traits>
+#include <initializer_list>
+#include <ostream>
+#include <iostream>
+#include "../chaiscript_defines.hpp"
+
+namespace json {
+
+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;
+
+
+
+
+class JSON
+{
+  public:
+    enum class Class {
+      Null,
+      Object,
+      Array,
+      String,
+      Floating,
+      Integral,
+      Boolean
+    };
+
+  private:
+
+    struct QuickFlatMap
+    {
+      auto find(const std::string &s) {
+        return std::find_if(std::begin(data), std::end(data), [&s](const auto &d) { return d.first == s; });
+      }
+
+      auto find(const std::string &s) const {
+        return std::find_if(std::begin(data), std::end(data), [&s](const auto &d) { return d.first == s; });
+      }
+
+      auto size() const {
+        return data.size();
+      }
+
+      auto begin() const {
+        return data.begin();
+      }
+
+      auto end() const {
+        return data.end();
+      }
+
+
+      auto begin() {
+        return data.begin();
+      }
+
+      auto end() {
+        return data.end();
+      }
+
+
+      JSON &operator[](const std::string &s) {
+        const auto itr = find(s);
+        if (itr != data.end()) {
+          return itr->second;
+        } else {
+          data.emplace_back(s, JSON());
+          return data.back().second;
+        }
+      }
+
+      JSON &at(const std::string &s) {
+        const auto itr = find(s);
+        if (itr != data.end()) {
+          return itr->second;
+        } else {
+          throw std::out_of_range("Unknown key: " + s);
+        }
+      }
+
+      const JSON &at(const std::string &s) const {
+        const auto itr = find(s);
+        if (itr != data.end()) {
+          return itr->second;
+        } else {
+          throw std::out_of_range("Unknown key: " + s);
+        }
+      }
+
+      size_t count(const std::string &s) const {
+        return (find(s) != data.end())?1:0;
+      }
+
+      std::vector<std::pair<std::string, JSON>> data;
+
+      using iterator = decltype(data)::iterator;
+      using const_iterator = decltype(data)::const_iterator;
+
+
+    };
+
+    struct Internal {
+      template<typename T>
+        auto clone(const std::unique_ptr<T> &ptr) {
+          if (ptr != nullptr) {
+            return std::make_unique<T>(*ptr);
+          } else {
+            return std::unique_ptr<T>(nullptr);
+          }
+        }
+
+      Internal( double d ) : Float( d ), Type(Class::Floating) {}
+      Internal( long   l ) : Int( l ), Type(Class::Integral) {}
+      Internal( bool   b ) : Bool( b ), Type(Class::Boolean) {}
+      Internal( std::string s ) : String(std::make_unique<std::string>(std::move(s))), Type(Class::String) {}
+      Internal()           : Type(Class::Null) {}
+
+      Internal(Class t_type) {
+        set_type(t_type);
+      }
+
+      Internal(const Internal &other)
+        : List(clone(other.List)),
+        Map(clone(other.Map)),
+        String(clone(other.String)),
+        Float(other.Float),
+        Int(other.Int),
+        Bool(other.Bool),
+        Type(other.Type)
+      {
+      }
+
+      Internal &operator=(const Internal &other)
+      {
+        List = clone(other.List);
+        Map = clone(other.Map);
+        String = clone(other.String);
+        Float = other.Float;
+        Int = other.Int;
+        Bool = other.Bool;
+        Type = other.Type;
+        return *this;
+      }
+
+      void set_type( Class type ) {
+        if( type == Type ) {
+          return;
+        }
+
+        Map.reset();
+        List.reset();
+        String.reset();
+
+        switch( type ) {
+          case Class::Object:    Map    = std::make_unique<QuickFlatMap>(); break;
+          case Class::Array:     List   = std::make_unique<std::vector<JSON>>();      break;
+          case Class::String:    String = std::make_unique<std::string>();           break;
+          case Class::Floating:  Float  = 0.0;                    break;
+          case Class::Integral:  Int    = 0;                      break;
+          case Class::Boolean:   Bool   = false;                  break;
+          case Class::Null:      break;
+        }
+
+        Type = type;
+      }
+
+      Internal(Internal &&) = default;
+      Internal &operator=(Internal &&) = default;
+
+      std::unique_ptr<std::vector<JSON>>      List;
+      std::unique_ptr<QuickFlatMap> Map;
+      std::unique_ptr<std::string>           String;
+      double              Float = 0;
+      long                Int = 0;
+      bool                Bool = false;
+
+      Class Type = Class::Null;
+    };
+
+    Internal internal;
+
+  public:
+
+    template <typename Container>
+      class JSONWrapper {
+        Container *object = nullptr;
+
+        public:
+        JSONWrapper( Container *val ) : object( val ) {}
+        JSONWrapper( std::nullptr_t ) {}
+
+        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 = nullptr;
+
+        public:
+        JSONConstWrapper( const Container *val ) : object( val ) {}
+        JSONConstWrapper( std::nullptr_t ) {}
+
+        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() = default;
+    JSON( std::nullptr_t ) {} 
+
+    explicit JSON(Class type)
+      : internal(type)
+    {
+    }
+
+    JSON( initializer_list<JSON> list ) 
+      : internal(Class::Object)
+    {
+      for( auto i = list.begin(), e = list.end(); i != e; ++i, ++i ) {
+        operator[]( i->to_string() ) = *std::next( i );
+      }
+    }
+
+    template <typename T>
+      explicit JSON( T b, typename enable_if<is_same<T,bool>::value>::type* = nullptr ) : internal( static_cast<bool>(b) ) {}
+
+    template <typename T>
+      explicit JSON( T i, typename enable_if<is_integral<T>::value && !is_same<T,bool>::value>::type* = nullptr ) : internal( static_cast<long>(i) ) {}
+
+    template <typename T>
+      explicit JSON( T f, typename enable_if<is_floating_point<T>::value>::type* = nullptr ) : internal( static_cast<double>(f) ) {}
+
+    template <typename T>
+      explicit JSON( T s, typename enable_if<is_convertible<T,std::string>::value>::type* = nullptr ) : internal( static_cast<std::string>(s) ) {}
+
+
+
+    static JSON Load( const std::string & );
+
+    JSON& operator[]( const std::string &key ) {
+      internal.set_type( Class::Object ); 
+      return internal.Map->operator[]( key );
+    }
+
+    JSON& operator[]( const size_t index ) {
+      internal.set_type( Class::Array );
+      if( index >= internal.List->size() ) {
+        internal.List->resize( index + 1 );
+      }
+
+      return internal.List->operator[]( index );
+    }
+
+
+    JSON &at( const std::string &key ) {
+      return operator[]( key );
+    }
+
+    const JSON &at( const std::string &key ) const {
+      return internal.Map->at( key );
+    }
+
+    JSON &at( size_t index ) {
+      return operator[]( index );
+    }
+
+    const JSON &at( size_t index ) const {
+      return internal.List->at( index );
+    }
+
+
+    long length() const {
+      if( internal.Type == Class::Array ) {
+        return static_cast<long>(internal.List->size());
+      } else {
+        return -1;
+      }
+    }
+
+    bool has_key( const std::string &key ) const {
+      if( internal.Type == Class::Object ) {
+        return internal.Map->count(key) != 0;
+      }
+
+      return false;
+    }
+
+    int size() const {
+      if( internal.Type == Class::Object ) {
+        return static_cast<int>(internal.Map->size());
+      } else if( internal.Type == Class::Array ) {
+        return static_cast<int>(internal.List->size());
+      } else {
+        return -1;
+      }
+    }
+
+    Class JSONType() const { return internal.Type; }
+
+    /// Functions for getting primitives from the JSON object.
+    bool is_null() const { return internal.Type == Class::Null; }
+
+    std::string to_string() const { bool b; return to_string( b ); }
+    std::string to_string( bool &ok ) const {
+      ok = (internal.Type == Class::String);
+      return ok ? *internal.String : std::string("");
+    }
+
+    double to_float() const { bool b; return to_float( b ); }
+    double to_float( bool &ok ) const {
+      ok = (internal.Type == Class::Floating);
+      return ok ? internal.Float : 0.0;
+    }
+
+    long to_int() const { bool b; return to_int( b ); }
+    long to_int( bool &ok ) const {
+      ok = (internal.Type == Class::Integral);
+      return ok ? internal.Int : 0;
+    }
+
+    bool to_bool() const { bool b; return to_bool( b ); }
+    bool to_bool( bool &ok ) const {
+      ok = (internal.Type == Class::Boolean);
+      return ok ? internal.Bool : false;
+    }
+
+    JSONWrapper<QuickFlatMap> object_range() {
+      if( internal.Type == Class::Object ) {
+        return JSONWrapper<QuickFlatMap>( internal.Map.get() );
+      } else {
+        return JSONWrapper<QuickFlatMap>( nullptr );
+      }
+    }
+
+    JSONWrapper<std::vector<JSON>> array_range() {
+      if( internal.Type == Class::Array ) {
+        return JSONWrapper<std::vector<JSON>>( internal.List.get() );
+      } else {
+        return JSONWrapper<std::vector<JSON>>( nullptr );
+      }
+    }
+
+    JSONConstWrapper<QuickFlatMap> object_range() const {
+      if( internal.Type == Class::Object ) {
+        return JSONConstWrapper<QuickFlatMap>( internal.Map.get() );
+      } else {
+        return JSONConstWrapper<QuickFlatMap>( nullptr );
+      }
+    }
+
+
+    JSONConstWrapper<std::vector<JSON>> array_range() const { 
+      if( internal.Type == Class::Array ) {
+        return JSONConstWrapper<std::vector<JSON>>( internal.List.get() );
+      } else {
+        return JSONConstWrapper<std::vector<JSON>>( nullptr );
+      }
+    }
+
+    std::string dump( long depth = 1, std::string tab = "  ") const {
+      switch( internal.Type ) {
+        case Class::Null:
+          return "null";
+        case Class::Object: {
+                              std::string pad = "";
+                              for( long i = 0; i < depth; ++i, pad += tab ) { }
+
+                              std::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: {
+                             std::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");
+    }
+
+
+  private:
+    static std::string json_escape( const std::string &str ) {
+      std::string output;
+      for(char i : str) {
+        switch( 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 += i; break;
+        }
+}
+      return output;
+    }
+
+
+  private:
+};
+
+
+struct JSONParser {
+  static bool isspace(const char c)
+  {
+#ifdef CHAISCRIPT_MSVC
+    // MSVC warns on these line in some circumstances
+#pragma warning(push)
+#pragma warning(disable : 6330)
+#endif
+    return ::isspace(c) != 0;
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif
+
+
+  }
+
+  static void consume_ws( const std::string &str, size_t &offset ) {
+    while( isspace( str[offset] ) && offset <= str.size() ) { ++offset; }
+  }
+
+  static JSON parse_object( const std::string &str, size_t &offset ) {
+    JSON Object( 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.to_string()] = 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;
+  }
+
+  static JSON parse_array( const std::string &str, size_t &offset ) {
+    JSON Array( JSON::Class::Array );
+    size_t 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;
+  }
+
+  static JSON parse_string( const std::string &str, size_t &offset ) {
+    std::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( size_t 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);
+  }
+
+  static JSON parse_number( const std::string &str, size_t &offset ) {
+    std::string val, exp_str;
+    char c = '\0';
+    bool isDouble = false;
+    bool isNegative = false;
+    long exp = 0;
+    if( offset < str.size() && str[offset] == '-' ) {
+      isNegative = true;
+      ++offset;
+    }
+    for (; offset < str.size() ;) {
+      c = str[offset++];
+      if( c >= '0' && c <= '9' ) {
+        val += c;
+      } else if( c == '.' && !isDouble ) {
+        val += c; 
+        isDouble = true;
+      } else {
+        break;
+      }
+    }
+    if( offset < str.size() && (c == 'E' || c == 'e' )) {
+      c = str[ offset++ ];
+      if( c == '-' ) { 
+        exp_str += '-';
+      } else if( c == '+' ) {
+        // do nothing
+      } 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 = chaiscript::parse_num<long>( 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 ) {
+      return JSON((isNegative?-1:1) * chaiscript::parse_num<double>( val ) * std::pow( 10, exp ));
+    } else {
+      if( !exp_str.empty() ) {
+        return JSON((isNegative?-1:1) * static_cast<double>(chaiscript::parse_num<long>( val )) * std::pow( 10, exp ));
+      } else {
+        return JSON((isNegative?-1:1) * chaiscript::parse_num<long>( val ));
+      }
+    }
+  }
+
+  static JSON parse_bool( const std::string &str, size_t &offset ) {
+    if( str.substr( offset, 4 ) == "true" ) {
+      offset += 4;
+      return JSON(true);
+    } else if( str.substr( offset, 5 ) == "false" ) {
+      offset += 5;
+      return JSON(false);
+    } else {
+      throw std::runtime_error(std::string("JSON ERROR: Bool: Expected 'true' or 'false', found '") + str.substr( offset, 5 ) + "'");
+    }
+  }
+
+  static JSON parse_null( const std::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();
+  }
+
+  static JSON parse_next( const std::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 + "'");
+  }
+
+};
+
+inline JSON JSON::Load( const std::string &str ) {
+  size_t offset = 0;
+  return JSONParser::parse_next( str, offset );
+}
+
+} // End Namespace json
+
+
+#endif 

include/chaiscript/utility/json_wrap.hpp

@@ -0,0 +1,150 @@
+#ifndef CHAISCRIPT_SIMPLEJSON_WRAP_HPP
+#define CHAISCRIPT_SIMPLEJSON_WRAP_HPP
+
+#include "json.hpp"
+
+namespace chaiscript
+{
+  class json_wrap
+  {
+    public:
+
+      static Module& library(Module& m)
+      {
+
+        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.object_range())
+              {
+                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.array_range()) 
+              {
+                vec.emplace_back(from_json(p));
+              }
+
+              return Boxed_Value(vec);
+            }
+          case json::JSON::Class::String:
+            return Boxed_Value(t_json.to_string());
+          case json::JSON::Class::Floating:
+            return Boxed_Value(t_json.to_float());
+          case json::JSON::Class::Integral:
+            return Boxed_Value(t_json.to_int());
+          case json::JSON::Class::Boolean:
+            return Boxed_Value(t_json.to_bool());
+        }
+
+        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);
+          if (Boxed_Number::is_floating_point(t_bv))
+          {
+            return json::JSON(bn.get_as<double>());
+          } else {
+            return json::JSON(bn.get_as<long>());
+          }
+        } catch (const chaiscript::detail::exception::bad_any_cast &) {
+          // not a number
+        }
+
+        try {
+          return json::JSON(boxed_cast<bool>(t_bv));
+        } catch (const chaiscript::exception::bad_boxed_cast &) {
+          // not a bool
+        }
+
+        try {
+          return json::JSON(boxed_cast<std::string>(t_bv));
+        } 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/static_string.hpp

@@ -0,0 +1,37 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_UTILITY_STATIC_STRING_HPP_
+#define CHAISCRIPT_UTILITY_STATIC_STRING_HPP_
+
+namespace chaiscript
+{
+  namespace utility
+  {
+
+    struct Static_String
+    {
+      template<size_t N>
+        constexpr Static_String(const char (&str)[N])
+        : m_size(N-1), data(&str[0])
+        {
+        }
+
+      constexpr size_t size() const {
+        return m_size;
+      }
+
+      constexpr const char *c_str() const {
+        return data;
+      }
+
+      const size_t m_size;
+      const char *data = nullptr;
+    };
+  }
+}
+
+#endif

include/chaiscript/utility/utility.hpp

@@ -1,19 +1,24 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #ifndef CHAISCRIPT_UTILITY_UTILITY_HPP_
 #define CHAISCRIPT_UTILITY_UTILITY_HPP_
 
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
-#include "../chaiscript.hpp"
-#include "../dispatchkit/proxy_functions.hpp"
-#include "../dispatchkit/type_info.hpp"
+#include "../language/chaiscript_common.hpp"
+#include "../dispatchkit/register_function.hpp"
+#include "../dispatchkit/operators.hpp"
 
 
 namespace chaiscript 
@@ -62,6 +67,55 @@ namespace chaiscript
           t_module.add(fun.first, fun.second);
         }
       }
+
+    template<typename Enum, typename ModuleType>
+      typename std::enable_if<std::is_enum<Enum>::value, void>::type
+      add_class(ModuleType &t_module,
+        const std::string &t_class_name,
+        const std::vector<std::pair<typename std::underlying_type<Enum>::type, std::string>> &t_constants
+        )
+      {
+        t_module.add(chaiscript::user_type<Enum>(), t_class_name);
+
+        t_module.add(chaiscript::constructor<Enum ()>(), t_class_name);
+        t_module.add(chaiscript::constructor<Enum (const Enum &)>(), t_class_name);
+
+        using namespace chaiscript::bootstrap::operators;
+        equal<Enum>(t_module);
+        not_equal<Enum>(t_module);
+        assign<Enum>(t_module);
+
+        t_module.add(chaiscript::fun([](const Enum &e, const int &i) { return e == i; }), "==");
+        t_module.add(chaiscript::fun([](const int &i, const Enum &e) { return i == e; }), "==");
+
+        for (const auto &constant : t_constants)
+        {
+          t_module.add_global_const(chaiscript::const_var(Enum(constant.first)), constant.second);
+        }
+      }
+
+    template<typename EnumClass, typename ModuleType>
+      typename std::enable_if<std::is_enum<EnumClass>::value, void>::type
+      add_class(ModuleType &t_module,
+        const std::string &t_class_name,
+        const std::vector<std::pair<EnumClass, std::string>> &t_constants
+        )
+      {
+        t_module.add(chaiscript::user_type<EnumClass>(), t_class_name);
+
+        t_module.add(chaiscript::constructor<EnumClass()>(), t_class_name);
+        t_module.add(chaiscript::constructor<EnumClass(const EnumClass &)>(), t_class_name);
+
+        using namespace chaiscript::bootstrap::operators;
+        equal<EnumClass>(t_module);
+        not_equal<EnumClass>(t_module);
+        assign<EnumClass>(t_module);
+
+        for (const auto &constant : t_constants)
+        {
+          t_module.add_global_const(chaiscript::const_var(EnumClass(constant.first)), constant.second);
+        }
+      }
   }
 }
 

license.txt

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

performance_tests/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";
+}

performance_tests/profile_cpp_calls_2.cpp

@@ -0,0 +1,20 @@
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+
+double f(const std::string &, double, bool) noexcept {
+  return .0;
+}
+
+int main()
+{
+  chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
+
+  chai.add(chaiscript::fun(&f), "f");
+
+  chai.eval(R"(
+      for (var i = 0; i < 100000; ++i) {
+        f("str", 1.2, false);
+      }
+    )");
+
+}

performance_tests/profile_fun_wrappers.cpp

@@ -0,0 +1,20 @@
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+
+double f(const std::string &, double, bool) noexcept {
+  return .0;
+}
+
+int main()
+{
+  chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
+
+  chai.add(chaiscript::fun(&f), "f");
+
+  const auto f = chai.eval<std::function<void ()>>(R"(fun(){ f("str", 1.2, false); })");
+
+  for (int i = 0; i < 100000; ++i) {
+    f();
+  }
+
+}

readme.md

@@ -1,14 +1,23 @@
-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)
+<a href="https://www.patreon.com/bePatron?u=2977989&redirect_uri=https%3A%2F%2Fwww.patreon.com%2Flefticus">
+    <img height="40" width="204" src="https://s3-us-west-1.amazonaws.com/widget-images/become-patron-widget-medium%402x.png">
+</a>
 
-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)
 
+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: [![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
 
 http://www.chaiscript.com
 
 (c) 2009-2012 Jonathan Turner
-(c) 2009-2015 Jason Turner
+(c) 2009-2017 Jason Turner
 
 Release under the BSD license, see "license.txt" for details.
 
@@ -34,10 +43,9 @@ languages:
 Requirements
 ============
 
-ChaiScript requires a C++11 compiler to build with support for variadic 
-templates.  It has been tested with gcc 4.6 and clang 3.1 (with libcxx). MacOS 
-10.8 (Mountain Lion) is also known to support the C++11 build with Apple's 
-clang 4.0. MSVC 2013 or newer is supports also. For more information see the build 
+ChaiScript requires a C++14 compiler to build with support for variadic 
+templates.  It has been tested with gcc 4.9 and clang 3.6 (with libcxx). 
+For more information see the build 
 [dashboard](http://chaiscript.com/ChaiScript-BuildResults/index.html).
 
 Usage
@@ -71,7 +79,7 @@ directory, and for more in-depth look at the language, the unit tests in the
 "unittests" directory cover the most ground.
 
 For examples of how to register parts of your C++ application, see 
-"example.cpp" in the "src" directory. Example.cpp is verbose and shows every 
+"example.cpp" in the "samples" directory. Example.cpp is verbose and shows every 
 possible way of working with the library. For further documentation generate 
 the doxygen documentation in the build folder or see the website 
 http://www.chaiscript.com.
@@ -79,6 +87,7 @@ http://www.chaiscript.com.
 
 The shortest complete example possible follows:
 
+```C++
 /// main.cpp
 
 #include <chaiscript/chaiscript.hpp>
@@ -95,28 +104,4 @@ The shortest complete example possible follows:
 
   double d = chai.eval<double>("function(3, 4.75);");
 }
-
-
-
-Or, if you want to compile the std lib into your code, which reduces
-runtime requirements.
-
-    /// main.cpp
-
-    #include <chaiscript/chaiscript.hpp>
-    #include <chaiscript/chaiscript_stdlib.hpp>
-
-    double function(int i, double j)
-    {
-      return i * j;
-    }
-
-    int main()
-    {
-      chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
-      chai.add(chaiscript::fun(&function), "function");
-
-      double d = chai.eval<double>("function(3, 4.75);");
-    }
-
-
+```

releasenotes.md

@@ -1,6 +1,126 @@
 Notes:
 =======
-Current Version: 5.7.0
+Current Version: 6.0.0
+
+### Changes since 5.8.6
+
+*6.0.0 is a massive rework compared to 5.x. It now requires a C++14 enabled compiler*
+
+#### Compiler Requirements
+
+* MSVC 2015 or greater
+* g++ 4.9 or greater
+* clang 3.6 or greater
+
+#### Breaking Changes
+
+* Instantiating a ChaiScript object now, by default, builds the stdlib in
+  * This was done to address the most common support issues of loading stdlib dynamically at runtime
+  * If you want the old behavior, use include/chaiscript/chaiscript_basic.hpp
+* Headers have been reorganized to fully separate stdlib/parser/engine from each other (some faster builds)
+* Bootstrap functions no longer return a reference to the module added to (compile time savings)
+* It's now no longer possible modify AST_Nodes (compile time, runtime efficiency)
+* Function annotations no longer exist (simplifies code, reduces compile time, compile size)
+
+#### New Features Added
+
+* Modular optimization system; this can be accessed via the ChaiScript_Basic interface
+* Execution tracing capability; also accessed via ChaiScript_Basic interface
+* range-based for loops `for( id : container ) { }` (much better performance than other loop types)
+* If-init expressions (ala C++17)
+* Support for passing r-value references to functions
+* Support for containing unique_ptr
+* Add helpers for exposing enum classes to ChaiScript
+* Allow typed ChaiScript defined functions to perform conversions on call #303
+
+#### Improvements
+
+* Compile time improvements
+* Compile size improvements
+* Significant runtime improvements (see "Modular optimization system")
+* Significant parser improvements, both with parse-time and parser initialization time (Thanks @niXman)
+* Fix type conversion to bool in conditionals
+
+#### Improvements Still Need To Be Made
+
+* File location tracking has been rewritten; this currently means error location reporting is not as good as it was
+* Tracing capability needs to be tested and vetted
+
+### Changes since 5.8.5
+* Optimize away `return` statements in lambdas also
+* Allow conversions to bool in conditionals
+* Don't allow `class` statements inside of scopes
+* Properly error when a dynamic object non-function member is called
+
+### Changes since 5.8.4
+* Fix order of operations for prefix operators
+* Make sure atomics are initialized properly
+* Remove parsing of unused prefix `&` operator
+
+### Changes since 5.8.3
+* Fix case with some numeric conversions mixed with numerics that do not need conversion
+
+### Changes since 5.8.2
+* Add support for reference of pointer return types
+
+### Changes since 5.8.1
+* Allow casting to non-const & std::shared_ptr<T>
+
+
+### Changes since 5.8.0
+* Fix parsing of floats to be locale independent #250
+* Various warning fixes on various platforms
+
+
+### Changes since 5.7.1
+* Make all parser iterator operations range checked
+* Parse in-string eval statements once, not once for each execution
+* Fix parsing of operators (ie 1<-1 now parses)
+* Fix variable scoping for functors
+* Exception reduction
+* Various object lifetime fixes
+* Add JSON support for load / save #207
+* Numeric overload resolution fixes #209 
+* Fix long long #208 
+* Add octal escapes in strings #211
+* Fixed sizing of binary literals #213
+* Added support for != with bool values #217
+* Various value assignment vector fixes 
+* Fixed broken hex escape sequences from @ChristianKaeser
+* Multiply defined symbols fixes #232 @RaptorFactor
+* Add add_class<Enum> helper #233  @vrennert
+* Cheatsheet fixes #235 @mlamby
+* Fix parsing of strings inside of in-string eval statements
+* Allow lower-case global keyword
+* Enable thread-local on MSVC (should be significant performance boost)
+
+
+### 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
 

samples/example.cpp

@@ -73,7 +73,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
 
   //Create a new system object and share it with the chaiscript engine
   System system;
-  chai.add(var(&system), "system");
+  chai.add_global(var(&system), "system");
 
   //Add a bound callback method
   chai.add(fun(&System::add_callback, std::ref(system)), "add_callback_bound");
@@ -108,9 +108,9 @@ int main(int /*argc*/, char * /*argv*/[]) {
   // A shortcut to using eval is just to use the chai operator()
   chai("log(\"Test Module\", \"Test Message\");");
 
-  //Finally, it is possible to register any std::function as a system function, in this 
+  //Finally, it is possible to register a lambda as a system function, in this 
   //way, we can, for instance add a bound member function to the system
-  chai.add(fun(&System::do_callbacks, std::ref(system), std::string("Bound Test")), "do_callbacks");
+  chai.add(fun([&system](){ return system.do_callbacks("Bound Test"); }), "do_callbacks");
 
   //Call bound version of do_callbacks
   chai("do_callbacks()");

samples/factory.cpp

@@ -0,0 +1,102 @@
+#include <chaiscript/chaiscript.hpp>
+
+class Entity
+{
+  public:
+    int width;
+    int height;
+    int x;
+    int y;
+    std::string name;
+
+    std::function<void (Entity &)> updater;
+
+    Entity(const int t_width, const int t_height, const int t_x, const int t_y, std::string t_name)
+      : width(t_width), height(t_height), x(t_x), y(t_y), name(std::move(t_name))
+    {
+    }
+};
+
+class Factory
+{
+  public:
+    // we may as well pass the parameters for the entity to the factory method, this does the initialization
+    // in one step.
+    Entity *make_entity(const int width, const int height, const int x, const int y, const std::string &name)
+    {
+      auto entity = entities.insert({name, Entity{width, height, x, y, name}});
+      return &(entity.first->second);
+    }
+
+    Entity *get_entity(const std::string &name)
+    {
+      return &entities.at(name);
+    }
+
+
+    // loop over all entities and all their updater function (if it exists)
+    void update_entities()
+    {
+      for (auto &entity : entities)
+      {
+        if (entity.second.updater) {
+          entity.second.updater(entity.second);
+        }
+      }
+    }
+
+
+  private:
+    // we cannot store the entities in a std::vector if we want to return a pointer to them,
+    // because a vector automatically resizing itself can invalidate the pointer that was returned.
+    // using a map guarantees that the memory assigned to the entity will never change, plus
+    // lets us easily look up an entity by name
+    std::map<std::string, Entity> entities;
+};
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+
+  chai.add(chaiscript::fun(&Entity::width), "width");
+  chai.add(chaiscript::fun(&Entity::height), "height");
+  chai.add(chaiscript::fun(&Entity::x), "x");
+  chai.add(chaiscript::fun(&Entity::y), "y");
+  chai.add(chaiscript::fun(&Entity::name), "name");
+  chai.add(chaiscript::fun(&Entity::updater), "updater");
+  chai.add(chaiscript::user_type<Entity>(), "Entity"); // this isn't strictly necessary but makes error messages nicer
+
+  chai.add(chaiscript::fun(&Factory::make_entity), "make_entity");
+  chai.add(chaiscript::fun(&Factory::get_entity), "get_entity");
+  chai.add(chaiscript::fun(&Factory::update_entities), "update_entities");
+  chai.add(chaiscript::user_type<Factory>(), "Factory"); // this isn't strictly necessary but makes error messages nicer
+
+
+  Factory f;
+  chai.add(chaiscript::var(&f), "f");
+
+  std::string script = R""(
+    f.make_entity(10,10,1,1,"entity1").updater = fun(e){ e.x += 1; e.y += 1 };
+    f.make_entity(10,10,10,10,"entity2").updater = fun(e){ e.x += 2; e.y += 2 };
+    f.make_entity(10,10,20,20,"entity3");
+
+    print(f.get_entity("entity1").x == 1)
+    print(f.get_entity("entity2").x == 10)
+    print(f.get_entity("entity3").x == 20)
+
+    f.update_entities(); // this runs the function objects we set in the previous lines
+    // we should now see the updated values
+
+    print(f.get_entity("entity1").x == 2)
+    print(f.get_entity("entity2").x == 12)
+    print(f.get_entity("entity3").x == 20) // this one has no updater, so it stays the same
+    )"";
+
+
+  chai.eval(script);
+
+
+
+}
+
+

samples/fun_call_performance.cpp

@@ -1,9 +1,13 @@
 // 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)
+// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
+// This is an open source non-commercial project. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+
 #include <iostream>
 #include <list>
 #include <regex>
@@ -13,7 +17,6 @@
 #endif
 
 #include <chaiscript/chaiscript.hpp>
-#include <chaiscript/chaiscript_stdlib.hpp>
 
 #ifdef READLINE_AVAILABLE
 #include <readline/readline.h>
@@ -65,6 +68,7 @@ std::vector<std::string> default_search_paths()
 {
   std::vector<std::string> paths;
 
+#ifndef CHAISCRIPT_NO_DYNLOAD
 #ifdef CHAISCRIPT_WINDOWS  // force no unicode
   CHAR path[4096];
   int size = GetModuleFileNameA(0, path, sizeof(path) - 1);
@@ -89,24 +93,24 @@ std::vector<std::string> default_search_paths()
   std::vector<char> buf(2048);
   ssize_t size = -1;
 
-  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) > 0)
   {
-    exepath = std::string(&buf.front(), size);
+    exepath = std::string(&buf.front(), static_cast<size_t>(size));
   }
 
   if (exepath.empty())
   {
-    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) > 0)
     {
-      exepath = std::string(&buf.front(), size);
+      exepath = std::string(&buf.front(), static_cast<size_t>(size));
     }
   }
 
   if (exepath.empty())
   {
-    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) > 0)
     {
-      exepath = std::string(&buf.front(), size);
+      exepath = std::string(&buf.front(), static_cast<size_t>(size));
     }
   }
 
@@ -134,6 +138,7 @@ std::vector<std::string> default_search_paths()
     paths.push_back(exepath.substr(0, secondtolastslash) + "/lib/chaiscript/");
   }
 #endif
+#endif // ifndef CHAISCRIPT_NO_DYNLOAD
 
   return paths;
 }
@@ -291,7 +296,7 @@ int main(int argc, char *argv[])
   }
 
   //chaiscript::ChaiScript chai(modulepaths, usepaths);
-  chaiscript::ChaiScript chai(chaiscript::Std_Lib::library(), usepaths);
+  chaiscript::ChaiScript chai(usepaths);
 
   chai.add(chaiscript::fun(&myexit), "exit");
   chai.add(chaiscript::fun(&myexit), "quit");

samples/inheritance.cpp

@@ -1,5 +1,4 @@
 #include <chaiscript/chaiscript.hpp>
-#include <chaiscript/chaiscript_stdlib.hpp>
 
 class BaseClass
 {
@@ -44,14 +43,14 @@ class ChaiScriptDerived : public BaseClass
       tie(t_funcs.at(1), m_validateValueImpl);
     }
 
-    std::string doSomething(float f, double d) const CHAISCRIPT_OVERRIDE
+    std::string doSomething(float f, double d) const override
     {
       assert(m_doSomethingImpl);
       return m_doSomethingImpl(*this, f, d);
     }
 
   protected:
-    bool validateValue(const std::string &t_val) CHAISCRIPT_OVERRIDE
+    bool validateValue(const std::string &t_val) override
     {
       assert(m_validateValueImpl);
       return m_validateValueImpl(*this, t_val);
@@ -70,7 +69,7 @@ class ChaiScriptDerived : public BaseClass
 
 int main()
 {
-  chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
+  chaiscript::ChaiScript chai;
   chai.add(chaiscript::fun(&BaseClass::doSomething), "doSomething");
   chai.add(chaiscript::fun(&BaseClass::setValue), "setValue");
   chai.add(chaiscript::fun(&BaseClass::getValue), "getValue");

samples/memory_leak_test.cpp

@@ -1,7 +1,6 @@
 #include <iostream>
 
 #include <chaiscript/chaiscript.hpp>
-#include <chaiscript/chaiscript_stdlib.hpp>
 
 #ifdef READLINE_AVAILABLE
 #include <readline/readline.h>
@@ -32,16 +31,9 @@ void function(void)
 class test
 {
   chaiscript::ChaiScript chai;
-  chaiscript::ChaiScript::State backupState;
+  chaiscript::ChaiScript::State backupState = chai.get_state();
 
   public:
-  test()
-    : chai(chaiscript::Std_Lib::library())
-  {
-    backupState = chai.get_state();
-  }
-  ~test(){}
-
   void ResetState()
   {
     chai.set_state(backupState);

samples/test_num_exceptions.cpp

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