Merge branch 'develop' into typed_function_ordering

Notes
 * Due to the limitations for how Boxed_Value is handled
   the unique_ptrs must still be wrapped in a shared_ptr
 * However, this caveat does not directly affect the user

.decent_ci-Linux.yaml

@@ -0,0 +1,53 @@
+compilers:
+  - name: "clang"
+    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 -DRUN_PERFORMANCE_TESTS:BOOL=ON
+    collect_performance_results: true
+  - name: "clang"
+    build_tag: "LibC++"
+    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.6"
+    skip_packaging: true
+    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.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: "clang"
+    version: "3.7"
+    skip_packaging: true
+    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="*:unittests/catch.hpp" --force --suppress="unusedFunction:*"
+  - name: custom_check
+    commands:
+       - ./contrib/check_for_tabs.rb
+       - ./contrib/check_for_todos.rb
+

.decent_ci-MacOS.yaml

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

.decent_ci-Windows.yaml

@@ -0,0 +1,21 @@
+compilers:
+  - name: Visual Studio
+    version: 14
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /analyze
+    skip_packaging: true
+  - name: Visual Studio
+    version: 14
+    architecture: Win64
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /analyze
+    skip_packaging: true
+  - name: Visual Studio
+    version: 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
+
+

.decent_ci.yaml

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

.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

@@ -0,0 +1,56 @@
+language: cpp
+compiler:
+  - gcc
+env:
+  matrix:
+    - GCC_VER="4.9"
+    - GCC_VER="5"
+
+  global:
+    - secure: eiaR6pXiiEpyB8+LLQ1NvZdl0Yylru1BLy9lMoHl+IpUNGGQGywmW/2WAn77rFfmR1OPA2qWQLfgPwgK0HxUA9HHlot9tre5QhiN2Lw8NOT8tCZ6tTm2+QntDBjBGJyal/knRvQkn/6qs6GxlXRerz4ArnnuPL1vESt3zwB0YtU=
+    # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
+    - secure: "LfolGjP8tWm3yAwthfu3yp8Zn40aueFae580UUR34gusG87cyglq2tQDtxdy+63gWEeNfArbv9n5rZv+bDW3ggHyPjuCKKc1PlZAy07lfXUXf1uz+SFhNvNoYTn3mQG3VZ08o116p4Le2p8yqu4bylJ8wckEq7PrTwvSGVQWTWM="
+
+before_install:
+  - export CXX="g++-$GCC_VER" CC="gcc-$GCC_VER" GCOV="gcov-$GCC_VER"
+  - if [ "$GCC_VER" = "5" ]; then export COVERAGE=1 CPPCHECK=1; fi
+  - if [ ${COVERAGE} = 1 ]; then export FUZZY_CMD="-D RUN_FUZZY_TESTS:BOOL=TRUE"; fi
+  - sudo pip install cpp-coveralls
+  - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+  - sudo apt-get update
+  - sudo apt-get install -qq g++-$GCC_VER
+
+script: 
+  - if [ ${COVERITY_SCAN_BRANCH} != 1 ]; then cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug $FUZZY_CMD . ; fi
+  - if [ ${COVERITY_SCAN_BRANCH} != 1 ]; then make -j2 ; fi
+  - make test
+  - 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:
+      - jason@emptycrate.com
+    on_success: always
+    on_failure: always
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/4be9a2720eaa1bb2a6c9
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false
+
+addons:
+  coverity_scan:
+    project:
+      name: "ChaiScript/ChaiScript"
+      description: "Build submitted via Travis CI"
+    notification_email: jason@emptycrate.com
+    build_command_prepend: "cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug . "
+    build_command:   "cmake --build . -- -j2"
+    branch_pattern: coverity_scan
+
+

CMakeLists.txt

@@ -1,10 +1,95 @@
 cmake_minimum_required(VERSION 2.8)
 
+if(NOT ${CMAKE_VERSION} VERSION_LESS "3.1")
+  cmake_policy(SET CMP0054 NEW)
+endif()
+
+IF(BIICODE)
+  INIT_BIICODE_BLOCK()
+  ADD_BIICODE_TARGETS()
+ELSE()
+  # Your regular CMakeLists configuration here
+
+
 project(chaiscript)
 
 option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
-option(BUILD_MODULES "Build Extra Modules (stl, reflection)" 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)
+
+if(USE_STD_MAKE_SHARED)
+  add_definitions(-DCHAISCRIPT_USE_STD_MAKE_SHARED)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC)
+  option(ENABLE_COVERAGE "Enable Coverage Reporting in GCC" FALSE)
+
+  if(ENABLE_COVERAGE)
+    add_definitions(--coverage -O0)
+    set(LINKER_FLAGS "${LINKER_FLAGS} --coverage")
+  endif()
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  option(ENABLE_THREAD_SANITIZER "Enable thread sanitizer testing in gcc/clang" FALSE)
+  if(ENABLE_THREAD_SANITIZER)
+    add_definitions(-fsanitize=thread -g)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=thread")
+  endif()
+
+  option(ENABLE_ADDRESS_SANITIZER "Enable address sanitizer testing in gcc/clang" FALSE)
+  if(ENABLE_ADDRESS_SANITIZER)
+    add_definitions(-fsanitize=address -g)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=address")
+  endif()
+
+  option(ENABLE_MEMORY_SANITIZER "Enable memory sanitizer testing in gcc/clang" FALSE)
+  if(ENABLE_MEMORY_SANITIZER)
+    add_definitions(-fsanitize=memory -g)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=memory")
+  endif()
+
+  option(ENABLE_UNDEFINED_SANITIZER "Enable undefined behavior sanitizer testing in gcc/clang" FALSE)
+  if(ENABLE_UNDEFINED_SANITIZER)
+    add_definitions(-fsanitize=undefined -g)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=undefined")
+  endif()
+
+  option(ENABLE_LTO "Enable Link Time Optimization" FALSE)
+
+  if (ENABLE_LTO)
+    add_definitions(-flto)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -flto")
+  endif()
+
+  option(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)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fprofile-generate")
+  endif()
+
+  option(PROFILE_USE "Use profile data" FALSE)
+  if (PROFILE_USE)
+    add_definitions(-fprofile-use)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fprofile-use")
+  endif()
+
+
+endif()
 
 list(APPEND CPACK_SOURCE_IGNORE_FILES "${CMAKE_CURRENT_BINARY_DIR}")
 list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.svn")
@@ -13,24 +98,23 @@ list(APPEND CPACK_SOURCE_IGNORE_FILES ".swp")
 list(APPEND CPACK_SOURCE_IGNORE_FILES ".*~")
 
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt")
-set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.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 4)
+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")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
 set(CPACK_PACKAGE_CONTACT "contact@chaiscript.com")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "An embedded scripting language for C++")
 
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libboost-dev (>=1.36.0)")
 set(CPACK_DEBIAN_PACKAGE_SECTION "devel")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 
 set(CPACK_RPM_PACKAGE_LICENSE "BSD")
 set(CPACK_RPM_PACKAGE_GROUP "Programming")
-set(CPACK_RPM_PACKAGE_REQUIRES "boost-devel >= 1.36.0, boost-thread >= 1.36.0")
 
 set(CHAI_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
 
@@ -39,186 +123,375 @@ configure_file(Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile)
 include(CTest)
 include(CPack)
 
-find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+if(NOT MINGW)
+  find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+endif()
+
+if (UNIX AND NOT APPLE)
+  find_program(VALGRIND NAMES valgrind PATH /usr/bin /usr/local/bin)
+endif()
 
 enable_testing()
 
 
 message(STATUS "Detecting readline support")
-if (READLINE_LIBRARY)
-    message(STATUS "Found: ${READLINE_LIBRARY}")
-    set (READLINE_LIB readline)
-    add_definitions(/DREADLINE_AVAILABLE)
-else(READLINE_LIBRARY)
-    message(STATUS "Not Found")
-    set (READLINE_LIB )
-    set (READLINE_FLAG )
-endif(READLINE_LIBRARY)
+if(READLINE_LIBRARY)
+  message(STATUS "Found: ${READLINE_LIBRARY}")
+  set(READLINE_LIB readline)
+  add_definitions(/DREADLINE_AVAILABLE)
+else()
+  message(STATUS "Not Found")
+  set(READLINE_LIB)
+  set(READLINE_FLAG)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC)
+  execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+
+  if(GCC_VERSION VERSION_LESS 4.9)
+    set(CPP11_FLAG "-std=c++1y")
+  else()
+    set(CPP11_FLAG "-std=c++14")
+  endif()
+else()
+  set(CPP11_FLAG "-std=c++14")
+endif()
 
 if(MSVC)
-  add_definitions(/W4)
-  if(CMAKE_CL_64)
-    add_definitions(/bigobj)
-   endif()
-else()
-  add_definitions(-Wall -Wextra -Wshadow -pedantic)
+  add_definitions(/W4 /w14545 /w34242 /w34254 /w34287 /w44263 /w44265 /w44296 /w44311 /w44826 /we4289 /w14546 /w14547 /w14549 /w14555 /w14619 /w14905 /w14906 /w14928)
 
-  if (APPLE)
-    # -Wno-missing-field-initializers is for boost on macos
-    add_definitions(-Wno-missing-field-initializers -Wno-sign-compare)
+  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)
+  # Note on MSVC compiler flags.
+  # The code base selective disables warnings as necessary when the compiler is complaining too much
+  # about something that is perfectly valid, or there is simply no technical way around it
+  # This particular warning, C4503 is in regards to the decorated names that MSVC generates internally.
+  # The error did not come up until the move to C++11, but the compiler doesn't give enough information
+  # to determine where the error is coming from, and the internet provides no real information for
+  # how to workaround or fix the error. So I'm disabling it globally.
+  add_definitions(/wd4503)
+else()
+  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-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()
+
+  if(APPLE)
+    add_definitions(-Wno-sign-compare)
+  endif()
+endif()
+
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  option(USE_LIBCXX "Use clang's libcxx" TRUE)
+
+  if(USE_LIBCXX)
+    add_definitions(-stdlib=libc++)
+    set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG} -stdlib=libc++")
+  else()
+    set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG}")
+  endif()
+elseif(CMAKE_COMPILER_IS_GNUCC)
+  set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG}")
+endif()
+
+# limitations in MinGW require us to make an optimized build
+# for the sake of object sizes or something
+if(MINGW OR CYGWIN)
+  add_definitions(-O3)
 endif()
 
 include_directories(include)
 
-set(Boost_ADDITIONAL_VERSIONS "1.44" "1.44.0" "1.43" "1.43.0" "1.42" "1.42.0" "1.41")
-set(Boost_USE_MULTITHREADED ON)
 
-set (Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.hpp 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)
 
-if (MULTITHREAD_SUPPORT_ENABLED)
-  find_package(Boost 1.36.0 COMPONENTS thread)
-
-  if (Boost_FOUND)
-    link_directories( ${Boost_LIBRARY_DIRS} )
-  else()
-    message(FATAL_ERROR "Can not find Boost")
-  endif(Boost_FOUND)
-else()
+if(NOT MULTITHREAD_SUPPORT_ENABLED)
   add_definitions(-DCHAISCRIPT_NO_THREADS)
 endif()
 
-if (CMAKE_HOST_UNIX)
-  set(DYNAMIC_LOADER "dl")
-endif(CMAKE_HOST_UNIX)
+if(CMAKE_HOST_UNIX)
+  if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
+    list(APPEND LIBS "dl")
+  endif()
+
+  if(MULTITHREAD_SUPPORT_ENABLED)
+    if(CMAKE_COMPILER_IS_GNUCC)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE GCC_FULL_VERSION)
+      if(GCC_FULL_VERSION MATCHES "4.8.1.*ubuntu")
+        set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--no-as-needed -pthread")
+      else()
+        set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
+      endif()
+    else()
+      set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
+    endif()
+
+    add_definitions(-pthread)
+  endif()
 
-if (MSVC)
-  # Boost on MSVC does automatic linking
-  set(LIBS ${DYNAMIC_LOADER} ${READLINE_LIB})
-else()
-  set(LIBS ${DYNAMIC_LOADER} ${Boost_LIBRARIES} ${READLINE_LIB})
 endif()
 
-if (CMAKE_COMPILER_2005)
-  # vs2005 is a bit too loud about possible loss of data warnings
-#  ADD_DEFINITIONS(/wd4244)
-endif()
+list(APPEND LIBS ${READLINE_LIB})
+
+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_module.cpp)
+target_link_libraries(chaiscript_stdlib-${CHAI_VERSION} ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
+
+set(CHAISCRIPT_LIBS stdlib parser)
 
-include_directories(${Boost_INCLUDE_DIRS})
-include_directories(${Boost_INCLUDE_DIR})
 add_executable(chai src/main.cpp ${Chai_INCLUDES})
-target_link_libraries(chai ${LIBS})
+target_link_libraries(chai ${LIBS} ${CHAISCRIPT_LIBS})
 
-if (BUILD_SAMPLES)
+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} ${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} ${CHAISCRIPT_LIBS})
 endif()
 
 
-if (BUILD_MODULES)
+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})
 
-  add_library(reflection MODULE src/reflection.cpp)
-  target_link_libraries(reflection ${LIBS})
-  set(MODULES stl_extra reflection)
+  set(MODULES stl_extra)
 endif()
 
-file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai)
-
+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
+  macro(ADD_CATCH_TESTS executable)
+    if (MSVC)
+      file(TO_NATIVE_PATH "${QT_LIBRARY_DIR}" QT_LIB_PATH)
+      set(NEWPATH "${QT_LIB_PATH};$ENV{PATH}")
+    else()
+      set(NEWPATH $ENV{PATH})
+    endif()
+
+    get_target_property(target_files ${executable} SOURCES)
+
+    foreach(source ${target_files})
+      if(NOT "${source}" MATCHES "/moc_.*cxx")
+        string(REGEX MATCH .*cpp source "${source}")
+        if(source)
+          file(READ "${source}" contents)
+          string(REGEX MATCHALL "TEST_CASE\\([ ]*\"[^\"]+\"" found_tests ${contents})
+          foreach(hit ${found_tests})
+            string(REGEX REPLACE "TEST_CASE\\([ ]*(\"[^\"]+\").*" "\\1" test_name ${hit})
+            add_test(compiled.${test_name} "${executable}" ${test_name})
+            set_tests_properties(compiled.${test_name} PROPERTIES TIMEOUT 660 ENVIRONMENT "PATH=${NEWPATH}")
+          endforeach()
+        endif()
+      endif()
+    endforeach()
+  endmacro()
+
+
+
+
+
   option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
 
-  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})
-  endforeach(filename)
-
-  set_property(TEST ${UNIT_TESTS}
-   PROPERTY ENVIRONMENT
+  add_test(version_check chai -c  "if(\"\\\${ version() };\\\${version_major()};\\\${version_minor()};\\\${version_patch()}\" != \"${CHAI_VERSION};${CPACK_PACKAGE_VERSION_MAJOR};${CPACK_PACKAGE_VERSION_MINOR};${CPACK_PACKAGE_VERSION_PATCH}\") { exit(-1) }")
+  set_property(TEST version_check
+    PROPERTY ENVIRONMENT
     "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
     "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
   )
 
-  if (NOT UNIT_TEST_LIGHT)
-    add_executable(utility_test unittests/utility_test.cpp)
-    target_link_libraries(utility_test ${LIBS})
-    add_test(NAME Utility_Test COMMAND utility_test)
+  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_executable(dynamic_object_test unittests/dynamic_object_test.cpp)
-    target_link_libraries(dynamic_object_test ${LIBS})
-    add_test(NAME Dynamic_Object_Test COMMAND dynamic_object_test)
+  add_test(help chai --help )
+  set_property(TEST help
+    PROPERTY ENVIRONMENT
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+  )
 
-    add_executable(functor_creation_test unittests/functor_creation_test.cpp)
-    target_link_libraries(functor_creation_test ${LIBS})
-    add_test(NAME Functor_Creation_Test COMMAND functor_creation_test)
 
-    add_executable(functor_cast_test unittests/functor_cast_test.cpp)
-    target_link_libraries(functor_cast_test ${LIBS})
-    add_test(NAME Functor_Cast_Test COMMAND functor_cast_test)
+  set(TESTS "")
+
+  foreach(filename ${UNIT_TESTS})
+    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()
+
+  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}/"
+  )
+
+  if(NOT UNIT_TEST_LIGHT)
+    add_executable(compiled_tests unittests/compiled_tests.cpp)
+    target_link_libraries(compiled_tests ${LIBS} ${CHAISCRIPT_LIBS})
+    ADD_CATCH_TESTS(compiled_tests)
+
 
     add_executable(boxed_cast_test unittests/boxed_cast_test.cpp)
     target_link_libraries(boxed_cast_test ${LIBS})
     add_test(NAME Boxed_Cast_Test COMMAND boxed_cast_test)
 
-    add_executable(object_lifetime_test unittests/object_lifetime_test.cpp)
-    target_link_libraries(object_lifetime_test ${LIBS})
-    add_test(NAME Object_Lifetime_Test COMMAND object_lifetime_test)
-
-    add_executable(function_ordering_test unittests/function_ordering_test.cpp)
-    target_link_libraries(function_ordering_test ${LIBS})
-    add_test(NAME Function_Ordering_Test COMMAND function_ordering_test)
-
     add_executable(type_info_test unittests/type_info_test.cpp)
     target_link_libraries(type_info_test ${LIBS})
     add_test(NAME Type_Info_Test COMMAND type_info_test)
 
-    add_executable(eval_catch_exception_test unittests/eval_catch_exception_test.cpp)
-    target_link_libraries(eval_catch_exception_test ${LIBS})
-    add_test(NAME Eval_Catch_Exception_Test COMMAND eval_catch_exception_test)
+    add_executable(c_linkage_test unittests/c_linkage_test.cpp)
+    target_link_libraries(c_linkage_test ${LIBS} ${CHAISCRIPT_LIBS})
+    add_test(NAME C_Linkage_Test COMMAND c_linkage_test)
 
-    add_executable(short_comparison_test unittests/short_comparison_test.cpp)
-    target_link_libraries(short_comparison_test ${LIBS})
-    add_test(NAME Short_Comparison_Test COMMAND short_comparison_test)
+    add_executable(integer_literal_test unittests/integer_literal_test.cpp)
+    target_link_libraries(integer_literal_test ${LIBS} ${CHAISCRIPT_LIBS})
+    add_test(NAME Integer_Literal_Test COMMAND integer_literal_test)
+
+    if(MULTITHREAD_SUPPORT_ENABLED)
+      add_executable(multithreaded_test unittests/multithreaded_test.cpp)
+      target_link_libraries(multithreaded_test ${LIBS})
+      add_test(NAME Multithreaded_Test COMMAND multithreaded_test)
+      set_property(TEST Multithreaded_Test
+        PROPERTY ENVIRONMENT
+        "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
+        "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+      )
+
+    endif()
 
 
-    add_executable(multifile_test unittests/multifile_test_main.cpp unittests/multifile_test_chai.cpp
-      unittests/multifile_test_module.cpp)
+    add_executable(multifile_test
+      unittests/multifile_test_main.cpp
+      unittests/multifile_test_chai.cpp
+      unittests/multifile_test_module.cpp
+    )
     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(BUILD_TESTING)
+endif()
+
+install(TARGETS chai chaiscript_stdlib-${CHAI_VERSION} ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
 
-install(TARGETS chai ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript )
 install(DIRECTORY include/chaiscript DESTINATION include
-   PATTERN "*.hpp"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.hpp"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 install(DIRECTORY unittests DESTINATION share/chaiscript
-   PATTERN "*.chai" 
-   PATTERN "*.inc"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.chai"
+  PATTERN "*.inc"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 install(DIRECTORY samples DESTINATION share/chaiscript
-   PATTERN "*.chai"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.chai"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 
 configure_file(contrib/pkgconfig/chaiscript.pc.in lib/pkgconfig/chaiscript.pc @ONLY)
 install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc"
         DESTINATION lib/pkgconfig)
 
+    
+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

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

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

biicode.conf

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

cheatsheet.md

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

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/codeanalysis.sh

@@ -50,7 +50,7 @@ function run_test
     # Run multithreaded tests
     echo "****Building multithreaded test"
     pushd src
-    g++ multithreaded.cpp -lboost_thread-mt -ldl -omultithreaded -I../include -O3
+    g++ multithreaded.cpp -ldl -omultithreaded -I../include -O3
     echo "****Testing 1 thread runtime"
     /usr/bin/time -p ./multithreaded 1 2> ../../r$1-1threadruntime.out
     echo "****Testing 2 thread runtime"

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

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+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
+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
+echo -n '{ "body": " ' > output.json
+echo -n `awk '{printf "%s\\\\n", $0;}' output` >> output.json
+echo -n '"}' >> output.json
+if [ "${TRAVIS_PULL_REQUEST}" = "false" ]; then curl -H "Authorization: token ${TOKEN}" --request POST --data @output.json https://api.github.com/repos/ChaiScript/ChaiScript/commits/${TRAVIS_COMMIT}/comments; else  curl -H "Authorization: token ${TOKEN}" --request POST --data @output.json https://api.github.com/repos/ChaiScript/ChaiScript/issues/${TRAVIS_PULL_REQUEST}/comments; fi
+
+

contrib/geshi/chaiscript.php

@@ -38,7 +38,7 @@
  ************************************************************************************/
 
 $language_data = array (
-    'LANG_NAME' => 'Chaiscript',
+    'LANG_NAME' => 'ChaiScript',
     'COMMENT_SINGLE' => array(1 => '//'),
     'COMMENT_MULTI' => array('/*' => '*/'),
     //Regular Expressions
@@ -51,7 +51,7 @@ $language_data = array (
             'break', 'else', 'else if', 'eval', 'for', 'if', 'return', 'while', 'try', 'catch', 'finally', 'case', 'switch', 'default',
             ),
         2 => array(
-            'def', 'false', 'fun', 'true', 'var', 'attr',
+            'def', 'false', 'fun', 'true', 'var', 'auto', 'attr',
             ),
         3 => array(
             // built in functions

contrib/sublimetext/ChaiScript.YAML-tmLanguage

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

contrib/sublimetext/ChaiScript.tmLanguage

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

contrib/vim/syntax/chaiscript.vim

@@ -52,7 +52,7 @@ syn keyword chaiscriptExceptions   try catch throw
 syn keyword chaiscriptKeyword      def true false attr
 
 "Built in types
-syn keyword chaiscriptType         fun var
+syn keyword chaiscriptType         fun var auto
 
 "Built in funcs, keep it simple
 syn keyword chaiscriptFunc         eval throw

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-2016, 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

@@ -0,0 +1,226 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2016, 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_COMPILER_VERSION CHAISCRIPT_STRINGIZE(_MSC_FULL_VER)
+#define CHAISCRIPT_MSVC _MSC_VER
+#define CHAISCRIPT_HAS_DECLSPEC
+
+static_assert(_MSC_FULL_VER >= 190024210, "Visual C++ 2015 Update 3 or later required");
+
+#else
+#define CHAISCRIPT_COMPILER_VERSION __VERSION__
+#endif
+
+#include <vector>
+
+#if defined( _LIBCPP_VERSION )
+#define CHAISCRIPT_LIBCPP
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define CHAISCRIPT_WINDOWS
+#endif
+
+#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(CHAISCRIPT_MSVC) ||  (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || (defined(__llvm__) && !defined(CHAISCRIPT_LIBCPP))
+/// \todo Make this support other compilers when possible
+#define CHAISCRIPT_HAS_THREAD_LOCAL
+#endif
+
+#if defined(__llvm__)
+#define CHAISCRIPT_CLANG
+#endif
+
+
+#ifdef  CHAISCRIPT_HAS_DECLSPEC
+#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
+#else
+#define CHAISCRIPT_MODULE_EXPORT extern "C" 
+#endif
+
+#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_DEBUG false
+#endif
+
+#include <memory>
+#include <string>
+#include <cmath>
+
+namespace chaiscript {
+  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)
+  {
+#ifdef CHAISCRIPT_USE_STD_MAKE_SHARED
+    return std::make_shared<D>(std::forward<Arg>(arg)...);
+#else
+    return std::shared_ptr<B>(static_cast<B*>(new D(std::forward<Arg>(arg)...)));
+#endif
+  }
+
+  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()
+  {
+    return {Options::Load_Modules, Options::External_Scripts};
+  }
+}
+#endif
+

include/chaiscript/chaiscript_stdlib.hpp

@@ -0,0 +1,71 @@
+// 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)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_STDLIB_HPP_
+#define CHAISCRIPT_STDLIB_HPP_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "chaiscript_defines.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 "language/chaiscript_prelude.hpp"
+#include "dispatchkit/register_function.hpp"
+#include "utility/json_wrap.hpp"
+
+#ifndef CHAISCRIPT_NO_THREADS
+#include <future>
+#endif
+
+
+/// @file
+///
+/// This file generates the standard library that normal ChaiScript usage requires.
+
+namespace chaiscript
+{
+  class Std_Lib
+  {
+    public:
+
+      static ModulePtr library()
+      {
+        auto lib = std::make_shared<Module>();
+        bootstrap::Bootstrap::bootstrap(*lib);
+
+        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
+        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;
+      }
+
+  };
+}
+
+#endif
+

include/chaiscript/chaiscript_threading.hpp

@@ -1,17 +1,25 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_THREADING_HPP_
 #define CHAISCRIPT_THREADING_HPP_
 
+
+#include <unordered_map>
+
 #ifndef CHAISCRIPT_NO_THREADS
-#include <boost/thread.hpp>
+#include <thread>
+#include <mutex>
 #else
+#ifndef CHAISCRIPT_NO_THREADS_WARNING
 #pragma message ("ChaiScript is compiling without thread safety.")
 #endif
+#endif
+
+#include "chaiscript_defines.hpp"
 
 /// \file
 ///
@@ -25,63 +33,158 @@ namespace chaiscript
 {
   namespace detail
   {
-    /// If threading is enabled, then this namespace contains boost::thread classes.
+    /// If threading is enabled, then this namespace contains std thread classes.
     /// If threading is not enabled, then stubbed in wrappers that do nothing are provided.
     /// This allows us to avoid \#ifdef code in the sections that need thread safety.
     namespace threading
     {
 
 #ifndef CHAISCRIPT_NO_THREADS
-      using boost::unique_lock; 
-      using boost::shared_lock;
-      using boost::lock_guard;
-      using boost::shared_mutex;
-      using boost::recursive_mutex;
+
+      template<typename T>
+        using unique_lock = std::unique_lock<T>;
+
+      template<typename T>
+        using shared_lock = std::unique_lock<T>;
+
+      template<typename T>
+        using lock_guard = std::lock_guard<T>;
 
 
-      /// Typesafe thread specific storage. If threading is enabled, this class uses boost::thread_specific_ptr<T>. If
+      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:
+
+            explicit Thread_Storage(void *t_key)
+              : m_key(t_key)
+            {
+            }
+
             ~Thread_Storage()
             {
-              m_thread_storage.reset();
+              t().erase(m_key);
             }
 
-            inline T *operator->() const
+            inline const T *operator->() const
             {
-              if (!m_thread_storage.get())
-              {
-                m_thread_storage.reset(new T());
-              }
-
-              return m_thread_storage.get();
+              return &(t()[m_key]);
             }
 
-            inline T &operator*() const
+            inline const T &operator*() const
             {
-              return *(this->operator->());
+              return t()[m_key];
             }
 
+            inline T *operator->()
+            {
+              return &(t()[m_key]);
+            }
+
+            inline T &operator*()
+            {
+              return t()[m_key];
+            }
+
+
+            void *m_key;
+
           private:
-            mutable boost::thread_specific_ptr<T> m_thread_storage;
+            static std::unordered_map<void*, T> &t()
+            {
+              thread_local static std::unordered_map<void *, T> my_t;
+              return my_t;
+            }
         };
 
 #else
+
+#pragma message ("Threading without thread_local support is not well supported.")
+
+
+      /// 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:
+
+            explicit Thread_Storage(void *)
+            {
+            }
+
+            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:
+            /// \todo this leaks thread instances. It needs to be culled from time to time
+            std::shared_ptr<T> get_tls() const
+            {
+              unique_lock<mutex> lock(m_mutex);
+
+              const auto id = std::this_thread::get_id();
+              auto itr = m_instances.find(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(id, new_instance));
+
+              return new_instance;
+            }
+
+
+            mutable mutex m_mutex;
+            mutable std::unordered_map<std::thread::id, std::shared_ptr<T> > m_instances;
+        };
+#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() {}
       };
 
       template<typename T>
       class shared_lock 
       {
         public:
-          shared_lock(T &) {}
+          explicit shared_lock(T &) {}
+          void lock() {}
           void unlock() {}
       };
 
@@ -89,7 +192,7 @@ namespace chaiscript
       class lock_guard 
       {
         public:
-          lock_guard(T &) {}
+          explicit lock_guard(T &) {}
       };
 
       class shared_mutex { };
@@ -101,6 +204,10 @@ namespace chaiscript
         class Thread_Storage
         {
           public:
+            explicit Thread_Storage(void *)
+            {
+            }
+
             inline T *operator->() const
             {
               return &obj;

include/chaiscript/dispatchkit/any.hpp

@@ -0,0 +1,164 @@
+// 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)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_ANY_HPP_
+#define CHAISCRIPT_ANY_HPP_
+
+#include <utility>
+
+namespace chaiscript {
+  namespace detail {
+    namespace exception
+    {
+      /// \brief Thrown in the event that an Any cannot be cast to the desired type
+      ///
+      /// It is used internally during function dispatch.
+      ///
+      /// \sa chaiscript::detail::Any
+      class bad_any_cast : public std::bad_cast
+      {
+        public:
+          bad_any_cast() = default;
+
+          bad_any_cast(const bad_any_cast &) = default;
+
+          ~bad_any_cast() noexcept override = default;
+
+          /// \brief Description of what error occurred
+          const char * what() const noexcept override
+          {
+            return m_what.c_str();
+          }
+
+        private:
+          std::string m_what = "bad any cast";
+      };
+    }
+  
+
+    class Any {
+      private:
+        struct Data
+        {
+          explicit Data(const std::type_info &t_type) 
+            : m_type(t_type)
+          {
+          }
+
+          Data &operator=(const Data &) = delete;
+
+          virtual ~Data() = default;
+
+          virtual void *data() = 0;
+
+          const std::type_info &type() const
+          {
+            return m_type;
+          }
+
+          virtual std::unique_ptr<Data> clone() const = 0;
+          const std::type_info &m_type;
+        };
+
+        template<typename T>
+          struct Data_Impl : Data
+          {
+            explicit Data_Impl(T t_type)
+              : Data(typeid(T)),
+                m_data(std::move(t_type))
+            {
+            }
+
+            void *data() override
+            {
+              return &m_data;
+            }
+
+            std::unique_ptr<Data> clone() const override
+            {
+              return std::unique_ptr<Data>(new Data_Impl<T>(m_data));
+            }
+
+            Data_Impl &operator=(const Data_Impl&) = delete;
+
+            T m_data;
+          };
+
+        std::unique_ptr<Data> m_data;
+
+      public:
+        // construct/copy/destruct
+        Any() = default;
+        Any(Any &&) = default;
+        Any &operator=(Any &&t_any) = default;
+
+        Any(const Any &t_any) 
+        { 
+          if (!t_any.empty())
+          {
+            m_data = t_any.m_data->clone(); 
+          } else {
+            m_data.reset();
+          }
+        }
+
+
+        template<typename ValueType,
+          typename = typename std::enable_if<!std::is_same<Any, typename std::decay<ValueType>::type>::value>::type>
+        explicit Any(ValueType &&t_value)
+          : m_data(std::unique_ptr<Data>(new Data_Impl<typename std::decay<ValueType>::type>(std::forward<ValueType>(t_value))))
+        {
+        }
+
+
+        Any & operator=(const Any &t_any)
+        {
+          Any copy(t_any);
+          swap(copy);
+          return *this; 
+        }
+
+        template<typename ToType>
+          ToType &cast() const
+          {
+            if (m_data && typeid(ToType) == m_data->type())
+            {
+              return *static_cast<ToType *>(m_data->data());
+            } else {
+              throw chaiscript::detail::exception::bad_any_cast();
+            }
+          }
+
+
+        // modifiers
+        Any & swap(Any &t_other)
+        {
+          std::swap(t_other.m_data, m_data);
+          return *this;
+        }
+
+        // queries
+        bool empty() const
+        {
+          return !bool(m_data);
+        }
+
+        const std::type_info & type() const
+        {
+          if (m_data) {
+            return m_data->type();
+          } else {
+            return typeid(void);
+          }
+        }
+    };
+
+  }
+}
+
+#endif
+
+

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -1,14 +1,22 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
 #define CHAISCRIPT_BAD_BOXED_CAST_HPP_
 
+#include <string>
+#include <typeinfo>
+
+#include "../chaiscript_defines.hpp"
 #include "type_info.hpp"
 
+namespace chaiscript {
+class Type_Info;
+}  // namespace chaiscript
+
 namespace chaiscript 
 {
   namespace exception
@@ -21,32 +29,33 @@ namespace chaiscript
     class bad_boxed_cast : public std::bad_cast
     {
       public:
-        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) throw()
-          : from(t_from), to(&t_to), m_what(t_what)
+        bad_boxed_cast(Type_Info t_from, const std::type_info &t_to,
+            std::string t_what) noexcept
+          : from(t_from), to(&t_to), m_what(std::move(t_what))
         {
         }
 
-        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
-          : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
+        bad_boxed_cast(Type_Info t_from, const std::type_info &t_to)
+          : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast: " + t_from.name() + " to: " + t_to.name())
         {
         }
 
-        bad_boxed_cast(const std::string &t_what) throw()
-          : to(0), m_what(t_what)
+        explicit bad_boxed_cast(std::string t_what) noexcept
+          : m_what(std::move(t_what))
         {
         }
 
-        virtual ~bad_boxed_cast() throw() {}
+        bad_boxed_cast(const bad_boxed_cast &) = default;
+        ~bad_boxed_cast() noexcept override = default;
 
-        /// \brief Description of what error occured
-        virtual const char * what() const throw()
+        /// \brief Description of what error occurred
+        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,93 +1,81 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-
-#define param(z,n,text) BOOST_PP_CAT(text, BOOST_PP_INC(n)) 
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_BIND_FIRST_HPP_
 #define CHAISCRIPT_BIND_FIRST_HPP_
 
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/ref.hpp>
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 8 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/bind_first.hpp>
-
-#include BOOST_PP_ITERATE()
-
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-# define m BOOST_PP_INC(n)
+#include <functional>
 
 namespace chaiscript
 {
   namespace detail
-  { 
-    /// \brief Helper function for binding the first parameter of a class method pointer. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
-      bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const O &o)
+  {
+
+    template<typename T>
+      T* get_pointer(T *t)
       {
-        return boost::bind(boost::mem_fn(f), o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return t;
       }
 
-    /// \brief Helper function for binding the first parameter of a const class method pointer. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
-      bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)) const, const O &o)
+    template<typename T>
+      T* get_pointer(const std::reference_wrapper<T> &t)
       {
-        return boost::bind(boost::mem_fn(f), o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return &t.get();
       }
 
-    /// \brief Helper function for binding the first parameter of a function pointer. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
-      bind_first(Ret (*f)(BOOST_PP_ENUM_PARAMS(m, Param)), const O &o)
+    template<typename O, typename Ret, typename P1, typename ... Param>
+      auto bind_first(Ret (*f)(P1, Param...), O&& o)
       {
-        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return [f, o](Param...param) -> Ret {
+          return f(std::forward<O>(o), std::forward<Param>(param)...);
+        };
       }
 
-    /// \brief Helper function for binding the first parameter of a boost::function object. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
-      bind_first(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(m, Param))> &f, const O &o)
+    template<typename O, typename Ret, typename Class, typename ... Param>
+      auto bind_first(Ret (Class::*f)(Param...), O&& o)
       {
-        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return [f, o](Param...param) -> Ret {
+          return (get_pointer(o)->*f)(std::forward<Param>(param)...);
+        };
+      }
+
+    template<typename O, typename Ret, typename Class, typename ... Param>
+      auto bind_first(Ret (Class::*f)(Param...) const, O&& o)
+      {
+        return [f, o](Param...param) -> Ret {
+          return (get_pointer(o)->*f)(std::forward<Param>(param)...);
+        };
+
+      }
+
+    template<typename O, typename Ret, typename P1, typename ... Param>
+      auto bind_first(const std::function<Ret (P1, Param...)> &f, O&& o)
+      {
+        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());
       }
 
   }
 }
 
-#undef n
-#undef m
 
 #endif

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,58 +1,71 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
 #define CHAISCRIPT_BOOTSTRAP_HPP_
 
-#include "dispatchkit.hpp"
-#include "dynamic_object.hpp"
+#include "../utility/utility.hpp"
 #include "register_function.hpp"
-#include "operators.hpp"
-#include "boxed_number.hpp"
-#include <boost/function_types/result_type.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>
-      boost::shared_ptr<P1> construct_pod(Boxed_Number v)
+    template<typename T, typename = typename std::enable_if<std::is_array<T>::value>::type >
+      void array(const std::string &type, Module& m)
       {
-        boost::shared_ptr<P1> p(new P1());
-        Boxed_Value bv(p);
-        Boxed_Number nb(bv);
-        nb = v;
-        return p;
+        typedef typename std::remove_extent<T>::type ReturnType;
+        const auto extent = std::extent<T>::value;
+        m.add(user_type<T>(), type);
+        m.add(fun(
+              [extent](T& t, size_t index)->ReturnType &{
+                if (extent > 0 && index >= extent) {
+                  throw std::range_error("Array index out of range. Received: " + std::to_string(index)  + " expected < " + std::to_string(extent));
+                } else {
+                  return t[index];
+                }
+              }
+              ), "[]"
+            );
+
+        m.add(fun(
+              [extent](const T &t, size_t index)->const ReturnType &{
+                if (extent > 0 && index >= extent) {
+                  throw std::range_error("Array index out of range. Received: " + std::to_string(index)  + " expected < " + std::to_string(extent));
+                } else {
+                  return t[index];
+                }
+              }
+              ), "[]"
+            );
+
+        m.add(fun(
+              [extent](const T &) {
+                return extent;
+              }), "size");
       }
-    }
 
     /// \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 = ModulePtr(new 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 = ModulePtr(new Module()))
+    void opers_comparison(Module& m)
     {
       operators::equal<T>(m);
       operators::greater_than<T>(m);
@@ -60,7 +73,6 @@ namespace chaiscript
       operators::less_than<T>(m);
       operators::less_than_equal<T>(m);
       operators::not_equal<T>(m);
-      return m;
     }
 
 
@@ -69,15 +81,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 = ModulePtr(new 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 
@@ -85,84 +96,78 @@ namespace chaiscript
     /// \param[in] type The name of the type
     /// \param[in,out] m The Module to add the constructor to
     template<typename T>
-    ModulePtr construct_pod(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    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<<
-    */
+    /// Internal function for converting from a string to a value
+    /// uses ostream operator >> to perform the conversion
     template<typename Input>
-    std::string to_string(Input 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
     {
-      return boost::lexical_cast<std::string>(i);
+      std::stringstream ss(i);
+      Input t;
+      ss >> t;
+      return t;
     }
 
-
-    /**
-    * 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 &) 
+      -> 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
     {
-      return boost::lexical_cast<Input>(i);
+      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
-    */
+    /// Add all common functions for a POD type. All operators, and
+    /// common conversions
     template<typename T>
-    ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
+    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);
 
-      m->add(fun(&to_string<T>), "to_string");
-      m->add(fun(&parse_string<T>), "to_" + name);
-      return m;
+      m.add(fun(&parse_string<T>), "to_" + name);
     }
 
 
-    /**
-    * "clone" function for a shared_ptr type. This is used in the case
-    * where you do not want to make a deep copy of an object during cloning
-    * but want to instead maintain the shared_ptr. It is needed internally
-    * for handling of Proxy_Function object (that is,
-    * function variables.
-    */
+    /// "clone" function for a shared_ptr type. This is used in the case
+    /// where you do not want to make a deep copy of an object during cloning
+    /// but want to instead maintain the shared_ptr. It is needed internally
+    /// for handling of Proxy_Function object (that is,
+    /// function variables.
     template<typename Type>
-    boost::shared_ptr<Type> shared_ptr_clone(const boost::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
-     */
+    /// Specific version of shared_ptr_clone just for Proxy_Functions
     template<typename Type>
-    boost::shared_ptr<typename boost::remove_const<Type>::type> 
-        shared_ptr_unconst_clone(const boost::shared_ptr<typename boost::add_const<Type>::type> &p)
+    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 boost::const_pointer_cast<typename boost::remove_const<Type>::type>(p);
+      return std::const_pointer_cast<typename std::remove_const<Type>::type>(p);
     }
 
 
 
-    /**
-    * Assignment function for shared_ptr objects, does not perform a copy of the
-    * object pointed to, instead maintains the shared_ptr concept.
-    * Similar to shared_ptr_clone. Used for Proxy_Function.
-    */
+    /// Assignment function for shared_ptr objects, does not perform a copy of the
+    /// object pointed to, instead maintains the shared_ptr concept.
+    /// Similar to shared_ptr_clone. Used for Proxy_Function.
     template<typename Type>
-    Boxed_Value ptr_assign(Boxed_Value lhs, const boost::shared_ptr<Type> &rhs)
+    Boxed_Value ptr_assign(Boxed_Value lhs, const std::shared_ptr<Type> &rhs)
     {
       if (lhs.is_undef() 
           || (!lhs.get_type_info().is_const() && lhs.get_type_info().bare_equal(chaiscript::detail::Get_Type_Info<Type>::get())))
@@ -174,16 +179,12 @@ namespace chaiscript
       }
     }
 
-    /**
-    * Class consisting of only static functions. All default bootstrapping occurs
-    * from this class.
-    */
+    /// Class consisting of only static functions. All default bootstrapping occurs
+    /// from this class.
     class Bootstrap
     {
     private:
-      /**
-      * Function allowing for assignment of an unknown type to any other value
-      */
+      /// Function allowing for assignment of an unknown type to any other value
       static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs)
       {
         if (lhs.is_undef())
@@ -196,282 +197,385 @@ namespace chaiscript
 
       static void print(const std::string &s)
       {
-        std::cout << s;
+        fwrite(s.c_str(), 1, s.size(), stdout);
       }
 
       static void println(const std::string &s)
       {
-        std::cout << s << std::endl;
+        puts(s.c_str());
       }
 
 
-      /**
-      * Add all arithmetic operators for PODs
-      */
-      static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
+      /// Add all arithmetic operators for PODs
+      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
-      */
+      /// 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]);
 
-        return Boxed_Value(Const_Proxy_Function(new dispatch::Bound_Function(f,
+        if (f->get_arity() != -1 && size_t(f->get_arity()) != params.size() - 1)
+        {
+          throw exception::arity_error(static_cast<int>(params.size()), f->get_arity());
+        }
+
+        return Boxed_Value(Const_Proxy_Function(std::make_shared<dispatch::Bound_Function>(std::move(f),
           std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
       }
 
-      /**
-      * Returns true if a call can be made that consists of the first parameter
-      * (the function) with the remaining parameters as its arguments.
-      */
-      static Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
-      {
-        if (params.size() < 1)
-        {
-          throw exception::arity_error(static_cast<int>(params.size()), 1);
-        }
-
-        Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
-
-        return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end())));
-      }
 
       static bool has_guard(const Const_Proxy_Function &t_pf)
       {
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
-        if (pf)
-        {
-          return pf->get_guard();
-        } else {
-          return false;
-        }
+        auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        return pf && pf->get_guard();
       }
 
       static Const_Proxy_Function get_guard(const Const_Proxy_Function &t_pf)
       {
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
-        if (pf)
+        const auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        if (pf && pf->get_guard())
         {
-          if (pf->get_guard())
-          {
-            return pf->get_guard();
-          } else {
-            throw std::runtime_error("Function does not have a guard");
-          }
+          return pf->get_guard();
         } else {
           throw std::runtime_error("Function does not have a guard");
         }
       }
 
-      static void throw_exception(const Boxed_Value &bv) {
-        throw bv;
-      }
-      
-      static boost::shared_ptr<chaiscript::detail::Dispatch_Engine> bootstrap2(boost::shared_ptr<chaiscript::detail::Dispatch_Engine> e = boost::shared_ptr<chaiscript::detail::Dispatch_Engine> (new chaiscript::detail::Dispatch_Engine()))
-      {
-        e->add(user_type<void>(), "void");
-        return e;
-      }
-
-      static std::string what(const std::exception &e)
-      {
-        return e.what();
-      }
-
-      /**
-       * Boolean specialization of internal to_string function 
-       */
-      static std::string bool_to_string(bool b)
-      {
-        if (b)
-        {
-          return "true";
-        } else {
-          return "false";
-        }
-      }
-
       template<typename FunctionType>
         static std::vector<Boxed_Value> do_return_boxed_value_vector(FunctionType f,
             const dispatch::Proxy_Function_Base *b)
         {
-          typedef typename boost::function_types::result_type<FunctionType>::type Vector;
-          Vector v = (b->*f)();
+          auto v = (b->*f)();
  
           std::vector<Boxed_Value> vbv;
-          for (typename Vector::const_iterator itr = v.begin();
-               itr != v.end();
-               ++itr)
+
+          for (const auto &o: v)
           {
-            vbv.push_back(const_var(*itr));
+            vbv.push_back(const_var(o));
           }
 
           return vbv;
         }
 
-      template<typename Function>
-      static boost::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
+
+      static bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
       {
-        return boost::bind(&do_return_boxed_value_vector<Function>, f, _1);
+        const auto pf = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+        return pf && pf->get_parse_tree();
       }
 
+      static chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
+      {
+        const auto pf = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+        if (pf && pf->get_parse_tree())
+        {
+          return pf->get_parse_tree();
+        } else {
+          throw std::runtime_error("Function does not have a parse tree");
+        }
+      }
+
+      template<typename Function>
+      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);
+        };
+      }
+
+
     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 = ModulePtr(new 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<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()), "call");
-        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(&dispatch::Proxy_Function_Base::get_arity), "get_arity");
+        m.add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
 
 
-        m->add(user_type<std::runtime_error>(), "runtime_error");
-        m->add(chaiscript::base_class<std::exception, std::runtime_error>());
- 
+        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(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
-        m->add(fun(boost::function<std::string (const std::runtime_error &)>(&what)), "what");     
+        m.add(fun([](const std::exception &e){ return std::string(e.what()); }), "what");
 
-        m->add(user_type<dispatch::Dynamic_Object>(), "Dynamic_Object");
-        m->add(constructor<dispatch::Dynamic_Object (const std::string &)>(), "Dynamic_Object");
-        m->add(fun(&dispatch::Dynamic_Object::get_type_name), "get_type_name");
-        m->add(fun(&dispatch::Dynamic_Object::get_attrs), "get_attrs");
-        m->add(fun(&dispatch::Dynamic_Object::get_attr), "get_attr");
+        m.add(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->eval("def Dynamic_Object::clone() { var new_o := Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
+        m.add(user_type<std::runtime_error>(), "runtime_error");
+        m.add(chaiscript::base_class<std::exception, std::runtime_error>());
 
-        m->add(fun(&has_guard), "has_guard");
-        m->add(fun(&get_guard), "get_guard");
+        m.add(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
 
-        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(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(&Boxed_Value::get_type_info), "get_type_info");
-        m->add(user_type<Type_Info>(), "Type_Info");
+        m.add(fun(static_cast<Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &)>(&dispatch::Dynamic_Object::get_attr)), "get_attr");
+        m.add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::get_attr)), "get_attr");
+
+        m.add(fun(static_cast<Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &)>(&dispatch::Dynamic_Object::method_missing)), "method_missing");
+        m.add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::method_missing)), "method_missing");
+
+        m.add(fun(static_cast<Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &)>(&dispatch::Dynamic_Object::get_attr)), "[]");
+        m.add(fun(static_cast<const Boxed_Value & (dispatch::Dynamic_Object::*)(const std::string &) const>(&dispatch::Dynamic_Object::get_attr)), "[]");
+
+        m.eval(R"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; 
+          }
+
+          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); } ); 
+          }
+
+          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::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(&to_string<const std::string &>), "internal_to_string");
-        m->add(fun(&Bootstrap::bool_to_string), "internal_to_string");
-        m->add(fun(&unknown_assign), "=");
-        m->add(fun(&throw_exception), "throw");
-        m->add(fun(&what), "what");
+        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");
+
+        
         bootstrap_pod_type<double>("double", m);
         bootstrap_pod_type<long double>("long_double", m);
         bootstrap_pod_type<float>("float", m);
         bootstrap_pod_type<int>("int", m);
+        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<boost::int8_t>("int8_t", m);
-        bootstrap_pod_type<boost::int16_t>("int16_t", m);
-        bootstrap_pod_type<boost::int32_t>("int32_t", m);
-        bootstrap_pod_type<boost::int64_t>("int64_t", m);
-        bootstrap_pod_type<boost::uint8_t>("uint8_t", m);
-        bootstrap_pod_type<boost::uint16_t>("uint16_t", m);
-        bootstrap_pod_type<boost::uint32_t>("uint32_t", m);
-        bootstrap_pod_type<boost::uint64_t>("uint64_t", 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);
+        bootstrap_pod_type<std::int64_t>("int64_t", m);
+        bootstrap_pod_type<std::uint8_t>("uint8_t", m);
+        bootstrap_pod_type<std::uint16_t>("uint16_t", m);
+        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(&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(fun(&print), "print_string");
-        m->add(fun(&println), "println_string");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&bind_function, _1))), 
-          "bind");
+        m.add(fun(&print), "print_string");
+        m.add(fun(&println), "println_string");
 
-        m->add(fun(&shared_ptr_unconst_clone<dispatch::Proxy_Function_Base>), "clone");
-        m->add(fun(&ptr_assign<boost::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
-        m->add(fun(&ptr_assign<boost::add_const<dispatch::Proxy_Function_Base>::type>), "=");
+        m.add(dispatch::make_dynamic_proxy_function(&bind_function), "bind");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), 
-          "call_exists");
+        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(&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::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::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,
+            "eval_error",
+            { },
+            { {fun(&chaiscript::exception::eval_error::reason), "reason"},
+              {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<const std::shared_ptr<const chaiscript::AST_Node> &>);
+                  return retval;
+                }), "call_stack"} }
+            );
+
+
+        chaiscript::utility::add_class<chaiscript::File_Position>(m,
+            "File_Position",
+            { constructor<File_Position()>(),
+              constructor<File_Position(int, int)>() },
+            { {fun(&File_Position::line), "line"},
+              {fun(&File_Position::column), "column"} }
+            );
+
+
+        chaiscript::utility::add_class<AST_Node>(m,
+            "AST_Node",
+            {  },
+            { {fun(&AST_Node::text), "text"},
+              {fun(&AST_Node::identifier), "identifier"},
+              {fun(&AST_Node::filename), "filename"},
+              {fun(&AST_Node::start), "start"},
+              {fun(&AST_Node::end), "end"},
+              {fun(&AST_Node::to_string), "to_string"},
+              {fun([](const chaiscript::AST_Node &t_node) -> std::vector<Boxed_Value> { 
+                std::vector<Boxed_Value> retval;
+                const auto children = t_node.get_children();
+                std::transform(children.begin(), children.end(),
+                               std::back_inserter(retval),
+                               &chaiscript::var<const std::shared_ptr<chaiscript::AST_Node> &>);
+                return retval;
+              }), "children"}
+            }
+            );
 
-        return m;
       }
     };
   }

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -1,26 +1,27 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __boxed_cast_hpp__
-#define __boxed_cast_hpp__
+#ifndef CHAISCRIPT_BOXED_CAST_HPP_
+#define CHAISCRIPT_BOXED_CAST_HPP_
 
-#include "type_info.hpp"
-#include "boxed_value.hpp"
+#include "../chaiscript_defines.hpp"
+#include "bad_boxed_cast.hpp"
 #include "boxed_cast_helper.hpp"
-#include "dynamic_cast_conversion.hpp"
+#include "boxed_value.hpp"
+#include "type_conversions.hpp"
+#include "type_info.hpp"
 
-#include "../chaiscript_threading.hpp"
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/integer_traits.hpp>
+namespace chaiscript {
+class Type_Conversions;
+namespace detail {
+namespace exception {
+class bad_any_cast;
+}  // namespace exception
+}  // namespace detail
+}  // namespace chaiscript
 
 namespace chaiscript 
 {
@@ -31,77 +32,73 @@ namespace chaiscript
   /// \returns Type equivalent to the requested type 
   /// \throws exception::bad_boxed_cast If the requested conversion is not possible
   /// 
-  /// boxed_cast will attempt to make conversions between value, &, *, boost::shared_ptr, boost::reference_wrapper,
-  /// and boost::function (const and non-const) where possible. boxed_cast is used internally during function
+  /// boxed_cast will attempt to make conversions between value, &, *, std::shared_ptr, std::reference_wrapper,
+  /// and std::function (const and non-const) where possible. boxed_cast is used internally during function
   /// dispatch. This means that all of these conversions will be attempted automatically for you during
   /// ChaiScript function calls.
   ///
   /// \li non-const values can be extracted as const or non-const
   /// \li const values can be extracted only as const
-  /// \li Boxed_Value constructed from pointer or boost::reference_wrapper can be extracted as reference,
+  /// \li Boxed_Value constructed from pointer or std::reference_wrapper can be extracted as reference,
   ///     pointer or value types
-  /// \li Boxed_Value constructed from boost::shared_ptr or value types can be extracted as reference,
-  ///     pointer, value, or boost::shared_ptr types
+  /// \li Boxed_Value constructed from std::shared_ptr or value types can be extracted as reference,
+  ///     pointer, value, or std::shared_ptr types
   ///
-  /// Conversions to boost::function objects are attempted as well
+  /// Conversions to std::function objects are attempted as well
   ///
   /// Example:
   /// \code
   /// // All of the following should succeed
   /// chaiscript::Boxed_Value bv(1);
-  /// boost::shared_ptr<int> spi = chaiscript::boxed_cast<boost::shared_ptr<int> >(bv);
+  /// std::shared_ptr<int> spi = chaiscript::boxed_cast<std::shared_ptr<int> >(bv);
   /// int i = chaiscript::boxed_cast<int>(bv);
   /// int *ip = chaiscript::boxed_cast<int *>(bv);
   /// int &ir = chaiscript::boxed_cast<int &>(bv);
-  /// boost::shared_ptr<const int> cspi = chaiscript::boxed_cast<boost::shared_ptr<const int> >(bv);
+  /// std::shared_ptr<const int> cspi = chaiscript::boxed_cast<std::shared_ptr<const int> >(bv);
   /// const int ci = chaiscript::boxed_cast<const int>(bv);
   /// const int *cip = chaiscript::boxed_cast<const int *>(bv);
   /// const int &cir = chaiscript::boxed_cast<const int &>(bv);
   /// \endcode
   ///
-  /// boost::function conversion example
+  /// std::function conversion example
   /// \code
   /// chaiscript::ChaiScript chai;
   /// Boxed_Value bv = chai.eval("`+`"); // Get the functor for the + operator which is built in 
-  /// boost::function<int (int, int)> f = chaiscript::boxed_cast<boost::function<int (int, int)> >(bv);
+  /// std::function<int (int, int)> f = chaiscript::boxed_cast<std::function<int (int, int)> >(bv);
   /// int i = f(2,3);
   /// assert(i == 5);
   /// \endcode
   template<typename Type>
-  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv)
+  decltype(auto) boxed_cast(const Boxed_Value &bv, const Type_Conversions_State *t_conversions = nullptr)
   {
-    try {
-      return detail::Cast_Helper<Type>::cast(bv);
-    } catch (const boost::bad_any_cast &) {
+    if (!t_conversions || bv.get_type_info().bare_equal(user_type<Type>()) || (t_conversions && !(*t_conversions)->convertable_type<Type>())) {
+      try {
+        return(detail::Cast_Helper<Type>::cast(bv, t_conversions));
+      } catch (const chaiscript::detail::exception::bad_any_cast &) {
+      }
+    }
 
-#ifdef BOOST_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 (boost::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value)
-      {
+    if (t_conversions && (*t_conversions)->convertable_type<Type>())
+    {
+      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
+        return(detail::Cast_Helper<Type>::cast((*t_conversions)->boxed_type_conversion<Type>(t_conversions->saves(), bv), t_conversions));
+      } catch (...) {
         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
-          return detail::Cast_Helper<Type>::cast(detail::boxed_dynamic_cast<Type>(bv));
-        } catch (const boost::bad_any_cast &) {
+          // 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 
-        // attempted dynamic_cast
-        throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
       }
+    } else {
+      // 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 BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-
-    } 
   }
 
 }

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -1,214 +1,255 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 #define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 
-#include "type_info.hpp"
-#include "boxed_value.hpp"
+#include <memory>
+#include <type_traits>
+
+#include "boxed_value.hpp"
+#include "type_info.hpp"
 
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/ref.hpp>
-#include <boost/type_traits/add_const.hpp>
 
 namespace chaiscript 
 {
+  class Type_Conversions_State;
+
   namespace detail
   {
     // Cast_Helper_Inner helper classes
 
-    /**
-     * Generic Cast_Helper_Inner, for casting to any type
-     */
+    template<typename T>
+      T* throw_if_null(T *t)
+      {
+        if (t) { return t; }
+        throw std::runtime_error("Attempted to dereference null Boxed_Value");
+      }
+
+    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 typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (ob.is_ref())
-          {
-            if (!ob.get_type_info().is_const())
-            {
-              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
-            } else {
-              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
-            }
-          } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
-            } else {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
-            }
-          }
+          return *static_cast<const Result *>(verify_type(ob, typeid(Result), ob.get_const_ptr()));
         }
       };
 
-	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 &> : Cast_Helper_Inner<Result>
+      struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
       {
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const * type
-     */
+
+    /// Cast_Helper_Inner for casting to a const * type
     template<typename Result>
       struct Cast_Helper_Inner<const Result *>
       {
-        typedef const Result * Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        static const Result * cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (ob.is_ref())
-          {
-            if (!ob.get_type_info().is_const())
-            {
-              return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
-            } else {
-              return (boost::any_cast<boost::reference_wrapper<const Result> >(ob.get())).get_pointer();
-            }
-          } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
-            } else {
-              return (boost::any_cast<boost::shared_ptr<const Result> >(ob.get())).get();
-            }
-          }
+          return static_cast<const Result *>(verify_type_no_throw(ob, typeid(Result), ob.get_const_ptr()));
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a * type
-     */
+    /// Cast_Helper_Inner for casting to a * type
     template<typename Result>
       struct Cast_Helper_Inner<Result *>
       {
-        typedef Result * Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result * cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (ob.is_ref())
-          {
-            return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
-          } else {
-            return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
-          }
+          return static_cast<Result *>(verify_type_no_throw(ob, typeid(Result), ob.get_ptr()));
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a & type
-     */
+    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()));
+        }
+      };
+
+
+
+    /// Cast_Helper_Inner for casting to a & type
     template<typename Result>
       struct Cast_Helper_Inner<Result &>
       {
-        typedef typename boost::reference_wrapper<Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result& cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          if (ob.is_ref())
-          {
-            return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
-          } else {
-            return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
-          }
+          return *static_cast<Result *>(verify_type(ob, typeid(Result), ob.get_ptr()));
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a boost::shared_ptr<> type
-     */
+    /// Cast_Helper_Inner for casting to a && type
     template<typename Result>
-      struct Cast_Helper_Inner<typename boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<Result &&>
       {
-        typedef typename boost::shared_ptr<Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result&& cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
-          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
+          return std::move(*static_cast<Result *>(verify_type(ob, typeid(Result), ob.get_ptr())));
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a boost::shared_ptr<const> type
-     */
+    /// 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<typename boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<std::unique_ptr<Result> &&>
       {
-        typedef typename boost::shared_ptr<const Result> Result_Type;
+        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>>>()));
+        }
+      };
 
-        static Result_Type cast(const Boxed_Value &ob)
+    /// 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::shared_ptr<> type
+    template<typename Result>
+      struct Cast_Helper_Inner<std::shared_ptr<Result> >
+      {
+        static auto cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return ob.get().cast<std::shared_ptr<Result> >();
+        }
+      };
+
+    /// Cast_Helper_Inner for casting to a std::shared_ptr<const> type
+    template<typename Result>
+      struct Cast_Helper_Inner<std::shared_ptr<const Result> >
+      {
+        static auto cast(const Boxed_Value &ob, const Type_Conversions_State *)
         {
           if (!ob.get_type_info().is_const())
           {
-            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
+            return std::const_pointer_cast<const Result>(ob.get().cast<std::shared_ptr<Result> >());
           } else {
-            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
+            return ob.get().cast<std::shared_ptr<const Result> >();
           }
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const boost::shared_ptr<> & type
-     */
+    /// Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<Result> > : Cast_Helper_Inner<boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<Result> > : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<Result> &> : Cast_Helper_Inner<boost::shared_ptr<Result> >
-      {
-      };
-
-
-    /**
-     * Cast_Helper_Inner for casting to a const boost::shared_ptr<const> & type
-     */
-    template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<const Result> > : Cast_Helper_Inner<boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<Result> &> : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<const Result> &> : Cast_Helper_Inner<boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<std::shared_ptr<Result> &>
       {
-      };
-
-
-
-    /**
-     * 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)
+        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 *)
         {
-          return ob;    
+          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 Boxed_Value & type
-     */
+
+    /// Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
+    template<typename Result>
+      struct Cast_Helper_Inner<const std::shared_ptr<const Result> > : Cast_Helper_Inner<std::shared_ptr<const Result> >
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<const std::shared_ptr<const Result> &> : Cast_Helper_Inner<std::shared_ptr<const Result> >
+      {
+      };
+
+
+    /// Cast_Helper_Inner for casting to a Boxed_Value type
+    template<>
+      struct Cast_Helper_Inner<Boxed_Value>
+      {
+        static Boxed_Value cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return ob;
+        }
+      };
+
+    /// Cast_Helper_Inner for casting to a Boxed_Value & type
+    template<>
+      struct Cast_Helper_Inner<Boxed_Value &>
+      {
+        static std::reference_wrapper<Boxed_Value> cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          return std::ref(const_cast<Boxed_Value &>(ob));
+        }
+      };
+
+
+    /// Cast_Helper_Inner for casting to a const Boxed_Value & type
     template<>
       struct Cast_Helper_Inner<const Boxed_Value> : Cast_Helper_Inner<Boxed_Value>
       {
@@ -218,52 +259,46 @@ namespace chaiscript
       struct Cast_Helper_Inner<const Boxed_Value &> : Cast_Helper_Inner<Boxed_Value>
       {
       };
-    
 
-	/**
-     * Cast_Helper_Inner for casting to a boost::reference_wrapper type
-     */
+
+    /// Cast_Helper_Inner for casting to a std::reference_wrapper type
     template<typename Result>
-      struct Cast_Helper_Inner<boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> & > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<const Result> & > : Cast_Helper_Inner<const Result &>
       {
       };
 
-    /**
-     * The exposed Cast_Helper object that by default just calls the Cast_Helper_Inner
-     */
+    /// The exposed Cast_Helper object that by default just calls the Cast_Helper_Inner
     template<typename T>
       struct Cast_Helper
       {
-        typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
-        
-        static Result_Type cast(const Boxed_Value &ob)
+        static decltype(auto) cast(const Boxed_Value &ob, const Type_Conversions_State *t_conversions)
         {
-          return Cast_Helper_Inner<T>::cast(ob);
+          return(Cast_Helper_Inner<T>::cast(ob, t_conversions));
         }
       };
   }

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,25 +1,19 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
 #define CHAISCRIPT_BOXED_VALUE_HPP_
 
-#include "type_info.hpp"
-
-#include "../chaiscript_threading.hpp"
-
 #include <map>
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-#include <boost/bind.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/integer_traits.hpp>
+#include <memory>
+#include <type_traits>
+
+#include "../chaiscript_defines.hpp"
+#include "any.hpp"
+#include "type_info.hpp"
 
 namespace chaiscript 
 {
@@ -29,25 +23,23 @@ namespace chaiscript
   class Boxed_Value
   {
     public:
-      /**
-       * used for explicitly creating a "void" object
-       */
+      /// used for explicitly creating a "void" object
       struct Void_Type
       {
       };
 
     private:
-      /**
-       * structure which holds the internal state of a Boxed_Value
-       */
+      /// structure which holds the internal state of a Boxed_Value
+      /// \todo Get rid of Any and merge it with this, reducing an allocation in the process
       struct Data
       {
         Data(const Type_Info &ti,
-            const boost::any &to,
+            chaiscript::detail::Any to,
             bool tr,
-            const void *t_void_ptr)
-          : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?0:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
-            m_is_ref(tr)
+            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)
         {
         }
 
@@ -58,220 +50,338 @@ namespace chaiscript
           m_is_ref = rhs.m_is_ref;
           m_data_ptr = rhs.m_data_ptr;
           m_const_data_ptr = rhs.m_const_data_ptr;
+          m_return_value = rhs.m_return_value;
+
+          if (rhs.m_attrs)
+          {
+            m_attrs = std::make_unique<std::map<std::string, std::shared_ptr<Data>>>(*rhs.m_attrs);
+          }
 
           return *this;
         }
 
-        ~Data()
-        {
-        }
+        Data(const Data &) = delete;
+
+        Data(Data &&) = default;
+        Data &operator=(Data &&rhs) = default;
+
 
         Type_Info m_type_info;
-        boost::any m_obj;
+        chaiscript::detail::Any m_obj;
         void *m_data_ptr;
         const void *m_const_data_ptr;
+        std::unique_ptr<std::map<std::string, std::shared_ptr<Data>>> m_attrs;
         bool m_is_ref;
+        bool m_return_value;
       };
 
       struct Object_Data
       {
-        static boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
+        static auto get(Boxed_Value::Void_Type, bool t_return_value)
         {
-          return boost::shared_ptr<Data> (new Data(
+          return std::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
-                boost::any(), 
+                chaiscript::detail::Any(), 
                 false,
-                0)
-              );
+                nullptr,
+                t_return_value)
+              ;
         }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> *obj)
+          static auto get(const std::shared_ptr<T> *obj, bool t_return_value)
           {
-            return get(*obj);
+            return get(*obj, t_return_value);
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> &obj)
+          static auto get(const std::shared_ptr<T> &obj, bool t_return_value)
           {
-            return boost::shared_ptr<Data>(new Data(
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(obj), 
+                  chaiscript::detail::Any(obj), 
                   false,
-                  obj.get())
+                  obj.get(),
+                  t_return_value
                 );
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(T *t)
+          static auto get(std::shared_ptr<T> &&obj, bool t_return_value)
           {
-            return get(boost::ref(*t));
+            auto ptr = obj.get();
+            return std::make_shared<Data>(
+                  detail::Get_Type_Info<T>::get(), 
+                  chaiscript::detail::Any(std::move(obj)), 
+                  false,
+                  ptr,
+                  t_return_value
+                );
+          }
+
+
+
+        template<typename T>
+          static auto get(T *t, bool t_return_value)
+          {
+            return get(std::ref(*t), t_return_value);
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
+          static auto get(const T *t, bool t_return_value)
           {
-            return boost::shared_ptr<Data>(new Data(
+            return get(std::cref(*t), t_return_value);
+          }
+
+
+        template<typename T>
+          static auto get(std::reference_wrapper<T> obj, bool t_return_value)
+          {
+            auto p = &obj.get();
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
-                  boost::any(obj),
+                  chaiscript::detail::Any(std::move(obj)),
                   true,
-                  obj.get_pointer())
+                  p,
+                  t_return_value
                 );
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const T& t)
+          static auto get(std::unique_ptr<T> &&obj, bool t_return_value)
           {
-            boost::shared_ptr<T> p(new T(t));
-            return boost::shared_ptr<Data>(new Data(
+            auto ptr = obj.get();
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(p), 
+                  chaiscript::detail::Any(std::make_shared<std::unique_ptr<T>>(std::move(obj))), 
                   false,
-                  p.get())
+                  ptr,
+                  t_return_value
                 );
           }
 
-        static boost::shared_ptr<Data> get()
+        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();
+            return std::make_shared<Data>(
+                  detail::Get_Type_Info<T>::get(), 
+                  chaiscript::detail::Any(std::move(p)),
+                  false,
+                  ptr,
+                  t_return_value
+                );
+          }
+
+        static std::shared_ptr<Data> get()
         {
-          return boost::shared_ptr<Data> (new Data(
+          return std::make_shared<Data>(
                 Type_Info(),
-                boost::any(),
+                chaiscript::detail::Any(),
                 false,
-                0)
+                nullptr,
+                false
               );
         }
 
       };
 
     public:
-      /**
-       * Basic Boxed_Value constructor
-       */
-      template<typename T>
-        explicit Boxed_Value(T t)
-        : m_data(Object_Data::get(t))
+      /// Basic Boxed_Value constructor
+        template<typename T,
+          typename = typename std::enable_if<!std::is_same<Boxed_Value, typename std::decay<T>::type>::value>::type>
+        explicit Boxed_Value(T &&t, bool t_return_value = false)
+          : m_data(Object_Data::get(std::forward<T>(t), t_return_value))
         {
         }
 
-      /**
-       * Copy constructor - each copy shares the same data pointer
-       */
-      Boxed_Value(const Boxed_Value &t_so)
-        : m_data(t_so.m_data)
-      {
-      }
+      /// Unknown-type constructor
+      Boxed_Value() = default;
 
-      /**
-       * Unknown-type constructor
-       */
-      Boxed_Value()
-        : m_data(Object_Data::get())    
-      {
-      }
-
-      ~Boxed_Value()
-      {
-      }
+      Boxed_Value(Boxed_Value&&) = default;
+      Boxed_Value& operator=(Boxed_Value&&) = default;
+      Boxed_Value(const Boxed_Value&) = default;
+      Boxed_Value& operator=(const Boxed_Value&) = default;
 
       void swap(Boxed_Value &rhs)
       {
         std::swap(m_data, rhs.m_data);
       }
 
-      /**
-       * copy the values stored in rhs.m_data to m_data
-       * m_data pointers are not shared in this case
-       */
+      /// Copy the values stored in rhs.m_data to m_data.
+      /// m_data pointers are not shared in this case
       Boxed_Value assign(const Boxed_Value &rhs)
       {
         (*m_data) = (*rhs.m_data);
         return *this;
       }
 
-      /**
-       * shared data assignment, same as copy construction
-       */
-      Boxed_Value &operator=(const Boxed_Value &rhs)
-      {
-        Boxed_Value temp(rhs);
-        swap(temp);
-        return *this;
-      }
-
-      const Type_Info &get_type_info() const
+      const Type_Info &get_type_info() const noexcept
       {
         return m_data->m_type_info;
       }
 
-      /**
-       * return true if the object is uninitialized
-       */
-      bool is_undef() const
+      /// return true if the object is uninitialized
+      bool is_undef() const noexcept
       {
         return m_data->m_type_info.is_undef();
       }
 
-      bool is_const() const
+      bool is_const() const noexcept
       {
         return m_data->m_type_info.is_const();
       }
 
-      bool is_type(const Type_Info &ti) const
+      bool is_type(const Type_Info &ti) const noexcept
       {
         return m_data->m_type_info.bare_equal(ti);
       }
 
-      bool is_null() const
+
+      template<typename T>
+      auto pointer_sentinel(std::shared_ptr<T> &ptr) const
       {
-        return (m_data->m_data_ptr == 0 && m_data->m_const_data_ptr == 0);
+        struct Sentinel {
+          Sentinel(std::shared_ptr<T> &t_ptr, Data &data)
+            : m_ptr(t_ptr), m_data(data)
+          {
+          }
+
+          ~Sentinel()
+          {
+            // save new pointer data
+            m_data.get().m_data_ptr = m_ptr.get().get();
+            m_data.get().m_const_data_ptr = m_ptr.get().get();
+          }
+
+          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()));
       }
 
-      const boost::any & get() const
+      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 noexcept
       {
         return m_data->m_obj;
       }
 
-      bool is_ref() const
+      bool is_ref() const noexcept
       {
         return m_data->m_is_ref;
       }
 
-      bool is_pointer() const
+      bool is_return_value() const noexcept
+      {
+        return m_data->m_return_value;
+      }
+
+      void reset_return_value() const noexcept
+      {
+        m_data->m_return_value = false;
+      }
+
+      bool is_pointer() const noexcept
       {
         return !is_ref();
       }
 
-      void *get_ptr() const
+      void *get_ptr() const noexcept
       {
         return m_data->m_data_ptr;
       }
 
-      const void *get_const_ptr() const
+      const void *get_const_ptr() const noexcept
       {
         return m_data->m_const_data_ptr;
       }
 
+      Boxed_Value get_attr(const std::string &t_name)
+      {
+        if (!m_data->m_attrs)
+        {
+          m_data->m_attrs = std::make_unique<std::map<std::string, std::shared_ptr<Data>>>();
+        }
+
+        auto &attr = (*m_data->m_attrs)[t_name];
+        if (attr) {
+          return Boxed_Value(attr, Internal_Construction());
+        } else {
+          Boxed_Value bv; //default construct a new one
+          attr = bv.m_data;
+          return bv;
+        }
+      }
+
+      Boxed_Value &copy_attrs(const Boxed_Value &t_obj)
+      {
+        if (t_obj.m_data->m_attrs)
+        {
+          m_data->m_attrs = std::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) noexcept
+      {
+        return l.get_type_info() == r.get_type_info();
+      }
+
     private:
-      boost::shared_ptr<Data> m_data;
+      // necessary to avoid hitting the templated && constructor of Boxed_Value
+      struct Internal_Construction{};
+
+      Boxed_Value(std::shared_ptr<Data> t_data, Internal_Construction)
+        : m_data(std::move(t_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, boost::shared_ptr, or boost::reference_type
+  /// @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
   ///        a copy is not made.
-  /// \param t The value to box
-  /// 
+  /// @param t The value to box
+  ///
   /// Example:
-  /// \code
+  ///
+  /// ~~~{.cpp}
   /// int i;
   /// chaiscript::ChaiScript chai;
   /// chai.add(chaiscript::var(i), "i");
   /// chai.add(chaiscript::var(&i), "ip");
-  /// \endcode
-  /// 
-  /// \sa \ref addingobjects
+  /// ~~~
+  ///
+  /// @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 {
@@ -282,7 +392,7 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(const T &t)
       {
-        return Boxed_Value(boost::shared_ptr<typename boost::add_const<T>::type >(new T(t)));
+        return Boxed_Value(std::make_shared<typename std::add_const<T>::type >(t));
       }
 
     /// \brief Takes a pointer to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
@@ -293,33 +403,33 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(T *t)
       {
-        return Boxed_Value( const_cast<typename boost::add_const<T>::type *>(t) );
+        return Boxed_Value( const_cast<typename std::add_const<T>::type *>(t) );
       }
 
-    /// \brief Takes a boost::shared_ptr to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
+    /// \brief Takes a std::shared_ptr to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
     ///        Does not copy the pointed to value.
     /// \param[in] t Pointer to make immutable
     /// \returns Immutable Boxed_Value
     /// \sa Boxed_Value::is_const
     template<typename T>
-      Boxed_Value const_var_impl(const boost::shared_ptr<T> &t)
+      Boxed_Value const_var_impl(const std::shared_ptr<T> &t)
       {
-        return Boxed_Value( boost::const_pointer_cast<typename boost::add_const<T>::type>(t) );
+        return Boxed_Value( std::const_pointer_cast<typename std::add_const<T>::type>(t) );
       }
 
-    /// \brief Takes a boost::reference_wrapper value, adds const to the referenced type and returns an immutable Boxed_Value.
+    /// \brief Takes a std::reference_wrapper value, adds const to the referenced type and returns an immutable Boxed_Value.
     ///        Does not copy the referenced value.
     /// \param[in] t Reference object to make immutable
     /// \returns Immutable Boxed_Value
     /// \sa Boxed_Value::is_const
     template<typename T>
-      Boxed_Value const_var_impl(const boost::reference_wrapper<T> &t)
+      Boxed_Value const_var_impl(const std::reference_wrapper<T> &t)
       {
-        return Boxed_Value( boost::cref(t.get()) );
+        return Boxed_Value( std::cref(t.get()) );
       }
   }
 
-  /// \brief Takes an object and returns an immutable Boxed_Value. If the object is a boost::reference or pointer type
+  /// \brief Takes an object and returns an immutable Boxed_Value. If the object is a std::reference or pointer type
   ///        the value is not copied. If it is an object type, it is copied.
   /// \param[in] t Object to make immutable
   /// \returns Immutable Boxed_Value
@@ -340,20 +450,30 @@ namespace chaiscript
   /// chai.add(chaiscript::const_var(Green), "Green");
   /// \endcode
   /// 
-  /// \sa \ref addingobjects
+  /// \todo support C++11 strongly typed enums
+  /// \sa \ref adding_objects
   template<typename T>
     Boxed_Value const_var(const T &t)
     {
       return detail::const_var_impl(t);
     }
 
-
-
-  /// \returns true if the two Boxed_Values share the same internal type
-  static bool type_match(Boxed_Value l, Boxed_Value r)
-  {
-    return l.get_type_info() == r.get_type_info();
+  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 const auto t = detail::const_var_impl(true);
+    static const auto f = detail::const_var_impl(false);
+
+    if (b) {
+      return t;
+    } else {
+      return f;
+    }
+  }
+
 }
 
 #endif

include/chaiscript/dispatchkit/callable_traits.hpp

@@ -0,0 +1,107 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2016, 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_cast_conversion.hpp

@@ -1,290 +0,0 @@
-// 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)
-// http://www.chaiscript.com
-
-#ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
-#define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
-
-#include "type_info.hpp"
-#include "boxed_value.hpp"
-#include "boxed_cast_helper.hpp"
-#include "bad_boxed_cast.hpp"
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-
-namespace chaiscript
-{
-  namespace exception
-  {
-    class bad_boxed_dynamic_cast : public bad_boxed_cast
-    {
-      public:
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) throw()
-          : bad_boxed_cast(t_from, t_to, t_what)
-        {
-        }
-
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
-          : bad_boxed_cast(t_from, t_to)
-        {
-        }
-
-        bad_boxed_dynamic_cast(const std::string &w) throw()
-          : bad_boxed_cast(w)
-        {
-        }
-
-        virtual ~bad_boxed_dynamic_cast() throw() {}
-    };
-  }
-
-  namespace detail
-  {
-    class Dynamic_Conversion
-    {
-      public:
-        virtual Boxed_Value convert(const Boxed_Value &derived) = 0;
-
-        const Type_Info &base()
-        {
-          return m_base;
-        }
-        const Type_Info &derived()
-        {
-          return m_derived;
-        }
-
-      protected:
-        Dynamic_Conversion(const Type_Info &t_base, const Type_Info &t_derived)
-          : m_base(t_base), m_derived(t_derived)
-        {
-        }
-
-        virtual ~Dynamic_Conversion() {} 
-
-      private:
-        Type_Info m_base;
-        Type_Info m_derived;
-
-    };
-
-    template<typename Base, typename Derived>
-    class Dynamic_Conversion_Impl : public Dynamic_Conversion
-    {
-      public:
-        Dynamic_Conversion_Impl()
-          : Dynamic_Conversion(user_type<Base>(), user_type<Derived>())
-        {
-        }
-
-        virtual Boxed_Value convert(const Boxed_Value &t_derived)
-        {
-          if (t_derived.get_type_info().bare_equal(user_type<Derived>()))
-          {
-            if (t_derived.is_pointer())
-            {
-              // Dynamic cast out the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                boost::shared_ptr<const Base> data 
-                  = boost::dynamic_pointer_cast<const Base>(detail::Cast_Helper<boost::shared_ptr<const Derived> >::cast(t_derived));
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
-
-                return Boxed_Value(data);
-              } else {
-                boost::shared_ptr<Base> data 
-                  = boost::dynamic_pointer_cast<Base>(detail::Cast_Helper<boost::shared_ptr<Derived> >::cast(t_derived));
-
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
-
-                return Boxed_Value(data);
-              }
-            } else {
-              // Pull the reference out of the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                const Derived &d = detail::Cast_Helper<const Derived &>::cast(t_derived);
-                const Base &data = dynamic_cast<const Base &>(d);
-                return Boxed_Value(boost::cref(data));
-              } else {
-                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived);
-                Base &data = dynamic_cast<Base &>(d);
-                return Boxed_Value(boost::ref(data));
-              }
-            }
-          } else {
-            throw exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
-          }
-        }
-    };
-
-
-    class Dynamic_Conversions
-    {
-      public:
-        static inline Dynamic_Conversions &get()
-        {
-          static Dynamic_Conversions obj;
-          return obj;
-        }
-
-        template<typename Base, typename Derived>
-        static boost::shared_ptr<Dynamic_Conversion> create()
-        {
-          boost::shared_ptr<Dynamic_Conversion> conversion(new Dynamic_Conversion_Impl<Base, Derived>());
-
-          /// \todo this is a hack and a kludge. The idea is to make sure that
-          ///       the conversion is registered both in the module's notion of the static conversion object
-          ///       and in the global notion of the static conversion object
-          ///       someday this will almost certainly have to change. Maybe it is time for ChaiScript
-          ///       to become a library?
-          Dynamic_Conversions::get().add_conversion(conversion);
-          return conversion;
-        }
-
-        template<typename InItr>
-        void cleanup(InItr begin, const InItr &end)
-        {
-          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          while (begin != end)
-          {
-            if (begin->unique())
-            {
-              m_conversions.erase(begin->get());
-            }
-
-            ++begin;
-          }
-        }
-
-        void add_conversion(const boost::shared_ptr<Dynamic_Conversion> &conversion)
-        {
-          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          m_conversions.insert(conversion.get());
-        }
-
-        bool has_conversion(const Type_Info &base, const Type_Info &derived) const
-        {
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          return find(base, derived) != m_conversions.end();
-        }
-
-
-        Dynamic_Conversion *get_conversion(const Type_Info &base, const Type_Info &derived) const
-        {
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          std::set<Dynamic_Conversion *>::const_iterator itr =
-            find(base, derived);
-
-          if (itr != m_conversions.end())
-          {
-            return *itr;
-          } else {
-            throw std::out_of_range("No such conversion exists from " + derived.bare_name() + " to " + base.bare_name());
-          }
-        }
-
-      private:
-        Dynamic_Conversions() {}
-
-        std::set<Dynamic_Conversion *>::const_iterator find(
-            const Type_Info &base, const Type_Info &derived) const
-        {
-          for (std::set<Dynamic_Conversion *>::const_iterator itr = m_conversions.begin();
-               itr != m_conversions.end();
-               ++itr)
-          {
-            if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
-            {
-              return itr;
-            }
-          }
-
-          return m_conversions.end();
-        }
-
-        mutable chaiscript::detail::threading::shared_mutex m_mutex;
-        std::set<Dynamic_Conversion *> m_conversions;
-    };
-  }
-
-  typedef boost::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
-
-  /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
-  ///        want automatic conversions up your inheritance hierarchy.
-  ///
-  /// Create a new base class registration for applying to a module or to the chaiscript engine
-  /// Currently, due to limitations in module loading on Windows, and for the sake of portability,
-  /// if you have a type that is introduced in a loadable module and is used by multiple modules
-  /// (through a tertiary dll that is shared between the modules, static linking the new type
-  /// into both loadable modules would not be portable), you need to register the base type
-  /// relationship in all modules that use the newly added type in a polymorphic way.
-  ///
-  /// Example:
-  /// \code
-  /// class Base
-  /// {};
-  /// class Derived : public Base
-  /// {};
-  ///
-  /// chaiscript::ChaiScript chai;
-  /// chai.add(chaiscript::base_class<Base, Derived>());
-  /// \endcode
-  /// 
-  /// \todo Move share static type registration code into a mechanism that allows it to be properly
-  ///       shared by all modules
-  template<typename Base, typename Derived>
-  Dynamic_Cast_Conversion base_class()
-  {
-    //Can only be used with related polymorphic types
-    //may be expanded some day to support conversions other than child -> parent
-    BOOST_STATIC_ASSERT((boost::is_base_of<Base,Derived>::value));
-    BOOST_STATIC_ASSERT(boost::is_polymorphic<Base>::value);
-    BOOST_STATIC_ASSERT(boost::is_polymorphic<Derived>::value);
-
-    return detail::Dynamic_Conversions::create<Base, Derived>();
-  }
-
-  namespace detail
-  {
-    template<typename Base, typename Derived>
-      bool dynamic_cast_converts()
-      {
-        return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
-      }
-
-    static bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived)
-    {
-      return detail::Dynamic_Conversions::get().has_conversion(base, derived);
-    }
-
-    template<typename Base>
-      Boxed_Value boxed_dynamic_cast(const Boxed_Value &derived)
-      {
-        try {
-          return detail::Dynamic_Conversions::get().get_conversion(user_type<Base>(), derived.get_type_info())->convert(derived);
-        } catch (const std::out_of_range &) {
-          throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "No known conversion");
-        } catch (const std::bad_cast &) {
-          throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
-        }
-      }
-  }
-}
-
-
-#endif

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,269 +1,126 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 #define CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 
-#include <boost/optional.hpp>
+#include <map>
+#include <string>
+#include <utility>
+
+#include "boxed_value.hpp"
+
+namespace chaiscript {
+class Type_Conversions;
+namespace dispatch {
+class Proxy_Function_Base;
+}  // namespace dispatch
+}  // namespace chaiscript
 
 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(const std::string &t_type_name)
-          : m_type_name(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() = 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
         {
           return m_type_name;
         }
 
-        Boxed_Value get_attr(const std::string &t_attr_name)
+        const Boxed_Value &operator[](const std::string &t_attr_name) const
+        {
+          return get_attr(t_attr_name);
+        }
+
+        Boxed_Value &operator[](const std::string &t_attr_name)
+        {
+          return get_attr(t_attr_name);
+        }
+
+        const Boxed_Value &get_attr(const std::string &t_attr_name) const
+        {
+          auto a = m_attrs.find(t_attr_name);
+
+          if (a != m_attrs.end()) {
+            return a->second;
+          } else {
+            throw std::range_error("Attr not found '" + t_attr_name + "' and cannot be added to const obj");
+          }
+        }
+
+        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];
         }
 
-        std::map<std::string, Boxed_Value> get_attrs()
+        Boxed_Value &method_missing(const std::string &t_method_name)
+        {
+          if (m_option_explicit && m_attrs.find(t_method_name) == m_attrs.end()) {
+            throw option_explicit_set(t_method_name);
+          }
+
+          return get_attr(t_method_name);
+        }
+
+        const Boxed_Value &method_missing(const std::string &t_method_name) const
+        {
+          if (m_option_explicit && m_attrs.find(t_method_name) == m_attrs.end()) {
+            throw option_explicit_set(t_method_name);
+          }
+
+          return get_attr(t_method_name);
+        }
+
+        std::map<std::string, Boxed_Value> get_attrs() const
         {
           return m_attrs;
         }
 
       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;
     };
 
-    namespace detail
-    {
-      /**
-       * A Proxy_Function implementation designed for calling a function
-       * that is automatically guarded based on the first param based on the
-       * param's type name
-       */
-      class Dynamic_Object_Function : public Proxy_Function_Base
-      {
-        public:
-          Dynamic_Object_Function(
-              const std::string &t_type_name,
-              const Proxy_Function &t_func,
-              const boost::optional<Type_Info> &t_ti = boost::optional<Type_Info>())
-            : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti)),
-            m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
-        {
-          assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-              && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-        }
-
-          virtual ~Dynamic_Object_Function() {}
-
-          virtual bool operator==(const Proxy_Function_Base &f) const
-          {
-            const Dynamic_Object_Function *df = dynamic_cast<const Dynamic_Object_Function *>(&f);
-            if (df)
-            {
-              return df->m_type_name == m_type_name && (*df->m_func) == (*m_func);
-            } else {
-              return false;
-            }
-          }
-
-          virtual bool call_match(const std::vector<Boxed_Value> &vals) const
-          {
-            if (dynamic_object_typename_match(vals, m_type_name, m_ti))
-            {
-              return m_func->call_match(vals);
-            } else {
-              return false;
-            }
-          }    
-
-          virtual std::vector<Const_Proxy_Function> get_contained_functions() const
-          {
-            std::vector<Const_Proxy_Function> fs;
-            fs.push_back(m_func);
-            return fs;
-          }
-
-
-          virtual int get_arity() const
-          {
-            return m_func->get_arity();
-          }
-
-          virtual std::string annotation() const
-          {
-            return m_func->annotation();
-          }
-
-
-        protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
-          {
-            if (dynamic_object_typename_match(params, m_type_name, m_ti))
-            {
-              return (*m_func)(params);
-            } else {
-              throw exception::guard_error();
-            } 
-          }
-
-          virtual bool compare_first_type(const Boxed_Value &bv) const
-          {
-            return dynamic_object_typename_match(bv, m_type_name, m_ti);
-          }
-
-        private:
-          static std::vector<Type_Info> build_param_types(
-              const std::vector<Type_Info> &t_inner_types, boost::optional<Type_Info> t_objectti)
-          {
-            if (t_objectti)
-            {
-              std::vector<Type_Info> types(t_inner_types);
-
-              assert(types.size() > 1);
-              assert(types[1].bare_equal(user_type<Boxed_Value>()));
-              types[1] = *t_objectti;
-              return types;
-            } else {
-              return t_inner_types;
-            }
-          }
-
-          static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const boost::optional<Type_Info> &ti)
-          {
-            static Type_Info doti = user_type<Dynamic_Object>();
-            if (bv.get_type_info().bare_equal(doti))
-            {
-              try {
-                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv);
-                return name == "Dynamic_Object" || d.get_type_name() == name;
-              } catch (const std::bad_cast &) {
-                return false;
-              } 
-            } else {
-              if (ti)
-              {
-                return bv.get_type_info().bare_equal(*ti);
-              } else {
-                return false;
-              }
-            }
-
-          }
-
-          static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const boost::optional<Type_Info> &ti) 
-          {
-            if (bvs.size() > 0)
-            {
-              return dynamic_object_typename_match(bvs[0], name, ti);
-            } else {
-              return false;
-            }
-          }
-
-          std::string m_type_name;
-          Proxy_Function m_func;
-          boost::optional<Type_Info> m_ti;
-
-      };
-
-
-      /**
-       * A Proxy_Function implementation designed for creating a new
-       * Dynamic_Object
-       * that is automatically guarded based on the first param based on the
-       * param's type name
-       */
-      class Dynamic_Object_Constructor : public Proxy_Function_Base
-      {
-        public:
-          Dynamic_Object_Constructor(
-              const std::string &t_type_name,
-              const Proxy_Function &t_func)
-            : Proxy_Function_Base(build_type_list(t_func->get_param_types())),
-            m_type_name(t_type_name), m_func(t_func)
-        {
-          assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-              && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-        }
-
-          static std::vector<Type_Info> build_type_list(const std::vector<Type_Info> &tl)
-          {
-            std::vector<Type_Info>::const_iterator begin = tl.begin();
-            std::vector<Type_Info>::const_iterator end = tl.end();
-
-            if (begin != end)
-            {
-              ++begin;
-            }
-
-            return std::vector<Type_Info>(begin, end);
-          }
-
-          virtual ~Dynamic_Object_Constructor() {}
-
-          virtual bool operator==(const Proxy_Function_Base &f) const
-          {
-            const Dynamic_Object_Constructor *dc = dynamic_cast<const Dynamic_Object_Constructor*>(&f);
-            if (dc)
-            {
-              return dc->m_type_name == m_type_name && (*dc->m_func) == (*m_func);
-            } else {
-              return false;
-            }
-          }
-
-          virtual bool call_match(const std::vector<Boxed_Value> &vals) const
-          {
-            std::vector<Boxed_Value> new_vals;
-            new_vals.push_back(Boxed_Value(Dynamic_Object(m_type_name)));
-            new_vals.insert(new_vals.end(), vals.begin(), vals.end());
-
-            return m_func->call_match(new_vals);
-          }    
-
-
-          virtual int get_arity() const
-          {
-            // "this" is not considered part of the arity
-            return m_func->get_arity() - 1; 
-          }
-
-          virtual std::string annotation() const
-          {
-            return m_func->annotation();
-          }
-
-        protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
-          {
-            std::vector<Boxed_Value> new_params;
-            chaiscript::Boxed_Value bv = var(Dynamic_Object(m_type_name));
-            new_params.push_back(bv);
-            new_params.insert(new_params.end(), params.begin(), params.end());
-
-            (*m_func)(new_params);
-
-            return bv;
-          }
-
-        private:
-          std::string m_type_name;
-          Proxy_Function m_func;
-
-      };
-    }
   }
 }
 #endif

include/chaiscript/dispatchkit/dynamic_object_detail.hpp

@@ -0,0 +1,261 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_DYNAMIC_OBJECT_DETAIL_HPP_
+#define CHAISCRIPT_DYNAMIC_OBJECT_DETAIL_HPP_
+
+#include <cassert>
+#include <map>
+#include <memory>
+#include <string>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#include "../chaiscript_defines.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "proxy_functions.hpp"
+#include "type_info.hpp"
+#include "dynamic_object.hpp"
+
+namespace chaiscript {
+class Type_Conversions;
+namespace dispatch {
+class Proxy_Function_Base;
+}  // namespace dispatch
+}  // namespace chaiscript
+
+namespace chaiscript
+{
+  namespace dispatch
+  {
+    namespace detail
+    {
+      /// A Proxy_Function implementation designed for calling a function
+      /// that is automatically guarded based on the first param based on the
+      /// param's type name
+      class Dynamic_Object_Function : public Proxy_Function_Base, public Dynamic_Function_Interface
+      {
+        public:
+          Dynamic_Object_Function(
+              std::string t_type_name,
+              const Proxy_Function &t_func,
+              bool t_is_attribute = false)
+            : Proxy_Function_Base(t_func->get_param_types(), t_func->get_arity()),
+              m_type_name(std::move(t_type_name)), m_func(t_func), m_doti(user_type<Dynamic_Object>()),
+              m_is_attribute(t_is_attribute)
+          {
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
+
+          Dynamic_Object_Function(
+              std::string t_type_name,
+              const Proxy_Function &t_func,
+              const Type_Info &t_ti,
+              bool t_is_attribute = false)
+            : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti), t_func->get_arity()),
+              m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(t_ti.is_undef()?nullptr:new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>()),
+              m_is_attribute(t_is_attribute)
+          {
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
+
+
+          Dynamic_Object_Function &operator=(const Dynamic_Object_Function) = delete;
+          Dynamic_Object_Function(Dynamic_Object_Function &) = delete;
+
+          Param_Types get_dynamic_param_types() const override {
+            auto dynamic(std::dynamic_pointer_cast<dispatch::Dynamic_Function_Interface>(m_func));
+
+            if (dynamic) {
+              return dynamic->get_dynamic_param_types();
+            } else {
+              return Param_Types(get_param_types());
+            }
+          }
+
+
+          bool operator==(const Proxy_Function_Base &f) const override
+          {
+            if (const auto *df = dynamic_cast<const Dynamic_Object_Function *>(&f))
+            {
+              return df->m_type_name == m_type_name && (*df->m_func) == (*m_func);
+            } else {
+              return false;
+            }
+          }
+
+          bool is_attribute_function() const override { return m_is_attribute; } 
+
+          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))
+            {
+              return m_func->call_match(vals, t_conversions);
+            } else {
+              return false;
+            }
+          }
+
+          std::vector<Const_Proxy_Function> get_contained_functions() const override
+          {
+            return {m_func};
+          }
+
+        protected:
+          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))
+            {
+              return (*m_func)(params, t_conversions);
+            } else {
+              throw exception::guard_error();
+            } 
+          }
+
+          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);
+          }
+
+        private:
+          static std::vector<Type_Info> build_param_types(
+              const std::vector<Type_Info> &t_inner_types, const Type_Info& t_objectti)
+          {
+            std::vector<Type_Info> types(t_inner_types);
+
+            assert(types.size() > 1);
+            //assert(types[1].bare_equal(user_type<Boxed_Value>()));
+            types[1] = t_objectti;
+            return types;
+          }
+
+          bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
+              const std::unique_ptr<Type_Info> &ti, const Type_Conversions_State &t_conversions) const
+          {
+            if (bv.get_type_info().bare_equal(m_doti))
+            {
+              try {
+                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
+                return name == "Dynamic_Object" || d.get_type_name() == name;
+              } catch (const std::bad_cast &) {
+                return false;
+              } 
+            } else {
+              if (ti)
+              {
+                return bv.get_type_info().bare_equal(*ti);
+              } else {
+                return false;
+              }
+            }
+
+          }
+
+          bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+              const std::unique_ptr<Type_Info> &ti, const Type_Conversions_State &t_conversions) const
+          {
+            if (!bvs.empty())
+            {
+              return dynamic_object_typename_match(bvs[0], name, ti, t_conversions);
+            } else {
+              return false;
+            }
+          }
+
+          std::string m_type_name;
+          Proxy_Function m_func;
+          std::unique_ptr<Type_Info> m_ti;
+          const Type_Info m_doti;
+          const bool m_is_attribute;
+      };
+
+
+      /**
+       * A Proxy_Function implementation designed for creating a new
+       * Dynamic_Object
+       * that is automatically guarded based on the first param based on the
+       * param's type name
+       */
+      class Dynamic_Object_Constructor final : public Proxy_Function_Base, public Dynamic_Function_Interface
+      {
+        public:
+          Dynamic_Object_Constructor(
+              std::string t_type_name,
+              const Proxy_Function &t_func)
+            : Proxy_Function_Base(build_type_list(t_func->get_param_types()), t_func->get_arity() - 1),
+              m_type_name(std::move(t_type_name)), m_func(t_func)
+          {
+            assert( t_func );
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
+
+          static std::vector<Type_Info> build_type_list(const std::vector<Type_Info> &tl)
+          {
+            auto begin = tl.begin();
+            auto end = tl.end();
+
+            if (begin != end)
+            {
+              ++begin;
+            }
+
+            return std::vector<Type_Info>(begin, end);
+          }
+
+
+          Param_Types get_dynamic_param_types() const override {
+            auto dynamic(std::dynamic_pointer_cast<dispatch::Dynamic_Function_Interface>(m_func));
+
+            if (dynamic) {
+              return dynamic->get_dynamic_param_types();
+            } else {
+              return Param_Types(get_param_types());
+            }
+          }
+
+
+          bool operator==(const Proxy_Function_Base &f) const override
+          {
+            const Dynamic_Object_Constructor *dc = dynamic_cast<const Dynamic_Object_Constructor*>(&f);
+            return (dc != nullptr) && dc->m_type_name == m_type_name && (*dc->m_func) == (*m_func);
+          }
+
+          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());
+
+            return m_func->call_match(new_vals, t_conversions);
+          }
+
+        protected:
+          Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions) const override
+          {
+            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());
+
+            (*m_func)(new_params, t_conversions);
+
+            return bv;
+          }
+
+        private:
+          const std::string m_type_name;
+          const Proxy_Function m_func;
+
+      };
+    }
+  }
+}
+#endif
+

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -1,79 +1,48 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
 #define CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
 
+#include <memory>
+
+#include "../chaiscript_defines.hpp"
 #include "boxed_cast.hpp"
 
+namespace chaiscript {
+class Boxed_Value;
+namespace exception {
+class bad_boxed_cast;
+}  // namespace exception
+}  // namespace chaiscript
+
 namespace chaiscript
 {
   namespace detail
   {
     struct Exception_Handler_Base
     {
-      virtual void handle(const Boxed_Value &bv) = 0;
+      virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) = 0;
+
+      virtual ~Exception_Handler_Base() = default;
 
       protected:
         template<typename T>
-        void throw_type(const Boxed_Value &bv)
+        static void throw_type(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
-          try { T t = boxed_cast<T>(bv); throw t; } catch (const exception::bad_boxed_cast &) {}
+          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 void handle(const Boxed_Value &bv)
+        void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) override
         {
-          throw_type<T1>(bv);
-        }
-      };
-    template<typename T1, typename T2>
-      struct Exception_Handler_Impl2 : Exception_Handler_Base
-      {
-        virtual void handle(const Boxed_Value &bv)
-        {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
-        }
-      };
-
-    template<typename T1, typename T2, typename T3>
-      struct Exception_Handler_Impl3 : Exception_Handler_Base
-      {
-        virtual void handle(const Boxed_Value &bv)
-        {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
-          throw_type<T3>(bv);
-        }
-      };
-    template<typename T1, typename T2, typename T3, typename T4>
-      struct Exception_Handler_Impl4 : Exception_Handler_Base
-      {
-        virtual void handle(const Boxed_Value &bv)
-        {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
-          throw_type<T3>(bv);
-          throw_type<T4>(bv);
-        }
-      };
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-      struct Exception_Handler_Impl5 : Exception_Handler_Base
-      {
-        virtual void handle(const Boxed_Value &bv)
-        {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
-          throw_type<T3>(bv);
-          throw_type<T4>(bv);
-          throw_type<T5>(bv);
+          (void)std::initializer_list<int>{(throw_type<T>(bv, t_engine), 0)...};
         }
       };
   }
@@ -128,46 +97,14 @@ namespace chaiscript
   ///
   /// \sa chaiscript::exception_specification for creation of chaiscript::Exception_Handler objects
   /// \sa \ref exceptions
-  typedef boost::shared_ptr<detail::Exception_Handler_Base> Exception_Handler;
+  typedef std::shared_ptr<detail::Exception_Handler_Base> Exception_Handler;
 
   /// \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,131 +1,123 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_HPP_
 
-#include <boost/shared_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
+#include <functional>
 #include <string>
 #include <vector>
-#include "proxy_functions.hpp"
+
+#include "boxed_cast.hpp"
 #include "function_call_detail.hpp"
+#include "proxy_functions.hpp"
+#include "callable_traits.hpp"
 
-
-#include <iostream>
+namespace chaiscript {
+class Boxed_Value;
+class Type_Conversions_State;
+namespace detail {
+template <typename T> struct Cast_Helper;
+}  // namespace detail
+}  // namespace chaiscript
 
 namespace chaiscript
 {
   namespace dispatch
   {
-    /**
-     * Build a function caller that knows how to dispatch on a set of functions
-     * example: 
-     * boost::function<void (int)> f = 
-     *      build_function_caller(dispatchkit.get_function("print"));
-     * \returns A boost::function object for dispatching
-     * \param[in] funcs the set of functions to dispatch on.
-     */
+    /// Build a function caller that knows how to dispatch on a set of functions
+    /// example:
+    /// std::function<void (int)> f =
+    ///      build_function_caller(dispatchkit.get_function("print"));
+    /// \returns A std::function object for dispatching
+    /// \param[in] funcs the set of functions to dispatch on.
     template<typename FunctionType>
-      boost::function<FunctionType>
-      functor(const std::vector<Const_Proxy_Function> &funcs)
+      std::function<FunctionType> functor(const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions_State *t_conversions)
       {
-        FunctionType *p=0;
-        return detail::build_function_caller_helper(p, funcs);
+        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);
       }
 
-    /**
-     * Build a function caller for a particular Proxy_Function object
-     * useful in the case that a function is being pass out from scripting back
-     * into code
-     * example: 
-     * void my_function(Proxy_Function f)
-     * {
-     *   boost::function<void (int)> local_f = 
-     *      build_function_caller(f);
-     * }
-     * \returns A boost::function object for dispatching
-     * \param[in] func A function to execute.
-     */
+    /// Build a function caller for a particular Proxy_Function object
+    /// useful in the case that a function is being pass out from scripting back
+    /// into code
+    /// example:
+    /// void my_function(Proxy_Function f)
+    /// {
+    ///   std::function<void (int)> local_f =
+    ///      build_function_caller(f);
+    /// }
+    /// \returns A std::function object for dispatching
+    /// \param[in] func A function to execute.
     template<typename FunctionType>
-      boost::function<FunctionType>
-      functor(Const_Proxy_Function func)
+      std::function<FunctionType> functor(Const_Proxy_Function func, const Type_Conversions_State *t_conversions)
       {
-        std::vector<Const_Proxy_Function> funcs;
-        funcs.push_back(func);
-        return functor<FunctionType>(funcs);
+        return functor<FunctionType>(std::vector<Const_Proxy_Function>({std::move(func)}), t_conversions);
       }
 
-    /**
-     * Helper for automatically unboxing a Boxed_Value that contains a function object
-     * and creating a typesafe C++ function caller from it.
-     */
+    /// Helper for automatically unboxing a Boxed_Value that contains a function object
+    /// and creating a typesafe C++ function caller from it.
     template<typename FunctionType>
-      boost::function<FunctionType>
-      functor(const Boxed_Value &bv)
+      std::function<FunctionType> functor(const Boxed_Value &bv, const Type_Conversions_State *t_conversions)
       {
-        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv));
+        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
       }
   }
 
   namespace detail{
-    /**
-     * Cast helper to handle automatic casting to const boost::function &
-     */
+    /// Cast helper to handle automatic casting to const std::function &
     template<typename Signature>
-      struct Cast_Helper<const boost::function<Signature> &>
+      struct Cast_Helper<const std::function<Signature> &>
       {
-        typedef boost::function<Signature> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        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>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> &>::cast(ob);
+            return Cast_Helper_Inner<const std::function<Signature> &>::cast(ob, t_conversions);
           }
         }
       };
 
-    /**
-     * Cast helper to handle automatic casting to boost::function
-     */
+    /// Cast helper to handle automatic casting to std::function
     template<typename Signature>
-      struct Cast_Helper<boost::function<Signature> >
+      struct Cast_Helper<std::function<Signature> >
       {
-        typedef boost::function<Signature> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        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>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<boost::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<std::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };
 
-    /**
-     * Cast helper to handle automatic casting to const boost::function
-     */
+    /// Cast helper to handle automatic casting to const std::function
     template<typename Signature>
-      struct Cast_Helper<const boost::function<Signature> >
+      struct Cast_Helper<const std::function<Signature> >
       {
-        typedef boost::function<Signature> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
+        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>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<const std::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,24 +1,22 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#define addparam(z,n,text)  params.push_back((boost::is_reference<Param ## n>::value&&!(boost::is_same<chaiscript::Boxed_Value, typename boost::remove_const<typename boost::remove_reference<Param ## n>::type>::type>::value))?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
-#define curry(z,n,text)  BOOST_PP_CAT(_, BOOST_PP_INC(n))
-
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 
-#include <boost/shared_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
+#include <functional>
+#include <memory>
 #include <string>
+#include <type_traits>
 #include <vector>
+
+#include "boxed_cast.hpp"
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+#include "type_conversions.hpp"
 #include "proxy_functions.hpp"
 
 namespace chaiscript
@@ -27,77 +25,128 @@ namespace chaiscript
   {
     namespace detail
     {
-
-      /**
-       * Internal helper class for handling the return
-       * value of a build_function_caller
-       */
-      template<typename Ret>
+      /// Internal helper class for handling the return
+      /// value of a build_function_caller
+      template<typename Ret, bool is_arithmetic>
         struct Function_Caller_Ret
         {
           static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params)
+              const std::vector<Boxed_Value> &params, const Type_Conversions_State *t_conversions)
           {
-            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params));
+            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);
+            }
           }
         };
 
+      /**
+       * Specialization for arithmetic return types
+       */
+      template<typename Ret>
+        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_State *t_conversions)
+          {
+            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>();
+            }
+          }
+        };
+
+
       /**
        * Specialization for void return types
        */
       template<>
-        struct Function_Caller_Ret<void>
+        struct Function_Caller_Ret<void, false>
         {
           static void call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params)
+              const std::vector<Boxed_Value> &params, const Type_Conversions_State *t_conversions)
           {
-            dispatch::dispatch(t_funcs, params);
+            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);
+            }
           }
         };
-    }
-  }
-}
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 9 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/function_call_detail.hpp>
-#include BOOST_PP_ITERATE()
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
-  namespace dispatch
-  {
-    namespace detail
-    {
-      /**
-       * used internally for unwrapping a function call's types
-       */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        Ret function_caller(const std::vector<Const_Proxy_Function> &funcs 
-            BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
-        {
-          std::vector<Boxed_Value> params;
-
-          BOOST_PP_REPEAT(n, addparam, ~)
-
-            return Function_Caller_Ret<Ret>::call(funcs, params);
-        }
 
       /**
        * used internally for unwrapping a function call's types
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
-        build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<Const_Proxy_Function> &funcs)
+      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)
+            : m_funcs(std::move(t_funcs)),
+              m_conversions(t_conversions)
+          {
+          }
+
+          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, { 
+                  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;
+          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_State *t_conversions)
+        {
+          /*
           if (funcs.size() == 1)
           {
-            boost::shared_ptr<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> > pfi = 
-              boost::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> >
-              (funcs[0]);
+            std::shared_ptr<const Proxy_Function_Impl<Ret (Params...)>> pfi = 
+              std::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (Params...)> >
+                (funcs[0]);
 
             if (pfi)
             {
@@ -106,14 +155,13 @@ 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 boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs
-              BOOST_PP_ENUM_TRAILING(n, curry, ~));
+          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions?t_conversions->get():nullptr));
         }
     }
   }
 }
-#undef n
 
 #endif
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,25 +1,30 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
 #define CHAISCRIPT_HANDLE_RETURN_HPP_
 
-#include "boxed_value.hpp"
-#include "boxed_number.hpp"
-#include "type_info.hpp"
-#include <string>
-#include <boost/function.hpp>
+#include <functional>
+#include <memory>
+#include <type_traits>
 
-#include <stdexcept>
-#include <vector>
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+
+namespace chaiscript {
+class Boxed_Number;
+}  // namespace chaiscript
 
 namespace chaiscript
 {
   namespace dispatch
   {
+    template<class T, class U> class Proxy_Function_Callable_Impl;
+    template<class T> class Assignable_Proxy_Function_Impl;
+
     namespace detail
     {
       /**
@@ -28,9 +33,88 @@ namespace chaiscript
       template<typename Ret>
         struct Handle_Return
         {
-          static Boxed_Value handle(const Ret &r)
+          template<typename T,
+                   typename = typename std::enable_if<std::is_pod<typename std::decay<T>::type>::value>::type>
+          static Boxed_Value handle(T r)
           {
-            return const_var(r);
+            return Boxed_Value(std::move(r), true);
+          }
+
+          template<typename T,
+                   typename = typename std::enable_if<!std::is_pod<typename std::decay<T>::type>::value>::type>
+          static Boxed_Value handle(T &&r)
+          {
+            return Boxed_Value(std::make_shared<T>(std::forward<T>(r)), true);
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const std::function<Ret> &>
+        {
+          static Boxed_Value handle(const std::function<Ret> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret, std::function<Ret>>>(f)
+              );
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::function<Ret>> : Handle_Return<const std::function<Ret> &>
+        {
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const std::shared_ptr<std::function<Ret>>>
+        {
+          static Boxed_Value handle(const std::shared_ptr<std::function<Ret>> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Assignable_Proxy_Function_Impl<Ret>>(std::ref(*f),f)
+                );
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const std::shared_ptr<std::function<Ret>> &> : Handle_Return<const std::shared_ptr<std::function<Ret>>>
+        {
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::shared_ptr<std::function<Ret>>> : Handle_Return<const std::shared_ptr<std::function<Ret>>>
+        {
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::function<Ret> &>
+        {
+          static Boxed_Value handle(std::function<Ret> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Assignable_Proxy_Function_Impl<Ret>>(std::ref(f),
+                  std::shared_ptr<std::function<Ret>>())
+              );
+          }
+
+          static Boxed_Value handle(const std::function<Ret> &f) {
+            return Boxed_Value(
+                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret, std::function<Ret>>>(f)
+              );
+          }
+        };
+
+      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);
           }
         };
 
@@ -39,35 +123,36 @@ namespace chaiscript
         {
           static Boxed_Value handle(Ret *p)
           {
-            return Boxed_Value(p);
+            return Boxed_Value(p, true);
           }
         };
 
       template<typename Ret>
-        struct Handle_Return<boost::shared_ptr<Ret> &>
+        struct Handle_Return<const Ret *>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(const Ret *p)
           {
-            return Boxed_Value(r);
+            return Boxed_Value(p, true);
           }
         };
 
       template<typename Ret>
-        struct Handle_Return<boost::shared_ptr<Ret> >
+        struct Handle_Return<std::shared_ptr<Ret> &>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
-            return Boxed_Value(r);
+            return Boxed_Value(r, true);
           }
         };
 
       template<typename Ret>
-        struct Handle_Return<const boost::shared_ptr<Ret> &>
+        struct Handle_Return<std::shared_ptr<Ret>> : Handle_Return<std::shared_ptr<Ret> &>
+        {
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const std::shared_ptr<Ret> &> : Handle_Return<std::shared_ptr<Ret> &>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
-          {
-            return Boxed_Value(r);
-          }
         };
 
       template<typename Ret>
@@ -75,31 +160,28 @@ namespace chaiscript
         {
           static Boxed_Value handle(const Ret &r)
           {
-            return Boxed_Value(boost::cref(r));
+            return Boxed_Value(std::cref(r), true);
           }
         };
 
+      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 &>
         {
           static Boxed_Value handle(Ret &r)
           {
-            return Boxed_Value(boost::ref(r));
-          }
-
-          static Boxed_Value handle(const Ret &r)
-          {
-            return Boxed_Value(boost::cref(r));
+            return Boxed_Value(std::ref(r));
           }
         };
 
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
       template<>
         struct Handle_Return<Boxed_Value>
         {
@@ -109,40 +191,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;
-          }
         };
 
       /**
@@ -157,16 +218,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;
-          }
         };
 
 
@@ -178,7 +232,7 @@ namespace chaiscript
         {
           static Boxed_Value handle()
           {
-            return Boxed_Value(Boxed_Value::Void_Type());
+            return void_var();
           }
         };
     }

include/chaiscript/dispatchkit/operators.hpp

@@ -1,455 +1,217 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_OPERATORS_HPP_
 #define CHAISCRIPT_OPERATORS_HPP_
 
+#include "../chaiscript_defines.hpp"
+#include "register_function.hpp"
+
 namespace chaiscript 
 {
   namespace bootstrap
   {
     namespace operators
     {
-      template<typename Ret, typename L, typename R>
-        Ret assign(L l, R r)
-        {
-          return (l = r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_bitwise_and(L l, R r)
-        {
-          return (l &= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_xor(L l, R r)
-        {
-          return (l ^= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_bitwise_or(L l, R r)
-        {
-          return (l |= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_difference(L l, R r)
-        {
-          return (l -= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_left_shift(L l, R r)
-        {
-          return (l <<= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_product(L l, R r)
-        {
-          return (l *= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_quotient(L l, R r)
-        {
-          return (l /= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_remainder(L l, R r)
-        {
-          return (l %= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_right_shift(L l, R r)
-        {
-          return (l >>= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret assign_sum(L l, R r)
-        {
-          return (l += r);
-        }
-
-      template<typename Ret, typename L>
-        Ret prefix_decrement(L l)
-        {
-          return (--l);
-        }
-
-      template<typename Ret, typename L>
-        Ret prefix_increment(L l)
-        {
-          return (++l);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret equal(L l, R r)
-        {
-          return (l == r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret greater_than(L l, R r)
-        {
-          return (l > r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret greater_than_equal(L l, R r)
-        {
-          return (l >= r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret less_than(L l, R r)
-        {
-          return (l < r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret less_than_equal(L l, R r)
-        {
-          return (l <= r);
-        }
-
-      template<typename Ret, typename L>
-        Ret logical_compliment(L l)
-        {
-          return (!l);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret not_equal(L l, R r)
-        {
-          return (l != r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret addition(L l, R r)
-        {
-          return (l + r);
-        }
-
-      template<typename Ret, typename L>
-        Ret unary_plus(L l)
-        {
-          return (+l);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret subtraction(L l, R r)
-        {
-          return (l - r);
-        }
-
-      template<typename Ret, typename L>
-        Ret unary_minus(L l)
-        {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4146)
-          return (-l);
-#pragma warning(pop)
-#else
-          return (-l);
-#endif
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_and(L l, R r)
-        {
-          return (l & r);
-        }
-
-      template<typename Ret, typename L>
-        Ret bitwise_compliment(L l)
-        {
-          return (~l);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_xor(L l, R r)
-        {
-          return (l ^ r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_or(L l, R r)
-        {
-          return (l | r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret division(L l, R r)
-        {
-          return (l / r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret left_shift(L l, R r)
-        {
-          return l << r;
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret multiplication(L l, R r)
-        {
-          return l * r;
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret remainder(L l, R r)
-        {
-          return (l % r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret right_shift(L l, R r)
-        {
-          return (l >> r);
-        }
-
-
-
-
       template<typename T>
-        ModulePtr assign(ModulePtr m = ModulePtr(new Module()))
+        void assign(Module& m)
         {
-          m->add(fun(&assign<T &, 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 = ModulePtr(new Module()))
+        void assign_bitwise_and(Module& m)
         {
-          m->add(fun(&assign_bitwise_and<T &, 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 = ModulePtr(new Module()))
+        void assign_xor(Module& m)
         {
-          m->add(fun(&assign_xor<T &, 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 = ModulePtr(new Module()))
+        void assign_bitwise_or(Module& m)
         {
-          m->add(fun(&assign_bitwise_or<T &, 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 = ModulePtr(new Module()))
+        void assign_difference(Module& m)
         {
-          m->add(fun(&assign_difference<T &, 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 = ModulePtr(new Module()))
+        void assign_left_shift(Module& m)
         {
-          m->add(fun(&assign_left_shift<T &, 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 = ModulePtr(new Module()))
+        void assign_product(Module& m)
         {
-          m->add(fun(&assign_product<T &, 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 = ModulePtr(new Module()))
+        void assign_quotient(Module& m)
         {
-          m->add(fun(&assign_quotient<T &, 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 = ModulePtr(new Module()))
+        void assign_remainder(Module& m)
         {
-          m->add(fun(&assign_remainder<T &, 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 = ModulePtr(new Module()))
+        void assign_right_shift(Module& m)
         {
-          m->add(fun(&assign_right_shift<T &, 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 = ModulePtr(new Module()))
+        void assign_sum(Module& m)
         {
-          m->add(fun(&assign_sum<T &, 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 = ModulePtr(new Module()))
+        void prefix_decrement(Module& m)
         {
-          m->add(fun(&prefix_decrement<T &, T &>), "--");
-          return m;
+          m.add(chaiscript::fun([](T &lhs)->T&{return --lhs;}), "--");
         }
 
       template<typename T>
-        ModulePtr prefix_increment(ModulePtr m = ModulePtr(new Module()))
+        void prefix_increment(Module& m)
         {
-          m->add(fun(&prefix_increment<T &, T &>), "++");
-          return m;
+          m.add(chaiscript::fun([](T &lhs)->T&{return ++lhs;}), "++");
         }
 
       template<typename T>
-        ModulePtr equal(ModulePtr m = ModulePtr(new Module()))
+        void equal(Module& m)
         {
-          m->add(fun(&equal<bool, 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 = ModulePtr(new Module()))
+        void greater_than(Module& m)
         {
-          m->add(fun(&greater_than<bool, 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 = ModulePtr(new Module()))
+        void greater_than_equal(Module& m)
         {
-          m->add(fun(&greater_than_equal<bool, 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 = ModulePtr(new Module()))
+        void less_than(Module& m)
         {
-          m->add(fun(&less_than<bool, 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 = ModulePtr(new Module()))
+        void less_than_equal(Module& m)
         {
-          m->add(fun(&less_than_equal<bool, 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 = ModulePtr(new Module()))
+        void logical_compliment(Module& m)
         {
-          m->add(fun(&logical_compliment<bool, const T &>), "!");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return !lhs;}), "!");
         }
 
       template<typename T>
-        ModulePtr not_equal(ModulePtr m = ModulePtr(new Module()))
+        void not_equal(Module& m)
         {
-          m->add(fun(&not_equal<bool, 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 = ModulePtr(new Module()))
+        void addition(Module& m)
         {
-          m->add(fun(&addition<T, 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 = ModulePtr(new Module()))
+        void unary_plus(Module& m)
         {
-          m->add(fun(&unary_plus<T, const T &>), "+");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return +lhs;}), "+");
         }
 
       template<typename T>
-        ModulePtr subtraction(ModulePtr m = ModulePtr(new Module()))
+        void subtraction(Module& m)
         {
-          m->add(fun(&subtraction<T, 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 = ModulePtr(new Module()))
+        void unary_minus(Module& m)
         {
-          m->add(fun(&unary_minus<T, const T &>), "-");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return -lhs;}), "-");
         }
 
       template<typename T>
-        ModulePtr bitwise_and(ModulePtr m = ModulePtr(new Module()))
+        void bitwise_and(Module& m)
         {
-          m->add(fun(&bitwise_and<T, 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 = ModulePtr(new Module()))
+        void bitwise_compliment(Module& m)
         {
-          m->add(fun(&bitwise_compliment<T, const T &>), "~");
-          return m;
+          m.add(chaiscript::fun([](const T &lhs){return ~lhs;}), "~");
         }
 
       template<typename T>
-        ModulePtr bitwise_xor(ModulePtr m = ModulePtr(new Module()))
+        void bitwise_xor(Module& m)
         {
-          m->add(fun(&bitwise_xor<T, 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 = ModulePtr(new Module()))
+        void bitwise_or(Module& m)
         {
-          m->add(fun(&bitwise_or<T, 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 = ModulePtr(new Module()))
+        void division(Module& m)
         {
-          m->add(fun(&division<T, 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 = ModulePtr(new Module()))
+        void left_shift(Module& m)
         {
-          m->add(fun(&left_shift<T, 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 = ModulePtr(new Module()))
+        void multiplication(Module& m)
         {
-          m->add(fun(&multiplication<T, 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 = ModulePtr(new Module()))
+        void remainder(Module& m)
         {
-          m->add(fun(&remainder<T, 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 = ModulePtr(new Module()))
+        void right_shift(Module& m)
         {
-          m->add(fun(&right_shift<T, 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,27 +1,34 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
 
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 #define CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 
-#include <boost/shared_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
-
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_constructors.hpp>
-#include BOOST_PP_ITERATE()
-# endif
+#include "proxy_functions.hpp"
 
 namespace chaiscript
 {
+  namespace dispatch
+  {
+    namespace detail
+    {
+
+      template<typename Class, typename ... Params  >
+        Proxy_Function build_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));
+        }
+    }
+  }
+
+
   /// \brief Generates a constructor function for use with ChaiScript
   /// 
   /// \tparam T The signature of the constructor to generate. In the form of: ClassType (ParamType1, ParamType2, ...)
@@ -36,46 +43,11 @@ namespace chaiscript
   template<typename T>
     Proxy_Function constructor()
     {
-      T *f = 0;
+      T *f = nullptr;
       return (dispatch::detail::build_constructor_(f));
     }
+
 }
 
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
-  namespace dispatch
-  {
-    namespace detail
-    {
-      /**
-       * A constructor function, used for creating a new object
-       * of a given type with a given set of params
-       */
-      template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        boost::shared_ptr<Class> constructor_( BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
-        {
-          return boost::shared_ptr<Class>(new Class( BOOST_PP_ENUM_PARAMS(n, p) ));
-        }
-
-      /**
-       * Helper function for build a constructor function
-       * example:
-       * dispatchengine.register_function(build_constructor<MyClass, int, const std::string&>, "MyClass");
-       * \todo See if it is possible to make this not be a variadic function
-       */
-      template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        Proxy_Function build_constructor_(Class (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
-        {
-          typedef boost::shared_ptr<Class> (sig)(BOOST_PP_ENUM_PARAMS(n, Param));
-          return Proxy_Function(new Proxy_Function_Impl<sig>(boost::function<sig>(&(constructor_<Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>))));
-        }
-    }
-  }
-}
-#undef n
-
 #endif
 

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -1,30 +1,30 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#define gettypeinfo(z,n,text)  ti.push_back(chaiscript::detail::Get_Type_Info<Param ## n>::get());
-#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n])
-#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n]);
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
-#include "boxed_value.hpp"
-#include "boxed_cast.hpp"
-#include "type_info.hpp"
-#include "handle_return.hpp"
-#include <string>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
-
+#include <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_State;
+namespace exception {
+class bad_boxed_cast;
+}  // namespace exception
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -42,26 +42,15 @@ namespace chaiscript
       {
       }
 
-      virtual ~arity_error() throw() {}
+      arity_error(const arity_error &) = default;
+
+      ~arity_error() noexcept override = default;
 
       int got;
       int expected;
     };
   }
 
-}
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_functions_detail.hpp>
-#include BOOST_PP_ITERATE()
-
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
   namespace dispatch
   {
     namespace detail
@@ -70,91 +59,77 @@ namespace chaiscript
        * Used by Proxy_Function_Impl to return a list of all param types
        * it contains.
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        std::vector<Type_Info> build_param_type_list(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
+      template<typename Ret, typename ... Params>
+        std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
         {
-          std::vector<Type_Info> ti;
-          ti.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
-
-          BOOST_PP_REPEAT(n, gettypeinfo, ~) 
-
-          return ti;
+          /// \note somehow this is responsible for a large part of the code generation
+          return { user_type<Ret>(), user_type<Params>()... };
         }
 
-      /**
-       * Used by Proxy_Function_Impl to perform typesafe execution of a function.
-       * The function attempts to unbox each paramter to the expected type.
-       * if any unboxing fails the execution of the function fails and
-       * the bad_boxed_cast is passed up to the caller.
-       */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-        Ret call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
-            const std::vector<Boxed_Value> &params)
-        {
-          if (params.size() != n)
-          {
-            throw exception::arity_error(static_cast<int>(params.size()), n);
-          } else {
-            return f(BOOST_PP_REPEAT(n, casthelper, ~));
-          }
-        }
 
       /**
        * Used by Proxy_Function_Impl to determine if it is equivalent to another
-       * Proxy_Function_Impl object. This function is primarly used to prevent
+       * Proxy_Function_Impl object. This function is primarily used to prevent
        * registration of two functions with the exact same signatures
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-        bool compare_types_cast(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)),
-            const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, ))
+      template<typename Ret, typename ... Params>
+        bool compare_types_cast(Ret (*)(Params...),
+             const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
         {
           try {
-            BOOST_PP_REPEAT(n, trycast, ~);
+            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 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)
+        {
+          (void)params; (void)t_conversions;
+          return f(boxed_cast<Params>(params[I], &t_conversions)...);
+        }
+
+
+      /// Used by Proxy_Function_Impl to perform typesafe execution of a function.
+      /// The function attempts to unbox each parameter to the expected type.
+      /// if any unboxing fails the execution of the function fails and
+      /// the bad_boxed_cast is passed up to the caller.
+      template<typename Callable, typename Ret, typename ... Params>
+        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 : 4702)
+#endif
+          // MSVC is reporting that this is unreachable code - and it's wrong.
+          return Handle_Return<void>::handle();
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif
+        }
+
     }
   }
+
 }
 
-#undef n
-
-#endif
-
-
-#ifndef BOOST_PP_IS_ITERATING
-
-namespace chaiscript
-{
-  namespace dispatch
-  {
-    namespace detail
-    {
-    template<typename Ret>
-      struct Do_Call
-      {
-        template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
-          {
-            return Handle_Return<Ret>::handle(call_func(fun, params));
-          }
-      };
-
-    template<>
-      struct Do_Call<void>
-      {
-        template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
-          {
-            call_func(fun, params);
-            return Handle_Return<void>::handle();
-          }
-      };
-    }
-  }
-}
 
 #endif

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,86 +1,19 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_
 #define CHAISCRIPT_REGISTER_FUNCTION_HPP_
 
-#include "dispatchkit.hpp"
+#include <type_traits>
+
 #include "bind_first.hpp"
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/function_types/components.hpp>
-#include <boost/function_types/function_type.hpp>
-#include <boost/function_types/is_member_object_pointer.hpp>
-#include <boost/function_types/is_member_function_pointer.hpp>
+#include "proxy_functions.hpp"
 
 namespace chaiscript
 {
-  namespace dispatch
-  {
-    namespace detail
-    {
-      template<bool Object, bool MemFn>
-        struct Fun_Helper
-        {
-          template<typename T>
-            static Proxy_Function go(T t)
-            {
-              return Proxy_Function(
-                  new Proxy_Function_Impl<
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(t)));
-            }      
-        };
-
-      template<>
-        struct Fun_Helper<false, true>
-        {
-          template<typename T>
-            static Proxy_Function go(T t)
-            {
-              return Proxy_Function(
-                  new Proxy_Function_Impl<
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(boost::mem_fn(t))));
-            }      
-        };
-
-
-      template<>
-        struct Fun_Helper<true, false>
-        {
-          template<typename T, typename Class>
-            static Proxy_Function go(T Class::* m)
-            {
-              return Proxy_Function(new Attribute_Access<T, Class>(m));
-            }
-        };
-    }
-  }
-
-  /// \brief Creates a new Proxy_Function object from a boost::function object
-  /// \param[in] f boost::function to expose to ChaiScript
-  ///
-  /// \b Example:
-  /// \code
-  /// boost::function<int (char, float, std::string)> f = get_some_function();
-  /// chaiscript::ChaiScript chai;
-  /// chai.add(fun(f), "some_function");
-  /// \endcode
-  /// 
-  /// \sa \ref addingfunctions
-  template<typename T>
-    Proxy_Function fun(const boost::function<T> &f)
-    {
-      return Proxy_Function(new dispatch::Proxy_Function_Impl<T>(f));
-    }
 
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member
   /// \param[in] t Function / member to expose
@@ -101,13 +34,55 @@ namespace chaiscript
   /// chai.add(fun(&MyClass::memberdata), "memberdata");
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T>
-    Proxy_Function fun(T t)
+    Proxy_Function fun(const T &t)
     {
-      return dispatch::detail::Fun_Helper<boost::function_types::is_member_object_pointer<T>::value, boost::function_types::is_member_function_pointer<T>::value>::go(t);
+      typedef typename dispatch::detail::Callable_Traits<T>::Signature Signature;
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Signature, T>>(t));
     }
 
+  template<typename Ret, typename ... Param>
+    Proxy_Function fun(Ret (*func)(Param...))
+    {
+      auto fun_call = dispatch::detail::Fun_Caller<Ret, Param...>(func);
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Param...), decltype(fun_call)>>(fun_call));
+
+    }
+
+  template<typename Ret, typename Class, typename ... Param>
+    Proxy_Function fun(Ret (Class::*t_func)(Param...) const)
+    {
+      auto call = dispatch::detail::Const_Caller<Ret, Class, Param...>(t_func);
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (const Class &, Param...), decltype(call)>>(call));
+    }
+
+  template<typename Ret, typename Class, typename ... Param>
+    Proxy_Function fun(Ret (Class::*t_func)(Param...))
+    {
+      auto call = dispatch::detail::Caller<Ret, Class, Param...>(t_func);
+
+      return Proxy_Function(
+          chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret (Class &, Param...), decltype(call)>>(call));
+
+    }
+
+
+  template<typename T, typename Class /*, typename = typename std::enable_if<std::is_member_object_pointer<T>::value>::type*/>
+    Proxy_Function fun(T Class::* m /*, typename std::enable_if<std::is_member_object_pointer<T>::value>::type* = 0*/ )
+    {
+      return Proxy_Function(chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Attribute_Access<T, Class>>(m));
+    }
+
+
+
+  
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member and binds the first parameter of it
   /// \param[in] t Function / member to expose
   /// \param[in] q Value to bind to first parameter
@@ -122,14 +97,14 @@ namespace chaiscript
   /// MyClass obj;
   /// chaiscript::ChaiScript chai;
   /// // Add function taking only one argument, an int, and permanently bound to "obj"
-  /// chai.add(fun(&MyClass::memberfunction, boost::ref(obj)), "memberfunction"); 
+  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj)), "memberfunction"); 
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T, typename Q>
-    Proxy_Function fun(T t, const Q &q)
+    Proxy_Function fun(T &&t, const Q &q)
     {
-      return fun(detail::bind_first(t, q));
+      return fun(detail::bind_first(std::forward<T>(t), q));
     }
 
   /// \brief Creates a new Proxy_Function object from a free function or member function and binds the first and second parameters of it
@@ -148,16 +123,16 @@ namespace chaiscript
   /// 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, boost::ref(obj), 1), "memberfunction"); 
+  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj), 1), "memberfunction"); 
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T, typename Q, typename R>
-    Proxy_Function fun(T t, const Q &q, const R &r)
+    Proxy_Function fun(T &&t, Q &&q, R &&r)
     {
-      return fun(detail::bind_first(detail::bind_first(t, q), r));
+      return fun(detail::bind_first(detail::bind_first(std::forward<T>(t), std::forward<Q>(q)), std::forward<R>(r)));
     }
-   
+
 }
 
 

include/chaiscript/dispatchkit/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

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

include/chaiscript/dispatchkit/type_info.hpp

@@ -1,25 +1,16 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_TYPE_INFO_HPP_
 #define CHAISCRIPT_TYPE_INFO_HPP_
 
-#include <string>
+#include <memory>
+#include <type_traits>
 #include <typeinfo>
-#include <boost/shared_ptr.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/ref.hpp>
+#include <string>
 
 namespace chaiscript
 {
@@ -29,86 +20,75 @@ namespace chaiscript
     template<typename T>
       struct Bare_Type
       {
-        typedef typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type type;
+        typedef typename std::remove_cv<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::type type;
       };
   }
 
+
   /// \brief Compile time deduced information about a type
   class Type_Info
   {
     public:
-      Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
-          bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
-        : m_type_info(t_ti), m_bare_type_info(t_bareti),
-        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)
+      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_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))
       {
       }
 
-      Type_Info()
-        : m_type_info(0), m_bare_type_info(0),
-        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;
 
-      Type_Info(const Type_Info &ti)
-        : m_type_info(ti.m_type_info), 
-        m_bare_type_info(ti.m_bare_type_info),
-        m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
-        m_is_pointer(ti.m_is_pointer),
-        m_is_void(ti.m_is_void), m_is_arithmetic(ti.m_is_arithmetic),
-        m_is_undef(ti.m_is_undef)
-      {
-      }
-
-      Type_Info &operator=(const Type_Info &ti)
-      {
-        m_type_info = ti.m_type_info;
-        m_bare_type_info = ti.m_bare_type_info;
-        m_is_const = ti.m_is_const;
-        m_is_reference = ti.m_is_reference;
-        m_is_pointer = ti.m_is_pointer;
-        m_is_void = ti.m_is_void;
-        m_is_arithmetic = ti.m_is_arithmetic;
-        m_is_undef = ti.m_is_undef;
-        return *this;
-      }
-
-      bool operator<(const Type_Info &ti) const
+      constexpr bool operator<(const Type_Info &ti) const noexcept
       {
         return m_type_info < ti.m_type_info;
       }
 
-      bool operator==(const Type_Info &ti) const
+      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);
+        return !(operator==(ti));
       }
 
-      bool operator==(const std::type_info &ti) const
+      constexpr bool operator!=(const std::type_info &ti) const noexcept
       {
-        return m_type_info != 0 && (*m_type_info) == ti;
+        return !(operator==(ti));
       }
 
-      bool bare_equal(const Type_Info &ti) const
+      constexpr bool operator==(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);
+        return ti.m_type_info == m_type_info
+           || *ti.m_type_info == *m_type_info;
       }
 
-      bool is_const() const { return m_is_const; }
-      bool is_reference() const { return m_is_reference; }
-      bool is_void() const { return m_is_void; }
-      bool is_arithmetic() const { return m_is_arithmetic; }
-      bool is_undef() const { return m_is_undef || m_bare_type_info == 0; }
-      bool is_pointer() const { return m_is_pointer; }
+      constexpr bool operator==(const std::type_info &ti) const noexcept
+      {
+        return !is_undef() && (*m_type_info) == ti;
+      }
+
+      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;
+      }
+
+      constexpr bool bare_equal_type_info(const std::type_info &ti) const noexcept
+      {
+        return !is_undef() && (*m_bare_type_info) == ti;
+      }
+
+      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 {
@@ -118,7 +98,7 @@ namespace chaiscript
 
       std::string bare_name() const
       {
-        if (m_bare_type_info)
+        if (!is_undef())
         {
           return m_bare_type_info->name();
         } else {
@@ -126,102 +106,102 @@ namespace chaiscript
         }
       }
 
+      constexpr const std::type_info *bare_type_info() const
+      {
+        return m_bare_type_info;
+      }
+
     private:
-      const std::type_info *m_type_info;
-      const std::type_info *m_bare_type_info;
-      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
   {
-    /**
-     * Helper used to create a Type_Info object
-     */
+    /// Helper used to create a Type_Info object
     template<typename T>
       struct Get_Type_Info
       {
-        typedef T type;
-
-        static Type_Info get()
+        static constexpr Type_Info get()
         {
-          return Type_Info(boost::is_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(T), 
+          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_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));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<boost::shared_ptr<T> >
+      struct Get_Type_Info<std::shared_ptr<T> >
       {
-        typedef T type;
+//        typedef T type;
 
-        static Type_Info get()
+        static constexpr Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(boost::shared_ptr<T> ), 
+          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<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<const boost::shared_ptr<T> &>
+      struct Get_Type_Info<std::shared_ptr<T> &> : Get_Type_Info<std::shared_ptr<T>>
       {
-        typedef T type;
+      };
 
-        static Type_Info get()
+    template<typename T>
+      struct Get_Type_Info<const std::shared_ptr<T> &>
+      {
+        static constexpr Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(const boost::shared_ptr<T> &), 
+          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<typename std::remove_reference<T>::type>::type, bool>::value,
+              &typeid(const std::shared_ptr<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<boost::reference_wrapper<T> >
+      struct Get_Type_Info<std::reference_wrapper<T> >
       {
-        typedef T type;
-
-        static Type_Info get()
+        static constexpr Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(boost::reference_wrapper<T> ), 
+          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<typename std::remove_reference<T>::type>::type, bool>::value,
+              &typeid(std::reference_wrapper<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<const boost::reference_wrapper<T> &>
+      struct Get_Type_Info<const std::reference_wrapper<T> &>
       {
-        typedef T type;
-
-        static Type_Info get()
+        static constexpr Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(const boost::reference_wrapper<T> &), 
+          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<typename std::remove_reference<T>::type>::type, bool>::value,
+              &typeid(const std::reference_wrapper<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
-    template<typename T>
-      struct Stripped_Type
-      {
-        typedef typename Bare_Type<typename detail::Get_Type_Info<T>::type>::type type;
-      };
   }
 
   /// \brief Creates a Type_Info object representing the type passed in
@@ -234,7 +214,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type(i);
   /// \endcode
   template<typename T>
-  Type_Info user_type(const T &/*t*/)
+  constexpr Type_Info user_type(const T &/*t*/)
   {
     return detail::Get_Type_Info<T>::get();
   }
@@ -249,7 +229,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
   /// \endcode
   template<typename T>
-  Type_Info user_type()
+  constexpr Type_Info user_type()
   {
     return detail::Get_Type_Info<T>::get();
   }

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -1,20 +1,21 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ALGEBRAIC_HPP_
-#define	CHAISCRIPT_ALGEBRAIC_HPP_
+#define CHAISCRIPT_ALGEBRAIC_HPP_
 
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
-#include <boost/enable_shared_from_this.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, 
@@ -32,7 +33,7 @@ namespace chaiscript
     };
 
     static const char *to_string(Opers t_oper) {
-      const char *opers[] = { 
+      static const char *opers[] = { 
         "",
         "==", "<", ">", "<=", ">=", "!=",
         "",
@@ -47,85 +48,48 @@ 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;
-      } 
+      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; }
+      }
     }
 
   };
 }
 
-#endif	/* _CHAISCRIPT_ALGEBRAIC_HPP */
+#endif /* _CHAISCRIPT_ALGEBRAIC_HPP */
 

include/chaiscript/language/chaiscript_common.hpp

@@ -1,45 +1,85 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
-#define	CHAISCRIPT_COMMON_HPP_
+#define CHAISCRIPT_COMMON_HPP_
 
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
-#include <boost/enable_shared_from_this.hpp>
+#include <algorithm>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../chaiscript_defines.hpp"
+#include "../dispatchkit/boxed_value.hpp"
+#include "../dispatchkit/dispatchkit.hpp"
+#include "../dispatchkit/proxy_functions.hpp"
+#include "../dispatchkit/type_info.hpp"
+
+namespace chaiscript {
+struct AST_Node;
+}  // namespace chaiscript
 
 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, 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, Switch, Case, Default, Ternary_Cond
-    };
+  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", "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", "Switch", "Case", "Default", "Ternary Condition"};
+    /// Helper lookup to get the name of each node type
+    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", "Ternary Condition", "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)];
     }
   }
 
@@ -54,219 +94,609 @@ namespace chaiscript
     File_Position() : line(0), column(0) { }
   };
 
+  struct Parse_Location {
+    Parse_Location(std::string t_fname="", const int t_start_line=0, const int t_start_col=0,
+        const int t_end_line=0, const int t_end_col=0)
+      : start(t_start_line, t_start_col), 
+        end(t_end_line, t_end_col),
+        filename(std::make_shared<std::string>(std::move(t_fname)))
+    {
+    }
+
+    Parse_Location(std::shared_ptr<std::string> t_fname, const int t_start_line=0, const int t_start_col=0,
+        const int t_end_line=0, const int t_end_col=0)
+      : start(t_start_line, t_start_col), 
+        end(t_end_line, t_end_col),
+        filename(std::move(t_fname))
+    {
+    }
+
+
+
+    File_Position start;
+    File_Position end;
+    std::shared_ptr<std::string> filename;
+  };
+
+
   /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<const AST_Node> AST_NodePtr_Const;
 
 
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
   namespace exception
   {
-    /**
-     * Errors generated during parsing or evaluation
-     */
-    struct eval_error : public std::runtime_error {
+    /// \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 {
       std::string reason;
       File_Position start_position;
-      File_Position end_position;
       std::string filename;
-      std::vector<AST_NodePtr> call_stack;
+      std::string detail;
+      std::vector<AST_NodePtr_Const> call_stack;
 
-      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) throw() :
-        std::runtime_error("Error: \"" + t_why + "\" " +
-            (t_fname != "__EVAL__" ? ("in '" + t_fname + "' ") : "during evaluation ") +
-            + "at (" + boost::lexical_cast<std::string>(t_where.line) + ", " +
-            boost::lexical_cast<std::string>(t_where.column) + ")"),
-        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
-        { }
+      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) 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)) 
+      {}
 
-      eval_error(const std::string &t_why) throw()
+      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) 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) noexcept :
+        std::runtime_error(format(t_why, t_where, t_fname)),
+        reason(t_why), start_position(t_where), filename(t_fname)
+      {}
+
+      explicit eval_error(const std::string &t_why) noexcept
         : std::runtime_error("Error: \"" + t_why + "\" "),
         reason(t_why) 
       {}
 
-      virtual ~eval_error() throw() {}
+      eval_error(const eval_error &) = default;
+
+      std::string pretty_print() const
+      {
+        std::ostringstream ss;
+
+        ss << what();
+        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]) << "'";
+          for (size_t j = 1; j < call_stack.size(); ++j) {
+            if (id(call_stack[j]) != chaiscript::AST_Node_Type::Block
+                && id(call_stack[j]) != chaiscript::AST_Node_Type::File)
+            {
+              ss << '\n';
+              ss << "  from " << fname(call_stack[j]) << " (" << startpos(call_stack[j]) << ") '" << pretty(call_stack[j]) << "'";
+            }
+          }
+        }
+        ss << '\n';
+        return ss.str();
+      }
+
+      ~eval_error() noexcept override = default;
+
+    private:
+
+      template<typename T>
+        static AST_Node_Type id(const T& t)
+        {
+          return t->identifier;
+        }
+
+      template<typename T>
+        static std::string pretty(const T& t)
+        {
+          return t->pretty_print();
+        }
+
+      template<typename T>
+        static const std::string &fname(const T& t)
+        {
+          return t->filename();
+        }
+
+      template<typename T>
+        static std::string startpos(const T& t)
+        {
+          std::ostringstream oss;
+          oss << t->start().line << ", " << t->start().column;
+          return oss.str();
+        }
+
+      static std::string format_why(const std::string &t_why)
+      {
+        return "Error: \"" + t_why + "\"";
+      }
+
+      static std::string format_types(const Const_Proxy_Function &t_func,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        int arity = t_func->get_arity();
+        std::vector<Type_Info> types = t_func->get_param_types();
+
+        std::string retval;
+        if (arity == -1)
+        {
+          retval = "(...)";
+          if (t_dot_notation)
+          {
+            retval = "(Object)." + retval;
+          }
+        } else if (types.size() <= 1) {
+          retval = "()";
+        } else {
+          std::stringstream ss;
+          ss << "(";
+
+          std::string paramstr;
+
+          for (size_t index = 1;
+               index != types.size();
+               ++index)
+          {
+            paramstr += (types[index].is_const()?"const ":"");
+            paramstr += t_ss.get_type_name(types[index]);
+
+            if (index == 1 && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (types.size() == 2)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+
+          ss << ")";
+          retval = ss.str();
+        }
+
+
+        std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfun 
+          = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_func);
+
+        if (dynfun)
+        {
+          Proxy_Function f = dynfun->get_guard();
+
+          if (f)
+          {
+            auto dynfunguard = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(f);
+            if (dynfunguard)
+            {
+              retval += " : " + format_guard(dynfunguard->get_parse_tree());
+            }
+          }
+
+          retval += "\n          Defined at " + format_location(dynfun->get_parse_tree());        
+        }
+
+        return retval;
+      }
+
+      template<typename T>
+        static std::string format_guard(const T &t)
+        {
+          return t->pretty_print();
+        }
+
+      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)";
+          }
+
+        }
+
+      static std::string format_detail(const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        if (t_functions.size() == 1)
+        {
+          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << '\n';
+        } else {
+          ss << "  " << t_functions.size() << " overloads available:\n";
+
+          for (const auto & t_function : t_functions)
+          {
+            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << '\n';
+          }
+
+        }
+
+        return ss.str();
+
+      }
+
+      static std::string format_parameters(const std::vector<Boxed_Value> &t_parameters,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        ss << "(";
+
+        if (!t_parameters.empty())
+        {
+          std::string paramstr;
+
+          for (auto itr = t_parameters.begin();
+               itr != t_parameters.end();
+               ++itr)
+          {
+            paramstr += (itr->is_const()?"const ":"");
+            paramstr += t_ss.type_name(*itr);
+
+            if (itr == t_parameters.begin() && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (t_parameters.size() == 1)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+        }
+        ss << ")";
+
+        return ss.str();
+      }
+
+      static std::string format_filename(const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        if (t_fname != "__EVAL__")
+        {
+          ss << "in '" << t_fname << "' ";
+        } else {
+          ss << "during evaluation ";
+        }
+
+        return ss.str();
+      }
+
+      static std::string format_location(const File_Position &t_where)
+      {
+        std::stringstream ss;
+        ss << "at (" << t_where.line << ", " << t_where.column << ")";
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
+          const std::vector<Boxed_Value> &t_parameters, bool t_dot_notation, const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, 
+          const std::vector<Boxed_Value> &t_parameters, 
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
     };
 
-    /**
-     * Errors generated when loading a file
-     */
-    struct file_not_found_error : public std::runtime_error {
-      file_not_found_error(const std::string &t_filename) throw()
+
+    /// Errors generated when loading a file
+    struct file_not_found_error : std::runtime_error {
+      explicit file_not_found_error(const std::string &t_filename) noexcept
         : std::runtime_error("File Not Found: " + t_filename)
       { }
 
-      virtual ~file_not_found_error() throw() {}
+      file_not_found_error(const file_not_found_error &) = default;
+      ~file_not_found_error() noexcept override = default;
     };
 
   }
 
  
   /// \brief Struct that doubles as both a parser ast_node and an AST node.
-  struct AST_Node : boost::enable_shared_from_this<AST_Node> {
+  struct AST_Node : std::enable_shared_from_this<AST_Node> {
     public:
+      const AST_Node_Type identifier;
       const std::string text;
-      const int identifier;
-      boost::shared_ptr<const std::string> filename;
-      File_Position start, end;
-      std::vector<AST_NodePtr> children;
-      AST_NodePtr annotation;
+      Parse_Location location;
 
-      /**
-       * Prints the contents of an AST node, including its children, recursively
-       */
-      std::string to_string(std::string t_prepend = "") {
+      const std::string &filename() const {
+        return *location.filename;
+      }
+
+      const File_Position &start() const {
+        return location.start;
+      }
+
+      const File_Position &end() const {
+        return location.end;
+      }
+
+      std::string pretty_print() const
+      {
+        std::ostringstream oss;
+
+        oss << text;
+
+        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 {
         std::ostringstream oss;
 
         oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
-            << this->text << " : " << this->start.line << ", " << this->start.column << std::endl;
-        
-        for (unsigned int j = 0; j < this->children.size(); ++j) {
-          oss << this->children[j]->to_string(t_prepend + "  ");
+            << this->text << " : " << this->location.start.line << ", " << this->location.start.column << '\n';
+
+        for (auto & elem : this->get_children()) {
+          oss << elem->to_string(t_prepend + "  ");
         }
         return oss.str();
       }
 
-      std::string internal_to_string() {
-        return to_string();
-      }
 
-      Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) 
-      {
+      static bool get_bool_condition(const Boxed_Value &t_bv, const chaiscript::detail::Dispatch_State &t_ss) {
         try {
-          return eval_internal(t_e);
-        } catch (exception::eval_error &ee) {
-          ee.call_stack.push_back(shared_from_this());
-          throw ee;
+          return t_ss->boxed_cast<bool>(t_bv);
+        }
+        catch (const exception::bad_boxed_cast &) {
+          throw exception::eval_error("Condition not boolean");
         }
       }
 
 
-      void replace_child(const AST_NodePtr &t_child, const AST_NodePtr &t_new_child)
-      {
-        std::replace(children.begin(), children.end(), t_child, t_new_child);
-      }
+      virtual ~AST_Node() = 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(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname, 
-          int t_start_line, int t_start_col, int t_end_line, int t_end_col) :
-        text(t_ast_node_text), identifier(t_id), filename(t_fname),
-        start(t_start_line, t_start_col), end(t_end_line, t_end_col)
+      AST_Node(std::string t_ast_node_text, AST_Node_Type t_id, Parse_Location t_loc)
+        : identifier(t_id), text(std::move(t_ast_node_text)),
+          location(std::move(t_loc))
       {
       }
 
-      AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname) :
-        text(t_ast_node_text), identifier(t_id), filename(t_fname) {}
 
-      virtual ~AST_Node() {}
-
-      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &)
-      {
-        throw std::runtime_error("Undispatched ast_node (internal error)");
-      }
-
-    private:
-      // Copy and assignment explicitly unimplemented
-      AST_Node(const AST_Node &);
-      AST_Node& operator=(const AST_Node &);
   };
 
+  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
   {
     namespace detail
     {
-      /**
-       * Special type for returned values
-       */
+      /// Special type for returned values
       struct Return_Value {
         Boxed_Value retval;
 
-        Return_Value(const Boxed_Value &t_return_value) : retval(t_return_value) { }
+        explicit Return_Value(Boxed_Value t_return_value) : retval(std::move(t_return_value)) { }
       };
 
-      /**
-       * Special type indicating a call to 'break'
-       */
+
+      /// 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() = default;
+      };
+
+
       /// Creates a new scope then pops it on destruction
       struct Scope_Push_Pop
       {
-        Scope_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
-          : m_de(t_de)
+        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;
+
+        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:
-        // explicitly unimplemented copy and assignment
-        Scope_Push_Pop(const Scope_Push_Pop &);
-        Scope_Push_Pop& operator=(const Scope_Push_Pop &);
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          const chaiscript::detail::Dispatch_State &m_ds;
       };
 
-      /// Creates a new functon call and pops it on destruction
+      /// Creates a new function call and pops it on destruction
       struct Function_Push_Pop
       {
-        Function_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
-          : m_de(t_de)
+        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;
+
+        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_ds->save_function_params(t_params);
         }
 
 
         private:
-        // explicitly unimplemented copy and assignment
-        Function_Push_Pop(const Function_Push_Pop &);
-        Function_Push_Pop& operator=(const Function_Push_Pop &);
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          const chaiscript::detail::Dispatch_State &m_ds;
       };
 
       /// Creates a new scope then pops it on destruction
       struct Stack_Push_Pop
       {
-        Stack_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
-          : m_de(t_de)
+        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;
+
+        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:
-        // explicitly unimplemented copy and assignment
-        Stack_Push_Pop(const Stack_Push_Pop &);
-        Stack_Push_Pop& operator=(const Stack_Push_Pop &);
-
-        chaiscript::detail::Dispatch_Engine &m_de;
+          const chaiscript::detail::Dispatch_State &m_ds;
       };
     }
   }
 }
 
-#endif	/* _CHAISCRIPT_COMMON_HPP */
+#endif /* _CHAISCRIPT_COMMON_HPP */
 

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

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -5,7 +5,7 @@
 namespace ChaiScript_Language
 {
 
-/// \page LangStandardLibraryRef ChaiScript Language Standard Libary Reference
+/// \page LangStandardLibraryRef ChaiScript Language Standard Library Reference
 ///
 /// ChaiScript, at its core, has some very functional programming-inspired habits. Few places show this off as clearly 
 /// as the prelude, itself a name taken as a nod to the popular functional language Haskell. This prelude is available 
@@ -112,7 +112,7 @@ class Map
 };
 
 
-/// \brief A concept implemented by string, Vector and Map. It is convertable to Range, default constructable and back_insertable
+/// \brief A concept implemented by string, Vector and Map. It is convertible to Range, default constructable and back_insertable
 class Container
 {
   public:
@@ -153,10 +153,10 @@ void print(Object o);
 
 /// \brief ChaiScript representation of std::string. It is an std::string but only some member are exposed to ChaiScript.
 /// 
-/// Because the ChaiScript string object is an std::string, it is directly convertable to and from std::string
+/// Because the ChaiScript string object is an std::string, it is directly convertible to and from std::string
 /// using the chaiscript::boxed_cast and chaiscript::var functions.
 ///
-/// With the exception of string::trim, string::rtrim, string::ltrim, all members are direct passthroughs to the
+/// With the exception of string::trim, string::rtrim, string::ltrim, all members are direct pass-throughs to the
 /// std::string of the same name. 
 ///
 /// \note Object and function notations are equivalent in ChaiScript. This means that
@@ -309,7 +309,7 @@ class Range
 
     /// \brief Moves the front pointer forward one
     /// 
-    /// \post front() returne the element at front() + 1;
+    /// \post front() returns the element at front() + 1;
     void pop_front();
 
 };
@@ -340,7 +340,7 @@ class Const_Range
 
     /// \brief Moves the front pointer forward one
     /// 
-    /// \post front() returne the element at front() + 1;
+    /// \post front() returns the element at front() + 1;
     void pop_front();
 
 };
@@ -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
@@ -519,7 +519,7 @@ class Function
     /// \brief Returns a vector of Type_Info objects that represent the param types for this function.
     ///        The first value in the list is the return type.
     /// 
-    /// If this function is a conglomeration of several functions (get_contained_values().size() > 0)
+    /// If this function is a conglomerate of several functions (get_contained_values().size() > 0)
     /// then the function returns as many Type_Info objects as it can. If the functions contained all have
     /// the same arity, then it represents the arity. If they have different arities, it returns only
     /// one value - the return type. 
@@ -534,7 +534,7 @@ class Function
     /// \endcode
     Vector get_param_types() const;
 
-    /// \brief Returns true if the function has a guard to it. Always returns falls for a conglomerate function
+    /// \brief Returns true if the function has a guard to it. Always returns false for a conglomerate function
     bool has_guard() const;
 
     /// \brief Calls the function with the given set of parameters and returns the value;
@@ -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-2016, 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,27 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2016, 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 &)
+      {
+        throw chaiscript::exception::load_module_error("Loadable module support not available for your platform");
+      }
+
+      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-2016, 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,22 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_UTILITY_FNV1A_HPP_
+#define CHAISCRIPT_UTILITY_FNV1A_HPP_
+
+#include <cstdint>
+
+namespace chaiscript
+{
+  namespace utility
+  {
+    static constexpr std::uint32_t fnv1a_32(const char *s, std::uint32_t h = 0x811c9dc5) {
+      return (*s == 0) ? h : fnv1a_32(s+1, ((h ^ (*s)) * 0x01000193));
+    }
+  }
+}
+
+#endif

include/chaiscript/utility/json.hpp

@@ -0,0 +1,669 @@
+// 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;
+    long exp = 0;
+    for (; offset < str.size() ;) {
+      c = str[offset++];
+      if( (c == '-') || (c >= '0' && c <= '9') ) {
+        val += c;
+      } else if( c == '.' ) {
+        val += c; 
+        isDouble = true;
+      } else {
+        break;
+      }
+    }
+    if( offset < str.size() && (c == 'E' || c == 'e' )) {
+      c = str[ offset++ ];
+      if( c == '-' ) { 
+        exp_str += '-';
+      } else if( c == '+' ) {
+        // 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(chaiscript::parse_num<double>( val ) * std::pow( 10, exp ));
+    } else {
+      if( !exp_str.empty() ) {
+        return JSON(static_cast<double>(chaiscript::parse_num<long>( val )) * std::pow( 10, exp ));
+      } else {
+        return JSON(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-2016, 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,97 +1,117 @@
 // 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)
+// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_UTILITY_UTILITY_HPP_
 #define CHAISCRIPT_UTILITY_UTILITY_HPP_
 
-#include "../chaiscript.hpp"
-#include <boost/preprocessor.hpp>
 #include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
-#define CHAISCRIPT_MODULE(_info) BOOST_PP_SEQ_ELEM(0, _info)
+#include "../language/chaiscript_common.hpp"
+#include "../dispatchkit/register_function.hpp"
+#include "../dispatchkit/operators.hpp"
 
-#define CHAISCRIPT_CLASS_ELEM(_info) BOOST_PP_SEQ_ELEM(1, _info)
-
-#define CHAISCRIPT_METHOD(_info, _method) & CHAISCRIPT_CLASS_ELEM(_info) :: BOOST_PP_SEQ_ELEM(0, _method)
-
-#define CHAISCRIPT_METHOD_NAME(_info, _method) \
-  BOOST_PP_SEQ_ELEM(3, _info) (BOOST_PP_STRINGIZE(BOOST_PP_SEQ_ELEM(0, _method ) ) )
-
-#define CHAISCRIPT_CLASS_NAME(_info) \
-  BOOST_PP_SEQ_ELEM(2, _info) (BOOST_PP_STRINGIZE(CHAISCRIPT_CLASS_ELEM(_info) ) )
-
-#define CHAISCRIPT_METHOD_SIGNATURE_PART(_r, _info, _i, _method_part) \
-  BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(_i, 1), < _method_part > )
-
-#define CHAISCRIPT_METHOD_SIGNATURE(_info, _method) \
-  BOOST_PP_SEQ_FOR_EACH_I(CHAISCRIPT_METHOD_SIGNATURE_PART, _info, _method)
-
-#define CHAISCRIPT_CLASS_CONSTRUCTOR(_r, _info, _constructor) \
-  CHAISCRIPT_MODULE(_info) ->add BOOST_PP_LPAREN() chaiscript::constructor<_constructor>() BOOST_PP_COMMA() CHAISCRIPT_CLASS_NAME(_info) BOOST_PP_RPAREN() ;
-
-#define CHAISCRIPT_CLASS_METHOD(_r, _info, _method) \
-  CHAISCRIPT_MODULE(_info) ->add BOOST_PP_LPAREN() chaiscript::fun CHAISCRIPT_METHOD_SIGNATURE(_info, _method) \
-      BOOST_PP_LPAREN() CHAISCRIPT_METHOD(_info, _method) BOOST_PP_RPAREN() BOOST_PP_COMMA() CHAISCRIPT_METHOD_NAME(_info, _method)BOOST_PP_RPAREN() ;
-  
-#define CHAISCRIPT_CLASS_CONSTRUCTORS(_info, _constructors) \
-  BOOST_PP_SEQ_FOR_EACH(CHAISCRIPT_CLASS_CONSTRUCTOR, _info, _constructors)
-
-#define CHAISCRIPT_CLASS_METHODS(_info, _methods) \
-  BOOST_PP_SEQ_FOR_EACH(CHAISCRIPT_CLASS_METHOD, _info, _methods)
-
-#define CHAISCRIPT_CLASS_EX(_module, _class_name, _class_name_translator, _method_name_translator, _constructors, _methods) \
-  { \
-    _module->add(chaiscript::user_type<_class_name>(), _class_name_translator (BOOST_PP_STRINGIZE(_class_name))); \
-    CHAISCRIPT_CLASS_CONSTRUCTORS((_module)(_class_name)(_class_name_translator), _constructors) \
-    CHAISCRIPT_CLASS_METHODS((_module)(_class_name)(_class_name_translator)(_method_name_translator), _methods) \
-  }
-
-#define CHAISCRIPT_CLASS_NO_CONSTRUCTOR_EX(_module, _class_name, _class_name_translator, _method_name_translator, _methods) \
-  { \
-    _module->add(chaiscript::user_type<_class_name>(), _class_name_translator (BOOST_PP_STRINGIZE(_class_name))); \
-    CHAISCRIPT_CLASS_METHODS((_module)(_class_name)(_class_name_translator)(_method_name_translator), _methods) \
-  }
-
-#define CHAISCRIPT_CLASS(_module, _class_name, _constructors, _methods) \
-  CHAISCRIPT_CLASS_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
-      chaiscript::utility::method_name_translator, _constructors, _methods)
-
-#define CHAISCRIPT_CLASS_NO_CONSTRUCTOR(_module, _class_name, _methods) \
-  CHAISCRIPT_CLASS_NO_CONSTRUCTOR_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
-      chaiscript::utility::method_name_translator, _methods)
 
 namespace chaiscript 
 {
-  /// \brief Classes and functions which provide general utility to the end user.
   namespace utility
   {
-    inline std::string class_name_translator(const std::string &t_name)
-    {
-      size_t colon = t_name.rfind("::");
-      if (colon != std::string::npos)
+
+    /// Single step command for registering a class with ChaiScript
+    /// 
+    /// \param[in,out] t_module Model to add class to
+    /// \param[in] t_class_name Name of the class being registered
+    /// \param[in] t_constructors Vector of constructors to add
+    /// \param[in] t_funcs Vector of methods to add
+    ///
+    /// \example Adding a basic class to ChaiScript in one step
+    /// 
+    /// \code
+    /// chaiscript::utility::add_class<test>(*m,
+    ///      "test",
+    ///      { constructor<test ()>(),
+    ///        constructor<test (const test &)>() },
+    ///      { {fun(&test::function), "function"},
+    ///        {fun(&test::function2), "function2"},
+    ///        {fun(&test::function3), "function3"},
+    ///        {fun(static_cast<std::string(test::*)(double)>(&test::function_overload)), "function_overload" },
+    ///        {fun(static_cast<std::string(test::*)(int)>(&test::function_overload)), "function_overload" },
+    ///        {fun(static_cast<test & (test::*)(const test &)>(&test::operator=)), "=" }
+    ///        }
+    ///      );
+    /// 
+    template<typename Class, typename ModuleType>
+      void add_class(ModuleType &t_module,
+          const std::string &t_class_name,
+          const std::vector<chaiscript::Proxy_Function> &t_constructors,
+          const std::vector<std::pair<chaiscript::Proxy_Function, std::string>> &t_funcs)
       {
-        return t_name.substr(colon+2, std::string::npos);
-      } else {
-        return t_name;
+        t_module.add(chaiscript::user_type<Class>(), t_class_name); 
+
+        for(const chaiscript::Proxy_Function &ctor: t_constructors)
+        {
+          t_module.add(ctor, t_class_name);
+        }
+
+        for(const auto &fun: t_funcs)
+        {
+          t_module.add(fun.first, fun.second);
+        }
       }
-    }
 
-    inline std::string method_name_translator(const std::string &t_name)
-    {
-      size_t namestart = t_name.rfind("operator");
-      namestart = (namestart == std::string::npos)?0:namestart+strlen("operator");
-
-      if (namestart == 0)
+    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
+        )
       {
-        namestart = t_name.rfind("::");
-        namestart = (namestart == std::string::npos)?0:namestart+strlen("::");
-      } 
+        t_module.add(chaiscript::user_type<Enum>(), t_class_name);
 
-      return t_name.substr(namestart, std::string::npos);
-    }
+        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,7 @@
-Copyright 2009-2012 Jason Turner and Jonathan Turner. All Rights Reserved.
+Copyright 2009-2016 Jason Turner
+Copyright 2009-2012 Jonathan Turner. 
+
+All Rights Reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:

performance_tests/heterogenous_array_loop.chai

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

performance_tests/is_prime.chai

@@ -22,4 +22,5 @@ def primes(n)
 
 
 var N = 5000
+
 print("primes: " + primes(N).to_string())

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();
+  }
+
+}

performance_tests/type_conversions.chai

@@ -0,0 +1,22 @@
+load_module("test_module")
+
+auto t := TestBaseType();
+
+// This uses the TestBaseType to Type2 user type
+// conversion which was added in the module and then calls
+// "get_val()" which exists on the Type2 type
+//assert_equal(t.get_val(), 10);
+//print("Made it past test 1");
+
+var t2 := Type2(t);
+
+//dump_system();
+
+for (var i = 0; i < 50000; ++i) {
+  var str = string(get_str(t2));
+  size(get_str(t2));
+  t2.get_str().size();
+  t.get_str().size();
+}
+
+

readme.md

@@ -0,0 +1,130 @@
+<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>
+
+
+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-2016 Jason Turner
+
+Release under the BSD license, see "license.txt" for details.
+
+
+Introduction
+============
+
+[![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/ChaiScript/ChaiScript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+ChaiScript is one of the only embedded scripting language designed from the 
+ground up to directly target C++ and take advantage of modern C++ development 
+techniques, working with the developer like he expects it to work.  Being a 
+native C++ application, it has some advantages over existing embedded scripting 
+languages:
+
+1. It uses a header-only approach, which makes it easy to integrate with 
+   existing projects.
+2. It maintains type safety between your C++ application and the user scripts.
+3. It supports a variety of C++ techniques including callbacks, overloaded 
+   functions, class methods, and stl containers.
+
+
+Requirements
+============
+
+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
+=====
+
+* Add the ChaiScript include directory to your project's header search path
+* Add `#include <chaiscript/chaiscript.hpp>` to your source file
+* Instantiate the ChaiScript engine in your application.  For example, create a 
+  new engine with the name `chai` like so: `chaiscript::ChaiScript chai`
+* The default behavior is to load the ChaiScript standard library from a 
+  loadable module. A second option is to compile the library into your code,
+  see below for an example.
+
+Once instantiated, the engine is ready to start running ChaiScript source.  You
+have two main options for processing ChaiScript source: a line at a time using 
+`chai.eval(string)` and a file at a time using `chai.eval_file(fname)`
+
+To make functions in your C++ code visible to scripts, they must be registered 
+with the scripting engine.  To do so, call add:
+
+    chai.add(chaiscript::fun(&my_function), "my_function_name");
+
+Once registered the function will be visible to scripts as "my_function_name"
+
+Examples
+========
+
+ChaiScript is similar to ECMAScript (aka JavaScript(tm)), but with some 
+modifications to make it easier to use.  For usage examples see the "samples" 
+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 
+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.
+
+
+The shortest complete example possible follows:
+
+    /// main.cpp
+
+    #include <chaiscript/chaiscript.hpp>
+
+    double function(int i, double j)
+    {
+      return i * j;
+    }
+
+    int main()
+    {
+      chaiscript::ChaiScript chai;
+      chai.add(chaiscript::fun(&function), "function");
+
+      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);");
+    }
+
+

readme.txt

@@ -1,55 +0,0 @@
-ChaiScript
-http://www.chaiscript.com
-(c) 2009-2012 Jason Turner and Jonathan Turner
-Release under the BSD license, see "license.txt" for details.
-
-[Introduction]
-
-ChaiScript is one of the only embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques, working with the developer like he expects it to work.  Being a native C++ application, it has some advantages over existing embedded scripting languages:
-
-1) It uses a header-only approach, which makes it easy to integrate with existing projects.
-2) It maintains type safety between your C++ application and the user scripts.
-3) It supports a variety of C++ techniques including callbacks, overloaded functions, class methods, and stl containers.
-
-[Requirements]
-
-ChaiScript requires a recent version of Boost (http://www.boost.org) to build.
-
-[Usage]
-
-* Add the ChaiScript include directory to your project's header search path
-* Add "#include <chaiscript/chaiscript.hpp> to your source file
-* Instantiate the ChaiScript engine in your application.  For example, create a new engine with the name 'chai' like so: "chaiscript::ChaiScript chai"
-
-Once instantiated, the engine is ready to start running ChaiScript source.  You have two main options for processing ChaiScript source: a line at a time using "chai.evaluate_string(string)" and a file at a time using "chai.evaluate_file(fname)"
-
-To make functions in your C++ code visible to scripts, they must be registered with the scripting engine.  To do so, call add:
-
-chai.add(chaiscript::fun(&my_function), "my_function_name");
-
-Once registered the function will be visible to scripts as "my_function_name"
-
-[Examples]
-
-ChaiScript is similar to ECMAScript (aka JavaScript(tm)), but with some modifications to make it easier to use.  For usage examples see the "samples" 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 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.
-
-The shortest complete example possible follows:
-
-/// main.cpp
-
-#include <chaiscript/chaiscript.hpp>
-
-double function(int i, double j)
-{
-  return i * j;
-}
-
-int main()
-{
-  chaiscript::ChaiScript chai;
-  chai.add(chaiscript::fun(&function), "function");
-
-  double d = chai.eval<double>("function(3, 4.75);");
-}

releasenotes.md

@@ -0,0 +1,297 @@
+Notes:
+=======
+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 ) { }`
+* 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
+
+#### 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)
+
+#### 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
+
+* Significant code cleanups and reduction
+* Smaller builds
+* Faster compiles
+* Less runtime memory usage
+* ~2x faster runtimes
+* biicode support
+* method_missing feature added #164 @arBmind
+* Generic objects with dynamic properties support
+* Add ability to call functions contained in properties
+* Add lambda captures
+* Create [cheatsheet.md](cheatsheet.md) for all-in-one reference of features
+* Fix support for libc++
+* Eliminate clone of return value stored locally
+* Eliminate 'return' statements when last line of function
+* Reduce number of runtime exceptions occuring
+* Reduce copies / moves of return values. 
+* make `use` statement return value of last statement in file
+* Add ability to access fixed array sizes
+* Add support for scientific notation floating point literals #174  @totalgee
+
+
+### Changes since 5.5.1
+* Throw exception on integer divide by 0
+* Add optional type specification to function declarations
+   
+  ```
+  def func(int i, j, double k) {
+    // i must be an int.
+    // j can be anything
+    // k must be a double
+    // normal conversion rules still apply
+  }
+   ```
+* Many minor fixes for compiler warnings
+* Add support for `std::future` and `std::async`
+  ```
+  var f := async(someFunction);
+  var f2 := async(someFunction2);
+
+  // someFunction and someFunction2 are running in parallel now
+  f.get();
+  f2.get();
+  ```
+* Fully support r-value returns, supporting move-only objects and reducing object copies
+
+
+### Changes since 5.5.0
+* 30% performance increase
+* Fix handling of object stack, resulting in greatly reduced memory usage
+* Code cleanups
+
+### Changes since 5.4.0
+* 2x performance increase
+* Significant code cleanups
+* Throw exception if user attempts to call function on null object
+* Allow user defined type conversions
+* Fix object lifetime for nested function calls made at the global scope
+* Fix returning of boolean values from function calls
+
+
+### Changes since 5.3.1
+* Decreased compile time and build size
+* Make "reflection" module built in (losing some of the time / build size gains)
+* Add new "class" syntax for ChaiScript defined methods and attributes see: [unittests/class.chai](unittests/class.chai) for examples
+* Minor performance enhancements
+* major to_string performance enhancements
+* Provide API for retrieving registered type name #124
+* Added strong reference to container to range object #132
+
+
+### Changes since 5.3.0
+* Add automatic conversion of arithmetic return types, following the same
+  rules as conversion of arithmetic types when passing parameters
+* Add automatic casting up the inheritence hierarchy when possible.
+* Enable travis.ci testing
+* Allow users to add globals from within script
+* Various static analysis fixes
+* Code modernization to C++11
+* Unofficial support for Haiku added
+* Fix #121 - Inability to compile on cygwin
+* Formatting fixes and spelling corrections
+* Apply "include what you use" https://code.google.com/p/include-what-you-use/
+* Apply clang-modernize
+* Various threading fixes
+* Performance improvements
+
+### Changes since 5.2.0
+* Official support for MSVC with C++11. All major platforms and compilers are now support for C++11 release
+
+### Changes since 4.2.0
+* Enhanced unit tests
+* Add `continue` statement, fix various use cases for `for`  loops
+* Fix use of suffixed numbers in vector initialization
+* Code cleanups
+* Eliminate global data, which makes code more portable and thread safe
+* Fix issue #79
+* Merge pretty_print fixes from @mgee #82
+* Compiler warning fixes for latest compiler releases
+* Fix threading problems
+* Fix linking error on MacOS Mavericks #88
+* Allow non-const globals
+* Make sure user cannot name a variable with `::` in it #91
+* Fix various string / map / vector `size` and `count` calls for compilers which have weird overloads for them. #90 #93 #95
+* Make module search path relative to the currently running executable
+* Build and work with wstring windows builds
+* fix for some new line cases in the middle of a vector initialization from jespada
+
+### Changes since 5.1.0
+* Add support for automatic conversion of arithmetic types when possible
+  and when no ambiguous method dispatch exists.
+
+### Changes since 5.0.0
+* Fix sizing of numeric constants to match that of the C++ standard
+* Add support for u,ll,l,f suffixes for numeric constants
+* Siginificant improvement in error reporting
+
+### Changes since 4.0.0
+* Dropped boost in favor of C++11
+* Separated out stdlib to make more options for compile time improvements
+
+### Changes since 3.1.0
+* svenstaro: Unused variables and CMake consistency fixes
+* Added support for returning pointers from functions (#13)
+* Compile with -pedantic (#9)
+* Fix issues with multiple ChaiScript object types having the same attribute name (#15)
+* Prevent variable redeclaration in same scope (#22)
+* mgee: Boxed_Number improvements (#27)
+* Support switch statements (#34)
+* Fix uint16 comparions (#26)
+* Add ability to add const_var globals in Module objects (#14)
+* Add support for ternary operators ?:
+* Add headers to CMakeLists so they show up in IDEs
+* Add ability to get vector of defined objects and vector of defined functions
+* Fix memory leak in cyclical references
+* Clean up static analysis issues discovered
+* Fix vector construction to be consistent with map construction
+* Increased unit tests to 161
+* Performance enhancements
+
+### Changes since 3.0.0
+* Numeric operations performance increased approximately 10x
+* Looping operations performance increased up to 2x
+* Engine start up time decreased
+* Several parsing bugs related to index operators fixed
+* Added full support for all C algebraic types: double, long double, float, int, long, char,
+  uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t
+* Enhanced support for capturing of exceptions thrown from ChaiScript in C++
+
+### Changes since 2.3.3
+* Code simplifications
+* Fully integrate documentation with source code in doxygen style comments
+* Unit tests increased from 114 to 137
+* Automatic conversion between boost::function objects and ChaiScript functions 
+* Many bug fixes
+* Minor performance improvements
+* Namespace reorganization to make end user code more accessible
+* clang support
+* VisualStudio 2010 Support
+* Support for C++ base classes and automatic upcasting 
+* Remove __ reserved identifiers
+* Better code organization to reduce #ifdefs 
+* clanmills: command line options for chai eval
+* clanmills: parser cleanups and code reduction
+* Function introspection and reflection 
+* Correct function dispatch order to account for base classes and provide a defined order of dispatch 
+* Predictable object lifetime that emulates C++ stack lifetime
+* emarcotte: pkgconfig support
+* standardize on method/member naming and indentation
+* 64bit Visual Studio support
+* Better support for const objects
+* Drastic reduction of runtime exceptions - making debug builds orders of magnitude faster
+* Support for platforms with no loadable module support
+* Add helper macro for registering class 

releasenotes.txt

@@ -1,54 +0,0 @@
-Changes since 3.1.0
-* svenstaro: Unused variables and CMake consistency fixes
-* Added support for returning pointers from functions (#13)
-* Compile with -pedantic (#9)
-* Fix issues with multiple ChaiScript object types having the same attribute name (#15)
-* Prevent variable redeclaration in same scope (#22)
-* mgee: Boxed_Number improvements (#27)
-* Support switch statements (#34)
-* Fix uint16 comparions (#26)
-* Add ability to add const_var globals in Module objects (#14)
-* Add support for ternary operators ?:
-* Add headers to CMakeLists so they show up in IDEs
-* Add ability to get vector of defined objects and vector of defined functions
-* Fix memory leak in cyclical references
-* Clean up static analysis issues discovered
-* Fix vector construction to be consistent with map construction
-* Increased unit tests to 161
-* Performance enhancements
-
-Changes since 3.0.0
-* Numeric operations performance increased approximately 10x
-* Looping operations performance increased up to 2x
-* Engine start up time decreased
-* Several parsing bugs related to index operators fixed
-* Added full support for all C algebraic types: double, long double, float, int, long, char,
-  uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t
-* Enhanced support for capturing of exceptions thrown from ChaiScript in C++
-
-Changes since 2.3.3
-
-* Code simplifications
-* Fully integrate documentation with source code in doxygen style comments
-* Unit tests increased from 114 to 137
-* Automatic conversion between boost::function objects and ChaiScript functions 
-* Many bug fixes
-* Minor performance improvements
-* Namespace reorganization to make end user code more accessible
-* clang support
-* VisualStudio 2010 Support
-* Support for C++ base classes and automatic upcasting 
-* Remove __ reserved identifiers
-* Better code organization to reduce #ifdefs 
-* clanmills: command line options for chai eval
-* clanmills: parser cleanups and code reduction
-* Function introspection and reflection 
-* Correct function dispatch order to account for base classes and provide a defined order of dispatch 
-* Predictable object lifetime that emulates C++ stack lifetime
-* emarcotte: pkgconfig support
-* standardize on method/member naming and indentation
-* 64bit Visual Studio support
-* Better support for const objects
-* Drastic reduction of runtime exceptions - making debug builds orders of magnitude faster
-* Support for platforms with no loadable module support
-* Add helper macro for registering class 

samples/example.cpp

@@ -5,21 +5,20 @@
 // http://www.chaiscript.com
 
 #include <iostream>
+#include <ctime>
 
 #include <chaiscript/chaiscript.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
 #include <chaiscript/dispatchkit/function_call.hpp>
-#include <boost/function.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/regex.hpp>
 
 void log(const std::string &msg)
 {
-  std::cout << "[" << boost::posix_time::microsec_clock::local_time() << "] " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] " << msg << '\n';
 }
 
 void log(const std::string &module, const std::string &msg)
 {
-  std::cout << "[" << boost::posix_time::microsec_clock::local_time() << "] <" << module << "> " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << '\n';
 }
 
 void bound_log(const std::string &msg)
@@ -29,30 +28,30 @@ void bound_log(const std::string &msg)
 
 void hello_world(const chaiscript::Boxed_Value & /*o*/)
 {
-  std::cout << "Hello World" << std::endl;
+  std::cout << "Hello World\n";
 }
 
 void hello_constructor(const chaiscript::Boxed_Value & /*o*/)
 {
-  std::cout << "Hello Constructor" << std::endl;
+  std::cout << "Hello Constructor\n";
 }
 
 
 struct System
 {
-  std::map<std::string, boost::function<std::string (const std::string &) > > m_callbacks;
+  std::map<std::string, std::function<std::string (const std::string &) > > m_callbacks;
 
   void add_callback(const std::string &t_name, 
-      const chaiscript::Proxy_Function &t_func)
+      const std::function<std::string (const std::string &)> &t_func)
   {
-    m_callbacks[t_name] = chaiscript::dispatch::functor<std::string (const std::string &)>(t_func);
+    m_callbacks[t_name] = t_func;
   }
 
 
   void do_callbacks(const std::string &inp)
   {
     log("Running Callbacks: " + inp);
-    for (std::map<std::string, boost::function<std::string (const std::string &)> >::iterator itr = m_callbacks.begin();
+    for (std::map<std::string, std::function<std::string (const std::string &)> >::iterator itr = m_callbacks.begin();
          itr != m_callbacks.end();
          ++itr)
     {
@@ -61,22 +60,23 @@ struct System
   }
 };
 
-void take_shared_ptr(const boost::shared_ptr<const std::string> &p)
+void take_shared_ptr(const std::shared_ptr<const std::string> &p)
 {
-  std::cout << *p << std::endl;
+  std::cout << *p << '\n';
 }
 
 int main(int /*argc*/, char * /*argv*/[]) {
   using namespace chaiscript;
 
   ChaiScript chai;
+  
 
   //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, system), "add_callback_bound");
+  chai.add(fun(&System::add_callback, std::ref(system)), "add_callback_bound");
 
   //Register the two methods of the System structure.
   chai.add(fun(&System::add_callback), "add_callback");
@@ -87,7 +87,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   // Let's use chaiscript to add a new lambda callback to our system. 
   // The function "{ 'Callback1' + x }" is created in chaiscript and passed into our C++ application
   // in the "add_callback" function of struct System the chaiscript function is converted into a 
-  // boost::function, so it can be handled and called easily and type-safely
+  // std::function, so it can be handled and called easily and type-safely
   chai.eval("system.add_callback(\"#1\", fun(x) { \"Callback1 \" + x });");
   
   // Because we are sharing the "system" object with the chaiscript engine we have equal
@@ -108,14 +108,14 @@ 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 boost::function as a system function, in this 
+  //Finally, it is possible to register any std::function 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, boost::ref(system), std::string("Bound Test")), "do_callbacks");
+  chai.add(fun(&System::do_callbacks, std::ref(system), std::string("Bound Test")), "do_callbacks");
 
   //Call bound version of do_callbacks
   chai("do_callbacks()");
 
-  boost::function<void ()> caller = chai.eval<boost::function<void ()> >("fun() { system.do_callbacks(\"From Functor\"); }");
+  std::function<void ()> caller = chai.eval<std::function<void ()> >("fun() { system.do_callbacks(\"From Functor\"); }");
   caller();
 
 
@@ -123,7 +123,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //the templated version of eval:
   int i = chai.eval<int>("5+5");
 
-  std::cout << "5+5: " << i << std::endl;
+  std::cout << "5+5: " << i << '\n';
 
   //Add a new variable
   chai("var scripti = 15");
@@ -131,19 +131,21 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //We can even get a handle to the variables in the system
   int &scripti = chai.eval<int &>("scripti");
 
-  std::cout << "scripti: " << scripti << std::endl;
+  std::cout << "scripti: " << scripti << '\n';
   scripti *= 2;
-  std::cout << "scripti (updated): " << scripti << std::endl;
+  std::cout << "scripti (updated): " << scripti << '\n';
   chai("print(\"Scripti from chai: \" + to_string(scripti))");
 
   //To do: Add examples of handling Boxed_Values directly when needed
 
-  //Creating a functor on the stack and using it immediatly 
-  int x = chai.eval<boost::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
+  //Creating a functor on the stack and using it immediately 
+  int x = chai.eval<std::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
 
-  log("Functor test output", boost::lexical_cast<std::string>(x));
+  std::stringstream ss;
+  ss << x;
+  log("Functor test output", ss.str());
 
-  chai.add(var(boost::shared_ptr<int>()), "nullvar");
+  chai.add(var(std::shared_ptr<int>()), "nullvar");
   chai("print(\"This should be true.\"); print(nullvar.is_var_null())");
 
   // test the global const action
@@ -165,7 +167,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //Dynamic objects test
   chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Function("TestType", fun(&hello_world))), "hello_world");
   chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Constructor("TestType", fun(&hello_constructor))), "TestType");
-//  chai.add(fun(boost::function<Boxed_Value (dispatch::Dynamic_Object &)>(boost::bind(&dispatch::detail::Dynamic_Object_Attribute::func, "TestType", "attr", _1))), "attr");
+//  chai.add(fun(std::function<Boxed_Value (dispatch::Dynamic_Object &)>(std::bind(&dispatch::detail::Dynamic_Object_Attribute::func, "TestType", "attr", std::placeholders::_1))), "attr");
 
   chai.eval("var x = TestType()");
 //  chai.eval("x.attr = \"hi\"");

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

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

samples/fun.chai

@@ -1,10 +1,10 @@
 //functions of zero params don't need them:
 def meet {
-	print("Hello")
+  print("Hello")
 }
 
 def greet(x) {
-	print("Hello, " + x.to_string())
+  print("Hello, " + x.to_string())
 }
 
 //but you need parens for invocation:

samples/fun_call_performance.chai

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

samples/fun_call_performance.cpp

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

samples/if.chai

@@ -1,10 +1,10 @@
 var i = 0
 if (i == 0) {
-	print("i is 0")
+  print("i is 0")
 }
 else if (i == 1) {
-	print("i is 1")
+  print("i is 1")
 }
 else {
-	print("i is not 0 or 1")
+  print("i is not 0 or 1")
 }

samples/inheritance.cpp

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

samples/loop_break.chai

@@ -1,20 +1,20 @@
 for (var i = 0; i < 10; ++i) {
-	print("i: " + i.to_string())
-	if (i == 5) {
-		break
-	}
+  print("i: " + i.to_string())
+  if (i == 5) {
+    break
+  }
 }
 
 var j = 0
 
 while (true) {
-	while (true) {
-		++j;
-		if (j == 5) {
-			break
-		}
-	}
-	break
+  while (true) {
+    ++j;
+    if (j == 5) {
+      break
+    }
+  }
+  break
 }
 
 print("j: " + j.to_string())

samples/memory_leak_test.cpp

@@ -1,13 +1,13 @@
 #include <iostream>
 
-#include "chaiscript/chaiscript.hpp"
+#include <chaiscript/chaiscript.hpp>
+
 #ifdef READLINE_AVAILABLE
 #include <readline/readline.h>
 #include <readline/history.h>
 #endif
 
 
-using namespace chaiscript;
 
 std::string get_next_command() {
 #ifdef READLINE_AVAILABLE
@@ -23,26 +23,21 @@ std::string get_next_command() {
 #endif
 }
 
-void fuction(void)
+void function(void)
 {
   // do nothing
 }
 
 class test
 {
-  ChaiScript chai;
-  ChaiScript::State backupState;
-  public:
-  test()
-  {		
-    backupState = chai.get_state();
-  }
-  ~test(){}
+  chaiscript::ChaiScript chai;
+  chaiscript::ChaiScript::State backupState = chai.get_state();
 
+  public:
   void ResetState()
   {
     chai.set_state(backupState);
-    chai.add(fun(&fuction),"Whatever()");
+    chai.add(chaiscript::fun(&function),"Whatever()");
   }
 
   void RunFile(std::string sFile)
@@ -51,7 +46,7 @@ class test
       chaiscript::Boxed_Value val = chai.eval_file(sFile);
     }
     catch (std::exception &e) {
-      std::cout << e.what() << std::endl;
+      std::cout << e.what() << '\n';
     }
   }
 
@@ -67,12 +62,12 @@ int main(int /*argc*/, char * /*argv*/[]) {
   std::string command = "";
 
   //
-  // this loop increases memoryusage, if RunFile is not called (just hittin enter)
+  // this loop increases memory usage, if RunFile is not called (just hitting enter)
   // as soon RunFile gets called, memory will be freed.
   //
-  // scenario1 - RunFile gets called every Loop: memoryusage does not change
-  // scenario2 - RunFile gets never called (just hitting enter): memoryusage increases every loop
-  // scenario3 - RunFile gets in changing intervals: memoryusage goes up and down, but never as 
+  // scenario1 - RunFile gets called every Loop: memory usage does not change
+  // scenario2 - RunFile gets never called (just hitting enter): memory usage increases every loop
+  // scenario3 - RunFile gets in changing intervals: memory usage goes up and down, but never as
   //            low as in case 1 scenario3 :
 
   while(command != "quit")

samples/oper.chai

@@ -2,7 +2,7 @@ var x = -(1 + 2 - 3 * 4 / 2)
 print("Answer: " + x.to_string())
 
 if (x >= 2 && x <= 4) {
-	print("x is between 2 and 4")
+  print("x is between 2 and 4")
 }
 
 

samples/range.chai

@@ -5,7 +5,7 @@ def for_each(container, function)
   while (!range.empty())
   {
     function(range.front());
-    range.popFront();
+    range.pop_front();
   }
 }
 

samples/scope.chai

@@ -6,10 +6,10 @@
 */
 var x = 4
 def do_it() {
-	var x = 1
-	print(x)
-	var y = fun(x) { x + 1 }
-	print(y(9))
+  var x = 1
+  print(x)
+  var y = fun(x) { x + 1 }
+  print(y(9))
 }
 do_it()
 print(x)