.decent_ci-Linux.yaml

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

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

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

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

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

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

.github/PULL_REQUEST_TEMPLATE.md

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

.travis.yml

@@ -1,73 +0,0 @@
-language: cpp
-
-
-addons:
-  apt:
-    sources: 
-      - ubuntu-toolchain-r-test
-    packages:
-      - g++-4.9
-      - g++-5
-  coverity_scan:
-    project:
-      name: "ChaiScript/ChaiScript"
-      description: "Build submitted via Travis CI"
-    notification_email: jason@emptycrate.com
-    build_command_prepend: "cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug . "
-    build_command:   "cmake --build . -- -j2"
-    branch_pattern: coverity_scan
-      
-matrix:
-  include:
-    - os: linux
-      sudo: false
-      env: GCC_VER="4.9"
-      compiler: gcc
-    - os: linux
-      sudo: false
-      env: GCC_VER="4.9" CMAKE_OPTIONS="-D DYNLOAD_ENABLED:BOOL=FALSE -D MULTITHREAD_SUPPORT_ENABLED:BOOL=FALSE -D USE_STD_MAKE_SHARED:BOOL=TRUE" BUILD_ONLY=1
-      compiler: gcc
-    - os: linux
-      sudo: false
-      env: GCC_VER="5" CPPCHECK=1 COVERAGE=1 CMAKE_OPTIONS="-D RUN_FUZZY_TESTS:BOOL=TRUE"
-      compiler: gcc
-    - os: osx
-      compiler: clang
-      osx_image: xcode8
-    - os: osx
-      compiler: clang
-      osx_image: xcode8
-      env: CMAKE_OPTIONS="-D DYNLOAD_ENABLED:BOOL=FALSE -D MULTITHREAD_SUPPORT_ENABLED:BOOL=FALSE -D USE_STD_MAKE_SHARED:BOOL=TRUE" BUILD_ONLY=1
-  
-env:
-  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:
-  - if [ "${GCC_VER}" != "" ]; then export CXX="g++-$GCC_VER" CC="gcc-$GCC_VER" GCOV="gcov-$GCC_VER" ; fi
-  - pip install --user cpp-coveralls
-
-script: 
-  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug $CMAKE_OPTIONS . 
-  - cmake --build . -- -j2
-  - if [ "${BUILD_ONLY}" != "1" ]; then ctest; fi
-  - if [ "${COVERAGE}" = "1" ]; then bash <(curl -s https://raw.githubusercontent.com/codecov/codecov-bash/master/codecov) -x $GCOV -a "-s `pwd`" ; fi
-
-#after_script:
-#  - if [ ${CPPCHECK} = 1 ]; then contrib/codeanalysis/runcppcheck.sh ; fi
-
-
-notifications:
-  email:
-    recipients:
-      - 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

CMakeLists.txt

@@ -1,507 +1,45 @@
-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
-
+cmake_minimum_required(VERSION 2.6)
 
 project(chaiscript)
 
-option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
-option(DYNLOAD_ENABLED "Dynamic Loading Support Enabled" TRUE)
+FIND_LIBRARY(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
 
+MESSAGE(STATUS "Detecting readline support")
+if (READLINE_LIBRARY)
+    MESSAGE(STATUS "Found: ${READLINE_LIBRARY}")
+    SET (READLINE_LIB readline)
+    SET (READLINE_FLAG " -DREADLINE_AVAILABLE")
+else(READLINE_LIBRARY)
+    MESSAGE(STATUS "Not Found")
+    SET (READLINE_LIB )
+    SET (READLINE_FLAG )
+endif(READLINE_LIBRARY)
 
-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)
+SET (CMAKE_C_FLAGS_REL " -Wall -O3 ${READLINE_FLAG}")
+SET (CMAKE_CXX_FLAGS_REL " -Wall -O3 ${READLINE_FLAG}")
 
-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")
-list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.git")
-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.md")
-set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
-
-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_SECTION "devel")
-set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
-
-set(CPACK_RPM_PACKAGE_LICENSE "BSD")
-set(CPACK_RPM_PACKAGE_GROUP "Programming")
-
-set(CHAI_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
-
-configure_file(Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile)
-
-include(CTest)
-include(CPack)
-
-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()
-  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 /w14545 /w34242 /w34254 /w34287 /w44263 /w44265 /w44296 /w44311 /w44826 /we4289 /w14546 /w14547 /w14549 /w14555 /w14619 /w14905 /w14906 /w14928)
-
-  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()
+SET (CMAKE_C_FLAGS " -Wall -ggdb ${READLINE_FLAG}")
+SET (CMAKE_CXX_FLAGS " -Wall -ggdb ${READLINE_FLAG}")
 
 include_directories(include)
-
-
-set(Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/type_conversions.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.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(NOT MULTITHREAD_SUPPORT_ENABLED)
-  add_definitions(-DCHAISCRIPT_NO_THREADS)
-endif()
-
-if(NOT DYNLOAD_ENABLED)
-  add_definitions(-DCHAISCRIPT_NO_DYNLOAD)
-endif()
-
-if(CMAKE_HOST_UNIX)
-  if(DYNLOAD_ENABLED)
-    if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-      list(APPEND LIBS "dl")
-    endif()
-  endif()
-
-  if(MULTITHREAD_SUPPORT_ENABLED)
-    if(CMAKE_COMPILER_IS_GNUCC)
-      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()
-
-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)
-
-add_executable(chai src/main.cpp ${Chai_INCLUDES})
-target_link_libraries(chai ${LIBS} ${CHAISCRIPT_LIBS})
-
-if(BUILD_SAMPLES)
-  add_executable(example samples/example.cpp)
-  target_link_libraries(example ${LIBS})
-  add_executable(test_num_exceptions samples/test_num_exceptions.cpp)
-  target_link_libraries(test_num_exceptions ${LIBS} ${CHAISCRIPT_LIBS})
-  add_executable(memory_leak_test samples/memory_leak_test.cpp)
-  target_link_libraries(memory_leak_test ${LIBS} ${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)
-  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})
-
-  set(MODULES stl_extra)
-endif()
-
-file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/3.x/*.chai)
-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)
-
-  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}/"
-  )
-
-  add_test(version_check_2 chai --version )
-  set_property(TEST version_check_2
-    PROPERTY ENVIRONMENT
-    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
-    PROPERTY PASS_REGULAR_EXPRESSION "${CHAI_VERSION}"
-  )
-
-  add_test(help chai --help )
-  set_property(TEST help
-    PROPERTY ENVIRONMENT
-    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
-  )
-
-
-  set(TESTS "")
-
-  foreach(filename ${UNIT_TESTS})
-    message(STATUS "Adding 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(static_chaiscript_test unittests/static_chaiscript.cpp)
-    target_link_libraries(static_chaiscript_test ${LIBS})
-    add_test(NAME Static_ChaiScript_Test COMMAND static_chaiscript_test)
-
-    add_executable(boxed_cast_test unittests/boxed_cast_test.cpp)
-    target_link_libraries(boxed_cast_test ${LIBS})
-    add_test(NAME Boxed_Cast_Test COMMAND boxed_cast_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(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(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
-    )
-    target_link_libraries(multifile_test ${LIBS})
-    add_test(NAME MultiFile_Test COMMAND multifile_test)
-
-    install(TARGETS test_module RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
-  endif()
-endif()
-
-install(TARGETS chai chaiscript_stdlib-${CHAI_VERSION} ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
-
-install(DIRECTORY include/chaiscript DESTINATION include
-  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)
-install(DIRECTORY samples DESTINATION share/chaiscript
-  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()
+ 
+find_package(Boost 1.36.0 COMPONENTS thread)
+
+if (Boost_FOUND)
+	include_directories(${Boost_INCLUDE_DIRS})
+	add_executable(chaiscript_eval src/main.cpp)
+	#add_executable(dispatchkit_test contrib/test/dispatchkit_test.cpp)
+	target_link_libraries(chaiscript_eval dl ${Boost_LIBRARIES} ${READLINE_LIB})
+
+        add_library(test MODULE src/test_module.cpp)
+	target_link_libraries(test ${Boost_LIBRARIES})
+
+        add_library(stl_extra MODULE src/stl_extra.cpp)
+	target_link_libraries(stl_extra ${Boost_LIBRARIES})
+
+	install(TARGETS chaiscript_eval DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/bin)
+        
+else(Boost_FOUND)
+        message(FATAL_ERROR "Can not find Boost")
+endif(Boost_FOUND)
 

DesignGoals.md

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

LICENSE

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

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

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

bin/placeholder.txt

@@ -0,0 +1 @@
+This is a placeholder

build_package.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo .
+make install
+
+INCLUDED_FILES="include/chaiscript/*.hpp include/chaiscript/dispatchkit/*.hpp include/chaiscript/language/*.hpp bin/chaiscript_eval"
+
+zip -r chaiscript-1.0.zip $INCLUDED_FILES

cheatsheet.md

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

@@ -1,11 +0,0 @@
-#!/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

@@ -1,11 +0,0 @@
-#!/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 -ldl -omultithreaded -I../include -O3
+    g++ multithreaded.cpp -lboost_thread-mt -ldl -omultithreaded -I../include -O3
     echo "****Testing 1 thread runtime"
     /usr/bin/time -p ./multithreaded 1 2> ../../r$1-1threadruntime.out
     echo "****Testing 2 thread runtime"

contrib/codeanalysis/fuzzy_tests/chaiscript.dict

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

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

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

contrib/codeanalysis/runcppcheck.sh

@@ -1,16 +0,0 @@
-#!/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
-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

@@ -1,136 +0,0 @@
-<?php
-/*************************************************************************************
- * chaiscript.php
- * --------------
- * Author: Jason Turner & Jonathan Turner (based on JavaScript by Ben Keen (ben.keen@gmail.com))
- * Copyright: (c) 2010 Jason Turner (jason@emptycrate.com) (c) 2009 Jonathan Turner 
- *            (c) 2004 Ben Keen (ben.keen@gmail.com), Nigel McNie (http://qbnz.com/highlighter)
- * Release Version: 1.0
- * Date Started: 2009/07/03
- *
- * ChaiScript language file for GeSHi.
- *
- * CHANGES
- * -------
- * 2009/07/03 (1.0.0)
- *  -  First Release
- * 2010/03/30 (1.1.0)
- *  -  Updated to include more language features and remove left over pieces from JavaScript
- *
- *************************************************************************************
- *
- *     This file is part of GeSHi.
- *
- *   GeSHi is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   GeSHi is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with GeSHi; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- ************************************************************************************/
-
-$language_data = array (
-    'LANG_NAME' => 'ChaiScript',
-    'COMMENT_SINGLE' => array(1 => '//'),
-    'COMMENT_MULTI' => array('/*' => '*/'),
-    //Regular Expressions
-    'COMMENT_REGEXP' => array(2 => "/(?<=[\\s^])s\\/(?:\\\\.|(?!\n)[^\\/\\\\])+\\/(?:\\\\.|(?!\n)[^\\/\\\\])+\\/[gimsu]*(?=[\\s$\\.\\;])|(?<=[\\s^(=])m?\\/(?:\\\\.|(?!\n)[^\\/\\\\])+\\/[gimsu]*(?=[\\s$\\.\\,\\;\\)])/iU"),
-    'CASE_KEYWORDS' => GESHI_CAPS_NO_CHANGE,
-    'QUOTEMARKS' => array("'", '"'),
-    'ESCAPE_CHAR' => '\\',
-    'KEYWORDS' => array(
-        1 => array(
-            'break', 'else', 'else if', 'eval', 'for', 'if', 'return', 'while', 'try', 'catch', 'finally', 'case', 'switch', 'default',
-            ),
-        2 => array(
-            'def', 'false', 'fun', 'true', 'var', 'auto', 'attr',
-            ),
-        3 => array(
-            // built in functions
-            'throw', 
-            )
-        ),
-    'SYMBOLS' => array(
-        '(', ')', '[', ']', '{', '}',
-        '+', '-', '*', '/', '%',
-        '!', '@', '&', '|', '^',
-        '<', '>', '=',
-        ',', ';', '?', ':'
-        ),
-    'CASE_SENSITIVE' => array(
-        GESHI_COMMENTS => false,
-        1 => false,
-        2 => false,
-        3 => false
-        ),
-    'STYLES' => array(
-        'KEYWORDS' => array(
-            1 => 'color: #000066; font-weight: bold;',
-            2 => 'color: #003366; font-weight: bold;',
-            3 => 'color: #000066;'
-            ),
-        'COMMENTS' => array(
-            1 => 'color: #006600; font-style: italic;',
-            2 => 'color: #009966; font-style: italic;',
-            'MULTI' => 'color: #006600; font-style: italic;'
-            ),
-        'ESCAPE_CHAR' => array(
-            0 => 'color: #000099; font-weight: bold;'
-            ),
-        'BRACKETS' => array(
-            0 => 'color: #009900;'
-            ),
-        'STRINGS' => array(
-            0 => 'color: #3366CC;'
-            ),
-        'NUMBERS' => array(
-            0 => 'color: #CC0000;'
-            ),
-        'METHODS' => array(
-            1 => 'color: #660066;'
-            ),
-        'SYMBOLS' => array(
-            0 => 'color: #339933;'
-            ),
-        'REGEXPS' => array(
-            ),
-        'SCRIPT' => array(
-            0 => '',
-            1 => '',
-            2 => '',
-            3 => ''
-            )
-        ),
-    'URLS' => array(
-        1 => '',
-        2 => '',
-        3 => ''
-        ),
-    'OOLANG' => true,
-    'OBJECT_SPLITTERS' => array(
-        1 => '.'
-        ),
-    'REGEXPS' => array(
-        ),
-    'STRICT_MODE_APPLIES' => GESHI_MAYBE,
-    'SCRIPT_DELIMITERS' => array(
-        0 => array(
-            ),
-        1 => array(
-            )
-        ),
-    'HIGHLIGHT_STRICT_BLOCK' => array(
-        0 => true,
-        1 => true
-        )
-);
-
-?>

contrib/pkgconfig/chaiscript.pc.in

@@ -1,12 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-libdir=${exec_prefix}/lib
-includedir=${prefix}/include
-
-Name: chaiscript
-Description: ChaiScript is a scripting language that easily embeds into your existing C++ applications. It's built to be flexible and dynamic, yet still maintain the type-safety you expect as a C++ user. It can natively use classes, methods, and attributes, even if the class inherits functionality from a parent class. 
-Version: @CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@
-Requires:
-Conflicts:
-Libs: 
-Cflags: -I${includedir}

contrib/test/callbacktest.cpp

@@ -0,0 +1,69 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+
+#include "function_call.hpp"
+#include "chaiscript.hpp"
+#include <boost/function.hpp>
+
+struct Callback_Handler
+{
+  typedef std::vector<std::pair<boost::function<std::string ()>,
+                        boost::function<double (int)> > > Callbacks;
+  
+  Callbacks m_callbacks;
+
+  void add_callbacks(boost::shared_ptr<dispatchkit::Proxy_Function> t_name,
+      boost::shared_ptr<dispatchkit::Proxy_Function> t_value)
+  {
+    m_callbacks.push_back(
+        std::make_pair(dispatchkit::build_function_caller<std::string ()>(t_name),
+                       dispatchkit::build_function_caller<double (int)>(t_value)
+          )
+        );
+  }
+
+  void do_callbacks()
+  {
+    int i=1;
+    for (Callbacks::iterator itr = m_callbacks.begin();
+         itr != m_callbacks.end();
+         ++itr)
+    {
+      std::cout << "Name: " << itr->first() << "  =  " << itr->second(i) << std::endl;
+      ++i;
+    }
+  }
+};
+
+int main(int argc, char *argv[]) {
+
+    chaiscript::ChaiScript_Engine chai;
+
+    Callback_Handler cb_handler;
+    chai.get_eval_engine().add_object("cb_handler", boost::ref(cb_handler));
+    dispatchkit::register_function(chai.get_eval_engine(), &Callback_Handler::add_callbacks, "add_callbacks");
+
+    for (int i = 1; i < argc; ++i) {
+      try {
+        dispatchkit::Boxed_Value val = chai.evaluate_file(argv[i]);
+      }
+      catch (std::exception &e) {
+        std::cerr << "Could not open: " << argv[i] << std::endl;
+        exit(1);
+      }
+    }
+
+    cb_handler.do_callbacks();
+
+    boost::function<std::string (const std::string&, const std::string &)> f = 
+      dispatchkit::build_functor<std::string (const std::string &, const std::string &)>
+        (chai, "function(x, y) { return x + y }");
+
+    std::cout << "Functor call: " << f("Hello", " World") << std::endl;
+}
+

contrib/test/dispatchkit_test.cpp

@@ -0,0 +1,212 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+
+#include <chaiscript/dispatchkit/dispatchkit.hpp>
+#include <chaiscript/dispatchkit/bootstrap.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
+#include <chaiscript/dispatchkit/function_call.hpp>
+
+using namespace dispatchkit;
+
+struct Test
+{
+  Test(const std::string &s)
+    : number(-25), message(s)
+  {
+    std::cout << "Test class constructed with value: " << s << std::endl;
+  }
+
+  void show_message()
+  {
+    std::cout << "Constructed Message: " << message << std::endl;
+  }
+
+  std::string &get_message()
+  {
+    return message;
+  }
+
+  int number;
+
+  std::string message;
+};
+
+
+
+Boxed_Value named_func_call(Dispatch_Engine &ss,
+    const std::string &nametocall, const std::vector<Boxed_Value> &params)
+{
+  if (params.size() == 2)
+  {
+    return dispatch(ss.get_function(nametocall), params);
+  } else {
+    throw std::runtime_error("Invalid num params");
+  }
+}
+
+// A function that takes a dynamic list of params
+// and calls a bunch of conversion functions on them and 
+// returns the result as a boxed_value
+Boxed_Value dynamic_function(Dispatch_Engine &ss, const std::string &name, 
+    const std::vector<Boxed_Value> &params)
+{
+  if (name == "concat_string")
+  {
+    Boxed_Value result;
+
+    //Return a void if there is nothing in the array
+    if (params.size() == 0)
+    {
+      return result;
+    } else {
+      //else, prepopulate the result with a string conversion of the first
+      //param
+      result = 
+        dispatch(ss.get_function("to_string"), Param_List_Builder() << params[0]);
+    }
+
+    //Then, loop over all remaining params, converting them to strings and adding
+    //them to the result. This example maybe bette served with a string += operator
+    //implementation, but it works.
+    for (size_t i = 1; i < params.size(); ++i)
+    {
+      result = 
+        dispatch(ss.get_function("+"), Param_List_Builder() << result << 
+            dispatch(ss.get_function("to_string"), Param_List_Builder() << params[i]));
+    }
+
+    return result;
+  } else {
+    throw std::runtime_error("Unknown function call");
+  }
+}
+
+void test(const std::string &p)
+{
+  std::cout << "Test: " << p << std::endl;
+}
+
+//Test main
+int main()
+{
+  Dispatch_Engine ss;
+  Bootstrap::bootstrap(ss);
+  bootstrap_vector<std::vector<int> >(ss, "VectorInt");
+  dump_system(ss);
+
+  //Calling a function by name and allowing the built in dispatch mechanism to
+  //choose the most appropriate version of the function
+  Boxed_Value addresult = dispatch(ss.get_function("+"), Param_List_Builder() << double(5.1) << double(10.3));
+
+  //Using the cast to unbox the resultant value and output it
+  std::cout << boxed_cast<double>(addresult) << std::endl;
+
+  //Using the Boxed_Value as input to another function, again with automatic dispatch.
+  //This time we will not bother saving the result and will instead send it straight out
+  std::cout << boxed_cast<double>(
+      dispatch(ss.get_function("*"), Param_List_Builder() << 2 << addresult)
+      ) << std::endl;
+
+  //Register a new function, this one with typing for us, so we don't have to ubox anything
+  //right here
+
+  //Now we have a print method, let's try to print out the earlier example:
+  //so, we dispatch the to_string and pass its result as a param to "print"
+  //In this example we don't bother with temporaries and we don't have to know
+  //anything about types
+  dispatch(ss.get_function("print_string"),
+      Param_List_Builder() << dispatch(ss.get_function("to_string"), Param_List_Builder() << addresult));
+
+  // Now we are going to register a new dynamic function,
+  // when this function is called the objects are not unboxed, but passed
+  // in in their boxed state
+  ss.register_function(boost::shared_ptr<Proxy_Function>(new Dynamic_Proxy_Function(boost::bind(&dynamic_function, boost::ref(ss), "concat_string", _1))), "concat_string");
+
+
+  // Call our newly defined dynamic function with 10 parameters, then send
+  // its output to the "print" function
+  dispatch(ss.get_function("print_string"),
+      Param_List_Builder() << dispatch(ss.get_function("concat_string"),
+        Param_List_Builder() << std::string("\n\t") << std::string("The Value Was: ") 
+                             << double(42.5) << std::string(".")
+                             << '\n'
+                             << '\t' << std::string("The old value was: ")
+                             << addresult << '.' << '\n' ));
+
+
+
+
+  //Register some local methods of the "Test" class
+  ss.register_function(build_constructor<Test, const std::string &>(), "Test");
+
+  register_function(ss, &Test::get_message, "get_message");
+  register_function(ss, &Test::show_message, "show_message");
+  register_member(ss, &Test::number, "number");
+
+  //Create a new object using the "Test" constructor, passing the param "Yo".
+  //Then, add the new object to the system with the name "testobj2"
+  ss.add_object("testobj2", 
+      dispatch(ss.get_function("Test"), Param_List_Builder() << std::string("Yo")));
+
+  // Look up and store a reference to our new object
+  std::vector<Boxed_Value> sos;
+  sos.push_back(ss.get_object("testobj2"));
+
+  //Build a bound function proxy for calling the script handled function
+  boost::function<void (Test &)> show_message = 
+    build_function_caller<void (Test &)>(ss.get_function("show_message"));
+
+  Test &t = boxed_cast<Test &>(ss.get_object("testobj2"));
+
+  //Print the message the object was created with
+  show_message(t);
+
+  //Now, get a reference to the object's stored message
+  Boxed_Value stringref = dispatch(ss.get_function("get_message"), sos);
+
+  //Unbox it using boxed_cast
+  std::string &sr = boxed_cast<std::string &>(stringref);
+
+  //Update the value of the reference
+  sr = "Bob Updated The message";
+
+  //Now, get a reference to the object's stored number
+  Boxed_Value numberref= dispatch(ss.get_function("number"), sos);
+
+  //Unbox it using boxed_cast
+  int &ir = boxed_cast<int &>(numberref);
+
+  std::cout << "Number: " << ir << std::endl;
+
+  //Now, prove that the reference was successfully acquired
+  //and we are able to peek into the boxed types
+  show_message(t);
+
+
+  // Finally, we are going to register some named function aliases, for 
+  // the fun of it
+  ss.register_function(boost::shared_ptr<Proxy_Function>(
+        new Dynamic_Proxy_Function(boost::bind(&named_func_call, boost::ref(ss), "+", _1))), "add");
+
+  //Call our newly named "add" function (which in turn dispatches +)
+  
+  std::cout << "Result of add function: " << 
+    boxed_cast<int>(dispatch(ss.get_function("add"), Param_List_Builder() << 5 << 2))
+    << std::endl; 
+
+
+  ss.set_object("myfunc", boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<boost::function<void (const std::string &)> >(&test)));
+
+  dispatch(ss.get_function("myfunc"), Param_List_Builder() << std::string("hello function variable"));
+
+}
+

contrib/test/dispatchkit_unittest.cpp

@@ -0,0 +1,23 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include "dispatchkit.hpp"
+#include "bootstrap.hpp"
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE boxedcpp_unittests
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE( add_operators )
+{
+  using namespace dispatchkit;
+
+  Dispatch_Engine ss;
+  Bootstrap::bootstrap(ss);
+  dump_system(ss);
+
+  BOOST_CHECK_EQUAL(boxed_cast<int>(dispatch(ss.get_function("+"), Param_List_Builder() << double(5.1) << double(10.3))), 15.4);
+}

contrib/test/sensors.cpp

@@ -0,0 +1,148 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+
+#include "chaiscript.hpp"
+#include "function_call.hpp"
+#include <boost/function.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/regex.hpp>
+
+
+std::string load_text_file(const std::string &filename)
+{
+  std::ifstream infile(filename.c_str());
+
+  std::string str;
+
+  std::string result;
+
+  while (std::getline(infile, str))
+  {
+    result += str + "\n";
+  }
+
+  return result;
+}
+
+std::vector<dispatchkit::Boxed_Value> regex_search(const std::string &str, const std::string &regex)
+{
+  boost::smatch matches;
+  boost::regex_search(str, matches, boost::regex(regex));
+
+  std::vector<dispatchkit::Boxed_Value> results;
+
+  for (unsigned int i = 0; i < matches.size(); ++i)
+  {
+    results.push_back(dispatchkit::Boxed_Value(std::string(matches.str(i))));
+  }
+
+  return results;
+}
+
+struct Sensor_Manager
+{
+  struct Sensor
+  {
+    int milliseconds;
+    dispatchkit::Boxed_Value state_object;
+    boost::function<double (dispatchkit::Boxed_Value)> sensor;
+    boost::posix_time::ptime next_run;
+
+    Sensor(int t_milliseconds, dispatchkit::Boxed_Value t_state_object, 
+        boost::function<double (dispatchkit::Boxed_Value)> t_sensor)
+      : milliseconds(t_milliseconds), state_object(t_state_object), sensor(t_sensor),
+        next_run(boost::posix_time::microsec_clock::universal_time() 
+            + boost::posix_time::milliseconds(milliseconds))
+    {
+    }
+
+    std::pair<boost::posix_time::ptime, double> get_value()
+    {
+      next_run = boost::posix_time::microsec_clock::universal_time() 
+            + boost::posix_time::milliseconds(milliseconds);
+
+      return std::make_pair(boost::posix_time::microsec_clock::universal_time(),
+          sensor(state_object));
+    }
+  };
+
+  std::map<std::string, Sensor> m_sensors;
+
+  //sensor_manager.add_sensor("CPU", 1000, global_state, function(state) { update_state(state); state["CPU"]; } )
+  void add_sensor(const std::string &t_name, int t_milliseconds, dispatchkit::Boxed_Value t_state_object,
+      boost::shared_ptr<dispatchkit::Proxy_Function> t_func)
+  {
+    m_sensors.insert(
+        std::make_pair(t_name, 
+          Sensor(t_milliseconds, t_state_object, 
+            dispatchkit::build_function_caller<double (dispatchkit::Boxed_Value)>(t_func)
+            )
+          )
+        );
+  }
+
+
+  std::vector<std::pair<std::string, double> > run_sensors()
+  {
+    std::vector<std::pair<std::string, double> > results;
+
+    boost::posix_time::ptime t(boost::posix_time::microsec_clock::universal_time());
+
+    for (std::map<std::string, Sensor>::iterator itr = m_sensors.begin();
+         itr != m_sensors.end();
+         ++itr)
+    {
+      if (itr->second.next_run <= t)
+      {
+        results.push_back(std::make_pair(itr->first, itr->second.get_value().second));
+      }
+    }
+
+    return results;
+  }
+
+};
+
+
+int main(int argc, char *argv[]) {
+
+  chaiscript::ChaiScript_Engine chai;
+
+  Sensor_Manager sensor_manager;
+  chai.get_eval_engine().add_object("sensor_manager", boost::ref(sensor_manager));
+
+  dispatchkit::register_function(chai.get_eval_engine(), &Sensor_Manager::add_sensor, "add_sensor");
+  dispatchkit::register_function(chai.get_eval_engine(), &regex_search, "regex_search");
+  dispatchkit::register_function(chai.get_eval_engine(), &load_text_file, "load_text_file");
+
+
+
+  for (int i = 1; i < argc; ++i) {
+    try {
+      chai.evaluate_file(argv[i]);
+    }
+    catch (std::exception &e) {
+      std::cerr << "Could not open: " << argv[i] << std::endl;
+      exit(1);
+    }
+  }
+
+  while (true)
+  {
+    usleep(1000);
+    std::vector<std::pair<std::string, double> > sensor_data = sensor_manager.run_sensors();
+
+    for (std::vector<std::pair<std::string, double> >::iterator itr = sensor_data.begin();
+         itr != sensor_data.end();
+         ++itr)
+    {
+      std::cout << "Sensor: " << itr->first << " value: " << itr->second << std::endl;
+    }
+  }
+}
+

contrib/vim/README.txt

@@ -1,7 +0,0 @@
-Install ftdetect, indent and syntax subdirectories to:
-
-~/.vim/
-
-See the vim documentation on this:
-
-http://vimdoc.sourceforge.net/htmldoc/syntax.html#mysyntaxfile

contrib/vim/ftdetect/chaiscript.vim

@@ -1,2 +0,0 @@
-au BufRead,BufNewFile *.chai            set filetype=chaiscript
-

contrib/vim/indent/chaiscript.vim

@@ -1,50 +0,0 @@
-" Vim indent file
-" Language:     ChaiScript
-" Maintainer:	Jason Turner <lefticus 'at' gmail com>
-
-" Only load this indent file when no other was loaded.
-if exists("b:did_indent")
-  finish
-endif
-let b:did_indent = 1
-
-setlocal indentexpr=GetChaiScriptIndent()
-setlocal autoindent
-
-" Only define the function once.
-if exists("*GetChaiScriptIndent")
-  finish
-endif
-
-function! GetChaiScriptIndent()
-  " Find a non-blank line above the current line.
-  let lnum = prevnonblank(v:lnum - 1)
-
-  " Hit the start of the file, use zero indent.
-  if lnum == 0
-    return 0
-  endif
-
-  " Add a 'shiftwidth' after lines that start a block:
-  " lines containing a {
-  let ind = indent(lnum)
-  let flag = 0
-  let prevline = getline(lnum)
-  if prevline =~ '^.*{.*'
-    let ind = ind + &shiftwidth
-    let flag = 1
-  endif
-
-  " Subtract a 'shiftwidth' after lines containing a { followed by a }
-  " to keep it balanced
-  if flag == 1 && prevline =~ '.*{.*}.*'
-    let ind = ind - &shiftwidth
-  endif
-
-  " Subtract a 'shiftwidth' on lines ending with }
-  if getline(v:lnum) =~ '^\s*\%(}\)'
-    let ind = ind - &shiftwidth
-  endif
-
-  return ind
-endfunction

contrib/vim/syntax/chaiscript.vim

@@ -1,99 +0,0 @@
-" Vim syntax file
-" Language:	ChaiScript
-" Maintainer:	Jason Turner <lefticus 'at' gmail com>
-
-" Quit when a (custom) syntax file was already loaded
-if exists("b:current_syntax")
-  finish
-end
-
-let s:cpo_save = &cpo
-set cpo&vim
-
-syn case match
-
-" syncing method
-syn sync fromstart
-
-" Strings
-syn region chaiscriptString        start=+"+ end=+"+ skip=+\\\\\|\\"+ contains=chaiscriptSpecial,chaiscriptEval,@Spell
-
-" Escape characters
-syn match  chaiscriptSpecial       contained "\\[\\abfnrtv\'\"]\|\\\d\{,3}"
-
-" String evals
-syn region chaiscriptEval          contained start="${" end="}"
-
-" integer number
-syn match  chaiscriptNumber        "\<\d\+\>"
-
-" floating point number, with dot, optional exponent
-syn match  chaiscriptFloat         "\<\d\+\.\d*\%(e[-+]\=\d\+\)\=\>"
-
-" floating point number, starting with a dot, optional exponent
-syn match  chaiscriptFloat         "\.\d\+\%(e[-+]\=\d\+\)\=\>"
-
-" floating point number, without dot, with exponent
-syn match  chaiscriptFloat         "\<\d\+e[-+]\=\d\+\>"
-
-" Hex strings
-syn match  chaiscriptNumber        "\<0x\x\+\>"
-
-" Binary strings
-syn match  chaiscriptNumber        "\<0b[01]\+\>"
-
-" Various language features
-syn keyword chaiscriptCond         if else
-syn keyword chaiscriptRepeat       while for do
-syn keyword chaiscriptStatement    break continue return switch case default
-syn keyword chaiscriptExceptions   try catch throw
-
-"Keyword
-syn keyword chaiscriptKeyword      def true false attr
-
-"Built in types
-syn keyword chaiscriptType         fun var auto
-
-"Built in funcs, keep it simple
-syn keyword chaiscriptFunc         eval throw
-
-"Let's treat all backtick operator function lookups as built in too
-syn region  chaiscriptFunc         matchgroup=chaiscriptFunc start="`" end="`"
-
-" Account for the "[1..10]" syntax, treating it as an operator
-" Intentionally leaving out all of the normal, well known operators
-syn match   chaiscriptOperator     "\.\."
-
-" Guard seperator as an operator
-syn match   chaiscriptOperator     ":"
-
-" Comments
-syn match   chaiscriptComment      "//.*$" contains=@Spell
-syn region  chaiscriptComment      matchgroup=chaiscriptComment start="/\*" end="\*/" contains=@Spell
-
-
-
-hi def link chaiscriptExceptions	Exception
-hi def link chaiscriptKeyword		Keyword
-hi def link chaiscriptStatement		Statement
-hi def link chaiscriptRepeat		Repeat
-hi def link chaiscriptString		String
-hi def link chaiscriptNumber		Number
-hi def link chaiscriptFloat		Float
-hi def link chaiscriptOperator		Operator
-hi def link chaiscriptConstant		Constant
-hi def link chaiscriptCond		Conditional
-hi def link chaiscriptFunction		Function
-hi def link chaiscriptComment		Comment
-hi def link chaiscriptTodo		Todo
-hi def link chaiscriptError		Error
-hi def link chaiscriptSpecial		SpecialChar
-hi def link chaiscriptFunc		Identifier
-hi def link chaiscriptType		Type
-hi def link chaiscriptEval	        Special
-
-let b:current_syntax = "chaiscript"
-
-let &cpo = s:cpo_save
-unlet s:cpo_save
-" vim: nowrap sw=2 sts=2 ts=8 noet

description.txt

@@ -1 +0,0 @@
-ChaiScript is a header-only C++ embedded scripting language loosely based on ECMA script. It is designed for ease of use and tight integration with C++. See http://www.chaiscript.com for more details.

include/chaiscript/chaiscript.hpp

@@ -1,845 +1,154 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
 #ifndef CHAISCRIPT_HPP_
 #define CHAISCRIPT_HPP_
 
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
 
+#include <stdexcept>
+#include <iostream>
+#include <map>
+#include <fstream>
+#include <boost/shared_ptr.hpp>
 
-/// @mainpage
-/// [ChaiScript](http://www.chaiscript.com") is a scripting language designed specifically for integration with C++. It provides
-/// seamless integration with C++ on all levels, including shared_ptr objects, functors and exceptions.
-/// 
-/// The parts of the ChaiScript API that the average user will be concerned with are contained in the 
-/// chaiscript namespace and the chaiscript::ChaiScript class.
-///
-/// The end user parts of the API are extremely simple both in size and ease of use.
-///
-/// Currently, all source control and project management aspects of ChaiScript occur on [github](http://www.github.com/ChaiScript/ChaiScript").
-///
-/// ------------------------------------------------------------
-/// 
-/// @sa chaiscript
-/// @sa chaiscript::ChaiScript
-/// @sa ChaiScript_Language for Built in Functions
-/// @sa @ref LangGettingStarted
-/// @sa @ref LangKeywordRef
-/// @sa @ref LangInPlaceRef
-/// @sa @ref LangObjectSystemRef
-/// @sa http://www.chaiscript.com
-/// @sa http://www.github.com/ChaiScript/ChaiScript
-///
-/// -----------------------------------------------------------
-///
-/// @section gettingstarted API Getting Started
-///
-/// - @ref basics
-/// - @ref compiling
-/// - @ref eval
-/// - @ref adding_items
-/// - @ref operatoroverloading
-/// - @ref add_class
-/// - @ref pointer_conversions
-/// - @ref baseclasses
-/// - @ref functionobjects
-/// - @ref threading
-/// - @ref exceptions
-/// 
-/// 
-/// @subsection basics Basics
-/// 
-/// Basic simple example:
-///
-/// ~~~~~~~{.cpp}
-/// //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);");
-/// } 
-/// ~~~~~~~
-///
-/// ------------------------------------------------------
-///
-/// @subsection compiling Compiling ChaiScript Applications
-///
-/// ChaiScript is a header only library with only one dependency: The
-/// operating system provided dynamic library loader, which has to be specified on some platforms.
-/// 
-/// @subsubsection compilinggcc Compiling with GCC
-/// 
-/// To compile the above application on a Unix like operating system (MacOS, Linux) with GCC you need to link
-/// the dynamic loader. For example:
-///
-/// ~~~~~~~~
-/// gcc main.cpp -I/path/to/chaiscript/headers -ldl 
-/// ~~~~~~~~
-///
-/// Alternatively, you may compile without threading support.
-///
-/// ~~~~~~~~
-/// gcc main.cpp -I/path/to/chaiscript/headers -ldl -DCHAISCRIPT_NO_THREADS
-/// ~~~~~~~~
-///
-/// ------------------------------------------
-///
-/// @subsection eval Evaluating Scripts
-///
-/// Scripts can be evaluated with the () operator, eval method or eval_file method.
-///
-/// @subsubsection parenoperator () Operator
-///
-/// operator() can be used as a handy shortcut for evaluating ChaiScript snippets.
-///
-/// ~~~~~~~~{.cpp}
-/// chaiscript::ChaiScript chai;
-/// chai("print(@"hello world@")");
-/// ~~~~~~~~
-/// 
-/// @sa chaiscript::ChaiScript::operator()(const std::string &)
-///
-/// @subsubsection evalmethod Method 'eval'
-/// 
-/// The eval method is somewhat more verbose and can be used to get type safely return values
-/// from the script.
-///
-/// ~~~~~~~~{.cpp}
-/// chaiscript::ChaiScript chai;
-/// chai.eval("callsomefunc()");
-/// int result = chai.eval<int>("1 + 3");
-/// // result now equals 4
-/// ~~~~~~~~
-///
-/// @sa chaiscript::ChaiScript::eval
-///
-/// @subsubsection evalfilemethod Method 'eval_file'
-/// 
-/// The 'eval_file' method loads a file from disk and executes the script in it
-/// 
-/// ~~~~~~~~{.cpp}
-/// chaiscript::ChaiScript chai;
-/// chai.eval_file("myfile.chai");
-/// std::string result = chai.eval_file<std::string>("myfile.chai") // extract the last value returned from the file
-/// ~~~~~~~~
-/// 
-/// @sa chaiscript::ChaiScript::eval_file
-///
-/// --------------------------------------------------
-///
-/// @subsection adding_items Adding Items to ChaiScript
-///
-/// ChaiScript supports 4 basic things that can be added: objects, functions, type infos and Modules
-///
-/// @subsubsection adding_objects Adding Objects
-///
-/// Named objects can be created with the chaiscript::var function. Note: adding a object
-/// adds it to the current thread scope, not to a global scope. If you have multiple 
-/// threads that need to access the same variables you will need to add them
-/// separately for each thread, from the thread itself.
-/// 
-/// ~~~~~~~~~{.cpp}
-/// using namespace chaiscript;
-/// ChaiScript chai;
-/// int i = 5;
-/// chai.add(var(i), "i");
-/// chai("print(i)");
-/// ~~~~~~~~~
-///
-/// Immutable objects can be created with the chaiscript::const_var function.
-///
-/// ~~~~~~~~~{.cpp}
-/// chai.add(const_var(i), "i");
-/// chai("i = 5"); // exception throw, cannot assign const var
-/// ~~~~~~~~~
-/// 
-/// Named variables can only be accessed from the context they are created in.
-/// If you want a global variable, it must be const, and created with the 
-/// chaiscript::ChaiScript::add_global_const function.
-///
-/// ~~~~~~~~~{.cpp}
-/// chai.add_global_const(const_var(i), "i");
-/// chai("def somefun() { print(i); }; somefun();");
-/// ~~~~~~~~~
-/// 
-/// @subsubsection adding_functions Adding Functions
-/// 
-/// Functions, methods and members are all added using the same function: chaiscript::fun.
-///
-/// ~~~~~~~~~{.cpp}
-/// using namespace chaiscript;
-/// 
-/// class MyClass {
-///   public:
-///     int memberdata;
-///     void method();
-///     void method2(int);
-///     static void staticmethod();
-///     void overloadedmethod();
-///     void overloadedmethod(const std::string &);
-/// };
-/// 
-/// ChaiScript chai;
-/// chai.add(fun(&MyClass::memberdata), "memberdata");
-/// chai.add(fun(&MyClass::method), "method");
-/// chai.add(fun(&MyClass::staticmethod), "staticmethod");
-/// ~~~~~~~~~
-///
-/// Overloaded methods will need some help, to hint the compiler as to which overload you want:
-///
-/// ~~~~~~~~~{.cpp}
-/// chai.add(fun<void (MyClass::*)()>(&MyClass::overloadedmethod), "overloadedmethod");
-/// chai.add(fun<void (MyClass::*)(const std::string &)>(&MyClass::overloadedmethod), "overloadedmethod");
-/// ~~~~~~~~~
-///
-/// There are also shortcuts built into chaiscript::fun for binding up to the first two parameters of the function.
-/// 
-/// ~~~~~~~~~{.cpp}
-/// MyClass obj;
-/// chai.add(fun(&MyClass::method, &obj), "method");
-/// chai("method()"); // equiv to obj.method()
-/// chai.add(fun(&MyClass::method2, &obj, 3), "method2");
-/// chai("method2()"); // equiv to obj.method2(3)
-/// ~~~~~~~~~
-///
-/// @subsubsection addingtypeinfo Adding Type Info
-///
-/// ChaiScript will automatically support any type implicitly provided to it in the form
-/// of objects and function parameters / return types. However, it can be nice to let ChaiScript 
-/// know more details about the types you are giving it. For instance, the "clone" functionality
-/// cannot work unless there is a copy constructor registered and the name of the type is known
-/// (so that ChaiScript can look up the copy constructor).
-///
-/// Continuing with the example "MyClass" from above:
-///
-/// ~~~~~~~~{.cpp}
-/// chai.add(user_type<MyClass>(), "MyClass");
-/// ~~~~~~~~
-///
-/// @subsubsection adding_modules Adding Modules
-/// 
-/// Modules are holders for collections of ChaiScript registrations.
-///
-/// ~~~~~~~~{.cpp}
-/// ModulePtr module = get_sum_module();
-/// chai.add(module);
-/// ~~~~~~~~
-/// 
-/// @sa chaiscript::Module
-///
-/// -----------------------------------------------------------------------
-///
-/// @subsection operatoroverloading Operator Overloading
-/// 
-/// Operators are just like any other function in ChaiScript, to overload an operator, simply register it.
-/// 
-/// ~~~~~~~~{.cpp} 
-/// class MyClass {
-///   MyClass operator+(const MyClass &) const;
-/// };
-///
-/// chai.add(fun(&MyClass::operator+), "+");
-///
-/// std::string append_string_int(const std::string &t_lhs, int t_rhs)
-/// {
-///   std::stringstream ss;
-///   ss << t_lhs << t_rhs;
-///   return ss.str();
-/// }
-///
-/// chai.add(fun(append_string_int), "+");
-/// ~~~~~~~~
-///
-/// @sa @ref adding_functions
-///
-/// -----------------------------------------------------------------------
-///
-/// @subsection add_class Class Helper Utility
-/// 
-/// Much of the work of adding new classes to ChaiScript can be reduced with the help
-/// of the add_class helper utility.
-///
-/// ~~~~~~~~{.cpp}
-/// class Test
-/// {
-///   public:
-///     void function() {}
-///     std::string function2() { return "Function2"; }
-///     void function3() {}
-///     std::string functionOverload(double) { return "double"; }
-///     std::string functionOverload(int) { return "int"; }
-/// };
-///
-/// int main()
-/// {
-///   chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
-///
-///   chaiscript::utility::add_class<chaiscript::Test>(*m,
-///      "Test",
-///      { constructor<Test()>(),
-///        constructor<Test(const Test &)>() },
-///      { {fun(&Test::function), "function"},
-///        {fun(&Test::function2), "function2"},
-///        {fun(&Test::function2), "function3"} 
-///        {fun(static_cast<std::string Test::*(double)>(&Test::functionOverload)), "functionOverload"} 
-///        {fun(static_cast<std::string Test::*(int)>(&Test::functionOverload)), "functionOverload"} }
-///      );
-///
-///
-///   chaiscript::ChaiScript chai;
-///   chai.add(m);
-/// }
-/// ~~~~~~~~
-/// 
-/// @sa @ref adding_modules
-///
-/// -----------------------------------------------------------------------
-///
-/// @subsection pointer_conversions Pointer / Object Conversions
-///
-/// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, std::shared_ptr<T>,
-/// std::shared_ptr<const T>, std::reference_wrapper<T>, std::reference_wrapper<const T> and value types automatically.
-///
-/// If a chaiscript::var object was created in C++ from a pointer, it cannot be converted to a shared_ptr (this would add invalid reference counting).
-/// Const may be added, but never removed. 
-///
-/// The take away is that you can pretty much expect function calls to Just Work when you need them to.
-///
-/// ~~~~~~~~{.cpp}
-/// void fun1(const int *);
-/// void fun2(int *);
-/// void fun3(int);
-/// void fun4(int &);
-/// void fun5(const int &);
-/// void fun5(std::shared_ptr<int>);
-/// void fun6(std::shared_ptr<const int>);
-/// void fun7(const std::shared_ptr<int> &);
-/// void fun8(const std::shared_ptr<const int> &);
-/// void fun9(std::reference_wrapper<int>);
-/// void fun10(std::reference_wrapper<const int>);
-///
-/// int main()
-/// {
-///   using namespace chaiscript
-///   chaiscript::ChaiScript chai;
-///   chai.add(fun(fun1), "fun1");
-///   chai.add(fun(fun2), "fun2");
-///   chai.add(fun(fun3), "fun3");
-///   chai.add(fun(fun4), "fun4");
-///   chai.add(fun(fun5), "fun5");
-///   chai.add(fun(fun6), "fun6");
-///   chai.add(fun(fun7), "fun7");
-///   chai.add(fun(fun8), "fun8");
-///   chai.add(fun(fun9), "fun9");
-///   chai.add(fun(fun10), "fun10");
-///
-///   chai("var i = 10;");
-///   chai("fun1(i)");
-///   chai("fun2(i)");
-///   chai("fun3(i)");
-///   chai("fun4(i)");
-///   chai("fun5(i)");
-///   chai("fun6(i)");
-///   chai("fun7(i)");
-///   chai("fun8(i)");
-///   chai("fun9(i)");
-///   chai("fun10(i)");
-/// }  
-/// ~~~~~~~~
-///
-/// See the unit test unittests/boxed_cast_test.cpp for a complete breakdown of the automatic casts that 
-/// available and tested.
-/// 
-/// -----------------------------------------------------------------------
-///
-/// @subsection baseclasses Base Classes
-/// 
-/// ChaiScript supports handling of passing a derived class object to a function expecting a base class object.
-/// For the process to work, the base/derived relationship must be registered with the engine.
-///
-/// ~~~~~~~~{.cpp}
-/// class Base {};
-/// class Derived : public Base {};
-/// void myfunction(Base *b);
-///
-/// int main()
-/// {
-///   chaiscript::ChaiScript chai;
-///   chai.add(chaiscript::base_class<Base, Derived>());
-///   Derived d;
-///   chai.add(chaiscript::var(&d), "d");
-///   chai.add(chaiscript::fun(&myfunction), "myfunction");
-///   chai("myfunction(d)");
-/// }
-/// ~~~~~~~~
-/// 
-/// -----------------------------------------------------------------------
-///
-///
-/// @subsection functionobjects Function Objects
-///
-/// Functions are first class objects in ChaiScript and ChaiScript supports automatic conversion
-/// between ChaiScript functions and std::function objects.
-///
-/// ~~~~~~~~{.cpp}
-/// void callafunc(const std::function<void (const std::string &)> &t_func)
-/// {
-///   t_func("bob");
-/// }
-/// 
-/// int main()
-/// {
-///   chaiscript::ChaiScript chai;
-///   chai.add(chaiscript::fun(&callafunc), "callafunc");
-///   chai("callafunc(fun(x) { print(x); })"); // pass a lambda function to the registered function
-///                                            // which expects a typed std::function
-///
-///   std::function<void ()> f = chai.eval<std::function<void ()> >("dump_system");
-///   f(); // call the ChaiScript function dump_system, from C++
-/// }
-/// ~~~~~~~~
-/// 
-/// -----------------------------------------------------------------------
-///
-///
-/// @subsection threading Threading
-/// 
-/// Thread safety is automatically handled within the ChaiScript system. Objects can be added
-/// and scripts executed from multiple threads. For each thread that executes scripts, a new
-/// context is created and managed by the engine.
-/// 
-/// Thread safety can be disabled by defining CHAISCRIPT_NO_THREADS when using the library.
-///
-/// Disabling thread safety increases performance in many cases.
-///
-/// -----------------------------------------------------------------------
-///
-///
-/// @subsection exceptions Exception Handling
-/// 
-/// @subsubsection exceptionsbasics Exception Handling Basics
-///
-/// Exceptions can be thrown in ChaiScript and caught in C++ or thrown in C++ and caught in 
-/// ChaiScript.
-///
-/// ~~~~~~~~{.cpp}
-/// void throwexception()
-/// {
-///   throw std::runtime_error("err");
-/// }
-/// 
-/// int main()
-/// {
-///   // Throw in C++, catch in ChaiScript
-///   chaiscript::ChaiScript chai;
-///   chai.add(chaiscript::fun(&throwexception), "throwexception");
-///   chai("try { throwexception(); } catch (e) { print(e.what()); }"); // prints "err"
-/// 
-///   // Throw in ChaiScript, catch in C++
-///   try {
-///     chai("throw(1)");
-///   } catch (chaiscript::Boxed_Value bv) {
-///     int i = chaiscript::boxed_cast<int>(bv);
-///     // i == 1
-///   }
-/// }
-/// ~~~~~~~~
-/// 
-/// @subsubsection exceptionsautomatic Exception Handling Automatic Unboxing
-///
-/// As an alternative to the manual unboxing of exceptions shown above, exception specifications allow the user to tell 
-/// ChaiScript what possible exceptions are expected from the script being executed. 
-///
-/// Example:
-/// ~~~~~~~~{.cpp}
-/// chaiscript::ChaiScript chai;
-///
-/// try {
-///   chai.eval("throw(runtime_error(@"error@"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
-/// } catch (const double 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
-/// }
-/// ~~~~~~~~
-///
-/// @sa chaiscript::Exception_Handler for details on automatic exception unboxing 
-/// @sa chaiscript::exception_specification
+#include "dispatchkit/dispatchkit.hpp"
+#include "dispatchkit/bootstrap.hpp"
+#include "dispatchkit/bootstrap_stl.hpp"
+#include "dispatchkit/function_call.hpp"
+#include "dispatchkit/dynamic_object.hpp"
+
+#ifdef  BOOST_HAS_DECLSPEC
+#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
+#else
+#define CHAISCRIPT_MODULE_EXPORT extern "C" 
+#endif
 
 
 
-/// @page LangObjectSystemRef ChaiScript Language Object Model Reference
-///
-///
-/// ChaiScript has an object system built in, for types defined within the ChaiScript system.
-///
-/// ~~~~~~~~~
-/// attr Rectangle::height
-/// attr Rectangle::width
-/// def Rectangle::Rectangle() { this.height = 10; this.width = 20 }
-/// def Rectangle::area() { this.height * this.width }
-/// 
-/// var rect = Rectangle()
-/// rect.height = 30
-/// print(rect.area())
-/// ~~~~~~~~~
-///
-/// Since ChaiScript 5.4.0 it has been possible to use the "class" keyword to simplify this code.
-///
-/// ~~~~~~~~~
-/// class Rectangle {
-///   attr height
-///   attr width
-///   def Rectangle() { this.height = 10; this.width = 20 }
-///   def area() { this.height * this.width }
-/// }
-///
-/// var rect = Rectangle()
-/// rect.height = 30
-/// print(rect.area())
-/// ~~~~~~~~~
-///
-/// @sa @ref keywordattr
-/// @sa @ref keyworddef
-
-/// @page LangInPlaceRef ChaiScript Language In-Place Creation Reference
-/// @section inplacevector Vector
-/// 
-/// ~~~~~~~~~
-/// In-place Vector ::= "[" [expression ("," expression)*]  "]"
-/// ~~~~~~~~~
-///
-/// @section inplacerangedvector Ranged Vector
-///
-/// ~~~~~~~~~
-/// In-place Ranged Vector ::= "[" value ".." value "]"
-/// ~~~~~~~~~
-///
-/// Creates a vector over a range (eg. 1..10)
-///
-/// @section inplacemap Map
-///
-/// ~~~~~~~~
-/// In-place Map ::= "[" (string ":" expression)+ "]"
-/// ~~~~~~~~
-
-/// @page LangGettingStarted ChaiScript Language Getting Started
-/// 
-/// ChaiScript is a simple language that should feel familiar to anyone who knows
-/// C++ or ECMAScript (JavaScript). 
-///
-/// -----------------------------------------------------------------------
-///
-/// @section chaiscriptloops Loops
-///
-/// Common looping constructs exist in ChaiScript
-///
-/// ~~~~~~~~
-/// var i = 0;
-/// while (i < 10)
-/// {
-///   // do something
-///   ++i;
-/// }
-/// ~~~~~~~~
-///
-/// ~~~~~~~~
-/// for (var i = 0; i < 10; ++i)
-/// {
-///   // do something
-/// }
-/// ~~~~~~~~
-///
-/// @sa @ref keywordfor
-/// @sa @ref keywordwhile
-///
-/// -----------------------------------------------------------------------
-///
-/// @section chaiscriptifs Conditionals
-///
-/// If statements work as expected
-/// 
-/// ~~~~~~~~
-/// var b = true;
-/// 
-/// if (b) {
-///   // do something
-/// } else if (c < 10) {
-///   // do something else
-/// } else {
-///   // or do this
-/// }
-/// ~~~~~~~~
-///
-/// @sa @ref keywordif
-///
-/// -----------------------------------------------------------------------
-///
-/// @section chaiscriptfunctions Functions
-/// 
-/// Functions are defined with the def keyword
-/// 
-/// ~~~~~~~~
-/// def myfun(x) { print(x); }
-///
-/// myfun(10);
-/// ~~~~~~~~
-///
-/// Functions may have "guards" which determine if which is called.
-///
-/// ~~~~~~~~
-/// eval> def myfun2(x) : x < 10 { print("less than 10"); }
-/// eval> def myfun2(x) : x >= 10 { print("10 or greater"); }
-/// eval> myfun2(5)
-/// less than 10
-/// eval> myfun2(12)
-/// 10 or greater
-/// ~~~~~~~~
-/// 
-/// @sa @ref keyworddef
-/// @sa @ref keywordattr
-/// @sa @ref LangObjectSystemRef
-///
-/// -----------------------------------------------------------------------
-///
-/// @section chaiscriptfunctionobjects Function Objects
-/// 
-/// Functions are first class types in ChaiScript and can be used as variables.
-///
-/// ~~~~~~~~
-/// eval> var p = print;
-/// eval> p(1);
-/// 1
-/// ~~~~~~~~
-/// 
-/// They can also be passed to functions. 
-///
-/// ~~~~~~~~
-/// eval> def callfunc(f, lhs, rhs) { return f(lhs, rhs); }
-/// eval> def do_something(lhs, rhs) { print("lhs: ${lhs}, rhs: ${rhs}"); }
-/// eval> callfunc(do_something, 1, 2);
-/// lhs: 1, rhs: 2
-/// ~~~~~~~~
-///
-/// Operators can also be treated as functions by using the back tick operator. Building on the above example:
-/// 
-/// ~~~~~~~~
-/// eval> callfunc(`+`, 1, 4);
-/// 5
-/// eval> callfunc(`*`, 3, 2);
-/// 6
-/// ~~~~~~~~
-///
-/// -----------------------------------------------------------------------
-///
-/// @sa @ref LangKeywordRef
-/// @sa ChaiScript_Language for Built in Functions
-
-
-/// @page LangKeywordRef ChaiScript Language Keyword Reference
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordattr attr
-/// Defines a ChaiScript object attribute
-/// 
-/// ~~~~~~~~ 
-/// Attribute Definition ::= "attr" class_name "::" attribute_name
-/// ~~~~~~~~
-///
-/// @sa @ref LangObjectSystemRef
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordauto auto
-///
-/// Defines a variable
-///
-/// ~~~~~~~~
-/// Variable ::= "auto" identifier
-/// ~~~~~~~~
-///
-/// Synonym for @ref keywordvar
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordbreak break
-/// Stops execution of a looping block.
-///
-/// ~~~~~~~~
-/// Break Statement ::= "break"
-/// ~~~~~~~~
-///
-/// @sa @ref keywordfor
-/// @sa @ref keywordwhile 
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keyworddef def
-/// Begins a function or method definition
-///
-/// ~~~~~~~~
-/// Function Definition ::= "def" identifier "(" [[type] arg ("," [type] arg)*] ")" [":" guard] block
-/// Method Definition ::= "def" class_name "::" method_name "(" [[type] arg ("," [type] arg)*] ")" [":" guard] block
-/// ~~~~~~~~
-/// 
-/// identifier: name of function. Required.
-/// args: comma-delimited list of parameter names with optional type specifiers. Optional.
-/// guards: guarding statement that act as a prerequisite for the function. Optional.
-/// { }: scoped block as function body. Required.
-///
-/// Functions return values in one of two ways:
-///
-/// By using an explicit return call, optionally passing the value to be returned.
-/// By implicitly returning the value of the last expression (if it is not a while or for loop).
-///
-/// Method definitions for known types extend those types with new methods. This includes C++ and ChaiScript defined types.
-/// Method definitions for unknown types implicitly define the named type.
-///
-/// @sa @ref LangObjectSystemRef
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordelse else
-/// @sa @ref keywordif 
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordfor for
-/// ~~~~~~~~
-/// For Block ::= "for" "(" [initial] ";" stop_condition ";" loop_expression ")" block
-/// ~~~~~~~~
-/// This loop can be broken using the @ref keywordbreak command.
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordfun fun
-/// Begins an anonymous function declaration (sometimes called a lambda).
-///
-/// ~~~~~~~~
-/// Lambda ::= "fun" "(" [variable] ("," variable)*  ")" block
-/// ~~~~~~~~
-///
-/// _Example_
-///
-/// ~~~~~~~~
-/// // Generate an anonymous function object that adds 2 to its parameter
-/// var f = fun(x) { x + 2; }
-/// ~~~~~~~~
-///
-/// @sa @ref keyworddef for more details on ChaiScript functions
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordif if
-/// Begins a conditional block of code that only executes if the condition evaluates as true.
-/// ~~~~~~~~
-/// If Block ::= "if" "(" condition ")" block
-/// Else If Block ::= "else if" "(" condition ")" block
-/// Else Block ::= "else" block
-/// ~~~~~~~~
-/// 
-/// _Example_
-///
-/// ~~~~~~~~
-/// if (true) {
-///   // do something
-/// } else if (false) {
-///   // do something else
-/// } else {
-///   // otherwise do this
-/// }
-/// ~~~~~~~~
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordtry try
-/// ~~~~~~~~
-/// Try Block ::= "try" block 
-///  ("catch" ["(" [type] variable ")"] [":" guards] block)+ 
-///    ["finally" block]
-/// ~~~~~~~~
-///
-/// @sa ChaiScript_Language::throw
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordwhile while
-/// 
-/// Begins a conditional block of code that loops 0 or more times, as long as the condition is true
-///
-/// ~~~~~~~~
-/// While Block ::= "while" "(" condition ")" block
-/// ~~~~~~~~
-///
-/// This loop can be broken using the @ref keywordbreak command.
-///
-///
-/// -----------------------------------------------------------------------
-///
-/// @section keywordvar var
-/// 
-/// Defines a variable
-///
-/// ~~~~~~~~
-/// Variable ::= "var" identifier
-/// ~~~~~~~~
-///
-/// Synonym for @ref keywordauto
-
-
-/// @namespace chaiscript
-/// @brief Namespace chaiscript contains every API call that the average user will be concerned with.
-
-/// @namespace chaiscript::detail
-/// @brief Classes and functions reserved for internal use. Items in this namespace are not supported.
-
-#include "chaiscript_basic.hpp"
-#include "language/chaiscript_parser.hpp"
-#include "chaiscript_stdlib.hpp"
-
-
-namespace chaiscript 
+namespace chaiscript
 {
-  class ChaiScript : public ChaiScript_Basic
-  {
-    public:
-      ChaiScript(std::vector<std::string> t_modulepaths = {},
-          std::vector<std::string> t_usepaths = {},
-          const std::vector<Options> &t_opts = {})
-        : ChaiScript_Basic(
-            chaiscript::Std_Lib::library(),
-            std::make_unique<parser::ChaiScript_Parser<eval::Noop_Tracer, optimizer::Optimizer_Default>>(),
-            t_modulepaths, t_usepaths, t_opts)
-        {
+    typedef ModulePtr (*Create_Module_Func)();
+
+    /**
+     * Types of AST nodes available to the parser and eval
+     */
+    class Token_Type { public: enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
+        Expression, Comparison, Additive, Multiplicative, Negate, Not, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
+        Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
+        Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl }; };
+
+    namespace 
+    {
+      /**
+       * Helper lookup to get the name of each node type
+       */
+      const char *token_type_to_string(int tokentype) {
+        const char *token_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Inplace_Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
+          "Expression", "Comparison", "Additive", "Multiplicative", "Negate", "Not", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
+          "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
+          "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl"};
+
+        return token_types[tokentype];
+      }
+    }
+
+    /**
+     * Convenience type for file positions
+     */
+    struct File_Position {
+        int line;
+        int column;
+
+        File_Position(int file_line, int file_column)
+            : line(file_line), column(file_column) { }
+
+        File_Position() : line(0), column(0) { }
+    };
+
+    typedef boost::shared_ptr<struct Token> TokenPtr;
+
+    /**
+     * The struct that doubles as both a parser token and an AST node
+     */
+    struct Token {
+        std::string text;
+        int identifier;
+        const char *filename;
+        File_Position start, end;
+        bool is_cached;
+        Boxed_Value cached_value;
+
+        std::vector<TokenPtr> children;
+        TokenPtr annotation;
+
+        Token(const std::string &token_text, int id, const char *fname) :
+            text(token_text), identifier(id), filename(fname), is_cached(false) { }
+
+        Token(const std::string &token_text, int id, const char *fname, int start_line, int start_col, int end_line, int end_col) :
+            text(token_text), identifier(id), filename(fname), is_cached(false) {
+
+            start.line = start_line;
+            start.column = start_col;
+            end.line = end_line;
+            end.column = end_col;
         }
-  };
+    };
+
+    /**
+     * Errors generated during parsing or evaluation
+     */
+    struct Eval_Error : public std::runtime_error {
+        std::string reason;
+        File_Position start_position;
+        File_Position end_position;
+        const char *filename;
+
+        Eval_Error(const std::string &why, const File_Position &where, const char *fname) :
+            std::runtime_error("Error: \"" + why + "\" " +
+                (std::string(fname) != "__EVAL__" ? ("in '" + std::string(fname) + "' ") : "during evaluation ") +
+                + "at (" + boost::lexical_cast<std::string>(where.line) + ", " +
+                boost::lexical_cast<std::string>(where.column) + ")"),
+            reason(why), start_position(where), end_position(where), filename(fname)
+        { }
+
+        Eval_Error(const std::string &why, const TokenPtr &where)
+            : std::runtime_error("Error: \"" + why + "\" " +
+                (std::string(where->filename) != "__EVAL__" ? ("in '" + std::string(where->filename) + "' ") : "during evaluation ") +
+                "at (" + boost::lexical_cast<std::string>(where->start.line) + ", " +
+                boost::lexical_cast<std::string>(where->start.column) + ")"),
+              reason(why), start_position(where->start), end_position(where->end), filename(where->filename) {
+        }
+
+        virtual ~Eval_Error() throw() {}
+    };
+
+    /**
+     * Special type for returned values
+     */
+    struct Return_Value {
+        Boxed_Value retval;
+        TokenPtr location;
+
+        Return_Value(const Boxed_Value &return_value, const TokenPtr where) : retval(return_value), location(where) { }
+    };
+
+    /**
+     * Special type indicating a call to 'break'
+     */
+    struct Break_Loop {
+        TokenPtr location;
+
+        Break_Loop(const TokenPtr where) : location(where) { }
+    };
 }
 
+#include "language/chaiscript_eval.hpp"
+#include "language/chaiscript_engine.hpp"
+
 #endif /* CHAISCRIPT_HPP_ */

include/chaiscript/chaiscript_basic.hpp

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

include/chaiscript/chaiscript_defines.hpp

@@ -1,227 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#ifndef CHAISCRIPT_DEFINES_HPP_
-#define CHAISCRIPT_DEFINES_HPP_
-
-#ifdef _MSC_VER
-#define CHAISCRIPT_STRINGIZE(x) "" #x
-#define CHAISCRIPT_STRINGIZE_EXPANDED(x) CHAISCRIPT_STRINGIZE(x)
-#define CHAISCRIPT_COMPILER_VERSION CHAISCRIPT_STRINGIZE_EXPANDED(_MSC_FULL_VER)
-#define CHAISCRIPT_MSVC _MSC_VER
-#define CHAISCRIPT_HAS_DECLSPEC
-
-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(__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()
-  {
-#ifdef CHAISCRIPT_NO_DYNLOAD
-    return {Options::No_Load_Modules, Options::External_Scripts};
-#else
-    return {Options::Load_Modules, Options::External_Scripts};
-#endif
-  }
-}
-#endif
-

include/chaiscript/chaiscript_stdlib.hpp

@@ -1,71 +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_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,186 +1,69 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_THREADING_HPP_
-#define CHAISCRIPT_THREADING_HPP_
-
-
-#include <unordered_map>
+#ifndef __chaiscript_threading_hpp__
+#define __chaiscript_threading_hpp__
 
 #ifndef CHAISCRIPT_NO_THREADS
-#include <thread>
-#include <mutex>
+#include <boost/thread.hpp>
 #else
-#ifndef CHAISCRIPT_NO_THREADS_WARNING
-#pragma message ("ChaiScript is compiling without thread safety.")
+#warning "ChaiScript is compiling without thread safety."
 #endif
-#endif
-
-#include "chaiscript_defines.hpp"
-
-/// \file
-///
-/// This file contains code necessary for thread support in ChaiScript.
-/// If the compiler definition CHAISCRIPT_NO_THREADS is defined then thread safety
-/// is disabled in ChaiScript. This has the result that some code is faster, because mutex locks are not required.
-/// It also has the side effect that the chaiscript::ChaiScript object may not be accessed from more than
-/// one thread simultaneously.
 
 namespace chaiscript
 {
-  namespace detail
+  namespace threading
   {
-    /// 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
 
-      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>;
-
-
-      using shared_mutex = std::mutex;
-
-      using std::mutex;
-
-      using std::recursive_mutex;
-
-      /// Typesafe thread specific storage. If threading is enabled, this class uses a mutex protected map. If
-      /// threading is not enabled, the class always returns the same data, regardless of which thread it is called from.
-      template<typename T>
-        class Thread_Storage
-        {
-          public:
-            Thread_Storage() = default;
-            Thread_Storage(const Thread_Storage &) = delete;
-            Thread_Storage(Thread_Storage &&) = delete;
-            Thread_Storage &operator=(const Thread_Storage &) = delete;
-            Thread_Storage &operator=(Thread_Storage &&) = delete;
-
-            ~Thread_Storage()
-            {
-              if (!destroyed) {
-                t().erase(this);
-              }
-            }
-
-            inline const T *operator->() const
-            {
-              return &(t()[const_cast<Thread_Storage *>(this)]);
-            }
-
-            inline const T &operator*() const
-            {
-              return t()[const_cast<Thread_Storage *>(this)];
-            }
-
-            inline T *operator->()
-            {
-              return &(t()[this]);
-            }
-
-            inline T &operator*()
-            {
-              return t()[this];
-            }
-
-          private:
-            struct Map_Holder {
-              std::unordered_map<Thread_Storage<T> *, T> map;
-
-              Map_Holder() = default;
-              Map_Holder(const Map_Holder &) = delete;
-              Map_Holder(Map_Holder &&) = delete;
-              Map_Holder& operator=(Map_Holder &&) = delete;
-              Map_Holder& operator=(const Map_Holder &&) = delete;
-              ~Map_Holder() {
-                // here is the theory:
-                //   * If the Map_Holder is destroyed before the Thread_Storage, a flag will get set
-                //   * If destroyed after the Thread_Storage, the * will have been removed from `map` and nothing will happen
-                for(auto &elem : map) { elem.first->destroyed = true; }
-              }
-            };
-
-            static std::unordered_map<Thread_Storage<T> *, T> &t()
-            {
-              thread_local Map_Holder my_map;
-              return my_map.map;
-            }
-
-            bool destroyed{false};
-        };
-
-#else // threading disabled
-      template<typename T>
-      class unique_lock 
+    template<typename T>
+      class Thread_Storage
       {
         public:
-          explicit unique_lock(T &) {}
-          void lock() {}
-          void unlock() {}
+          ~Thread_Storage()
+          {
+            m_thread_storage.reset();
+          }
+
+          inline T *operator->() const
+          {
+            if (!m_thread_storage.get())
+            {
+              m_thread_storage.reset(new T());
+            }
+
+            return m_thread_storage.get();
+          }
+
+          inline T &operator*() const
+          {
+            return *(this->operator->());
+          }
+
+        private:
+          mutable boost::thread_specific_ptr<T> m_thread_storage;
       };
 
-      template<typename T>
-      class shared_lock 
+#else
+
+    template<typename T>
+      class Thread_Storage
       {
         public:
-          explicit shared_lock(T &) {}
-          void lock() {}
-          void unlock() {}
+          inline T *operator->() const
+          {
+            return &obj;
+          }
+
+          inline T &operator*() const
+          {
+            return obj;
+          }
+
+        private:
+          mutable T obj;
       };
 
-      template<typename T>
-      class lock_guard 
-      {
-        public:
-          explicit lock_guard(T &) {}
-      };
-
-      class shared_mutex { };
-
-      class recursive_mutex {};
-
-
-      template<typename T>
-        class Thread_Storage
-        {
-          public:
-            explicit Thread_Storage(void *)
-            {
-            }
-
-            inline T *operator->() const
-            {
-              return &obj;
-            }
-
-            inline T &operator*() const
-            {
-              return obj;
-            }
-
-          private:
-            mutable T obj;
-        };
-
 #endif
-    }
+
   }
 }
 

include/chaiscript/dispatchkit/any.hpp

@@ -1,164 +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_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,73 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
-#define CHAISCRIPT_BAD_BOXED_CAST_HPP_
-
-#include <string>
-#include <typeinfo>
-
-#include "../chaiscript_defines.hpp"
-#include "type_info.hpp"
-
-namespace chaiscript {
-class Type_Info;
-}  // namespace chaiscript
-
-namespace chaiscript 
-{
-  namespace exception
-  {
-    /// \brief Thrown in the event that a Boxed_Value cannot be cast to the desired type
-    ///
-    /// It is used internally during function dispatch and may be used by the end user.
-    ///
-    /// \sa chaiscript::boxed_cast
-    class bad_boxed_cast : public std::bad_cast
-    {
-      public:
-        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(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())
-        {
-        }
-
-        explicit bad_boxed_cast(std::string t_what) noexcept
-          : m_what(std::move(t_what))
-        {
-        }
-
-        bad_boxed_cast(const bad_boxed_cast &) = default;
-        ~bad_boxed_cast() noexcept override = default;
-
-        /// \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 = nullptr; ///< std::type_info of the desired (but failed) result type
-
-      private:
-        std::string m_what;
-    };
-  }
-}
-
-
-
-#endif
-

include/chaiscript/dispatchkit/bind_first.hpp

@@ -1,85 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_BIND_FIRST_HPP_
-#define CHAISCRIPT_BIND_FIRST_HPP_
-
-#include <functional>
-
-namespace chaiscript
-{
-  namespace detail
-  {
-
-    template<typename T>
-      T* get_pointer(T *t)
-      {
-        return t;
-      }
-
-    template<typename T>
-      T* get_pointer(const std::reference_wrapper<T> &t)
-      {
-        return &t.get();
-      }
-
-    template<typename O, typename Ret, typename P1, typename ... Param>
-      auto bind_first(Ret (*f)(P1, Param...), O&& o)
-      {
-        return [f, o](Param...param) -> Ret {
-          return f(std::forward<O>(o), std::forward<Param>(param)...);
-        };
-      }
-
-    template<typename O, typename Ret, typename Class, typename ... Param>
-      auto bind_first(Ret (Class::*f)(Param...), O&& o)
-      {
-        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());
-      }
-
-  }
-}
-
-
-#endif

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -1,113 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_BOXED_CAST_HPP_
-#define CHAISCRIPT_BOXED_CAST_HPP_
-
-#include "../chaiscript_defines.hpp"
-#include "bad_boxed_cast.hpp"
-#include "boxed_cast_helper.hpp"
-#include "boxed_value.hpp"
-#include "type_conversions.hpp"
-#include "type_info.hpp"
-
-namespace chaiscript {
-class Type_Conversions;
-namespace detail {
-namespace exception {
-class bad_any_cast;
-}  // namespace exception
-}  // namespace detail
-}  // namespace chaiscript
-
-namespace chaiscript 
-{
- 
-  /// \brief Function for extracting a value stored in a Boxed_Value object
-  /// \tparam Type The type to extract from the Boxed_Value
-  /// \param[in] bv The Boxed_Value to extract a typed value from
-  /// \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, &, *, 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 std::reference_wrapper can be extracted as reference,
-  ///     pointer or value 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 std::function objects are attempted as well
-  ///
-  /// Example:
-  /// \code
-  /// // All of the following should succeed
-  /// chaiscript::Boxed_Value bv(1);
-  /// 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);
-  /// 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
-  ///
-  /// std::function conversion example
-  /// \code
-  /// chaiscript::ChaiScript chai;
-  /// Boxed_Value bv = chai.eval("`+`"); // Get the functor for the + operator which is built in 
-  /// 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>
-  decltype(auto) boxed_cast(const Boxed_Value &bv, const Type_Conversions_State *t_conversions = nullptr)
-  {
-    if (!t_conversions || bv.get_type_info().bare_equal(user_type<Type>()) || (t_conversions && !(*t_conversions)->convertable_type<Type>())) {
-      try {
-        return(detail::Cast_Helper<Type>::cast(bv, t_conversions));
-      } catch (const chaiscript::detail::exception::bad_any_cast &) {
-      }
-    }
-
-
-    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 {
-          // 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 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));
-    }
-
-  }
-
-}
-
-
-
-#endif
-

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -1,323 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
-#define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
-
-#include <memory>
-#include <type_traits>
-
-#include "boxed_value.hpp"
-#include "type_info.hpp"
-
-
-namespace chaiscript 
-{
-  class Type_Conversions_State;
-
-  namespace detail
-  {
-    // Cast_Helper_Inner helper classes
-
-    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
-      {
-        static Result cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          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 *>
-      {
-        static const Result * cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return static_cast<const Result *>(verify_type_no_throw(ob, typeid(Result), ob.get_const_ptr()));
-        }
-      };
-
-    /// Cast_Helper_Inner for casting to a * type
-    template<typename Result>
-      struct Cast_Helper_Inner<Result *>
-      {
-        static Result * cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return static_cast<Result *>(verify_type_no_throw(ob, typeid(Result), ob.get_ptr()));
-        }
-      };
-
-    template<typename Result>
-    struct Cast_Helper_Inner<Result * const &> : public Cast_Helper_Inner<Result *>
-    {
-    };
-
-    template<typename Result>
-    struct Cast_Helper_Inner<const Result * const &> : public Cast_Helper_Inner<const Result *>
-    {
-    };
-
-
-    /// Cast_Helper_Inner for casting to a & type
-    template<typename Result>
-      struct Cast_Helper_Inner<const Result &>
-      {
-        static const Result & cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return *static_cast<const Result *>(verify_type(ob, typeid(Result), ob.get_const_ptr()));
-        }
-      };
-
-
-
-    /// Cast_Helper_Inner for casting to a & type
-    template<typename Result>
-      struct Cast_Helper_Inner<Result &>
-      {
-        static Result& cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return *static_cast<Result *>(verify_type(ob, typeid(Result), ob.get_ptr()));
-        }
-      };
-
-    /// Cast_Helper_Inner for casting to a && type
-    template<typename Result>
-      struct Cast_Helper_Inner<Result &&>
-      {
-        static Result&& cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return std::move(*static_cast<Result *>(verify_type(ob, typeid(Result), ob.get_ptr())));
-        }
-      };
-
-    /// Cast_Helper_Inner for casting to a std::unique_ptr<> && type
-    /// \todo Fix the fact that this has to be in a shared_ptr for now
-    template<typename Result>
-      struct Cast_Helper_Inner<std::unique_ptr<Result> &&>
-      {
-        static std::unique_ptr<Result> &&cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return std::move(*(ob.get().cast<std::shared_ptr<std::unique_ptr<Result>>>()));
-        }
-      };
-
-    /// Cast_Helper_Inner for casting to a std::unique_ptr<> & type
-    /// \todo Fix the fact that this has to be in a shared_ptr for now
-    template<typename Result>
-      struct Cast_Helper_Inner<std::unique_ptr<Result> &>
-      {
-        static std::unique_ptr<Result> &cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return *(ob.get().cast<std::shared_ptr<std::unique_ptr<Result>>>());
-        }
-      };
-
-    /// Cast_Helper_Inner for casting to a std::unique_ptr<> & type
-    /// \todo Fix the fact that this has to be in a shared_ptr for now
-    template<typename Result>
-      struct Cast_Helper_Inner<const std::unique_ptr<Result> &>
-      {
-        static std::unique_ptr<Result> &cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return *(ob.get().cast<std::shared_ptr<std::unique_ptr<Result>>>());
-        }
-      };
-
-
-    /// Cast_Helper_Inner for casting to a std::shared_ptr<> type
-    template<typename Result>
-      struct Cast_Helper_Inner<std::shared_ptr<Result> >
-      {
-        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 std::const_pointer_cast<const Result>(ob.get().cast<std::shared_ptr<Result> >());
-          } else {
-            return ob.get().cast<std::shared_ptr<const Result> >();
-          }
-        }
-      };
-
-    /// Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
-    template<typename Result>
-      struct Cast_Helper_Inner<const std::shared_ptr<Result> > : Cast_Helper_Inner<std::shared_ptr<Result> >
-      {
-      };
-
-    template<typename Result>
-      struct Cast_Helper_Inner<const std::shared_ptr<Result> &> : Cast_Helper_Inner<std::shared_ptr<Result> >
-      {
-      };
-
-    template<typename Result>
-      struct Cast_Helper_Inner<std::shared_ptr<Result> &>
-      {
-        static_assert(!std::is_const<Result>::value, "Non-const reference to std::shared_ptr<const T> is not supported");
-        static auto cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          std::shared_ptr<Result> &res = ob.get().cast<std::shared_ptr<Result> >();
-          return ob.pointer_sentinel(res);
-        }
-      };
-
-
-    /// Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
-    template<typename Result>
-      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>
-      {
-      };
-
-    template<>
-      struct Cast_Helper_Inner<const Boxed_Value &> : Cast_Helper_Inner<Boxed_Value>
-      {
-      };
-
-
-    /// Cast_Helper_Inner for casting to a std::reference_wrapper type
-    template<typename Result>
-      struct Cast_Helper_Inner<std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
-      {
-      };
-
-    template<typename Result>
-      struct Cast_Helper_Inner<const std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
-      {
-      };
-
-    template<typename Result>
-      struct Cast_Helper_Inner<const std::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
-      {
-      };
-
-    template<typename Result>
-      struct Cast_Helper_Inner<std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
-      {
-      };
-
-    template<typename Result>
-      struct Cast_Helper_Inner<const std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
-      {
-      };
-
-    template<typename 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
-    template<typename T>
-      struct Cast_Helper
-      {
-        static decltype(auto) cast(const Boxed_Value &ob, const Type_Conversions_State *t_conversions)
-        {
-          return(Cast_Helper_Inner<T>::cast(ob, t_conversions));
-        }
-      };
-  }
-  
-}
-
-#endif

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -1,942 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-#ifndef CHAISCRIPT_BOXED_NUMERIC_HPP_
-#define CHAISCRIPT_BOXED_NUMERIC_HPP_
-
-#include <cstdint>
-#include <sstream>
-#include <string>
-
-#include "../language/chaiscript_algebraic.hpp"
-#include "any.hpp"
-#include "boxed_cast.hpp"
-#include "boxed_cast_helper.hpp"
-#include "boxed_value.hpp"
-#include "type_info.hpp"
-
-namespace chaiscript {
-class Type_Conversions;
-}  // namespace chaiscript
-
-namespace chaiscript
-{
-  namespace exception
-  {
-    struct arithmetic_error : std::runtime_error
-    {
-      explicit arithmetic_error(const std::string& reason) : std::runtime_error("Arithmetic error: " + reason) {}
-      arithmetic_error(const arithmetic_error &) = default;
-      ~arithmetic_error() noexcept override = default;
-    };
-  }
-}
-
-namespace chaiscript 
-{
-
-// Due to the nature of generating every possible arithmetic operation, there
-// are going to be warnings generated on every platform regarding size and sign,
-// this is OK, so we're disabling size/and sign type warnings
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4244 4018 4389 4146 4365 4267 4242)
-#endif
-
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunknown-pragmas"
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#pragma GCC diagnostic ignored "-Wfloat-conversion"
-#endif
-
-  /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values
-  class Boxed_Number
-  {
-    private:
-      enum class Common_Types {
-        t_int32,
-        t_double,
-        t_uint8,
-        t_int8,
-        t_uint16,
-        t_int16,
-        t_uint32,
-        t_uint64,
-        t_int64,
-        t_float,
-        t_long_double
-      };
-
-      template<typename T>
-      static inline void check_divide_by_zero(T t, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr)
-      {
-#ifndef CHAISCRIPT_NO_PROTECT_DIVIDEBYZERO
-        if (t == 0) {
-          throw chaiscript::exception::arithmetic_error("divide by zero");
-        }
-#endif
-      }
-
-      template<typename T>
-      static inline void check_divide_by_zero(T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr)
-      {
-      }
-
-      static constexpr Common_Types get_common_type(size_t t_size, bool t_signed)
-      {
-        return   (t_size == 1 && t_signed)?(Common_Types::t_int8)
-                :(t_size == 1)?(Common_Types::t_uint8)
-                :(t_size == 2 && t_signed)?(Common_Types::t_int16)
-                :(t_size == 2)?(Common_Types::t_uint16)
-                :(t_size == 4 && t_signed)?(Common_Types::t_int32)
-                :(t_size == 4)?(Common_Types::t_uint32)
-                :(t_size == 8 && t_signed)?(Common_Types::t_int64)
-                :(Common_Types::t_uint64);
-      }
-
-
-      static Common_Types get_common_type(const Boxed_Value &t_bv)
-      {
-        const Type_Info &inp_ = t_bv.get_type_info();
-
-        if (inp_ == typeid(int)) {
-          return get_common_type(sizeof(int), true);
-        } else if (inp_ == typeid(double)) {
-          return Common_Types::t_double;
-        } else if (inp_ == typeid(long double)) {
-          return Common_Types::t_long_double;
-        } else if (inp_ == typeid(float)) {
-          return Common_Types::t_float;
-        } else if (inp_ == typeid(char)) {
-          return get_common_type(sizeof(char), std::is_signed<char>::value);
-        } else if (inp_ == typeid(unsigned char)) {
-          return get_common_type(sizeof(unsigned char), false);
-        } else if (inp_ == typeid(unsigned int)) {
-          return get_common_type(sizeof(unsigned int), false);
-        } else if (inp_ == typeid(long)) {
-          return get_common_type(sizeof(long), true);
-        } else if (inp_ == typeid(long long)) {
-          return get_common_type(sizeof(long long), true);
-        } else if (inp_ == typeid(unsigned long)) {
-          return get_common_type(sizeof(unsigned long), false);
-        } else if (inp_ == typeid(unsigned long long)) {
-          return get_common_type(sizeof(unsigned long long), false);
-        } else if (inp_ == typeid(std::int8_t)) {
-          return Common_Types::t_int8;
-        } else if (inp_ == typeid(std::int16_t)) {
-          return Common_Types::t_int16;
-        } else if (inp_ == typeid(std::int32_t)) {
-          return Common_Types::t_int32;
-        } else if (inp_ == typeid(std::int64_t)) {
-          return Common_Types::t_int64;
-        } else if (inp_ == typeid(std::uint8_t)) {
-          return Common_Types::t_uint8;
-        } else if (inp_ == typeid(std::uint16_t)) {
-          return Common_Types::t_uint16;
-        } else if (inp_ == typeid(std::uint32_t)) {
-          return Common_Types::t_uint32;
-        } else if (inp_ == typeid(std::uint64_t)) {
-          return Common_Types::t_uint64;
-        } else if (inp_ == typeid(wchar_t)) {
-          return get_common_type(sizeof(wchar_t), std::is_signed<wchar_t>::value);
-        } else if (inp_ == typeid(char16_t)) {
-          return get_common_type(sizeof(char16_t), std::is_signed<char16_t>::value);
-        } else if (inp_ == typeid(char32_t)) {
-          return get_common_type(sizeof(char32_t), std::is_signed<char32_t>::value);
-        } else  {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename T>
-      static Boxed_Value boolean_go(Operators::Opers t_oper, const T &t, const T &u)
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::equals:
-            return const_var(t == u);
-          case Operators::Opers::less_than:
-            return const_var(t < u);
-          case Operators::Opers::greater_than:
-            return const_var(t > u);
-          case Operators::Opers::less_than_equal:
-            return const_var(t <= u);
-          case Operators::Opers::greater_than_equal:
-            return const_var(t >= u);
-          case Operators::Opers::not_equal:
-            return const_var(t != u);
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename T>
-      static Boxed_Value unary_go(Operators::Opers t_oper, T &t, const Boxed_Value &t_lhs) 
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::pre_increment:
-            ++t;
-            break;
-          case Operators::Opers::pre_decrement:
-            --t;
-            break;
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-
-        return t_lhs;
-      }
-
-      template<typename T, typename U>
-      static Boxed_Value binary_go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::assign:
-            t = u;
-            break;
-          case Operators::Opers::assign_product:
-            t *= u;
-            break;
-          case Operators::Opers::assign_sum:
-            t += u;
-            break;
-          case Operators::Opers::assign_quotient:
-            check_divide_by_zero(u);
-            t /= u;
-            break;
-          case Operators::Opers::assign_difference:
-            t -= u;
-            break;
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-
-        return t_lhs;
-      }
-
-      template<typename T, typename U>
-      static Boxed_Value binary_int_go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::assign_bitwise_and:
-            t &= u;
-            break;
-          case Operators::Opers::assign_bitwise_or:
-            t |= u;
-            break;
-          case Operators::Opers::assign_shift_left:
-            t <<= u;
-            break;
-          case Operators::Opers::assign_shift_right:
-            t >>= u;
-            break;
-          case Operators::Opers::assign_remainder:
-            check_divide_by_zero(u);
-            t %= u;
-            break;
-          case Operators::Opers::assign_bitwise_xor:
-            t ^= u;
-            break;
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-        return t_lhs;
-      }
-
-      template<typename T>
-      static Boxed_Value const_unary_int_go(Operators::Opers t_oper, const T &t) 
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::bitwise_complement:
-            return const_var(~t);
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename T>
-      static Boxed_Value const_binary_int_go(Operators::Opers t_oper, const T &t, const T &u) 
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::shift_left:
-            return const_var(t << u);
-          case Operators::Opers::shift_right:
-            return const_var(t >> u);
-          case Operators::Opers::remainder:
-            check_divide_by_zero(u);
-            return const_var(t % u);
-          case Operators::Opers::bitwise_and:
-            return const_var(t & u);
-          case Operators::Opers::bitwise_or:
-            return const_var(t | u);
-          case Operators::Opers::bitwise_xor:
-            return const_var(t ^ u);
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename T>
-      static Boxed_Value const_unary_go(Operators::Opers t_oper, const T &t)
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::unary_minus:
-            return const_var(-t);
-          case Operators::Opers::unary_plus:
-            return const_var(+t);
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename T>
-      static Boxed_Value const_binary_go(Operators::Opers t_oper, const T &t, const T &u) 
-      {
-        switch (t_oper)
-        {
-          case Operators::Opers::sum:
-            return const_var(t + u);
-          case Operators::Opers::quotient:
-            check_divide_by_zero(u);
-            return const_var(t / u);
-          case Operators::Opers::product:
-            return const_var(t * u);
-          case Operators::Opers::difference:
-            return const_var(t - u);
-          default:
-            throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename LHS, typename RHS>
-      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
-          -> typename std::enable_if<!std::is_floating_point<LHS>::value && !std::is_floating_point<RHS>::value, Boxed_Value>::type
-      {
-        typedef typename std::common_type<LHS, RHS>::type common_type;
-        if (t_oper > Operators::Opers::boolean_flag && t_oper < Operators::Opers::non_const_flag)
-        {
-          return boolean_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
-        } else if (t_oper > Operators::Opers::non_const_flag && t_oper < Operators::Opers::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
-          return binary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), get_as_aux<common_type, RHS>(t_rhs), t_lhs);
-        } else if (t_oper > Operators::Opers::non_const_int_flag && t_oper < Operators::Opers::const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
-          return binary_int_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), get_as_aux<common_type, RHS>(t_rhs), t_lhs);
-        } else if (t_oper > Operators::Opers::const_int_flag && t_oper < Operators::Opers::const_flag) {
-          return const_binary_int_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
-        } else if (t_oper > Operators::Opers::const_flag) {
-          return const_binary_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
-        } else {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename LHS, typename RHS>
-      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs) 
-          -> typename std::enable_if<std::is_floating_point<LHS>::value || std::is_floating_point<RHS>::value, Boxed_Value>::type
-      {
-        typedef typename std::common_type<LHS, RHS>::type common_type;
-        if (t_oper > Operators::Opers::boolean_flag && t_oper < Operators::Opers::non_const_flag)
-        {
-          return boolean_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
-        } else if (t_oper > Operators::Opers::non_const_flag && t_oper < Operators::Opers::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
-          return binary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), get_as_aux<common_type, RHS>(t_rhs), t_lhs);
-        } else if (t_oper > Operators::Opers::const_flag) {
-          return const_binary_go(t_oper, get_as_aux<common_type, LHS>(t_lhs), get_as_aux<common_type, RHS>(t_rhs));
-        } else {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      // Unary 
-      template<typename LHS>
-      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs)
-          -> typename std::enable_if<!std::is_floating_point<LHS>::value, Boxed_Value>::type
-      {
-        if (t_oper > Operators::Opers::non_const_flag && t_oper < Operators::Opers::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
-          return unary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), t_lhs);
-        } else if (t_oper > Operators::Opers::const_int_flag && t_oper < Operators::Opers::const_flag) {
-          return const_unary_int_go(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()));
-        } else if (t_oper > Operators::Opers::const_flag) {
-          return const_unary_go(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()));
-        } else {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename LHS>
-      static auto go(Operators::Opers t_oper, const Boxed_Value &t_lhs) 
-          -> typename std::enable_if<std::is_floating_point<LHS>::value, Boxed_Value>::type
-      {
-        if (t_oper > Operators::Opers::non_const_flag && t_oper < Operators::Opers::non_const_int_flag && !t_lhs.is_const() && !t_lhs.is_return_value()) {
-          return unary_go(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), t_lhs);
-        } else if (t_oper > Operators::Opers::const_flag) {
-          return const_unary_go(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()));
-        } else {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-      template<typename LHS>
-        inline static Boxed_Value oper_rhs(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
-        {
-          switch (get_common_type(t_rhs)) {
-            case Common_Types::t_int32:
-              return go<LHS, int32_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint8:
-              return go<LHS, uint8_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_int8:
-              return go<LHS, int8_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint16:
-              return go<LHS, uint16_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_int16:
-              return go<LHS, int16_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint32:
-              return go<LHS, uint32_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint64:
-              return go<LHS, uint64_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_int64:
-              return go<LHS, int64_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_double:
-              return go<LHS, double>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_float:
-              return go<LHS, float>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_long_double:
-              return go<LHS, long double>(t_oper, t_lhs, t_rhs);
-          }
-
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-
-        inline static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs)
-        {
-          switch (get_common_type(t_lhs)) {
-            case Common_Types::t_int32:
-              return go<int32_t>(t_oper, t_lhs);
-            case Common_Types::t_uint8:
-              return go<uint8_t>(t_oper, t_lhs);
-            case Common_Types::t_int8:
-              return go<int8_t>(t_oper, t_lhs);
-            case Common_Types::t_uint16:
-              return go<uint16_t>(t_oper, t_lhs);
-            case Common_Types::t_int16:
-              return go<int16_t>(t_oper, t_lhs);
-            case Common_Types::t_uint32:
-              return go<uint32_t>(t_oper, t_lhs);
-            case Common_Types::t_uint64:
-              return go<uint64_t>(t_oper, t_lhs);
-            case Common_Types::t_int64:
-              return go<int64_t>(t_oper, t_lhs);
-            case Common_Types::t_double:
-              return go<double>(t_oper, t_lhs);
-            case Common_Types::t_float:
-              return go<float>(t_oper, t_lhs);
-            case Common_Types::t_long_double:
-              return go<long double>(t_oper, t_lhs);
-          }
-
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-
-
-        inline static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
-        {
-          switch (get_common_type(t_lhs)) {
-            case Common_Types::t_int32:
-              return oper_rhs<int32_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint8:
-              return oper_rhs<uint8_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_int8:
-              return oper_rhs<int8_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint16:
-              return oper_rhs<uint16_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_int16:
-              return oper_rhs<int16_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint32:
-              return oper_rhs<uint32_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_uint64:
-              return oper_rhs<uint64_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_int64:
-              return oper_rhs<int64_t>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_double:
-              return oper_rhs<double>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_float:
-              return oper_rhs<float>(t_oper, t_lhs, t_rhs);
-            case Common_Types::t_long_double:
-              return oper_rhs<long double>(t_oper, t_lhs, t_rhs);
-          }
-
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-
-        template<typename Target, typename Source>
-          static inline Target get_as_aux(const Boxed_Value &t_bv)
-          {
-            return static_cast<Target>(*static_cast<const Source *>(t_bv.get_const_ptr()));
-          }
-
-        template<typename Source>
-         static std::string to_string_aux(const Boxed_Value &v)
-        {
-          std::ostringstream oss;
-          oss << *static_cast<const Source *>(v.get_const_ptr());
-          return oss.str();
-        }
-
-    public:
-      Boxed_Number()
-        : bv(Boxed_Value(0))
-      {
-      }
-
-      explicit Boxed_Number(Boxed_Value v)
-        : bv(std::move(v))
-      {
-        validate_boxed_number(bv);
-      }
-
-      Boxed_Number(const Boxed_Number &) = default;
-      Boxed_Number(Boxed_Number &&) = default;
-      Boxed_Number& operator=(Boxed_Number &&) = default;
-
-      template<typename T> explicit Boxed_Number(T t)
-        : bv(Boxed_Value(t))
-      {
-        validate_boxed_number(bv);
-      }
-
-      static bool is_floating_point(const Boxed_Value &t_bv)
-      {
-        const Type_Info &inp_ = t_bv.get_type_info();
-
-        if (inp_ == typeid(double)) {
-          return true;
-        } else if (inp_ == typeid(long double)) {
-          return true;
-        } else if (inp_ == typeid(float)) {
-          return true;
-        } else {
-          return false;
-        }
-      }
-
-      Boxed_Number get_as(const Type_Info &inp_) const
-      {
-        if (inp_.bare_equal_type_info(typeid(int))) {
-          return Boxed_Number(get_as<int>());
-        } else if (inp_.bare_equal_type_info(typeid(double))) {
-          return Boxed_Number(get_as<double>());
-        } else if (inp_.bare_equal_type_info(typeid(float))) {
-          return Boxed_Number(get_as<float>());
-        } else if (inp_.bare_equal_type_info(typeid(long double))) {
-          return Boxed_Number(get_as<long double>());
-        } else if (inp_.bare_equal_type_info(typeid(char))) {
-          return Boxed_Number(get_as<char>());
-        } else if (inp_.bare_equal_type_info(typeid(unsigned char))) {
-          return Boxed_Number(get_as<unsigned char>());
-        } else if (inp_.bare_equal_type_info(typeid(wchar_t))) {
-          return Boxed_Number(get_as<wchar_t>());
-        } else if (inp_.bare_equal_type_info(typeid(char16_t))) {
-          return Boxed_Number(get_as<char16_t>());
-        } else if (inp_.bare_equal_type_info(typeid(char32_t))) {
-          return Boxed_Number(get_as<char32_t>());
-        } else if (inp_.bare_equal_type_info(typeid(unsigned int))) {
-          return Boxed_Number(get_as<unsigned int>());
-        } else if (inp_.bare_equal_type_info(typeid(long))) {
-          return Boxed_Number(get_as<long>());
-        } else if (inp_.bare_equal_type_info(typeid(long long))) {
-          return Boxed_Number(get_as<long long>());
-        } else if (inp_.bare_equal_type_info(typeid(unsigned long))) {
-          return Boxed_Number(get_as<unsigned long>());
-        } else if (inp_.bare_equal_type_info(typeid(unsigned long long))) {
-          return Boxed_Number(get_as<unsigned long long>());
-        } else if (inp_.bare_equal_type_info(typeid(int8_t))) {
-          return Boxed_Number(get_as<int8_t>());
-        } else if (inp_.bare_equal_type_info(typeid(int16_t))) {
-          return Boxed_Number(get_as<int16_t>());
-        } else if (inp_.bare_equal_type_info(typeid(int32_t))) {
-          return Boxed_Number(get_as<int32_t>());
-        } else if (inp_.bare_equal_type_info(typeid(int64_t))) {
-          return Boxed_Number(get_as<int64_t>());
-        } else if (inp_.bare_equal_type_info(typeid(uint8_t))) {
-          return Boxed_Number(get_as<uint8_t>());
-        } else if (inp_.bare_equal_type_info(typeid(uint16_t))) {
-          return Boxed_Number(get_as<uint16_t>());
-        } else if (inp_.bare_equal_type_info(typeid(uint32_t))) {
-          return Boxed_Number(get_as<uint32_t>());
-        } else if (inp_.bare_equal_type_info(typeid(uint64_t))) {
-          return Boxed_Number(get_as<uint64_t>());
-        } else {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-
-      }
-
-      template<typename Source, typename Target> 
-      static void check_type()
-      {
-#ifdef CHAISCRIPT_MSVC
-// MSVC complains about this being redundant / tautologica l
-#pragma warning(push)
-#pragma warning(disable : 4127 6287)
-#endif
-        if (sizeof(Source) != sizeof(Target)
-            || std::is_signed<Source>() != std::is_signed<Target>()
-            || std::is_floating_point<Source>() != std::is_floating_point<Target>())
-        {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(pop)
-#endif
-      }
-
-      template<typename Target> Target get_as_checked() const
-      {
-        switch (get_common_type(bv)) {
-          case Common_Types::t_int32:
-            check_type<int32_t, Target>();
-            return get_as_aux<Target, int32_t>(bv);
-          case Common_Types::t_uint8:
-            check_type<uint8_t, Target>();
-            return get_as_aux<Target, uint8_t>(bv);
-          case Common_Types::t_int8:
-            check_type<int8_t, Target>();
-            return get_as_aux<Target, int8_t>(bv);
-          case Common_Types::t_uint16:
-            check_type<uint16_t, Target>();
-            return get_as_aux<Target, uint16_t>(bv);
-          case Common_Types::t_int16:
-            check_type<int16_t, Target>();
-            return get_as_aux<Target, int16_t>(bv);
-          case Common_Types::t_uint32:
-            check_type<uint32_t, Target>();
-            return get_as_aux<Target, uint32_t>(bv);
-          case Common_Types::t_uint64:
-            check_type<uint64_t, Target>();
-            return get_as_aux<Target, uint64_t>(bv);
-          case Common_Types::t_int64:
-            check_type<int64_t, Target>();
-            return get_as_aux<Target, int64_t>(bv);
-          case Common_Types::t_double:
-            check_type<double, Target>();
-            return get_as_aux<Target, double>(bv);
-          case Common_Types::t_float:
-            check_type<float, Target>();
-            return get_as_aux<Target, float>(bv);
-          case Common_Types::t_long_double:
-            check_type<long double, Target>();
-            return get_as_aux<Target, long double>(bv);
-        }
-
-        throw chaiscript::detail::exception::bad_any_cast();
-      }
-
-
-      template<typename Target> Target get_as() const
-      {
-        switch (get_common_type(bv)) {
-          case Common_Types::t_int32:
-            return get_as_aux<Target, int32_t>(bv);
-          case Common_Types::t_uint8:
-            return get_as_aux<Target, uint8_t>(bv);
-          case Common_Types::t_int8:
-            return get_as_aux<Target, int8_t>(bv);
-          case Common_Types::t_uint16:
-            return get_as_aux<Target, uint16_t>(bv);
-          case Common_Types::t_int16:
-            return get_as_aux<Target, int16_t>(bv);
-          case Common_Types::t_uint32:
-            return get_as_aux<Target, uint32_t>(bv);
-          case Common_Types::t_uint64:
-            return get_as_aux<Target, uint64_t>(bv);
-          case Common_Types::t_int64:
-            return get_as_aux<Target, int64_t>(bv);
-          case Common_Types::t_double:
-            return get_as_aux<Target, double>(bv);
-          case Common_Types::t_float:
-            return get_as_aux<Target, float>(bv);
-          case Common_Types::t_long_double:
-            return get_as_aux<Target, long double>(bv);
-        }
-
-        throw chaiscript::detail::exception::bad_any_cast();
-      }
-
-      std::string to_string() const
-      {
-        switch (get_common_type(bv)) {
-          case Common_Types::t_int32:
-            return std::to_string(get_as<int32_t>());
-          case Common_Types::t_uint8:
-            return std::to_string(get_as<uint32_t>());
-          case Common_Types::t_int8:
-            return std::to_string(get_as<int32_t>());
-          case Common_Types::t_uint16:
-            return std::to_string(get_as<uint16_t>());
-          case Common_Types::t_int16:
-            return std::to_string(get_as<int16_t>());
-          case Common_Types::t_uint32:
-            return std::to_string(get_as<uint32_t>());
-          case Common_Types::t_uint64:
-            return std::to_string(get_as<uint64_t>());
-          case Common_Types::t_int64:
-            return std::to_string(get_as<int64_t>());
-          case Common_Types::t_double:
-            return to_string_aux<double>(bv);
-          case Common_Types::t_float:
-            return to_string_aux<float>(bv);
-          case Common_Types::t_long_double:
-            return to_string_aux<long double>(bv);
-        }
-
-        throw chaiscript::detail::exception::bad_any_cast();
-      }
-
-      static void validate_boxed_number(const Boxed_Value &v)
-      {
-        const Type_Info &inp_ = v.get_type_info();
-        if (inp_ == typeid(bool))
-        {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-
-        if (!inp_.is_arithmetic())
-        {
-          throw chaiscript::detail::exception::bad_any_cast();
-        }
-      }
-
-
-
-      static bool equals(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return boxed_cast<bool>(oper(Operators::Opers::equals, t_lhs.bv, t_rhs.bv));
-      }
-
-      static bool less_than(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return boxed_cast<bool>(oper(Operators::Opers::less_than, t_lhs.bv, t_rhs.bv));
-      }
-
-      static bool greater_than(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
-      {
-        return boxed_cast<bool>(oper(Operators::Opers::greater_than, t_lhs.bv, t_rhs.bv));
-      }
-
-      static bool greater_than_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return boxed_cast<bool>(oper(Operators::Opers::greater_than_equal, t_lhs.bv, t_rhs.bv));
-      }
-
-      static bool less_than_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return boxed_cast<bool>(oper(Operators::Opers::less_than_equal, t_lhs.bv, t_rhs.bv));
-      }
-
-      static bool not_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
-      {
-        return boxed_cast<bool>(oper(Operators::Opers::not_equal, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number pre_decrement(Boxed_Number t_lhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::pre_decrement, t_lhs.bv));
-      }
-
-      static Boxed_Number pre_increment(Boxed_Number t_lhs) 
-      {
-        return Boxed_Number(oper(Operators::Opers::pre_increment, t_lhs.bv));
-      }
-
-      static const Boxed_Number sum(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
-      {
-        return Boxed_Number(oper(Operators::Opers::sum, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number unary_plus(const Boxed_Number &t_lhs) 
-      {
-        return Boxed_Number(oper(Operators::Opers::unary_plus, t_lhs.bv));
-      }
-
-      static const Boxed_Number unary_minus(const Boxed_Number &t_lhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::unary_minus, t_lhs.bv));
-      }
-
-      static const Boxed_Number difference(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
-      {
-        return Boxed_Number(oper(Operators::Opers::difference, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_bitwise_and(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_bitwise_and, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign(Boxed_Number t_lhs, const Boxed_Number &t_rhs) 
-      {
-        return Boxed_Number(oper(Operators::Opers::assign, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_bitwise_or(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_bitwise_or, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_bitwise_xor(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_bitwise_xor, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_remainder(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_remainder, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_shift_left(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_shift_left, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_shift_right(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_shift_right, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number bitwise_and(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::bitwise_and, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number bitwise_complement(const Boxed_Number &t_lhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::bitwise_complement, t_lhs.bv, Boxed_Value(0)));
-      }
-
-      static const Boxed_Number bitwise_xor(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::bitwise_xor, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number bitwise_or(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::bitwise_or, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_product(Boxed_Number t_lhs, const Boxed_Number &t_rhs) 
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_product, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_quotient(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_quotient, t_lhs.bv, t_rhs.bv));
-      }
-
-      static Boxed_Number assign_sum(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_sum, t_lhs.bv, t_rhs.bv));
-      }
-      static Boxed_Number assign_difference(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::assign_difference, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number quotient(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
-      {
-        return Boxed_Number(oper(Operators::Opers::quotient, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number shift_left(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::shift_left, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number product(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::product, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number remainder(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::remainder, t_lhs.bv, t_rhs.bv));
-      }
-
-      static const Boxed_Number shift_right(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
-      {
-        return Boxed_Number(oper(Operators::Opers::shift_right, t_lhs.bv, t_rhs.bv));
-      }
-
-
-
-      static Boxed_Value do_oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
-      {
-        return oper(t_oper, t_lhs, t_rhs);
-      }
-
-      static Boxed_Value do_oper(Operators::Opers t_oper, const Boxed_Value &t_lhs)
-      {
-        return oper(t_oper, t_lhs);
-      }
-
-
-
-      Boxed_Value bv;
-  };
-
-  namespace detail
-  {
-    /// Cast_Helper for converting from Boxed_Value to Boxed_Number
-    template<>
-      struct Cast_Helper<Boxed_Number>
-      {
-        static Boxed_Number cast(const Boxed_Value &ob, const Type_Conversions_State *)
-        {
-          return Boxed_Number(ob);
-        }
-      };
-
-    /// Cast_Helper for converting from Boxed_Value to Boxed_Number
-    template<>
-      struct Cast_Helper<const Boxed_Number &> : Cast_Helper<Boxed_Number>
-      {
-      };
-
-    /// Cast_Helper for converting from Boxed_Value to Boxed_Number
-    template<>
-      struct Cast_Helper<const Boxed_Number> : Cast_Helper<Boxed_Number>
-      {
-      };
-  }
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(pop)
-#endif
-
-}
-
-
-
-#endif
-

include/chaiscript/dispatchkit/callable_traits.hpp

@@ -1,107 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#ifndef CHAISCRIPT_CALLABLE_TRAITS_HPP_
-#define CHAISCRIPT_CALLABLE_TRAITS_HPP_
-
-#include <memory>
-
-namespace chaiscript {
-  namespace dispatch {
-    namespace detail {
-
-      template<typename Class, typename ... Param>
-      struct Constructor
-      {
-        template<typename ... Inner>
-        std::shared_ptr<Class> operator()(Inner&& ... inner) const {
-          return std::make_shared<Class>(std::forward<Inner>(inner)...);
-        }
-      };
-
-      template<typename Ret, typename Class, typename ... Param>
-      struct Const_Caller
-      {
-        explicit Const_Caller(Ret (Class::*t_func)(Param...) const) : m_func(t_func) {}
-
-        template<typename ... Inner>
-        Ret operator()(const Class &o, Inner&& ... inner) const {
-          return (o.*m_func)(std::forward<Inner>(inner)...);
-        }
-
-        Ret (Class::*m_func)(Param...) const;
-      };
-
-      template<typename Ret, typename ... Param>
-      struct Fun_Caller
-      {
-        explicit Fun_Caller(Ret( * t_func)(Param...) ) : m_func(t_func) {}
-
-        template<typename ... Inner>
-        Ret operator()(Inner&& ... inner) const {
-          return (m_func)(std::forward<Inner>(inner)...);
-        }
-
-        Ret(*m_func)(Param...);
-      };
-
-      template<typename Ret, typename Class, typename ... Param>
-      struct Caller
-      {
-        explicit Caller(Ret (Class::*t_func)(Param...)) : m_func(t_func) {}
-
-        template<typename ... Inner>
-        Ret operator()(Class &o, Inner&& ... inner) const {
-          return (o.*m_func)(std::forward<Inner>(inner)...);
-        }
-
-        Ret (Class::*m_func)(Param...);
-      };
-
-      template<typename T>
-        struct Arity
-        {
-        };
-
-      template<typename Ret, typename ... Params>
-      struct Arity<Ret (Params...)>
-        {
-          static const size_t arity = sizeof...(Params);
-        };
-
-
-      template<typename T>
-        struct Function_Signature
-        {
-        };
-
-      template<typename Ret, typename ... Params>
-      struct Function_Signature<Ret (Params...)>
-        {
-          typedef Ret Return_Type;
-          typedef Ret (Signature)(Params...);
-        };
-
-      template<typename Ret, typename T, typename ... Params>
-      struct Function_Signature<Ret (T::*)(Params...) const>
-        {
-          typedef Ret Return_Type;
-          typedef Ret (Signature)(Params...);
-        };
-
-
-      template<typename T>
-        struct Callable_Traits
-        {
-          typedef typename Function_Signature<decltype(&T::operator())>::Signature Signature;
-          typedef typename Function_Signature<decltype(&T::operator())>::Return_Type Return_Type;
-        };
-    }
-  }
-}
-
-#endif
-

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,131 +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-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
+#ifndef __DYNAMIC_OBJECT_HPP__
+#define __DYNAMIC_OBJECT_HPP__
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
-#define CHAISCRIPT_DYNAMIC_OBJECT_HPP_
-
-#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
+#include <boost/optional.hpp>
 
 namespace chaiscript
 {
-  namespace dispatch
+  class Dynamic_Object
   {
-    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")
+    public:
+      Dynamic_Object(const std::string &t_type_name)
+        : m_type_name(t_type_name)
       {
-
       }
 
-      option_explicit_set(const option_explicit_set &) = default;
+      std::string get_type_name() const
+      {
+        return m_type_name;
+      }
 
-      ~option_explicit_set() noexcept override = default;
-    };
+      Boxed_Value get_attr(const std::string &t_attr_name)
+      {
+        return m_attrs[t_attr_name];
+      }
 
-    class Dynamic_Object
+      std::map<std::string, Boxed_Value> get_attrs()
+      {
+        return m_attrs;
+      }
+
+    private:
+      std::string m_type_name;
+
+      std::map<std::string, Boxed_Value> m_attrs;
+  };
+
+  struct Dynamic_Object_Attribute
+  {
+    static Boxed_Value func(const std::string &t_type_name, const std::string &t_attr_name,
+        Dynamic_Object &t_do)
     {
-      public:
-        explicit Dynamic_Object(std::string t_type_name)
-          : m_type_name(std::move(t_type_name)), m_option_explicit(false)
+      if (t_do.get_type_name() != t_type_name) 
+      {
+        throw bad_boxed_cast("Dynamic object type mismatch");
+      }
+
+      return t_do.get_attr(t_attr_name);
+    }
+  };
+
+  /**
+   * A Proxy_Function implementation designed for calling a function
+   * that is automatically guarded based on the first param based on the
+   * param's type name
+   */
+  class Dynamic_Object_Function : public Proxy_Function_Base
+  {
+    public:
+      Dynamic_Object_Function(
+          const std::string &t_type_name,
+          const Proxy_Function &t_func,
+          const boost::optional<Type_Info> &t_ti = boost::optional<Type_Info>())
+        : Proxy_Function_Base(t_func->get_param_types()),
+          m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
+      {
+        assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+            && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+      }
+
+      virtual ~Dynamic_Object_Function() {}
+
+      virtual bool operator==(const Proxy_Function_Base &f) const
+      {
+        try
         {
+          const Dynamic_Object_Function &df = dynamic_cast<const Dynamic_Object_Function &>(f);
+          return df.m_type_name == m_type_name && (*df.m_func) == (*m_func);
+        } catch (const std::bad_cast &) {
+          return false;
         }
+      }
 
-        Dynamic_Object() = default;
-
-        bool is_explicit() const
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+      {
+        if (dynamic_object_typename_match(vals, m_type_name, m_ti))
         {
-          return m_option_explicit;
+          return m_func->call_match(vals);
+        } else {
+          return false;
         }
+      }    
 
-        void set_explicit(const bool t_explicit)
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+      {
+        if (dynamic_object_typename_match(params, m_type_name, m_ti))
         {
-          m_option_explicit = t_explicit;
-        }
+          return (*m_func)(params);
+        } else {
+          throw guard_error();
+        } 
+      }
 
-        std::string get_type_name() const
+      virtual int get_arity() const
+      {
+	return m_func->get_arity();
+      }
+
+      virtual std::string annotation() const
+      {
+        return m_func->annotation();
+      }
+
+    private:
+      static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+          const boost::optional<Type_Info> &ti) 
+      {
+        if (bvs.size() > 0)
         {
-          return m_type_name;
-        }
-
-        const Boxed_Value &operator[](const std::string &t_attr_name) const
-        {
-          return get_attr(t_attr_name);
-        }
-
-        Boxed_Value &operator[](const std::string &t_attr_name)
-        {
-          return get_attr(t_attr_name);
-        }
-
-        const Boxed_Value &get_attr(const std::string &t_attr_name) const
-        {
-          auto a = m_attrs.find(t_attr_name);
-
-          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");
+          try {
+            const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bvs[0]);
+            return name == "Dynamic_Object" || d.get_type_name() == name;
+          } catch (const std::bad_cast &) {
+            if (ti)
+            {
+              return bvs[0].get_type_info().bare_equal(*ti);
+            } else {
+              return false;
+            }
           }
+        } else {
+          return false;
         }
+      }
 
-        bool has_attr(const std::string &t_attr_name) const {
-          return m_attrs.find(t_attr_name) != m_attrs.end();
-        }
+      std::string m_type_name;
+      Proxy_Function m_func;
+      boost::optional<Type_Info> m_ti;
 
-        Boxed_Value &get_attr(const std::string &t_attr_name)
+  };
+
+
+  /**
+   * 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)
         {
-          return m_attrs[t_attr_name];
+          ++begin;
         }
 
-        Boxed_Value &method_missing(const std::string &t_method_name)
+        return std::vector<Type_Info>(begin, end);
+      }
+
+      virtual ~Dynamic_Object_Constructor() {}
+
+      virtual bool operator==(const Proxy_Function_Base &f) const
+      {
+        try
         {
-          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 Dynamic_Object_Constructor &dc = dynamic_cast<const Dynamic_Object_Constructor&>(f);
+          return dc.m_type_name == m_type_name && (*dc.m_func) == (*m_func);
+        } catch (const std::bad_cast &) {
+          return false;
         }
+      }
 
-        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);
-          }
+      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 get_attr(t_method_name);
-        }
+        return m_func->call_match(new_vals);
+      }    
 
-        std::map<std::string, Boxed_Value> get_attrs() const
-        {
-          return m_attrs;
-        }
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+      {
+        std::vector<Boxed_Value> new_params;
+        chaiscript::Boxed_Value bv = var(Dynamic_Object(m_type_name));
+        new_params.push_back(bv);
+        new_params.insert(new_params.end(), params.begin(), params.end());
 
-      private:
-        const std::string m_type_name = "";
-        bool m_option_explicit = false;
+        (*m_func)(new_params);
 
-        std::map<std::string, Boxed_Value> m_attrs;
-    };
+        return bv;
+      }
 
-  }
+      virtual int get_arity() const
+      {
+        // "this" is not considered part of the arity
+	return m_func->get_arity() - 1; 
+      }
+
+      virtual std::string annotation() const
+      {
+        return m_func->annotation();
+      }
+
+    private:
+      std::string m_type_name;
+      Proxy_Function m_func;
+
+  };
 }
 #endif
 

include/chaiscript/dispatchkit/dynamic_object_detail.hpp

@@ -1,237 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, 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 final : public Proxy_Function_Base
-      {
-        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;
-
-          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_Object_Constructor(
-              std::string t_type_name,
-              const Proxy_Function &t_func)
-            : Proxy_Function_Base(build_type_list(t_func->get_param_types()), t_func->get_arity() - 1),
-              m_type_name(std::move(t_type_name)), m_func(t_func)
-          {
-            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-          }
-
-          static std::vector<Type_Info> build_type_list(const std::vector<Type_Info> &tl)
-          {
-            auto begin = tl.begin();
-            auto end = tl.end();
-
-            if (begin != end)
-            {
-              ++begin;
-            }
-
-            return std::vector<Type_Info>(begin, end);
-          }
-
-          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,117 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
-#define CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
-
-#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, const Dispatch_Engine &t_engine) = 0;
-
-      virtual ~Exception_Handler_Base() = default;
-
-      protected:
-        template<typename T>
-        static void throw_type(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
-        {
-          try { T t = t_engine.boxed_cast<T>(bv); throw t; } catch (const chaiscript::exception::bad_boxed_cast &) {}
-        }
-    };
-
-    template<typename ... T>
-      struct Exception_Handler_Impl : Exception_Handler_Base
-      {
-        void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) override
-        {
-          (void)std::initializer_list<int>{(throw_type<T>(bv, t_engine), 0)...};
-        }
-      };
-  }
-
-  /// \brief Used in the automatic unboxing of exceptions thrown during script evaluation
-  ///
-  /// Exception specifications allow the user to tell ChaiScript what possible exceptions are expected from the script
-  /// being executed. Exception_Handler objects are created with the chaiscript::exception_specification() function.
-  ///
-  /// Example:
-  /// \code
-  /// chaiscript::ChaiScript chai;
-  ///
-  /// try {
-  ///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
-  /// } catch (const double 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
-  /// }
-  /// \endcode
-  ///
-  /// It is recommended that if catching the generic \c std::exception& type that you specifically catch
-  /// the chaiscript::exception::eval_error type, so that there is no confusion.
-  ///
-  /// \code
-  /// try {
-  ///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<const std::exception &>());
-  /// } catch (const chaiscript::exception::eval_error &) {
-  ///   // Error in script parsing / execution
-  /// } catch (const std::exception &e) {
-  ///   // Error explicitly thrown from script
-  /// }
-  /// \endcode
-  ///
-  /// Similarly, if you are using the ChaiScript::eval form that unboxes the return value, then chaiscript::exception::bad_boxed_cast
-  /// should be handled as well.
-  /// 
-  /// \code
-  /// try {
-  ///   chai.eval<int>("1.0", chaiscript::exception_specification<const std::exception &>());
-  /// } catch (const chaiscript::exception::eval_error &) {
-  ///   // Error in script parsing / execution
-  /// } catch (const chaiscript::exception::bad_boxed_cast &) {
-  ///   // Error unboxing return value
-  /// } catch (const std::exception &e) {
-  ///   // Error explicitly thrown from script
-  /// }
-  /// \endcode
-  ///
-  /// \sa chaiscript::exception_specification for creation of chaiscript::Exception_Handler objects
-  /// \sa \ref exceptions
-  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 ... T>
-  Exception_Handler exception_specification()
-  {
-    return std::make_shared<detail::Exception_Handler_Impl<T...>>();
-  }
-}
-
-
-#endif
-

include/chaiscript/dispatchkit/function_call.hpp

@@ -1,131 +1,71 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+#ifndef __function_call_hpp__
+#define __function_call_hpp__
 
-
-#ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
-#define CHAISCRIPT_FUNCTION_CALL_HPP_
-
-#include <functional>
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
 #include <string>
 #include <vector>
-
-#include "boxed_cast.hpp"
-#include "function_call_detail.hpp"
 #include "proxy_functions.hpp"
-#include "callable_traits.hpp"
-
-namespace chaiscript {
-class Boxed_Value;
-class Type_Conversions_State;
-namespace detail {
-template <typename T> struct Cast_Helper;
-}  // namespace detail
-}  // namespace chaiscript
+#include "function_call_detail.hpp"
 
 namespace chaiscript
 {
-  namespace dispatch
-  {
-    /// Build a function caller that knows how to dispatch on a set of functions
-    /// example:
-    /// std::function<void (int)> f =
-    ///      build_function_caller(dispatchkit.get_function("print"));
-    /// \returns A std::function object for dispatching
-    /// \param[in] funcs the set of functions to dispatch on.
-    template<typename FunctionType>
-      std::function<FunctionType> functor(const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions_State *t_conversions)
+  /**
+   * 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.
+   */
+  template<typename FunctionType>
+    boost::function<FunctionType>
+      functor(const std::vector<std::pair<std::string, Proxy_Function > > &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);
+        FunctionType *p=0;
+        return detail::build_function_caller_helper(p, funcs);
       }
 
-    /// Build a function caller for a particular Proxy_Function object
-    /// useful in the case that a function is being pass out from scripting back
-    /// into code
-    /// example:
-    /// void my_function(Proxy_Function f)
-    /// {
-    ///   std::function<void (int)> local_f =
-    ///      build_function_caller(f);
-    /// }
-    /// \returns A std::function object for dispatching
-    /// \param[in] func A function to execute.
-    template<typename FunctionType>
-      std::function<FunctionType> functor(Const_Proxy_Function func, const Type_Conversions_State *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.
+   */
+  template<typename FunctionType>
+    boost::function<FunctionType>
+      functor(Proxy_Function func)
       {
-        return functor<FunctionType>(std::vector<Const_Proxy_Function>({std::move(func)}), t_conversions);
+        std::vector<std::pair<std::string, Proxy_Function > > funcs;
+        funcs.push_back(std::make_pair(std::string(), func));
+        return functor<FunctionType>(funcs);
       }
 
-    /// Helper for automatically unboxing a Boxed_Value that contains a function object
-    /// and creating a typesafe C++ function caller from it.
-    template<typename FunctionType>
-      std::function<FunctionType> functor(const Boxed_Value &bv, const Type_Conversions_State *t_conversions)
+  /**
+   * 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)
       {
-        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
+        return functor<FunctionType>(boxed_cast<Proxy_Function >(bv));
       }
-  }
 
-  namespace detail{
-    /// Cast helper to handle automatic casting to const std::function &
-    template<typename Signature>
-      struct Cast_Helper<const std::function<Signature> &>
-      {
-        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, t_conversions);
-          } else {
-            return Cast_Helper_Inner<const std::function<Signature> &>::cast(ob, t_conversions);
-          }
-        }
-      };
-
-    /// Cast helper to handle automatic casting to std::function
-    template<typename Signature>
-      struct Cast_Helper<std::function<Signature> >
-      {
-        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, t_conversions);
-          } else {
-            return Cast_Helper_Inner<std::function<Signature> >::cast(ob, t_conversions);
-          }
-        }
-      };
-
-    /// Cast helper to handle automatic casting to const std::function
-    template<typename Signature>
-      struct Cast_Helper<const std::function<Signature> >
-      {
-        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, t_conversions);
-          } else {
-            return Cast_Helper_Inner<const std::function<Signature> >::cast(ob, t_conversions);
-          }
-        }
-      };
-  }
 }
 
 #endif

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,169 +1,96 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+#include <boost/preprocessor.hpp>
+
+#define addparam(z,n,text)  params.push_back(boost::is_reference<Param ## n>::value?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
+#define curry(z,n,text)  BOOST_PP_CAT(_, BOOST_PP_INC(n))
 
 
-#ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
-#define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
+#ifndef  BOOST_PP_IS_ITERATING
+#ifndef __function_call_detail_hpp__
+#define __function_call_detail_hpp__
 
-#include <functional>
-#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
 #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
 {
-  namespace dispatch
+  namespace detail
   {
-    namespace detail
-    {
-      /// Internal helper class for handling the return
-      /// value of a build_function_caller
-      template<typename Ret, bool is_arithmetic>
-        struct Function_Caller_Ret
+    /**
+     * Internal helper class for handling the return
+     * value of a build_function_caller
+     */
+    template<typename Ret>
+      struct Function_Caller_Ret
+      {
+        static Ret call(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs, 
+            const std::vector<Boxed_Value> &params)
         {
-          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_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, false>
-        {
-          static void 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) {
-              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);
-            }
-          }
-        };
-
-      /**
-       * used internally for unwrapping a function call's types
-       */
-      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)
-          {
-            std::shared_ptr<const Proxy_Function_Impl<Ret (Params...)>> pfi = 
-              std::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (Params...)> >
-                (funcs[0]);
-
-            if (pfi)
-            {
-              return pfi->internal_function();
-            } 
-            // looks like this either wasn't a Proxy_Function_Impl or the types didn't match
-            // we cannot make any other guesses or assumptions really, so continuing
-          }
-*/
-
-          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions?t_conversions->get():nullptr));
+          return boxed_cast<Ret>(dispatch(t_funcs, params));
         }
-    }
+      };
+
+    /**
+     * Specialization for void return types
+     */
+    template<>
+      struct Function_Caller_Ret<void>
+      {
+        static void call(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs, 
+            const std::vector<Boxed_Value> &params)
+        {
+          dispatch(t_funcs, params);
+        }
+      };
+  }
+}
+
+#define BOOST_PP_ITERATION_LIMITS ( 0, 9 )
+#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/function_call_detail.hpp>
+#include BOOST_PP_ITERATE()
+
+# endif
+#else
+# define n BOOST_PP_ITERATION()
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    /**
+     * used internally for unwrapping a function call's types
+     */
+    template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+      Ret function_caller(const std::vector<std::pair<std::string, Proxy_Function > > &funcs 
+          BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
+      {
+        std::vector<Boxed_Value> params;
+
+        BOOST_PP_REPEAT(n, addparam, ~)
+
+          return Function_Caller_Ret<Ret>::call(funcs, params);
+      }
+
+    /**
+     * used internally for unwrapping a function call's types
+     */
+    template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+      boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
+      build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<std::pair<std::string, Proxy_Function> > &funcs)
+      {
+        return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs
+            BOOST_PP_ENUM_TRAILING(n, curry, ~));
+      }
+
   }
 }
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,256 +1,99 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+#ifndef __handle_return_hpp__
+#define __handle_return_hpp__
 
-
-#ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
-#define CHAISCRIPT_HANDLE_RETURN_HPP_
-
-#include <functional>
-#include <memory>
-#include <type_traits>
-
-#include "boxed_number.hpp"
 #include "boxed_value.hpp"
+#include "type_info.hpp"
+#include <string>
+#include <boost/function.hpp>
 
-namespace chaiscript {
-class Boxed_Number;
-}  // namespace chaiscript
+#include <stdexcept>
+#include <vector>
 
 namespace chaiscript
 {
-  namespace dispatch
-  {
-    template<class T, class U> class Proxy_Function_Callable_Impl;
-    template<class T> class Assignable_Proxy_Function_Impl;
-
-    namespace detail
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<typename Ret>
+    struct Handle_Return
     {
-      /// Used internally for handling a return value from a Proxy_Function call
-      template<typename Ret>
-        struct Handle_Return
-        {
-          template<typename T,
-                   typename = typename std::enable_if<std::is_pod<typename std::decay<T>::type>::value>::type>
-          static Boxed_Value handle(T r)
-          {
-            return Boxed_Value(std::move(r), true);
-          }
+      static Boxed_Value handle(const Ret &r)
+      {
+        return Boxed_Value(r);
+      }
+    };
 
-          template<typename T,
-                   typename = typename std::enable_if<!std::is_pod<typename std::decay<T>::type>::value>::type>
-          static Boxed_Value handle(T &&r)
-          {
-            return Boxed_Value(std::make_shared<T>(std::forward<T>(r)), true);
-          }
-        };
+  template<typename Ret>
+    struct Handle_Return<boost::shared_ptr<Ret> &>
+    {
+      static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+      {
+        return Boxed_Value(r);
+      }
+    };
 
-      template<typename Ret>
-        struct Handle_Return<const std::function<Ret> &>
-        {
-          static Boxed_Value handle(const std::function<Ret> &f) {
-            return Boxed_Value(
-                chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Proxy_Function_Callable_Impl<Ret, std::function<Ret>>>(f)
-              );
-          }
-        };
+  template<typename Ret>
+    struct Handle_Return<const boost::shared_ptr<Ret> &>
+    {
+      static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+      {
+        return Boxed_Value(r);
+      }
+    };
 
-      template<typename Ret>
-        struct Handle_Return<std::function<Ret>> : Handle_Return<const std::function<Ret> &>
-        {
-        };
+  /**
+   * 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));
+      }
+    };
 
-      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)
-                );
-          }
-        };
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<>
+    struct Handle_Return<Boxed_Value>
+    {
+      static Boxed_Value handle(const Boxed_Value &r)
+      {
+        return r;
+      }
+    };
 
-      template<typename Ret>
-        struct Handle_Return<const std::shared_ptr<std::function<Ret>> &> : Handle_Return<const std::shared_ptr<std::function<Ret>>>
-        {
-        };
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<>
+    struct Handle_Return<Boxed_Value &>
+    {
+      static Boxed_Value handle(const Boxed_Value &r)
+      {
+        return r;
+      }
+    };
 
-      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);
-          }
-        };
-
-      template<typename Ret>
-        struct Handle_Return<Ret *>
-        {
-          static Boxed_Value handle(Ret *p)
-          {
-            return Boxed_Value(p, true);
-          }
-        };
-
-      template<typename Ret>
-        struct Handle_Return<const Ret *>
-        {
-          static Boxed_Value handle(const Ret *p)
-          {
-            return Boxed_Value(p, true);
-          }
-        };
-
-      template<typename Ret>
-        struct Handle_Return<std::shared_ptr<Ret> &>
-        {
-          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
-          {
-            return Boxed_Value(r, true);
-          }
-        };
-
-      template<typename Ret>
-        struct Handle_Return<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> &>
-        {
-        };
-
-
-      template<typename Ret>
-        struct Handle_Return<std::unique_ptr<Ret>> : Handle_Return<std::unique_ptr<Ret> &>
-        {
-          static Boxed_Value handle(std::unique_ptr<Ret> &&r)
-          {
-            return Boxed_Value(std::move(r), true);
-          }
-        };
-
-
-
-      template<typename Ret>
-        struct Handle_Return<const Ret &>
-        {
-          static Boxed_Value handle(const Ret &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));
-          }
-        };
-
-      template<typename Ret>
-        struct Handle_Return<Ret &>
-        {
-          static Boxed_Value handle(Ret &r)
-          {
-            return Boxed_Value(std::ref(r));
-          }
-        };
-
-      template<>
-        struct Handle_Return<Boxed_Value>
-        {
-          static Boxed_Value handle(const Boxed_Value &r)
-          {
-            return r;
-          }
-        };
-
-      template<>
-        struct Handle_Return<const Boxed_Value> : Handle_Return<Boxed_Value>
-        {
-        };
-
-      template<>
-        struct Handle_Return<Boxed_Value &> : Handle_Return<Boxed_Value>
-        {
-        };
-
-      template<>
-        struct Handle_Return<const Boxed_Value &> : Handle_Return<Boxed_Value>
-        {
-        };
-
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
-      template<>
-        struct Handle_Return<Boxed_Number>
-        {
-          static Boxed_Value handle(const Boxed_Number &r)
-          {
-            return r.bv;
-          }
-        };
-
-      template<>
-        struct Handle_Return<const Boxed_Number> : Handle_Return<Boxed_Number>
-        {
-        };
-
-
-      /**
-       * Used internally for handling a return value from a Proxy_Function call
-       */
-      template<>
-        struct Handle_Return<void>
-        {
-          static Boxed_Value handle()
-          {
-            return void_var();
-          }
-        };
-    }
-  }
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<>
+    struct Handle_Return<void>
+    {
+      static Boxed_Value handle()
+      {
+        return Boxed_Value(Boxed_Value::Void_Type());
+      }
+    };
 }
 
 #endif

include/chaiscript/dispatchkit/operators.hpp

@@ -1,224 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_OPERATORS_HPP_
-#define CHAISCRIPT_OPERATORS_HPP_
-
-#include "../chaiscript_defines.hpp"
-#include "register_function.hpp"
-
-namespace chaiscript 
-{
-  namespace bootstrap
-  {
-    namespace operators
-    {
-      template<typename T>
-        void assign(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs = rhs;}), "=");
-        }
-
-      template<typename T>
-        void assign_bitwise_and(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs &= rhs;}), "&=");
-        }
-
-      template<typename T>
-        void assign_xor(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs ^= rhs;}), "^=");
-        }
-
-      template<typename T>
-        void assign_bitwise_or(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs |= rhs;}), "|=");
-        }
-
-      template<typename T>
-        void assign_difference(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs -= rhs;}), "-=");
-        }
-
-      template<typename T>
-        void assign_left_shift(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs <<= rhs;}), "<<=");
-        }
-
-      template<typename T>
-        void assign_product(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs <<= rhs;}), "*=");
-        }
-
-      template<typename T>
-        void assign_quotient(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs /= rhs;}), "/=");
-        }
-
-      template<typename T>
-        void assign_remainder(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs %= rhs;}), "%=");
-        }
-
-      template<typename T>
-        void assign_right_shift(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs >>= rhs;}), ">>=");
-        }
-
-      template<typename T>
-        void assign_sum(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs += rhs;}), "+=");
-        }
-
-      template<typename T>
-        void prefix_decrement(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs)->T&{return --lhs;}), "--");
-        }
-
-      template<typename T>
-        void prefix_increment(Module& m)
-        {
-          m.add(chaiscript::fun([](T &lhs)->T&{return ++lhs;}), "++");
-        }
-
-      template<typename T>
-        void equal(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs==rhs;}), "==");
-        }
-
-      template<typename T>
-        void greater_than(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>rhs;}), ">");
-        }
-
-      template<typename T>
-        void greater_than_equal(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>=rhs;}), ">=");
-        }
-
-      template<typename T>
-        void less_than(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<rhs;}), "<");
-        }
-
-      template<typename T>
-        void less_than_equal(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<=rhs;}), "<=");
-        }
-
-      template<typename T>
-        void logical_compliment(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs){return !lhs;}), "!");
-        }
-
-      template<typename T>
-        void not_equal(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs!=rhs;}), "!=");
-        }
-
-      template<typename T>
-        void addition(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs+rhs;}), "+");
-        }
-
-      template<typename T>
-        void unary_plus(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs){return +lhs;}), "+");
-        }
-
-      template<typename T>
-        void subtraction(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs-rhs;}), "-");
-        }
-
-      template<typename T>
-        void unary_minus(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs){return -lhs;}), "-");
-        }
-
-      template<typename T>
-        void bitwise_and(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs&rhs;}), "&");
-        }
-
-      template<typename T>
-        void bitwise_compliment(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs){return ~lhs;}), "~");
-        }
-
-      template<typename T>
-        void bitwise_xor(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs^rhs;}), "^");
-        }
-
-      template<typename T>
-        void bitwise_or(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs|rhs;}), "|");
-        }
-
-      template<typename T>
-        void division(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs/rhs;}), "/");
-        }
-
-      template<typename T>
-        void left_shift(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<<rhs;}), "<<");
-        }
-
-      template<typename T>
-        void multiplication(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs*rhs;}), "*");
-        }
-
-      template<typename T>
-        void remainder(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs%rhs;}), "%");
-        }
-
-      template<typename T>
-        void right_shift(Module& m)
-        {
-          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>>rhs;}), ">>");
-        }
-    }
-  }
-}
-
-#endif

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -1,55 +1,65 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+#include <boost/preprocessor.hpp>
+
+#ifndef  BOOST_PP_IS_ITERATING
+#ifndef __proxy_constructors_hpp__
+#define __proxy_constructors_hpp__
+
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
 
 
-#ifndef CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
-#define CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
-
-#include "proxy_functions.hpp"
+#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
+#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_constructors.hpp>
+#include BOOST_PP_ITERATE()
+# endif
 
 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, ...)
-  /// 
-  /// Example:
-  /// \code
-  ///    chaiscript::ChaiScript chai;
-  ///    // Create a new function that creates a MyClass object using the (int, float) constructor
-  ///    // and call that function "MyClass" so that it appears as a normal constructor to the user.
-  ///    chai.add(constructor<MyClass (int, float)>(), "MyClass");
-  /// \endcode
   template<typename T>
     Proxy_Function constructor()
     {
-      T *f = nullptr;
-      return (dispatch::detail::build_constructor_(f));
+      T *f = 0;
+      return (detail::build_constructor_(f));
     }
+}
 
+#else
+# define n BOOST_PP_ITERATION()
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    /**
+     * A constructor function, used for creating a new object
+     * of a given type with a given set of params
+     */
+    template<typename Class 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)>))));
+      }
+  }
 }
 
 #endif

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -1,139 +1,133 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+#include <boost/preprocessor.hpp>
 
+#define gettypeinfo(z,n,text)  ti.push_back(detail::Get_Type_Info<Param ## n>::get());
+#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n])
+#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n]);
 
-#ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
-#define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
+#ifndef  BOOST_PP_IS_ITERATING
+#ifndef __proxy_functions_detail_hpp__
+#define __proxy_functions_detail_hpp__
+
+#include "boxed_value.hpp"
+#include "type_info.hpp"
+#include "handle_return.hpp"
+#include <string>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/lexical_cast.hpp>
 
-#include <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
 {
-  namespace exception
+  /**
+   * Exception thrown when there is a mismatch in number of
+   * parameters during Proxy_Function execution
+   */
+  struct arity_error : std::range_error
   {
-    /**
-     * Exception thrown when there is a mismatch in number of
-     * parameters during Proxy_Function execution
-     */
-    struct arity_error : std::range_error
+    arity_error(int t_got, int t_expected)
+      : std::range_error("Function dispatch arity mismatch"),
+      got(t_got), expected(t_expected)
     {
-      arity_error(int t_got, int t_expected)
-        : std::range_error("Function dispatch arity mismatch"),
-        got(t_got), expected(t_expected)
+    }
+
+    virtual ~arity_error() throw() {}
+    int got;
+    int expected;
+  };
+
+  template<typename Ret>
+    struct Do_Call
+    {
+      template<typename Fun>
+      static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
       {
+        return Handle_Return<Ret>::handle(call_func(fun, params));
+      }
+    };
+
+  template<>
+    struct Do_Call<void>
+    {
+      template<typename Fun>
+      static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+      {
+        call_func(fun, params);
+        return Handle_Return<void>::handle();
+      };
+    };
+}
+
+#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
+#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_functions_detail.hpp>
+#include BOOST_PP_ITERATE()
+
+
+# endif
+#else
+# define n BOOST_PP_ITERATION()
+
+namespace chaiscript
+{
+  /**
+   * Used by Proxy_Function_Impl to return a list of all param types
+   * it contains.
+   */
+  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+    std::vector<Type_Info> build_param_type_list(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
+    {
+      std::vector<Type_Info> ti;
+      ti.push_back(detail::Get_Type_Info<Ret>::get());
+
+      BOOST_PP_REPEAT(n, gettypeinfo, ~) 
+
+      return ti;
+    }
+
+  /**
+   * Used by Proxy_Function_Impl to perform typesafe execution of a function.
+   * The function attempts to unbox each paramter to the expected type.
+   * if any unboxing fails the execution of the function fails and
+   * the bad_boxed_cast is passed up to the caller.
+   */
+  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+    Ret call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
+        const std::vector<Boxed_Value> &params)
+    {
+      if (params.size() != n)
+      {
+        throw arity_error(params.size(), n);
+      } else {
+        return f(BOOST_PP_REPEAT(n, casthelper, ~));
+      }
+    }
+
+  /**
+   * Used by Proxy_Function_Impl to determine if it is equivalent to another
+   * Proxy_Function_Impl object. This function is primarly used to prevent
+   * registration of two functions with the exact same signatures
+   */
+  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+    bool compare_types_cast(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)),
+        const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, ))
+    {
+      try {
+        BOOST_PP_REPEAT(n, trycast, ~);
+      } catch (const bad_boxed_cast &) {
+        return false;
       }
 
-      arity_error(const arity_error &) = default;
-
-      ~arity_error() noexcept override = default;
-
-      int got;
-      int expected;
-    };
-  }
-
-  namespace dispatch
-  {
-    namespace detail
-    {
-      /**
-       * Used by Proxy_Function_Impl to return a list of all param types
-       * it contains.
-       */
-      template<typename Ret, typename ... Params>
-        std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
-        {
-          /// \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 determine if it is equivalent to another
-       * Proxy_Function_Impl object. This function is primarily used to prevent
-       * registration of two functions with the exact same signatures
-       */
-      template<typename Ret, typename ... Params>
-        bool compare_types_cast(Ret (*)(Params...),
-             const std::vector<Boxed_Value> &params, const Type_Conversions_State &t_conversions)
-        {
-          try {
-            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;
-          }
-        }
-
-
-      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
-        }
-
+      return true;
     }
-  }
 
 }
 
-
 #endif

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,119 +1,102 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+#include <boost/preprocessor.hpp>
 
+#ifndef  BOOST_PP_IS_ITERATING
+#ifndef __register_function_hpp__
+#define __register_function_hpp__
 
-#ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_
-#define CHAISCRIPT_REGISTER_FUNCTION_HPP_
-
-#include <type_traits>
-
-#include "bind_first.hpp"
-#include "proxy_functions.hpp"
+#include "dispatchkit.hpp"
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
 
 namespace chaiscript
 {
+  namespace detail
+  {
+    /**
+     * Helper function for register_member function
+     */
+    template<typename T, typename Class>
+      T &get_member(T Class::* m, Class *obj)
+      {
+        return (obj->*m);
+      }
 
-  /// \brief Creates a new Proxy_Function object from a free function, member function or data member
-  /// \param[in] t Function / member to expose
-  ///
-  /// \b Example:
-  /// \code
-  /// int myfunction(const std::string &);
-  /// class MyClass
-  /// {
-  ///   public:
-  ///     void memberfunction();
-  ///     int memberdata;
-  /// };
-  /// 
-  /// chaiscript::ChaiScript chai;
-  /// chai.add(fun(&myfunction), "myfunction");
-  /// chai.add(fun(&MyClass::memberfunction), "memberfunction");
-  /// chai.add(fun(&MyClass::memberdata), "memberdata");
-  /// \endcode
-  /// 
-  /// \sa \ref adding_functions
+    template<typename T>
+      Proxy_Function fun_helper(const boost::function<T> &f)
+      {
+        return Proxy_Function(new Proxy_Function_Impl<T>(f));
+      }
+
+    /**
+     * Automatically create a get_member helper function for an object 
+     * to allow for runtime dispatched access to public data members
+     * for example, the case of std::pair<>::first and std::pair<>::second
+     */
+    template<typename T, typename Class>
+      Proxy_Function fun_helper(T Class::* m)
+      {
+        return fun_helper(boost::function<T& (Class *)>(boost::bind(&detail::get_member<T, Class>, m, _1)));
+      }
+  }
+}
+
+#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
+#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/register_function.hpp>
+#include BOOST_PP_ITERATE()
+
+namespace chaiscript
+{
   template<typename T>
-    Proxy_Function fun(const T &t)
+    Proxy_Function fun(T 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));
+      return detail::fun_helper(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
-  ///
-  /// \b Example:
-  /// \code
-  /// struct MyClass
-  /// {
-  ///   void memberfunction(int);
-  /// };
-  /// 
-  /// MyClass obj;
-  /// chaiscript::ChaiScript chai;
-  /// // Add function taking only one argument, an int, and permanently bound to "obj"
-  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj)), "memberfunction"); 
-  /// \endcode
-  /// 
-  /// \sa \ref adding_functions
-  template<typename T, typename Q>
-    Proxy_Function fun(T &&t, const Q &q)
-    {
-      return fun(detail::bind_first(std::forward<T>(t), q));
-    }
-
-
 }
 
 
+# endif
+#else
+# define n BOOST_PP_ITERATION()
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    /**
+     * Register a global function of n parameters with name 
+     */
+    template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+      Proxy_Function fun_helper(Ret (*f)(BOOST_PP_ENUM_PARAMS(n, Param)))
+      {
+        return fun_helper(boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))>(f));
+      }
+
+    /**
+     * Register a class method of n parameters with name 
+     */
+    template<typename Ret, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+      Proxy_Function fun_helper(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)))
+      {
+        return fun_helper(boost::function<Ret (Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f));
+      }
+
+    /**
+     * Register a const class method of n parameters with name 
+     */
+    template<typename Ret, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+      Proxy_Function fun_helper(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param))const)
+      {
+        return fun_helper(boost::function<Ret (const Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f));
+      }
+
+  }
+}
+
 #endif
 

include/chaiscript/dispatchkit/short_alloc.hpp

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

include/chaiscript/dispatchkit/type_conversions.hpp

@@ -1,649 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
-#define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
-
-#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)
-      {
-      }
-
-      Type_Conversions(const Type_Conversions &t_other) = delete;
-      Type_Conversions(Type_Conversions &&) = default;
-
-      Type_Conversions &operator=(const Type_Conversions &) = delete;
-      Type_Conversions &operator=(Type_Conversions &&) = default;
-
-      const std::set<const std::type_info *, Less_Than> &thread_cache() const
-      {
-        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
-        {
-          return boxed_type_conversion(user_type<To>(), t_saves, from);
-        }
-
-      template<typename From>
-        Boxed_Value boxed_type_down_conversion(Conversion_Saves &t_saves, const Boxed_Value &to) const
-        {
-          return boxed_type_down_conversion(user_type<From>(), t_saves, to);
-        }
-
-
-        Boxed_Value boxed_type_conversion(const Type_Info &to, Conversion_Saves &t_saves, const Boxed_Value &from) const
-        {
-          try {
-            Boxed_Value ret = get_conversion(to, 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(), *to.bare_type_info(), "No known conversion");
-          } catch (const std::bad_cast &) {
-            throw exception::bad_boxed_dynamic_cast(from.get_type_info(), *to.bare_type_info(), "Unable to perform dynamic_cast operation");
-          }
-        }
-
-        Boxed_Value boxed_type_down_conversion(const Type_Info &from, Conversion_Saves &t_saves, const Boxed_Value &to) const
-        {
-          try {
-            Boxed_Value ret = get_conversion(to.get_type_info(), from)->convert_down(to);
-            if (t_saves.enabled) { t_saves.saves.push_back(ret); }
-            return ret;
-          } catch (const std::out_of_range &) {
-            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), *from.bare_type_info(), "No known conversion");
-          } catch (const std::bad_cast &) {
-            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), *from.bare_type_info(), "Unable to perform dynamic_cast operation");
-          }
-        }
-
-      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,108 +1,96 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+#ifndef __type_info_hpp__
+#define __type_info_hpp__
 
-
-#ifndef CHAISCRIPT_TYPE_INFO_HPP_
-#define CHAISCRIPT_TYPE_INFO_HPP_
-
-#include <memory>
-#include <type_traits>
-#include <typeinfo>
-#include <string>
+#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/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/ref.hpp>
 
 namespace chaiscript
 {
-
-  namespace detail
-  {
-    template<typename T>
-      struct Bare_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
+  /**
+   * compile time deduced information about a type
+   */
   class Type_Info
   {
     public:
-      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(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
+          const std::type_info *t_ti, const std::type_info *t_bareti)
+        : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
+        m_is_void(t_is_void),
+        m_type_info(t_ti), m_bare_type_info(t_bareti),
+        m_is_unknown(false)
       {
       }
 
-      constexpr Type_Info() = default;
+      Type_Info()
+        : m_is_const(false), m_is_reference(false), m_is_pointer(false),
+        m_is_void(false), m_type_info(0), m_bare_type_info(0),
+        m_is_unknown(true)
+      {
+      }
 
-      constexpr bool operator<(const Type_Info &ti) const noexcept
+      Type_Info(const Type_Info &ti)
+        : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
+        m_is_pointer(ti.m_is_pointer),
+        m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
+        m_bare_type_info(ti.m_bare_type_info),
+        m_is_unknown(ti.m_is_unknown)
+      {
+      }
+
+      Type_Info &operator=(const Type_Info &ti)
+      {
+        m_is_const = ti.m_is_const;
+        m_is_reference = ti.m_is_reference;
+        m_is_pointer = ti.m_is_pointer;
+        m_is_void = ti.m_is_void;
+        m_type_info = ti.m_type_info;
+        m_bare_type_info = ti.m_bare_type_info;
+        m_is_unknown = ti.m_is_unknown;
+        return *this;
+      }
+
+      bool operator<(const Type_Info &ti) const
       {
         return m_type_info < ti.m_type_info;
       }
 
-      constexpr bool operator!=(const Type_Info &ti) const noexcept
+      bool operator==(const Type_Info &ti) const
       {
-        return !(operator==(ti));
+        return ti.m_type_info == m_type_info 
+          || (ti.m_type_info && m_type_info && *ti.m_type_info == *m_type_info);
       }
 
-      constexpr bool operator!=(const std::type_info &ti) const noexcept
+      bool operator==(const std::type_info &ti) const
       {
-        return !(operator==(ti));
+        return m_type_info != 0 && (*m_type_info) == ti;
       }
 
-      constexpr bool operator==(const Type_Info &ti) const noexcept
+      bool bare_equal(const Type_Info &ti) const
       {
-        return ti.m_type_info == m_type_info
-           || *ti.m_type_info == *m_type_info;
+        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);
       }
 
-      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 (!is_undef())
-        {
-          return m_type_info->name();
-        } else {
-          return "";
-        }
-      }
+      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_unknown() const { return m_is_unknown || m_bare_type_info == 0; }
 
       std::string bare_name() const
       {
-        if (!is_undef())
+        if (m_bare_type_info)
         {
           return m_bare_type_info->name();
         } else {
@@ -110,130 +98,79 @@ namespace chaiscript
         }
       }
 
-      constexpr const std::type_info *bare_type_info() const
-      {
-        return m_bare_type_info;
-      }
-
     private:
-      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);
+      bool m_is_const;
+      bool m_is_reference;
+      bool m_is_pointer;
+      bool m_is_void;
+      const std::type_info *m_type_info;
+      const std::type_info *m_bare_type_info;
+      bool m_is_unknown;
   };
 
   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
       {
-        static constexpr Type_Info get()
+        static Type_Info get()
         {
-          return Type_Info(std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value, 
-              std::is_reference<T>::value, std::is_pointer<T>::value, 
-              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));
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(T), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<std::shared_ptr<T> >
+      struct Get_Type_Info<boost::shared_ptr<T> >
       {
-//        typedef T type;
-
-        static constexpr Type_Info get()
+        static Type_Info get()
         {
-          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
-              &typeid(std::shared_ptr<T> ), 
-              &typeid(typename Bare_Type<T>::type));
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(boost::shared_ptr<T> ), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<std::shared_ptr<T> &> : Get_Type_Info<std::shared_ptr<T>>
+      struct Get_Type_Info<const boost::shared_ptr<T> &>
       {
-      };
-
-    template<typename T>
-      struct Get_Type_Info<const std::shared_ptr<T> &>
-      {
-        static constexpr Type_Info get()
+        static Type_Info get()
         {
-          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
-              &typeid(const std::shared_ptr<T> &), 
-              &typeid(typename Bare_Type<T>::type));
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(const boost::shared_ptr<T> &), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<std::reference_wrapper<T> >
+      struct Get_Type_Info<boost::reference_wrapper<T> >
       {
-        static constexpr Type_Info get()
+        static Type_Info get()
         {
-          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
-              &typeid(std::reference_wrapper<T> ), 
-              &typeid(typename Bare_Type<T>::type));
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(boost::reference_wrapper<T> ), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
         }
       };
-
-    template<typename T>
-      struct Get_Type_Info<const std::reference_wrapper<T> &>
-      {
-        static constexpr Type_Info get()
-        {
-          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              std::is_void<T>::value,
-              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, bool>::value,
-              &typeid(const std::reference_wrapper<T> &), 
-              &typeid(typename Bare_Type<T>::type));
-        }
-      };
-
   }
-
-  /// \brief Creates a Type_Info object representing the type passed in
-  /// \tparam T Type of object to get a Type_Info for, derived from the passed in parameter
-  /// \return Type_Info for T
-  /// 
-  /// \b Example:
-  /// \code
-  /// int i;
-  /// chaiscript::Type_Info ti = chaiscript::user_type(i);
-  /// \endcode
+  
   template<typename T>
-  constexpr Type_Info user_type(const T &/*t*/)
+  Type_Info user_type(T)
   {
     return detail::Get_Type_Info<T>::get();
   }
 
 
-  /// \brief Creates a Type_Info object representing the templated type
-  /// \tparam T Type of object to get a Type_Info for
-  /// \return Type_Info for T
-  /// 
-  /// \b Example:
-  /// \code
-  /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
-  /// \endcode
   template<typename T>
-  constexpr Type_Info user_type()
+  Type_Info user_type()
   {
     return detail::Get_Type_Info<T>::get();
   }

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -1,108 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_ALGEBRAIC_HPP_
-#define CHAISCRIPT_ALGEBRAIC_HPP_
-
-#include "../utility/fnv1a.hpp"
-
-#include <string>
-
-namespace chaiscript
-{
-
-  struct Operators {
-    enum class Opers
-    {
-      boolean_flag,
-      equals, less_than, greater_than, less_than_equal, greater_than_equal, not_equal, 
-      non_const_flag, 
-      assign, pre_increment, pre_decrement, assign_product, assign_sum,
-      assign_quotient, assign_difference,
-      non_const_int_flag,
-      assign_bitwise_and, assign_bitwise_or, assign_shift_left, assign_shift_right,
-      assign_remainder, assign_bitwise_xor,
-      const_int_flag,
-      shift_left, shift_right, remainder, bitwise_and, bitwise_or, bitwise_xor, bitwise_complement,
-      const_flag,
-      sum, quotient, product, difference, unary_plus, unary_minus, 
-      invalid
-    };
-
-    static const char *to_string(Opers t_oper) {
-      static const char *opers[] = { 
-        "",
-        "==", "<", ">", "<=", ">=", "!=",
-        "",
-        "=", "++", "--", "*=", "+=",
-        "/=", "-=",
-        "",
-        "&=", "|=", "<<=", ">>=",
-        "%=", "^=",
-        "", 
-        "<<", ">>", "%", "&", "|", "^", "~",
-        "",
-        "+", "/", "*", "-", "+", "-",
-        ""
-      };
-      return opers[static_cast<int>(t_oper)];
-    }
-
-    static Opers to_operator(const std::string &t_str, bool t_is_unary = false)
-    {
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4307)
-#endif
-
-      const auto op_hash = utility::fnv1a_32(t_str.c_str());
-      switch (op_hash) {
-        case utility::fnv1a_32("=="): { return Opers::equals; }
-        case utility::fnv1a_32("<"): { return Opers::less_than; }
-        case utility::fnv1a_32(">"): { return Opers::greater_than; }
-        case utility::fnv1a_32("<="): { return Opers::less_than_equal; }
-        case utility::fnv1a_32(">="): { return Opers::greater_than_equal; }
-        case utility::fnv1a_32("!="): { return Opers::not_equal; }
-        case utility::fnv1a_32("="): { return Opers::assign; }
-        case utility::fnv1a_32("++"): { return Opers::pre_increment; }
-        case utility::fnv1a_32("--"): { return Opers::pre_decrement; }
-        case utility::fnv1a_32("*="): { return Opers::assign_product; }
-        case utility::fnv1a_32("+="): { return Opers::assign_sum; }
-        case utility::fnv1a_32("-="): { return Opers::assign_difference; }
-        case utility::fnv1a_32("&="): { return Opers::assign_bitwise_and; }
-        case utility::fnv1a_32("|="): { return Opers::assign_bitwise_or; }
-        case utility::fnv1a_32("<<="): { return Opers::assign_shift_left; }
-        case utility::fnv1a_32(">>="): { return Opers::assign_shift_right; }
-        case utility::fnv1a_32("%="): { return Opers::assign_remainder; }
-        case utility::fnv1a_32("^="): { return Opers::assign_bitwise_xor; }
-        case utility::fnv1a_32("<<"): { return Opers::shift_left; }
-        case utility::fnv1a_32(">>"): { return Opers::shift_right; }
-        case utility::fnv1a_32("%"): { return Opers::remainder; }
-        case utility::fnv1a_32("&"): { return Opers::bitwise_and; }
-        case utility::fnv1a_32("|"): { return Opers::bitwise_or; }
-        case utility::fnv1a_32("^"): { return Opers::bitwise_xor; }
-        case utility::fnv1a_32("~"): { return Opers::bitwise_complement; }
-        case utility::fnv1a_32("+"): { return t_is_unary ? Opers::unary_plus : Opers::sum; }
-        case utility::fnv1a_32("-"): { return t_is_unary ? Opers::unary_minus : Opers::difference; }
-        case utility::fnv1a_32("/"): { return Opers::quotient; }
-        case utility::fnv1a_32("*"): { return Opers::product; }
-        default: { return Opers::invalid; }
-      }
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(pop)
-#endif
-
-    }
-
-  };
-}
-
-#endif /* _CHAISCRIPT_ALGEBRAIC_HPP */
-

include/chaiscript/language/chaiscript_common.hpp

@@ -1,706 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-// This is an open source non-commercial project. Dear PVS-Studio, please check it.
-// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
-
-#ifndef CHAISCRIPT_COMMON_HPP_
-#define CHAISCRIPT_COMMON_HPP_
-
-#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
-  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
-    inline const char *ast_node_type_to_string(AST_Node_Type ast_node_type) {
-      static const char * const ast_node_types[] = { "Id", "Fun_Call", "Unused_Return_Fun_Call", "Arg_List", "Equation", "Var_Decl",
-                                    "Array_Call", "Dot_Access", 
-                                    "Lambda", "Block", "Scopeless_Block", "Def", "While", "If", "For", "Ranged_For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Continue", "Map_Pair", "Value_Range",
-                                    "Inline_Range", "Try", "Catch", "Finally", "Method", "Attr_Decl",
-                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Noop", "Class", "Binary", "Arg", "Global_Decl", "Constant", "Compiled"};
-
-      return ast_node_types[static_cast<int>(ast_node_type)];
-    }
-  }
-
-  /// \brief Convenience type for file positions
-  struct File_Position {
-    int line;
-    int column;
-
-    File_Position(int t_file_line, int t_file_column)
-      : line(t_file_line), column(t_file_column) { }
-
-    File_Position() : line(0), column(0) { }
-  };
-
-  struct Parse_Location {
-    Parse_Location(std::string t_fname="", const int t_start_line=0, const int t_start_col=0,
-        const int t_end_line=0, const int t_end_col=0)
-      : start(t_start_line, t_start_col), 
-        end(t_end_line, t_end_col),
-        filename(std::make_shared<std::string>(std::move(t_fname)))
-    {
-    }
-
-    Parse_Location(std::shared_ptr<std::string> t_fname, const int t_start_line=0, const int t_start_col=0,
-        const int t_end_line=0, const int t_end_col=0)
-      : start(t_start_line, t_start_col), 
-        end(t_end_line, t_end_col),
-        filename(std::move(t_fname))
-    {
-    }
-
-
-
-    File_Position start;
-    File_Position end;
-    std::shared_ptr<std::string> filename;
-  };
-
-
-  /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
-  typedef std::shared_ptr<AST_Node> AST_NodePtr;
-  typedef std::shared_ptr<const AST_Node> AST_NodePtr_Const;
-
-
-  /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
-  namespace exception
-  {
-    /// \brief Thrown if an error occurs while attempting to load a binary module
-    struct load_module_error : std::runtime_error
-    {
-      explicit load_module_error(const std::string &t_reason) noexcept
-        : std::runtime_error(t_reason)
-      {
-      }
-
-      load_module_error(const std::string &t_name, const std::vector<load_module_error> &t_errors)
-        : std::runtime_error(format_error(t_name, t_errors))
-      {
-      }
-
-      load_module_error(const load_module_error &) = default;
-      ~load_module_error() noexcept override = default;
-
-      static std::string format_error(const std::string &t_name, const std::vector<load_module_error> &t_errors)
-      {
-        std::stringstream ss;
-        ss << "Error loading module '" << t_name << "'\n"
-           << "  The following locations were searched:\n";
-
-        for (const auto &err : t_errors) {
-          ss << "    " << err.what() << "\n";
-        }
-
-        return ss.str();
-      }
-    };
-
-
-    /// Errors generated during parsing or evaluation
-    struct eval_error : std::runtime_error {
-      std::string reason;
-      File_Position start_position;
-      std::string filename;
-      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,
-          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, 
-           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) 
-      {}
-
-      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 : std::runtime_error {
-      explicit file_not_found_error(const std::string &t_filename) noexcept
-        : std::runtime_error("File Not Found: " + t_filename)
-      { }
-
-      file_not_found_error(const file_not_found_error &) = default;
-      ~file_not_found_error() noexcept override = default;
-    };
-
-  }
-
- 
-  /// \brief Struct that doubles as both a parser ast_node and an AST node.
-  struct AST_Node : std::enable_shared_from_this<AST_Node> {
-    public:
-      const AST_Node_Type identifier;
-      const std::string text;
-      Parse_Location location;
-
-      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->location.start.line << ", " << this->location.start.column << '\n';
-
-        for (auto & elem : this->get_children()) {
-          oss << elem->to_string(t_prepend + "  ");
-        }
-        return oss.str();
-      }
-
-
-      static bool get_bool_condition(const Boxed_Value &t_bv, const chaiscript::detail::Dispatch_State &t_ss) {
-        try {
-          return t_ss->boxed_cast<bool>(t_bv);
-        }
-        catch (const exception::bad_boxed_cast &) {
-          throw exception::eval_error("Condition not boolean");
-        }
-      }
-
-
-      virtual ~AST_Node() = default;
-      AST_Node(AST_Node &&) = default;
-      AST_Node &operator=(AST_Node &&) = default;
-      AST_Node(const AST_Node &) = delete;
-      AST_Node& operator=(const AST_Node &) = delete;
-
-
-    protected:
-      AST_Node(std::string t_ast_node_text, AST_Node_Type t_id, Parse_Location t_loc)
-        : identifier(t_id), text(std::move(t_ast_node_text)),
-          location(std::move(t_loc))
-      {
-      }
-
-
-  };
-
-  namespace parser {
-    class ChaiScript_Parser_Base
-    {
-      public:
-        virtual AST_NodePtr parse(const std::string &t_input, const std::string &t_fname) = 0;
-        virtual void debug_print(AST_NodePtr t, std::string prepend = "") const = 0;
-        virtual void *get_tracer_ptr() = 0;
-        virtual ~ChaiScript_Parser_Base() = default;
-        ChaiScript_Parser_Base() = default;
-        ChaiScript_Parser_Base(ChaiScript_Parser_Base &&) = default;
-        ChaiScript_Parser_Base &operator=(ChaiScript_Parser_Base &&) = delete;
-        ChaiScript_Parser_Base &operator=(const ChaiScript_Parser_Base &&) = delete;
-
-        template<typename T>
-        T &get_tracer()
-        {
-          // to do type check this somehow?
-          return *static_cast<T*>(get_tracer_ptr());
-        }
-
-      protected:
-        ChaiScript_Parser_Base(const ChaiScript_Parser_Base &) = default;
-    };
-  }
-
-  namespace eval
-  {
-    namespace detail
-    {
-      /// Special type for returned values
-      struct Return_Value {
-        Boxed_Value retval;
-
-        explicit Return_Value(Boxed_Value t_return_value) : retval(std::move(t_return_value)) { }
-      };
-
-
-      /// Special type indicating a call to 'break'
-      struct Break_Loop {
-        Break_Loop() = 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(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_ds->new_scope(m_ds.stack_holder());
-        }
-
-        ~Scope_Push_Pop()
-        {
-          m_ds->pop_scope(m_ds.stack_holder());
-        }
-
-
-        private:
-          const chaiscript::detail::Dispatch_State &m_ds;
-      };
-
-      /// Creates a new function call and pops it on destruction
-      struct Function_Push_Pop
-      {
-        Function_Push_Pop(Function_Push_Pop &&) = default;
-        Function_Push_Pop& operator=(Function_Push_Pop &&) = default;
-        Function_Push_Pop(const Function_Push_Pop &) = delete;
-        Function_Push_Pop& operator=(const Function_Push_Pop &) = delete;
-
-        explicit Function_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
-          : m_ds(t_ds)
-        {
-          m_ds->new_function_call(m_ds.stack_holder(), m_ds.conversion_saves());
-        }
-
-        ~Function_Push_Pop()
-        {
-          m_ds->pop_function_call(m_ds.stack_holder(), m_ds.conversion_saves());
-        }
-
-        void save_params(const std::vector<Boxed_Value> &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:
-          const chaiscript::detail::Dispatch_State &m_ds;
-      };
-
-      /// Creates a new scope then pops it on destruction
-      struct Stack_Push_Pop
-      {
-        Stack_Push_Pop(Stack_Push_Pop &&) = default;
-        Stack_Push_Pop& operator=(Stack_Push_Pop &&) = default;
-        Stack_Push_Pop(const Stack_Push_Pop &) = delete;
-        Stack_Push_Pop& operator=(const Stack_Push_Pop &) = delete;
-
-        explicit Stack_Push_Pop(const chaiscript::detail::Dispatch_State &t_ds)
-          : m_ds(t_ds)
-        {
-          m_ds->new_stack(m_ds.stack_holder());
-        }
-
-        ~Stack_Push_Pop()
-        {
-          m_ds->pop_stack(m_ds.stack_holder());
-        }
-
-
-        private:
-          const chaiscript::detail::Dispatch_State &m_ds;
-      };
-    }
-  }
-}
-
-#endif /* _CHAISCRIPT_COMMON_HPP */
-

include/chaiscript/language/chaiscript_optimizer.hpp

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

include/chaiscript/language/chaiscript_posix.hpp

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

include/chaiscript/language/chaiscript_prelude.hpp

@@ -1,562 +1,305 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and 2009-2017, Jason Turner (jason@emptycrate.com)
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_PRELUDE_HPP_
 #define CHAISCRIPT_PRELUDE_HPP_
 
-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";
-}
-
-};
-}
-
+//Note, the expression "[x,y]" in "collate" is parsed as two separate expressions
+//by C++, so CODE_STRING, takes two expressions and adds in the missing comma
+#define CODE_STRING(x, y) #x ", " #y 
+
+#define chaiscript_prelude CODE_STRING(\
+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 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 len = y.size(); \n\
+  var i = 0; \n\
+  while (i < len) { \n\
+    retval.push_back(y[i]); \n\
+    ++i; \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 find(str, substr) { \n\
+  int(find(str, substr, size_t(0))); \n\
+} \n\
+# Returns the position of last match of the second value string in the first value string\n\
+def rfind(str, substr) { \n\
+  int(rfind(str, substr, size_t(-1))); \n\
+} \n\
+# Returns the position of the first match of elements in the second value string in the first value string\n\
+def find_first_of(str, list) { \n\
+  int(find_first_of(str, list, size_t(0))); \n\
+} \n\
+# Returns the position of the last match of elements in the second value string in the first value string\n\
+def find_last_of(str, list) { \n\
+  int(find_last_of(str, list, size_t(-1))); \n\
+} \n\
+# Returns the position of the first non-matching element in the second value string in the first value string\n\
+def find_first_not_of(str, list) { \n\
+  int(find_first_not_of(str, list, size_t(0))); \n\
+} \n\
+# Returns the position of the last non-matching element in the second value string in the first value string\n\
+def find_last_not_of(str, list) { \n\
+  int(find_last_not_of(str, list, size_t(-1))); \n\
+} \n\
+def ltrim(str) { \n\
+  drop_while(str, fun(x) { x == ' ' || x == '\t' }); \n\
+} \n\
+def rtrim(str) { \n\
+  reverse(drop_while(reverse(str), fun(x) { x == ' ' || x == '\t' })); \n\
+} \n\
+def trim(str) { \n\
+  ltrim(rtrim(str)); \n\
+} \
+)
 #endif /* CHAISCRIPT_PRELUDE_HPP_ */

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -1,830 +0,0 @@
-/// This file is not technically part of the ChaiScript API. It is used solely for generating Doxygen docs
-/// regarding the ChaiScript standard runtime library.
-
-/// \brief Items in this namespace exist in the ChaiScript language runtime. They are not part of the C++ API
-namespace ChaiScript_Language
-{
-
-/// \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 
-/// to all standard ChaiScript applications, and provides a simple foundation for using numbers, strings, and ranges 
-/// (the general category of Range cs and their iteration).
-///
-
-
-/// \brief Generic concept of a value in ChaiScript. 
-///
-/// The Object type exists merely as a concept. All objects in ChaiScript support this concept 
-/// and have the following methods available to them. All objects are stored internally as chaiscript::Boxed_Value types.
-///
-/// \sa chaiscript::Boxed_Value
-class Object
-{
-  public:
-    /// \brief Returns the Type_Info value for this Object
-    Type_Info get_type_info() const;
-
-    /// \brief Returns true if the Object is of the named type
-    bool is_type(string) const;
-
-    /// \brief Returns true if the Object is of the Type_Info passed in
-    bool is_type(Type_Info) const;
-
-    /// \brief Returns true if the Object is immutable
-    bool is_var_const() const;
-
-    /// \brief Returns true if the Object is a pointer and the pointer is null
-    bool is_var_null() const;
-
-    /// \brief Returns true if the Object is stored as a pointer
-    bool is_var_pointer() const;
-
-    /// \brief Returns true if the Object is stored as a reference    
-    bool is_var_reference() const;
-
-    /// \brief Returns true if the Object does not contain a value is is undefined.
-    bool is_var_undef() const;
-
-    /// \brief Returns the registered name of the type of the object. 
-    ///
-    /// \sa Type_Info::name();
-    string type_name() const;
-};
-
-/// \brief Item returned from a Range object from a Map
-class Map_Pair
-{
-  public:
-    /// \brief Returns the key of the Map entry
-    const string first();
-
-    /// \brief Returns the value Object of the Map entry 
-    Object second();
-};
-
-
-/// \brief Maps strings to Objects
-///
-/// ChaiScript has a built in shortcut for generating Map objects:
-/// 
-/// Example:
-/// \code
-/// eval> var m = ["a":1, "b":2];
-/// [<a,1>, <b,2>]
-/// eval> m.count("a");
-/// 1
-/// eval> m.count("c");
-/// 0
-/// eval> m.size();
-/// 2
-/// \endcode
-///
-/// Implemented as std::map<Boxed_Value>
-///
-/// \sa Map_Pair
-/// \sa chaiscript::bootstrap::standard_library::map_type
-class Map
-{
-  public:
-    /// \brief Returns an object that implements the Range concept for the Map_Pair's in this Map
-    Range range();
-
-    /// \brief Returns an object that implements the Const_Range concept for the Map_Pair's in this Map
-    Const_Range range() const;
-
-    /// \brief Returns the number of elements in the Map
-    int size() const;
-
-    /// \brief Returns the item at the given key, creating an undefined Object if the key does not yet exist in the map
-    Object operator[](string);
-
-    /// \brief Clears the map of all items
-    void clear();
-
-    /// \brief Returns the number of items in the Map with the given key. Returns 0 or 1 since this is not an std::multimap.
-    int count(string) const;
-
-    /// \brief Returns true if the map contains no items
-    bool empty() const;
-
-};
-
-
-/// \brief A concept implemented by string, Vector and Map. It is convertible to Range, default constructable and back_insertable
-class Container
-{
-  public:
-    void push_back(Object);
-    Range range();
-    Const_Range range() const;
-};
-
-
-/// \brief Converts o into a string.
-///
-/// \code
-/// eval> to_string(3).is_type("string") <br>
-/// true<br>
-/// \endcode
-string to_string(Object o);
-
-
-/// \brief Prints o to the terminal, without a trailing carriage return. Applies conversions to string automatically.
-/// \code
-/// eval> puts("hi, "); puts("there")
-/// hi, thereeval>
-/// \endcode
-/// \sa to_string
-/// \sa print
-void puts(Object o);
-
-
-/// \brief Prints o to the terminal, with a trailing carriage return. Applies conversions to string automatically
-/// \code
-/// eval> print("hello")
-/// hello
-/// eval>
-/// \endcode
-/// \sa to_string
-/// \sa puts
-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 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 pass-throughs to the
-/// std::string of the same name. 
-///
-/// \note Object and function notations are equivalent in ChaiScript. This means that
-///       \c "bob".find("b") and \c find("bob", "b") are exactly the same. Most examples below follow the
-///       second formation of the function calls.
-/// \sa \ref keyworddef for extending existing C++ classes in ChaiScript
-/// \sa chaiscript::bootstrap::standard_library::string_type
-class string
-{
-  public:
-    /// \brief Finds the first instance of substr.
-    /// \code
-    /// eval> find("abab", "ab")
-    /// 0
-    /// \endcode
-    int find(string s) const;
-
-
-    /// \brief Finds the last instance of substr.
-    /// \code
-    /// eval> rfind("abab", "ab")
-    /// 2
-    /// \endcode
-    int rfind(string s) const;
-
-    /// \brief Finds the first of characters in list in the string.
-    ///
-    /// \code
-    /// eval> find_first_of("abab", "bec")
-    /// 1
-    /// \endcode
-    int find_first_of(string list) const;
-
-    /// \brief Finds the last of characters in list in the string.
-    ///
-    /// \code
-    /// eval> find_last_of("abab", "bec")
-    /// 3
-    /// \endcode
-    int find_last_of(string list) const;
-
-    /// \brief Finds the first non-matching character to list in the str string.
-    ///
-    /// \code
-    /// eval> find_first_not_of("abcd", "fec")
-    /// 0
-    /// \endcode
-    int find_first_not_of(string list) const;
-
-    /// \brief Finds the last non-matching character to list in the list string.
-    ///
-    /// \code
-    /// eval> find_last_not_of("abcd", "fec")
-    /// 3
-    /// \endcode 
-    int find_last_not_of(string list) const;
-
-    /// \brief Removes whitespace from the front of the string, returning a new string
-    ///
-    /// \note This function is implemented as a ChaiScript function using the def member function notation.
-    ///
-    /// \code
-    /// eval> ltrim("  bob")
-    /// bob
-    /// \endcode
-    ///
-    /// \sa \ref keyworddef
-    string lstrim() const;
-
-    /// \brief Removes whitespace from the back of the string, returning a new string
-    ///
-    /// \note This function is implemented as a ChaiScript function using the def member function notation.
-    ///
-    /// \code
-    /// eval> rtrim("bob  ") + "|"
-    /// bob|
-    /// \endcode
-    ///
-    /// \sa \ref keyworddef
-    string rtrim() const;
-
-    /// \brief Removes whitespace from the front and back of the string, returning a new string
-    ///
-    /// \note This function is implemented as a ChaiScript function using the def member function notation.
-    ///
-    /// \code
-    /// eval> trim("  bob  ") + "|"
-    /// bob|
-    /// \endcode
-    /// 
-    /// Equivalent to rtrim(ltrim("  bob  "));
-    ///
-    /// \sa \ref keyworddef
-    string trim() const;
-
-    /// \brief Returns the character at the given index in the string, const version
-    const char &operator[](int t_index) const;
-
-    /// \brief Returns the character at the given index in the string
-    char &operator[](int t_index);
-
-    /// \brief Returns underlying const char * for C api compatibility
-    const char *c_str() const;
-
-    /// \brief Returns a pointer to the raw data in the string
-    const char *data() const;
-
-    /// \brief Resets the string to empty
-    void clear();
-
-    /// \brief Returns true if the string is empty
-    bool empty() const;
-
-    /// \brief Returns the size of the string in bytes.
-    ///
-    /// This function normally returns size_t in C++. In ChaiScript the return value is cast to int
-    /// for ease of use.
-    int size() const;
-
-    /// \brief Returns an object that implements the Range concept for the characters of this string
-    Range range();
-
-    /// \brief Returns an object that implements the Const_Range concept for the characters of this string
-    Const_Range range() const;
-};
-
-/// \brief A concept in ChaiScript that is implemented by \ref string, Vector and Map. It provides
-///        easy iteration over the elements in a container.
-///
-/// Implemented by the template chaiscript::bootstrap::standard_library::Bidir_Range
-///
-/// \sa Const_Range
-class Range
-{
-  public:
-    /// \brief Returns the last item of the range
-    Object back();
-
-    /// \brief Returns true if the front and back pointers have passed each other, if no items
-    ///        are left in the Range
-    bool empty() const;
-
-    /// \brief Returns the first item of the range
-    Object front();
-
-    /// \brief Moves the back pointer back one.
-    /// 
-    /// \post back() returns the element at back() - 1;
-    void pop_back();
-
-    /// \brief Moves the front pointer forward one
-    /// 
-    /// \post front() returns the element at front() + 1;
-    void pop_front();
-
-};
-
-/// \brief A concept in ChaiScript that is implemented by \ref string, Vector and Map. It provides
-///        easy iteration over the elements in a container. Contained values are const.
-///
-/// Implemented by the template chaiscript::bootstrap::standard_library::Const_Bidir_Range
-///
-/// \sa Range
-class Const_Range
-{
-  public:
-    /// \brief Returns the last item of the range
-    const Object back();
-
-    /// \brief Returns true if the front and back pointers have passed each other, if no items
-    ///        are left in the Range
-    bool empty() const;
-
-    /// \brief Returns the first item of the range
-    const Object front();
-
-    /// \brief Moves the back pointer back one.
-    /// 
-    /// \post back() returns the element at back() - 1;
-    void pop_back();
-
-    /// \brief Moves the front pointer forward one
-    /// 
-    /// \post front() returns the element at front() + 1;
-    void pop_front();
-
-};
-
-/// \brief A vector of Objects
-///
-/// ChaiScript includes a shortcut for creating a Vector of Objects
-/// 
-/// Example:
-/// \code
-/// eval> var v = [1,2,3,4]
-/// [1, 2, 3, 4]
-/// eval> v[0];
-/// 1
-/// eval> v.size();
-/// 4
-/// \endcode 
-///
-/// Implemented with std::vector<chaiscript::Boxed_Value>
-/// 
-/// \sa chaiscript::bootstrap::standard_library::vector_type
-class Vector
-{
-  public:
-    /// \brief returns the Object at the given index. Throws an exception if the index does not exist
-    Object operator[](int t_index);
-
-    /// \brief returns a const Object at the given index. Throws an exception if the index does not exist.
-    const Object operator[](int t_index) const;
-
-    /// \brief returns the last item in the Vector
-    Object back();
-
-    /// \brief Clears the Vector of all items
-    void clear();
-
-    /// \brief Returns true if the Vector is contains 0 items
-    bool empty();
-
-    /// \brief Erases the element at the given index
-    void erase_at(int t_index);
-
-    /// \brief Returns the first item in the Vector
-    Object front();
-
-    /// \brief Inserts a new item in the Vector at the given index. The item is not cloned on insert
-    /// 
-    /// \sa insert_ref
-    void insert_ref_at(int, Object);
-
-    /// \brief Inserts a new item in the Vector at the given index. The item is cloned on insert
-    /// 
-    /// \sa insert_ref
-    void insert_at(int, Object);
-   
-    /// \brief Removes the last item from the Vector
-    void pop_back();
-
-    /// \brief Adds an item to the end of the Vector. The item is not cloned.
-    ///
-    /// \sa push_back
-    void push_back_ref(Object);
-
-    /// \brief Adds an item to the end of the Vector. The item is cloned.
-    ///
-    /// \sa push_back_ref
-    void push_back(Object);
-
-    /// \brief Returns a Range object for the entire vector
-    Range range();
-
-    /// \brief Returns a Const_Range object for the entire vector
-    Const_Range range() const;
-
-    /// \brief Returns the number of elements in the Vector
-    int size() const;
-
-};
-
-class Type_Info
-{
-  public:
-    /// \brief Compares this Type_Info object with another one and returns true if the two types are the same
-    ///        after const, pointer, reference are removed.
-    bool bare_equal(Type_Info t_ti) const;
-
-    /// \brief Returns the mangled C++ name for the type given by the compiler after const, pointer, reference is removed.
-    string cpp_bare_name() const;
-
-    /// \brief Returns the mangled C++ name for the type given by the compiler.
-    string cpp_name() const;
-
-    /// \brief Returns true if the type is const
-    bool is_type_const() const;
-
-    /// \brief Returns true if the type is a pointer
-    bool is_type_pointer() const;
-
-    /// \brief Returns true if the type is a reference 
-    bool is_type_reference() const;
-
-    /// \brief Returns true if the type is undefined 
-    bool is_type_undef() const;
-
-    /// \brief Returns true if the type is "void"
-    bool is_type_void() const;
-
-    /// \brief Returns the ChaiScript registered name for the type if one exists.
-    string name() const;
-
-};
-
-
-/// \brief Represents a function object in ChaiScript
-///
-/// A function object may be one function, such as:
-/// \code
-/// var f = fun(x) { return x; }
-/// \endcode
-/// 
-/// Or it may represent multiple functions
-/// \code
-/// var f2 = `-`; // represents the unary - as well as the set of binary - operators
-/// \endcode
-///
-/// Guarded function example
-/// \code
-/// def f3(x) : x > 2 {
-///  return x;
-/// }
-/// \endcode
-///
-/// Examples in the function definitions below will reference these examples
-class Function
-{
-  public:
-    /// \brief Returns the annotation description of the function
-    string get_annotation() const;
-
-    /// \brief Returns the arity of the function, -1 if the function takes a variable number of parameters
-    ///
-    /// Example:
-    /// \code
-    /// eval> f.get_arity()
-    /// 1
-    /// eval> f2.get_arity()
-    /// -1
-    /// \endcode
-    int get_arity() const;
-
-    /// \brief Returns a vector of the contained functions
-    /// 
-    /// Example:
-    /// \code
-    /// eval> f.get_contained_functions().size()
-    /// 0
-    /// eval> f2.get_contained_functions().size()
-    /// 11
-    /// eval> var v = f2.get_contained_functions();
-    /// v[0].get_arity()
-    /// 2
-    /// \endcode
-    Vector get_contained_functions() const;
-
-    /// \brief Returns a function guard as function
-    /// 
-    /// Example:
-    /// \code
-    /// eval> f.get_guard() // Throws exception
-    /// Function does not have a guard
-    /// eval> f3.get_guard().get_arity()
-    /// 1
-    /// \endcode
-    Function get_guard() const;
-
-    /// \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 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. 
-    /// 
-    /// For each parameter that is the same type, the type is returned. If the types are different
-    /// then a Type_Info for Object is returned.
-    ///
-    /// Example:
-    /// \code
-    /// eval> f2.get_param_types().size(); // Returns a Type_Info for Object for the return type
-    /// 1
-    /// \endcode
-    Vector get_param_types() const;
-
-    /// \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;
-    /// 
-    /// Example:
-    /// \code
-    /// eval> `-`.call([2,1]);
-    /// 1
-    /// \endcode
-    Object call(Vector t_params) const;
-}
-
-
-
-/// \brief Returns the max of a or b. Requires that operator>(a, b) exists
-/// Equivalent to 
-/// \code
-/// return a>b?a:b;
-/// \endcode
-///
-/// Example:
-/// \code
-/// eval> max(4, 10)
-/// 10
-/// \endcode
-Object max(Object a, Object b);
-
-/// \brief Returns the min of a or b. Requires that operator<(a, b) exists
-///
-/// Equivalent to 
-/// \code
-/// return a<b?a:b;
-/// \endcode
-///
-/// Example:
-/// \code
-/// eval> min(4, 10)
-/// 4
-/// \endcode
-Object min(Object a, Object b);
-
-/// \brief Returns true if x is an even integer. 
-/// 
-/// Will also work on any non-integer type for which an operator%(x, int) exists
-///
-/// Example:
-/// \code
-/// eval> even(4)
-/// true
-/// \endcode
-bool even(Object x);
-
-/// \brief Returns true if x is an odd integer. 
-/// 
-/// Will also work on any non-integer type for which an operator%(x, int) exists
-///
-/// Example:
-/// \code
-/// eval> odd(4)
-/// false 
-/// \endcode
-bool even(Object x);
-
-
-/// \brief Applies the function f over each element in the Range c.
-///
-/// Example:
-/// \code
-/// eval> for_each([1, 2, 3], print)
-/// 1
-/// 2
-/// 3
-/// \endcode
-void for_each(Range c, Function f);
-
-
-/// \brief Applies f over each element in the Range c, joining all the results.
-///
-/// Example:
-/// \code
-/// eval> map([1, 2, 3], odd)
-/// [true, false, true]
-/// \endcode
-Object map(Range c, Function f);
-
-
-/// \brief Starts with the initial value and applies the function f to it and the first element of the Range c. 
-///        The result is then applied to the second element, and so on until the elements are exhausted.
-///
-/// Example:
-/// \code
-/// eval> foldl([1, 2, 3, 4], `+`, 0)
-/// 10
-/// \endcode
-Object foldl(Range c, Function f, Object initial);
-
-
-/// \brief Returns the sum total of the values in the Range c.
-///
-/// Example:
-/// \code
-/// eval> sum([1, 2, 3, 4])
-/// 10
-/// \endcode
-///
-/// Equivalent to:
-/// \code
-/// foldl(c, `+`, 0.0);
-/// \endcode
-Numeric sum(Range c);
-
-
-/// \brief Returns the product of the value in the Range c.
-///
-/// Example:
-/// \code
-/// eval> product([1, 2, 3, 4])
-/// 24
-/// \endcode
-///
-/// Equivalent to:
-/// \code
-/// foldl(c, `*`, 1.0);
-/// \endcode
-Numeric product(Range c);
-
-
-/// \brief Takes num elements from the Range c, returning them.
-///
-/// Example:
-/// \code
-/// eval> take([1, 2, 3, 4], 2)
-/// [1, 2]
-/// \endcode
-///
-/// \returns A container of the same type that was passed in
-Object take(Range c, int num);
-
-
-/// \brief Takes elements from the Range c that match function f, stopping at the first non-match, returning them as a new Vector.
-///
-/// Example:
-/// \code
-/// eval> take_while([1, 2, 3], odd)
-/// [1]
-/// \endcode
-///
-/// \returns A container of the same type that was passed in
-Object take_while(Range c, Function f);
-
-
-/// \brief Drops num elements from the Range c, returning the remainder.
-///
-/// Example:
-/// \code
-/// eval> drop([1, 2, 3, 4], 2)
-/// [3, 4]
-/// \endcode
-///
-/// \returns A container of the same type that was passed in
-Object drop(Range c, int num);
-
-
-/// \brief Drops elements from the Range c that match f, stopping at the first non-match, returning the remainder.
-///
-/// Example:
-/// \code
-/// eval> drop_while([1, 2, 3], odd)         
-/// [2, 3]
-/// \endcode
-Object drop_while(Range c, Function f);
-
-
-/// \brief Similar to foldl, this takes the first two elements as its starting values for f. This assumes Range c has at least 2 elements.
-///
-/// Example:
-/// \code
-/// eval> reduce([1, 2, 3, 4], `+`)
-/// 10
-/// \endcode
-Object reduce(Range c, Function f);
-
-
-/// \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(Container c, Function f);
-
-
-/// \brief Joins the elements of the Range c into a string, delimiting each with the delim string.
-///
-/// Example:
-/// \code
-/// eval> join([1, 2, 3], "*") 
-/// 1*2*3
-/// \endcode
-string join(Range c, string delim);
-
-
-/// \brief Returns the contents of the Container c in reversed order.
-///
-/// Example:
-/// \code
-/// eval> reverse([1, 2, 3, 4, 5, 6, 7])
-/// [7, 6, 5, 4, 3, 2, 1]
-/// \endcode
-Container reverse(Container c);
-
-
-/// \brief Generates a new Vector filled with values starting at x and ending with y.
-///
-/// Works on types supporting operator<=(x, y) and operator++(x)
-///
-/// Example:
-/// \code
-/// eval> generate_range(1, 10)
-/// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-/// \endcode
-Vector generate_range(Object x, Object y);
-
-
-/// \brief Returns a new Range with x and y concatenated.
-///
-/// Example:
-/// \code
-/// eval> concat([1, 2, 3], [4, 5, 6])
-/// [1, 2, 3, 4, 5, 6]
-/// \endcode
-Object concat(Range x, Range y);
-
-
-/// \brief Returns a new Vector with x and y as its values.
-///
-/// Example:
-/// \code
-/// eval> collate(1, 2)
-/// [1, 2]
-/// \endcode
-Vector collate(Object x, Object y);
-
-
-/// \brief Applies f to elements of x and y, returning a new Vector with the result of each application.
-///
-/// Example:
-/// \code
-/// eval> zip_with(`+`, [1, 2, 3], [4, 5, 6])
-/// [5, 7, 9]
-/// \endcode
-Vector zip_with(Function f, Range x, Range y);
-
-
-/// \brief Collates elements of x and y, returning a new Vector with the result.
-///
-/// Example:
-/// \code
-/// eval> zip([1, 2, 3], [4, 5, 6])
-/// [[1, 4], [2, 5], [3, 6]]
-/// \endcode
-Vector zip(Range x, Range y);
-
-
-/// \brief returns true if there exists a call to the Function f that takes the given parameters
-///
-/// Example:
-/// \code
-/// eval> call_exists(`+`, 1, 2)
-/// true
-/// \endcode
-bool call_exists(Function f, ...);
-
-/// \brief Reverses a Range object so that the elements are accessed in reverse
-Range retro(Range);
-
-/// \brief Reverses a Const_Range object so that the elements are accessed in reverse
-Const_Range retro(Const_Range);
-
-
-/// \brief Raises the given object as an exception. Any type of object can be thrown.
-///
-/// Example:
-/// \code
-/// eval> try { throw(1); } catch (e) { print("Exception caught: " + to_string(e)); }
-/// Exception caught: 1
-/// \endcode
-/// 
-/// \sa \ref keywordtry
-void throw(Object); 
-}
-

include/chaiscript/language/chaiscript_tracer.hpp

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

include/chaiscript/language/chaiscript_unknown.hpp

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

include/chaiscript/language/chaiscript_windows.hpp

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

include/chaiscript/utility/fnv1a.hpp

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

include/chaiscript/utility/json.hpp

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

include/chaiscript/utility/json_wrap.hpp

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

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

include/chaiscript/utility/utility.hpp

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

license.txt

@@ -1,7 +1,4 @@
-Copyright 2009-2016 Jason Turner
-Copyright 2009-2012 Jonathan Turner. 
-
-All Rights Reserved.
+Copyright 2009 Jason and 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:

msvc/chai-example/chai-example.vcproj

@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="chai-example"
+	ProjectGUID="{CE422E94-B360-4588-8C65-6A9BE80798F9}"
+	RootNamespace="chaiexample"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			CharacterSet="0"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			CharacterSet="0"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\example.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

msvc/chaiscript/Boost.vsprops

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="Boost"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		AdditionalIncludeDirectories="&quot;C:\boost\include\boost-1_38&quot;"
+	/>
+	<Tool
+		Name="VCLibrarianTool"
+		AdditionalLibraryDirectories="C:\Programming\Boost\lib"
+	/>
+	<Tool
+		Name="VCLinkerTool"
+		AdditionalLibraryDirectories="C:\Boost\lib"
+	/>
+</VisualStudioPropertySheet>

msvc/chaiscript/chaiscript.sln

@@ -0,0 +1,32 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual C++ Express 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chaiscript", "chaiscript.vcproj", "{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chai-example", "..\chai-example\chai-example.vcproj", "{CE422E94-B360-4588-8C65-6A9BE80798F9}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_module", "..\test_module\test_module.vcproj", "{775EDCC2-102F-4E75-A860-9AF398D04145}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Debug|Win32.Build.0 = Debug|Win32
+		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.ActiveCfg = Release|Win32
+		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.Build.0 = Release|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.Build.0 = Debug|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.ActiveCfg = Release|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.Build.0 = Release|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Debug|Win32.ActiveCfg = Debug|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Debug|Win32.Build.0 = Debug|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Release|Win32.ActiveCfg = Release|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

msvc/chaiscript/chaiscript.vcproj

@@ -0,0 +1,278 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="chaiscript"
+	ProjectGUID="{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}"
+	RootNamespace="chaiscript"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets=".\Boost.vsprops"
+			UseOfMFC="2"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				UseUnicodeResponseFiles="false"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DisableLanguageExtensions="false"
+				TreatWChar_tAsBuiltInType="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+				CompileAs="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets=".\Boost.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\main.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\bootstrap.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\bootstrap_stl.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\boxed_value.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\chaiscript.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\language\chaiscript_engine.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\language\chaiscript_eval.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\language\chaiscript_parser.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\language\chaiscript_prelude.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\chaiscript_threading.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\dispatchkit.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\dynamic_object.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\function_call.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\function_call_detail.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\handle_return.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_constructors.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_functions.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_functions_detail.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\register_function.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\type_info.hpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

msvc/test_module/test_module.vcproj

@@ -0,0 +1,198 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="test_module"
+	ProjectGUID="{775EDCC2-102F-4E75-A860-9AF398D04145}"
+	RootNamespace="test_module"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			UseOfMFC="0"
+			CharacterSet="0"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;TEST_MODULE_EXPORTS"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;TEST_MODULE_EXPORTS"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\test_module.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

performance_tests/heterogenous_array_loop.chai

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

@@ -1,26 +0,0 @@
-def isprime(n)
-{
-  for (var i = 2; i < n; ++i)
-  {
-    if (n % i == 0) {return false}
-  }
-
-  return true
-}
-
-
-def primes(n)
-{
-  var count = 0
-  for (var i = 2; i <= n; ++i)
-  {
-    if (isprime(i)) {++count}
-  }
-
-  return count
-}
-
-
-var N = 5000
-
-print("primes: " + primes(N).to_string())

performance_tests/profile_cpp_calls.chai

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

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

@@ -1,20 +0,0 @@
-#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/profile_math.chai

@@ -1,9 +0,0 @@
-
-var something = 0;
-
-for (var i = 1; i < 10000; ++i)
-{
-  something += int(3 % 2 * 4 + 2 / 16.0 - 100 + (10 ^ 19) / 64 + (3 & 12) - (4 | 14)) % i;
-}
-
-print(something);

performance_tests/type_conversions.chai

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

@@ -1,107 +0,0 @@
-<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-2017 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 "samples" directory. Example.cpp is verbose and shows every 
-possible way of working with the library. For further documentation generate 
-the doxygen documentation in the build folder or see the website 
-http://www.chaiscript.com.
-
-
-The shortest complete example possible follows:
-
-```C++
-/// 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);");
-}
-```

readme.txt

@@ -0,0 +1,36 @@
+ChaiScript v1.0 
+http://www.chaiscript.com
+(c) 2009 Jason Turner and Jonathan Turner
+Release under the BSD license, see "license.txt" for details.
+
+[Introduction]
+
+ChaiScript is one of the first (and perhaps only) embedded scripting language designed from the ground up to directly target C++.  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_Engine 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 register_function:
+
+dispatchkit::register_function(chai.get_eval_engine(), &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 example of how to register parts of your C++ application, see "example.cpp" in the "src" directory.

releasenotes.md

@@ -1,299 +0,0 @@
-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 ) { }` (much better performance than other loop types)
-* If-init expressions (ala C++17)
-* Support for passing r-value references to functions
-* Support for containing unique_ptr
-* Add helpers for exposing enum classes to ChaiScript
-* Allow typed ChaiScript defined functions to perform conversions on call #303
-
-#### Improvements
-
-* Compile time improvements
-* Compile size improvements
-* Significant runtime improvements (see "Modular optimization system")
-* Significant parser improvements, both with parse-time and parser initialization time (Thanks @niXman)
-* Fix type conversion to bool in conditionals
-
-#### Improvements Still Need To Be Made
-
-* File location tracking has been rewritten; this currently means error location reporting is not as good as it was
-* Tracing capability needs to be tested and vetted
-
-### Changes since 5.8.5
-* Optimize away `return` statements in lambdas also
-* Allow conversions to bool in conditionals
-* Don't allow `class` statements inside of scopes
-* Properly error when a dynamic object non-function member is called
-
-### Changes since 5.8.4
-* Fix order of operations for prefix operators
-* Make sure atomics are initialized properly
-* Remove parsing of unused prefix `&` operator
-
-### Changes since 5.8.3
-* Fix case with some numeric conversions mixed with numerics that do not need conversion
-
-### Changes since 5.8.2
-* Add support for reference of pointer return types
-
-### Changes since 5.8.1
-* Allow casting to non-const & std::shared_ptr<T>
-
-
-### Changes since 5.8.0
-* Fix parsing of floats to be locale independent #250
-* Various warning fixes on various platforms
-
-
-### Changes since 5.7.1
-* Make all parser iterator operations range checked
-* Parse in-string eval statements once, not once for each execution
-* Fix parsing of operators (ie 1<-1 now parses)
-* Fix variable scoping for functors
-* Exception reduction
-* Various object lifetime fixes
-* Add JSON support for load / save #207
-* Numeric overload resolution fixes #209 
-* Fix long long #208 
-* Add octal escapes in strings #211
-* Fixed sizing of binary literals #213
-* Added support for != with bool values #217
-* Various value assignment vector fixes 
-* Fixed broken hex escape sequences from @ChristianKaeser
-* Multiply defined symbols fixes #232 @RaptorFactor
-* Add add_class<Enum> helper #233  @vrennert
-* Cheatsheet fixes #235 @mlamby
-* Fix parsing of strings inside of in-string eval statements
-* Allow lower-case global keyword
-* Enable thread-local on MSVC (should be significant performance boost)
-
-
-### Changes since 5.7.0
-* Build time reduction
-* Build size reduction
-* Performance increases
-* Fixed ~20 crash-bugs found with fuzzy testing #194
-  * Let unhandled exceptions propogate to user
-  * Report eval_error when break statement is not in loop
-  * Fix handling of 0 length scripts closes #193
-  * Don't crash on arity mismatch - Specifically affects the case where no overloads exist for a given function
-  * Fix error printing for `bind` calls
-  * Handle unexpected continue statement
-  * Check arity during bind
-  * Don't allow arith conversion on variadic function
-  * Correct `bind` parameter match count
-  * Add in expected Boxed_Value exception cases
-  * Check access to AST, don't allow `;` in func def
-  * Don't attempt arithmetic unary & call
-  * Don't crash on 0 param call to `bind`
-  * Catch errors during member function dispatch
-  * Properly handle type of const bool &
-* Automatic deduction of lambda type signatures
-* Work with non-polymorphic parent/child conversions
-* Move to codecov for coverage reporting
-* Add `.at` method for Map objects
-* Various corrections for support of move-only objects
-
-
-### Changes since 5.6.0
-
-* 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 

run_unit_tests.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+
+successes=0
+failures=0
+
+echo -n "Running unit tests"
+for file in unittests/*.chai
+do
+  tstname=${file%.*}
+	tst="$tstname.txt"
+	LD_LIBRARY_PATH=. ./chaiscript_eval $file > /tmp/tstout.txt
+	diff $tst /tmp/tstout.txt
+	if [ "$?" -eq "0" ]
+	then
+		echo -n "."
+		successes=$((successes+1))
+	else
+		echo "[from failed test $file]"
+		failures=$((failures+1))
+	fi
+done
+echo ""
+
+total=$((successes+failures))
+echo "$successes out of $total succeeded"