Update release notes for 5.3.1

discovered by @axelstudios

.travis.yml

@@ -0,0 +1,31 @@
+language: cpp
+compiler:
+  - gcc
+env:
+  - GCC_VER=4.6
+  - GCC_VER=4.8
+before_install:
+  - sudo pip install cpp-coveralls
+  - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+  - sudo apt-get update
+  - sudo apt-get install -qq g++-4.8
+  - if [ "$GCC_VER" = "4.8" ]; then export CXX="g++-4.8" CC="gcc-4.8" GCOV="gcov-4.8"; else export CXX="g++-4.6" CC="gcc-4.6" GCOV="gcov-4.6"; fi
+script: 
+  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug .
+  - make -j2
+  - make test
+  - mkdir gcov
+  - find CMakeFiles/ -name "*.gc*" -exec mv {} gcov/ \;
+  - $GCOV -d -o gcov gcov/*.gcda
+  - coveralls -n -E ".*\.cpp"
+after_script:
+  - contrib/codeanalysis/runcppcheck.sh
+notifications:
+  email:
+    recipients:
+      - jason@emptycrate.com
+    on_success: always
+    on_failure: always
+env:
+  global:
+    secure: eiaR6pXiiEpyB8+LLQ1NvZdl0Yylru1BLy9lMoHl+IpUNGGQGywmW/2WAn77rFfmR1OPA2qWQLfgPwgK0HxUA9HHlot9tre5QhiN2Lw8NOT8tCZ6tTm2+QntDBjBGJyal/knRvQkn/6qs6GxlXRerz4ArnnuPL1vESt3zwB0YtU=

CMakeLists.txt

@@ -2,10 +2,47 @@ cmake_minimum_required(VERSION 2.8)
 
 project(chaiscript)
 
-option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
+# MINGW does not yet support C++11's concurrency features
+if(MINGW)
+  option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" FALSE)
+else()
+  option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
+endif()
+
+
 option(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
 option(BUILD_SAMPLES "Build Samples Folder" FALSE)
 
+
+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_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()
+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")
@@ -16,21 +53,20 @@ 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 4)
+set(CPACK_PACKAGE_VERSION_MAJOR 5)
 set(CPACK_PACKAGE_VERSION_MINOR 3)
-set(CPACK_PACKAGE_VERSION_PATCH 0)
+set(CPACK_PACKAGE_VERSION_PATCH 1)
+
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
 set(CPACK_PACKAGE_CONTACT "contact@chaiscript.com")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "An embedded scripting language for C++")
 
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libboost-dev (>=1.36.0)")
 set(CPACK_DEBIAN_PACKAGE_SECTION "devel")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 
 set(CPACK_RPM_PACKAGE_LICENSE "BSD")
 set(CPACK_RPM_PACKAGE_GROUP "Programming")
-set(CPACK_RPM_PACKAGE_REQUIRES "boost-devel >= 1.36.0, boost-thread >= 1.36.0")
 
 set(CHAI_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
 
@@ -39,84 +75,130 @@ configure_file(Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile)
 include(CTest)
 include(CPack)
 
-find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+include(cmake/CheckCXX11Features.cmake)
+
+if(NOT MINGW)
+  find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+endif()
+
+if(HAS_CXX11_VARIADIC_TEMPLATES)
+  message(STATUS "Variadic Template support detected")
+else()
+  message(SEND_ERROR "The selected compiler does not support the C++11 feature Variadic Templates.")
+endif()
 
 enable_testing()
 
 
 message(STATUS "Detecting readline support")
-if (READLINE_LIBRARY)
-    message(STATUS "Found: ${READLINE_LIBRARY}")
-    set (READLINE_LIB readline)
-    add_definitions(/DREADLINE_AVAILABLE)
-else(READLINE_LIBRARY)
-    message(STATUS "Not Found")
-    set (READLINE_LIB )
-    set (READLINE_FLAG )
-endif(READLINE_LIBRARY)
+if(READLINE_LIBRARY)
+  message(STATUS "Found: ${READLINE_LIBRARY}")
+  set(READLINE_LIB readline)
+  add_definitions(/DREADLINE_AVAILABLE)
+else()
+  message(STATUS "Not Found")
+  set(READLINE_LIB)
+  set(READLINE_FLAG)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC)
+  execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+
+  if(GCC_VERSION VERSION_LESS 4.8)
+    set(CPP11_FLAG "-std=c++0x")
+  else()
+    set(CPP11_FLAG "-std=c++11")
+  endif()
+else()
+  set(CPP11_FLAG "-std=c++11")
+endif()
 
 if(MSVC)
-  add_definitions(/W4)
-  if(CMAKE_CL_64)
-    add_definitions(/bigobj)
-   endif()
+  add_definitions(/W4 /w44640)
+  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 -Wshadow -pedantic)
+  add_definitions(-Wall -Wextra -Wshadow -Wnon-virtual-dtor -pedantic ${CPP11_FLAG})
 
-  if (APPLE)
-    # -Wno-missing-field-initializers is for boost on macos
-    add_definitions(-Wno-missing-field-initializers -Wno-sign-compare)
+  if(APPLE)
+    add_definitions(-Wno-sign-compare)
   endif()
 endif()
 
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  option(USE_LIBCXX "Use clang's libcxx" TRUE)
+
+  if(USE_LIBCXX)
+    add_definitions(-stdlib=libc++)
+    set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG} -stdlib=libc++")
+  else()
+    set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG}")
+  endif()
+elseif(CMAKE_COMPILER_IS_GNUCC)
+  set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG}")
+endif()
+
+# limitations in MinGW require us to make an optimized build
+# for the sake of object sizes or something
+if(MINGW OR CYGWIN)
+  add_definitions(-O3)
+endif()
+
 include_directories(include)
 
-set(Boost_ADDITIONAL_VERSIONS "1.44" "1.44.0" "1.43" "1.43.0" "1.42" "1.42.0" "1.41")
-set(Boost_USE_MULTITHREADED ON)
 
-set (Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.hpp include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
+set(Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.chai include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
 
 set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
 
-if (MULTITHREAD_SUPPORT_ENABLED)
-  find_package(Boost 1.36.0 COMPONENTS thread system)
-
-  if (Boost_FOUND)
-    link_directories( ${Boost_LIBRARY_DIRS} )
-  else()
-    message(FATAL_ERROR "Can not find Boost")
-  endif(Boost_FOUND)
-
-  if (CMAKE_HOST_UNIX)
-    add_definitions(-pthread)
-    list(APPEND LIBS "pthread")
-  endif()
-else()
+if(NOT MULTITHREAD_SUPPORT_ENABLED)
   add_definitions(-DCHAISCRIPT_NO_THREADS)
 endif()
 
-if (CMAKE_HOST_UNIX AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
-  list(APPEND LIBS "dl")
+if(CMAKE_HOST_UNIX)
+  if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
+    list(APPEND LIBS "dl")
+  endif()
+
+  if(MULTITHREAD_SUPPORT_ENABLED)
+    if(CMAKE_COMPILER_IS_GNUCC)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE GCC_FULL_VERSION)
+      if(GCC_FULL_VERSION MATCHES "4.8.1.*ubuntu")
+        set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--no-as-needed -pthread")
+      else()
+        set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
+      endif()
+    else()
+      set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
+    endif()
+
+    add_definitions(-pthread)
+  endif()
+
 endif()
-  
+
 list(APPEND LIBS ${READLINE_LIB})
 
-if (NOT MSVC)
-  # Boost on MSVC does automatic linking
-  list(APPEND LIBS ${Boost_LIBRARIES})
-endif()
+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}")
 
-if (CMAKE_COMPILER_2005)
-  # vs2005 is a bit too loud about possible loss of data warnings
-#  ADD_DEFINITIONS(/wd4244)
-endif()
 
-include_directories(${Boost_INCLUDE_DIRS})
-include_directories(${Boost_INCLUDE_DIR})
+add_library(chaiscript_stdlib-${CHAI_VERSION} MODULE src/chaiscript_stdlib.cpp)
+target_link_libraries(chaiscript_stdlib-${CHAI_VERSION} ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
+
 add_executable(chai src/main.cpp ${Chai_INCLUDES})
 target_link_libraries(chai ${LIBS})
+add_dependencies(chai chaiscript_stdlib-${CHAI_VERSION})
 
-if (BUILD_SAMPLES)
+if(BUILD_SAMPLES)
   add_executable(example samples/example.cpp)
   target_link_libraries(example ${LIBS})
   add_executable(memory_leak_test samples/memory_leak_test.cpp)
@@ -124,7 +206,7 @@ if (BUILD_SAMPLES)
 endif()
 
 
-if (BUILD_MODULES)
+if(BUILD_MODULES)
   add_library(stl_extra MODULE src/stl_extra.cpp)
   target_link_libraries(stl_extra ${LIBS})
 
@@ -133,25 +215,34 @@ if (BUILD_MODULES)
   set(MODULES stl_extra reflection)
 endif()
 
-file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai)
+file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/3.x/*.chai)
 
 list(SORT UNIT_TESTS)
 
 if(BUILD_TESTING)
   option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
 
-  foreach(filename ${UNIT_TESTS})
-    message(STATUS "Adding test ${filename}")
-    add_test(${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
-  endforeach(filename)
-
-  set_property(TEST ${UNIT_TESTS}
-   PROPERTY ENVIRONMENT
+  add_test(version_check chai -c  "if(\"\\\${ version() };\\\${version_major()};\\\${version_minor()};\\\${version_patch()}\" != \"${CHAI_VERSION};${CPACK_PACKAGE_VERSION_MAJOR};${CPACK_PACKAGE_VERSION_MINOR};${CPACK_PACKAGE_VERSION_PATCH}\") { exit(-1) }")
+  set_property(TEST version_check
+    PROPERTY ENVIRONMENT
     "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
     "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
   )
 
-  if (NOT UNIT_TEST_LIGHT)
+
+  foreach(filename ${UNIT_TESTS})
+    message(STATUS "Adding test ${filename}")
+    add_test(${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
+  endforeach()
+
+  set_property(TEST ${UNIT_TESTS}
+    PROPERTY ENVIRONMENT
+    "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+  )
+
+  if(NOT UNIT_TEST_LIGHT)
+    # commented out because uniform initializer syntax is not working properly in MSVC 2013
     add_executable(utility_test unittests/utility_test.cpp)
     target_link_libraries(utility_test ${LIBS})
     add_test(NAME Utility_Test COMMAND utility_test)
@@ -192,6 +283,10 @@ if(BUILD_TESTING)
     target_link_libraries(short_comparison_test ${LIBS})
     add_test(NAME Short_Comparison_Test COMMAND short_comparison_test)
 
+    add_executable(cpp_lambda_test unittests/cpp_lambda_test.cpp)
+    target_link_libraries(cpp_lambda_test ${LIBS})
+    add_test(NAME cpp_lambda_test COMMAND cpp_lambda_test)
+
     add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
     target_link_libraries(expected_eval_errors_test ${LIBS})
     add_test(NAME Expected_Eval_Errors_Test COMMAND expected_eval_errors_test)
@@ -202,7 +297,11 @@ if(BUILD_TESTING)
 
     add_executable(simultaneous_chaiscript_test unittests/simultaneous_chaiscript_test.cpp)
     target_link_libraries(simultaneous_chaiscript_test ${LIBS})
-    add_test(NAME Simultaneous_Chaiscript_Test COMMAND simultaneous_chaiscript_test)
+    add_test(NAME Simultaneous_ChaiScript_Test COMMAND simultaneous_chaiscript_test)
+
+    add_executable(heap_allocated_chaiscript_test unittests/heap_allocated_chaiscript_test.cpp)
+    target_link_libraries(heap_allocated_chaiscript_test ${LIBS})
+    add_test(NAME Heap_Allocated_ChaiScript_Test COMMAND heap_allocated_chaiscript_test)
 
     add_executable(c_linkage_test unittests/c_linkage_test.cpp)
     target_link_libraries(c_linkage_test ${LIBS})
@@ -216,7 +315,7 @@ if(BUILD_TESTING)
     target_link_libraries(arithmetic_conversions_test ${LIBS})
     add_test(NAME Arithmetic_Conversions_Test COMMAND arithmetic_conversions_test)
 
-    if (MULTITHREAD_SUPPORT_ENABLED)
+    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)
@@ -224,13 +323,16 @@ if(BUILD_TESTING)
         PROPERTY ENVIRONMENT
         "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
         "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
-        )
+      )
 
     endif()
 
 
-    add_executable(multifile_test unittests/multifile_test_main.cpp unittests/multifile_test_chai.cpp
-      unittests/multifile_test_module.cpp)
+    add_executable(multifile_test
+      unittests/multifile_test_main.cpp
+      unittests/multifile_test_chai.cpp
+      unittests/multifile_test_module.cpp
+    )
     target_link_libraries(multifile_test ${LIBS})
     add_test(NAME MultiFile_Test COMMAND multifile_test)
 
@@ -239,26 +341,26 @@ if(BUILD_TESTING)
 
     install(TARGETS test_module RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
   endif()
-endif(BUILD_TESTING)
+endif()
 
-install(TARGETS chai ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript )
+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)
+  PATTERN "*.hpp"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 install(DIRECTORY unittests DESTINATION share/chaiscript
-   PATTERN "*.chai" 
-   PATTERN "*.inc"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.chai"
+  PATTERN "*.inc"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 install(DIRECTORY samples DESTINATION share/chaiscript
-   PATTERN "*.chai"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.chai"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 
 configure_file(contrib/pkgconfig/chaiscript.pc.in lib/pkgconfig/chaiscript.pc @ONLY)
 install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc"

cmake/CheckCXX11Features.cmake

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

contrib/codeanalysis/codeanalysis.sh

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

contrib/codeanalysis/is_prime.chai

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

contrib/codeanalysis/runcppcheck.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+pushd ..
+wget http://sourceforge.net/projects/cppcheck/files/cppcheck/1.64/cppcheck-1.65.tar.bz2
+tar -xvf cppcheck-1.65.tar.bz2
+cd cppcheck-1.65
+make -j2
+popd
+../cppcheck-1.65/cppcheck --enable=all -I include --inline-suppr --std=c++11 --platform=unix64 src/main.cpp src/chai*.cpp --template ' - __{severity}__: [{file}:{line}](../blob/TRAVIS_COMMIT/{file}#L{line}) {message} ({id})'  2>output
+sed -i "s/TRAVIS_COMMIT/${TRAVIS_COMMIT}/g" output
+echo -n '{ "body": " ' > output.json
+echo -n `awk '{printf "%s\\\\n", $0;}' output` >> output.json
+echo -n '"}' >> output.json
+if [ "${TRAVIS_PULL_REQUEST}" = "false" ]; then curl -H "Authorization: token ${TOKEN}" --request POST --data @output.json https://api.github.com/repos/ChaiScript/ChaiScript/commits/${TRAVIS_COMMIT}/comments; else  curl -H "Authorization: token ${TOKEN}" --request POST --data @output.json https://api.github.com/repos/ChaiScript/ChaiScript/issues/${TRAVIS_PULL_REQUEST}/comments; fi
+
+

contrib/geshi/chaiscript.php

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

contrib/vim/syntax/chaiscript.vim

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

include/chaiscript/chaiscript.hpp

@@ -9,8 +9,8 @@
 
 
 
-/// \mainpage
-/// <a href="http://www.chaiscript.com">ChaiScript</a> is a scripting language designed specifically for integration with C++. It provides
+/// @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 
@@ -18,42 +18,42 @@
 ///
 /// 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 <a href="http://www.github.com/ChaiScript/ChaiScript">github</a>.
+/// Currently, all source control and project management aspects of ChaiScript occur on [github](http://www.github.com/ChaiScript/ChaiScript").
 ///
-/// <hr>
+/// ------------------------------------------------------------
 /// 
-/// \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
+/// @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
 ///
-/// <hr>
+/// -----------------------------------------------------------
 ///
-/// \section gettingstarted API Getting Started
+/// @section gettingstarted API Getting Started
 ///
-/// \li \ref basics
-/// \li \ref compiling
-/// \li \ref eval
-/// \li \ref addingitems
-/// \li \ref operatoroverloading
-/// \li \ref helpermacro
-/// \li \ref pointerconversions
-/// \li \ref baseclasses
-/// \li \ref functionobjects
-/// \li \ref threading
-/// \li \ref exceptions
+/// - @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
+/// @subsection basics Basics
 /// 
 /// Basic simple example:
 ///
-/// \code
+/// ~~~~~~~{.cpp}
 /// //main.cpp
 /// #include <chaiscript/chaiscript.hpp>
 /// 
@@ -69,111 +69,115 @@
 ///
 ///   double d = chai.eval<double>("function(3, 4.75);");
 /// } 
-/// \endcode
+/// ~~~~~~~
 ///
-/// <hr>
-/// \subsection compiling Compiling ChaiScript Applications
+/// ------------------------------------------------------
 ///
-/// ChaiScript is a header only library with only two dependecies. boost::threads (optional) and the
+/// @subsection compiling Compiling ChaiScript Applications
+///
+/// ChaiScript is a header only library with only one dependecy: The
 /// operating system provided dynamic library loader, which has to be specified on some platforms.
 /// 
-/// \subsubsection compilinggcc Compiling with GCC
+/// @subsubsection compilinggcc Compiling with GCC
 /// 
 /// To compile the above application on a Unix like operating system (MacOS, Linux) with GCC you need to link
-/// both boost::threads and the dynamic loader. For example:
+/// the dynamic loader. For example:
 ///
-/// \code
-/// gcc main.cpp -I/path/to/chaiscript/headers -ldl -lboost_threads
-/// \endcode
+/// ~~~~~~~~
+/// gcc main.cpp -I/path/to/chaiscript/headers -ldl 
+/// ~~~~~~~~
 ///
 /// Alternatively, you may compile without threading support.
 ///
-/// \code
+/// ~~~~~~~~
 /// gcc main.cpp -I/path/to/chaiscript/headers -ldl -DCHAISCRIPT_NO_THREADS
-/// \endcode
-/// 
-/// <hr>
-/// \subsection eval Evaluating Scripts
+/// ~~~~~~~~
+///
+/// ------------------------------------------
+///
+/// @subsection eval Evaluating Scripts
 ///
 /// Scripts can be evaluated with the () operator, eval method or eval_file method.
 ///
-/// \subsubsection parenoperator () Operator
+/// @subsubsection parenoperator () Operator
 ///
 /// operator() can be used as a handy shortcut for evaluating ChaiScript snippets.
-/// \code
-/// chaiscript::ChaiScript chai;
-/// chai("print(\"hello world\")");
-/// \endcode
-/// 
-/// \sa chaiscript::ChaiScript::operator()(const std::string &)
 ///
-/// \subsubsection evalmethod Method 'eval'
+/// ~~~~~~~~{.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 typesafely return values
 /// from the script.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// chaiscript::ChaiScript chai;
 /// chai.eval("callsomefunc()");
 /// int result = chai.eval<int>("1 + 3");
 /// // result now equals 4
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa chaiscript::ChaiScript::eval
+/// @sa chaiscript::ChaiScript::eval
 ///
-/// \subsubsection evalfilemethod Method 'eval_file'
+/// @subsubsection evalfilemethod Method 'eval_file'
 /// 
 /// The 'eval_file' method loads a file from disk and executes the script in it
 /// 
-/// \code
+/// ~~~~~~~~{.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
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa chaiscript::ChaiScript::eval_file
+/// @sa chaiscript::ChaiScript::eval_file
 ///
-/// <hr>
-/// \subsection addingitems Adding Items to ChaiScript
+/// --------------------------------------------------
+///
+/// @subsection adding_items Adding Items to ChaiScript
 ///
 /// ChaiScript supports 4 basic things that can be added: objects, functions, type infos and Modules
 ///
-/// \subsubsection addingobjects Adding Objects
+/// @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.
 /// 
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// using namespace chaiscript;
 /// ChaiScript chai;
 /// int i = 5;
 /// chai.add(var(i), "i");
 /// chai("print(i)");
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// Immutable objects can be created with the chaiscript::const_var function.
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// chai.add(const_var(i), "i");
 /// chai("i = 5"); // exception throw, cannot assign const var
-/// \endcode
+/// ~~~~~~~~~
 /// 
 /// 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.
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// chai.add_global_const(const_var(i), "i");
 /// chai("def somefun() { print(i); }; sumfun();");
-/// \endcode
+/// ~~~~~~~~~
 /// 
-/// \subsubsection addingfunctions Adding Functions
+/// @subsubsection adding_functions Adding Functions
 /// 
 /// Functions, methods and members are all added using the same function: chaiscript::fun.
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// using namespace chaiscript;
 /// 
 /// class MyClass {
@@ -190,26 +194,26 @@
 /// chai.add(fun(&MyClass::memberdata), "memberdata");
 /// chai.add(fun(&MyClass::method), "method");
 /// chai.add(fun(&MyClass::staticmethod), "staticmethod");
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// Overloaded methods will need some help, to hint the compiler as to which overload you want:
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// chai.add(fun<void (MyClass::*)()>(&MyClass::overloadedmethod), "overloadedmethod");
 /// chai.add(fun<void (MyClass::*)(const std::string &)>(&MyClass::overloadedmethod), "overloadedmethod");
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// There are also shortcuts built into chaiscript::fun for binding up to the first two parameters of the function.
 /// 
-/// \code
+/// ~~~~~~~~~{.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)
-/// \endcode
+/// ~~~~~~~~~
 ///
-/// \subsubsection addingtypeinfo Adding Type Info
+/// @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 
@@ -219,27 +223,28 @@
 ///
 /// Continuing with the example "MyClass" from above:
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// chai.add(user_type<MyClass>(), "MyClass");
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \subsubsection addingmodules Adding Modules
+/// @subsubsection adding_modules Adding Modules
 /// 
 /// Modules are holders for collections of ChaiScript registrations.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// ModulePtr module = get_sum_module();
 /// chai.add(module);
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa chaiscript::Module
+/// @sa chaiscript::Module
 ///
-/// <hr>
-/// \subsection operatoroverloading Operator Overloading
+/// -----------------------------------------------------------------------
+///
+/// @subsection operatoroverloading Operator Overloading
 /// 
 /// Operators are just like any other function in ChaiScript, to overload an operator, simply register it.
 /// 
-/// \code 
+/// ~~~~~~~~{.cpp} 
 /// class MyClass {
 ///   MyClass operator+(const MyClass &) const;
 /// };
@@ -248,21 +253,24 @@
 ///
 /// std::string append_string_int(const std::string &t_lhs, int t_rhs)
 /// {
-///   return t_lhs + boost::lexical_cast<std::string>(t_rhs);
+///   std::stringstream ss;
+///   ss << t_lhs << t_rhs;
+///   return ss.str();
 /// }
 ///
 /// chai.add(fun(append_string_int), "+");
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref addingfunctions
+/// @sa @ref adding_functions
 ///
-/// <hr>
-/// \subsection helpermacro Class Helper Macro
+/// -----------------------------------------------------------------------
+///
+/// @subsection add_class Class Helper Utility
 /// 
 /// Much of the work of adding new classes to ChaiScript can be reduced with the help
-/// of the CHAISCRIPT_CLASS helper macro.
+/// of the add_class helper utility.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// class Test
 /// {
 ///   public:
@@ -275,51 +283,51 @@
 ///
 /// int main()
 /// {
-///
 ///   chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
 ///
-///   CHAISCRIPT_CLASS( m, 
-///       Test,
-///       (Test ())
-///       (Test (const Test &)),
-///       ((function))
-///       ((function2))
-///       ((function3))
-///       ((functionOverload)(std::string (Test::*)(double)))
-///       ((functionOverload)(std::string (Test::*)(int)))
-///       ((operator=))
-///     );
-/// 
+///   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);
 /// }
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa \ref addingmodules
+/// @sa @ref adding_modules
 ///
-/// <hr>
-/// \subsection pointerconversions Pointer / Object Conversions
+/// -----------------------------------------------------------------------
 ///
-/// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, boost::shared_ptr<T>,
-/// boost::shared_ptr<const T>, boost::reference_wrapper<T>, boost::reference_wrapper<const T> and value types automatically.
+/// @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 convered 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.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// void fun1(const int *);
 /// void fun2(int *);
 /// void fun3(int);
 /// void fun4(int &);
 /// void fun5(const int &);
-/// void fun5(boost::shared_ptr<int>);
-/// void fun6(boost::shared_ptr<const int>);
-/// void fun7(const boost::shared_ptr<int> &);
-/// void fun8(const boost::shared_ptr<const int> &);
-/// void fun9(boost::reference_wrapper<int>);
-/// void fun10(boost::reference_wrapper<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()
 /// {
@@ -348,18 +356,19 @@
 ///   chai("fun9(i)");
 ///   chai("fun10(i)");
 /// }  
-/// \endcode
+/// ~~~~~~~~
 ///
 /// See the unit test unittests/boxed_cast_test.cpp for a complete breakdown of the automatic casts that 
 /// available and tested.
 /// 
-/// <hr>
-/// \subsection baseclasses Base Classes
+/// -----------------------------------------------------------------------
+///
+/// @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.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// class Base {};
 /// class Derived : public Base {};
 /// void myfunction(Base *b);
@@ -373,17 +382,18 @@
 ///   chai.add(chaiscript::fun(&myfunction), "myfunction");
 ///   chai("myfunction(d)");
 /// }
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// <hr>
+/// -----------------------------------------------------------------------
 ///
-/// \subsection functionobjects Function Objects
 ///
-/// Functions are first class objects in Chaiscript and ChaiScript supports automatic conversion
-/// between ChaiScript functions and boost::function objects.
+/// @subsection functionobjects Function Objects
 ///
-/// \code
-/// void callafunc(const boost::function<void (const std::string &)> &t_func)
+/// 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");
 /// }
@@ -393,16 +403,17 @@
 ///   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 boost::function
+///                                            // which expects a typed std::function
 ///
-///   boost::function<void ()> f = chai.eval<boost::function<void ()> >("dump_system");
+///   std::function<void ()> f = chai.eval<std::function<void ()> >("dump_system");
 ///   f(); // call the ChaiScript function dump_system, from C++
 /// }
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// <hr>
+/// -----------------------------------------------------------------------
 ///
-/// \subsection threading Threading
+///
+/// @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
@@ -410,18 +421,19 @@
 /// 
 /// Thread safety can be disabled by defining CHAISCRIPT_NO_THREADS when using the library.
 ///
-/// Disabling thread safety increases performance and removes the requirement for boost_threads.
+/// Disabling thread safety increases performance in many cases.
 ///
-/// <hr>
+/// -----------------------------------------------------------------------
 ///
-/// \subsection exceptions Exception Handling
+///
+/// @subsection exceptions Exception Handling
 /// 
-/// \subsubsection exceptionsbasics Exception Handling Basics
+/// @subsubsection exceptionsbasics Exception Handling Basics
 ///
 /// Exceptions can be thrown in ChaiScript and caught in C++ or thrown in C++ and caught in 
 /// ChaiScript.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// void throwexception()
 /// {
 ///   throw std::runtime_error("err");
@@ -442,19 +454,19 @@
 ///     // i == 1
 ///   }
 /// }
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \subsubsection exceptionsautomatic Exception Handling Automatic Unboxing
+/// @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:
-/// \code
+/// ~~~~~~~~{.cpp}
 /// chaiscript::ChaiScript chai;
 ///
 /// try {
-///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+///   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) {
@@ -462,19 +474,19 @@
 /// } catch (const std::exception &e) {
 ///   // This is the one what will be called in the specific throw() above
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa chaiscript::Exception_Handler for details on automatic exception unboxing 
-/// \sa chaiscript::exception_specification
+/// @sa chaiscript::Exception_Handler for details on automatic exception unboxing 
+/// @sa chaiscript::exception_specification
 
 
 
-/// \page LangObjectSystemRef ChaiScript Language Object Model Reference
+/// @page LangObjectSystemRef ChaiScript Language Object Model Reference
 ///
 ///
 /// ChaiScript has an object system built in, for types defined within the ChaiScript system.
 ///
-/// \code
+/// ~~~~~~~~~
 /// attr Rectangle::height
 /// attr Rectangle::width
 /// def Rectangle::Rectangle() { this.height = 10; this.width = 20 }
@@ -483,67 +495,69 @@
 /// var rect = Rectangle()
 /// rect.height = 30
 /// print(rect.area())
-/// \endcode
+/// ~~~~~~~~~
 ///
-/// \sa \ref keywordattr
-/// \sa \ref keyworddef
+/// @sa @ref keywordattr
+/// @sa @ref keyworddef
 
-/// \page LangInPlaceRef ChaiScript Language In-Place Creation Reference
-/// \section inplacevector Vector
+/// @page LangInPlaceRef ChaiScript Language In-Place Creation Reference
+/// @section inplacevector Vector
 /// 
-/// \code
+/// ~~~~~~~~~
 /// In-place Vector ::= "[" [expression ("," expression)*]  "]"
-/// \endcode
+/// ~~~~~~~~~
 ///
-/// \section inplacerangedvector Ranged Vector
+/// @section inplacerangedvector Ranged Vector
 ///
-/// \code
+/// ~~~~~~~~~
 /// In-place Ranged Vector ::= "[" value ".." value "]"
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// Creates a vector over a range (eg. 1..10)
 ///
-/// \section inplacemap Map
+/// @section inplacemap Map
 ///
-/// \code
+/// ~~~~~~~~
 /// In-place Map ::= "[" (string ":" expression)+ "]"
-/// \endcode
+/// ~~~~~~~~
 
-/// \page LangGettingStarted ChaiScript Language Getting Started
+/// @page LangGettingStarted ChaiScript Language Getting Started
 /// 
 /// ChaiScript is a simple language that should feel familiar to anyone who knows
 /// C++ or ECMAScript (JavaScript). 
 ///
-/// <hr>
-/// \section chaiscriptloops Loops
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptloops Loops
 ///
 /// Common looping constructs exist in ChaiScript
 ///
-/// \code
+/// ~~~~~~~~
 /// var i = 0;
 /// while (i < 10)
 /// {
 ///   // do something
 ///   ++i;
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \code
+/// ~~~~~~~~
 /// for (var i = 0; i < 10; ++i)
 /// {
 ///   // do something
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref keywordfor
-/// \sa \ref keywordwhile
+/// @sa @ref keywordfor
+/// @sa @ref keywordwhile
 ///
-/// <hr>
-/// \section chaiscriptifs Conditionals
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptifs Conditionals
 ///
 /// If statements work as expected
 /// 
-/// \code
+/// ~~~~~~~~
 /// var b = true;
 /// 
 /// if (b) {
@@ -553,103 +567,109 @@
 /// } else {
 ///   // or do this
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref keywordif
+/// @sa @ref keywordif
 ///
-/// <hr>
-/// \section chaiscriptfunctions Functions
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptfunctions Functions
 /// 
 /// Functions are defined with the def keyword
 /// 
-/// \code
+/// ~~~~~~~~
 /// def myfun(x) { print(x); }
 ///
 /// myfun(10);
-/// \endcode
+/// ~~~~~~~~
 ///
 /// Functions may have "guards" which determine if which is called.
 ///
-/// \code
+/// ~~~~~~~~
 /// 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
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa \ref keyworddef
-/// \sa \ref keywordattr
-/// \sa \ref LangObjectSystemRef
+/// @sa @ref keyworddef
+/// @sa @ref keywordattr
+/// @sa @ref LangObjectSystemRef
 ///
-/// <hr>
-/// \section chaiscriptfunctionobjects Function Objects
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptfunctionobjects Function Objects
 /// 
 /// Functions are first class types in ChaiScript and can be used as variables.
 ///
-/// \code
+/// ~~~~~~~~
 /// eval> var p = print;
 /// eval> p(1);
 /// 1
-/// \endcode
+/// ~~~~~~~~
 /// 
 /// They can also be passed to functions. 
 ///
-/// \code
+/// ~~~~~~~~
 /// eval> def callfunc(f, lhs, rhs) { return f(lhs, rhs); }
-/// eval> def dosomething(lhs, rhs) { print("lhs: ${lhs}, rhs: ${rhs}"); }
-/// eval> callfunc(dosomething, 1, 2);
+/// eval> def do_something(lhs, rhs) { print("lhs: ${lhs}, rhs: ${rhs}"); }
+/// eval> callfunc(do_something, 1, 2);
 /// lhs: 1, rhs: 2
-/// \endcode
+/// ~~~~~~~~
 ///
 /// Operators can also be treated as functions by using the back tick operator. Building on the above example:
 /// 
-/// \code
+/// ~~~~~~~~
 /// eval> callfunc(`+`, 1, 4);
 /// 5
 /// eval> callfunc(`*`, 3, 2);
 /// 6
-/// \endcode
+/// ~~~~~~~~
 ///
-/// <hr>
-/// \sa \ref LangKeywordRef
-/// \sa ChaiScript_Language for Built in Functions
+/// -----------------------------------------------------------------------
+///
+/// @sa @ref LangKeywordRef
+/// @sa ChaiScript_Language for Built in Functions
 
 
-/// \page LangKeywordRef ChaiScript Language Keyword Reference
+/// @page LangKeywordRef ChaiScript Language Keyword Reference
 ///
 ///
-/// <hr>
-/// \section keywordattr attr
+/// -----------------------------------------------------------------------
+///
+/// @section keywordattr attr
 /// Defines a ChaiScript object attribute
 /// 
-/// \code 
+/// ~~~~~~~~ 
 /// Attribute Definition ::= "attr" class_name "::" attribute_name
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref LangObjectSystemRef
+/// @sa @ref LangObjectSystemRef
 ///
-/// <hr>
-/// \section keywordbreak break
+/// -----------------------------------------------------------------------
+///
+/// @section keywordbreak break
 /// Stops execution of a looping block.
 ///
-/// \code
+/// ~~~~~~~~
 /// Break Statement ::= "break"
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref keywordfor
-/// \sa \ref keywordwhile 
+/// @sa @ref keywordfor
+/// @sa @ref keywordwhile 
 ///
 ///
-/// <hr>
-/// \section keyworddef def
+/// -----------------------------------------------------------------------
+///
+/// @section keyworddef def
 /// Begins a function or method definition
 ///
-/// \code
+/// ~~~~~~~~
 /// Function Definition ::= [annotation + CR/LF] "def" identifier "(" [arg ("," arg)*] ")" [":" guard] block
 /// Method Definition ::= [annotation + CR/LF] "def" class_name "::" method_name "(" [arg ("," arg)*] ")" [":" guard] block
-/// \endcode
+/// ~~~~~~~~
 /// 
 /// annotation: meta-annotation on function, currently used as documentation. Optional.
 /// identifier: name of function. Required.
@@ -665,50 +685,56 @@
 /// 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
+/// @sa @ref LangObjectSystemRef
 ///
 ///
-/// <hr>
-/// \section keywordelse else
-/// \sa \ref keywordif 
+/// -----------------------------------------------------------------------
+///
+/// @section keywordelse else
+/// @sa @ref keywordif 
 ///
 ///
-/// <hr>
-/// \section keywordfor for
-/// \code
+/// -----------------------------------------------------------------------
+///
+/// @section keywordfor for
+/// ~~~~~~~~
 /// For Block ::= "for" "(" [initial] ";" stop_condition ";" loop_expression ")" block
-/// \endcode
-/// This loop can be broken using the \ref keywordbreak command.
+/// ~~~~~~~~
+/// This loop can be broken using the @ref keywordbreak command.
 ///
 ///
-/// <hr>
-/// \section keywordfun fun
+/// -----------------------------------------------------------------------
+///
+/// @section keywordfun fun
 /// Begins an anonymous function declaration (sometimes called a lambda).
 ///
-/// \code
+/// ~~~~~~~~
 /// Lambda ::= "fun" "(" [variable] ("," variable)*  ")" block
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \b Examples:
+/// _Example_
 ///
-/// \code
+/// ~~~~~~~~
 /// // Generate an anonymous function object that adds 2 to its parameter
 /// var f = fun(x) { x + 2; }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref keyworddef for more details on ChaiScript functions
+/// @sa @ref keyworddef for more details on ChaiScript functions
 ///
 ///
-/// <hr>
-/// \section keywordif if
+/// -----------------------------------------------------------------------
+///
+/// @section keywordif if
 /// Begins a conditional block of code that only executes if the condition evaluates as true.
-/// \code
+/// ~~~~~~~~
 /// If Block ::= "if" "(" condition ")" block
 /// Else If Block ::= "else if" "(" condition ")" block
 /// Else Block ::= "else" block
-/// \endcode
-/// \b Example:
-/// \code
+/// ~~~~~~~~
+/// 
+/// _Example_
+///
+/// ~~~~~~~~
 /// if (true) {
 ///   // do something
 /// } else if (false) {
@@ -716,50 +742,49 @@
 /// } else {
 ///   // otherwise do this
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
 ///
-/// <hr>
-/// \section keywordtry try
-/// \code
+/// -----------------------------------------------------------------------
+///
+/// @section keywordtry try
+/// ~~~~~~~~
 /// Try Block ::= "try" block 
 ///  ("catch" ["(" variable ")"] [":" guards] block)+ 
 ///    ["finally" block]
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa ChaiScript_Language::throw
+/// @sa ChaiScript_Language::throw
 ///
-/// <hr>
-/// \section keywordwhile while
+/// -----------------------------------------------------------------------
+///
+/// @section keywordwhile while
 /// 
 /// Begins a conditional block of code that loops 0 or more times, as long as the condition is true
 ///
-/// \code
+/// ~~~~~~~~
 /// While Block ::= "while" "(" condition ")" block
-/// \endcode
-/// This loop can be broken using the \ref keywordbreak command.
+/// ~~~~~~~~
+///
+/// This loop can be broken using the @ref keywordbreak command.
 
 
-/// \namespace chaiscript
-/// \brief Namespace chaiscript contains every API call that the average user will be concerned with.
+/// @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.
+/// @namespace chaiscript::detail
+/// @brief Classes and functions reserved for internal use. Items in this namespace are not supported.
+
+#include "chaiscript_defines.hpp"
 
 #include "dispatchkit/dispatchkit.hpp"
-#include "dispatchkit/bootstrap.hpp"
-#include "dispatchkit/bootstrap_stl.hpp"
 #include "dispatchkit/function_call.hpp"
 #include "dispatchkit/dynamic_object.hpp"
 #include "dispatchkit/boxed_number.hpp"
 
-#ifdef  BOOST_HAS_DECLSPEC
-#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
-#else
-#define CHAISCRIPT_MODULE_EXPORT extern "C" 
-#endif
-
 #include "language/chaiscript_eval.hpp"
 #include "language/chaiscript_engine.hpp"
 
+
+
 #endif /* CHAISCRIPT_HPP_ */

include/chaiscript/chaiscript_defines.hpp

@@ -0,0 +1,53 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_DEFINES_HPP_
+#define CHAISCRIPT_DEFINES_HPP_
+
+#ifdef _MSC_VER
+#define CHAISCRIPT_MSVC _MSC_VER
+#define CHAISCRIPT_HAS_DECLSPEC
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define CHAISCRIPT_WINDOWS
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+/// Currently only g++>=4.8supports this natively
+/// \todo Make this support other compilers when possible
+#define CHAISCRIPT_HAS_THREAD_LOCAL
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) || defined(CHAISCRIPT_MSVC) || defined(__llvm__)
+#define CHAISCRIPT_OVERRIDE override
+#else
+#define CHAISCRIPT_OVERRIDE
+#endif
+
+
+#ifdef  CHAISCRIPT_HAS_DECLSPEC
+#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
+#else
+#define CHAISCRIPT_MODULE_EXPORT extern "C" 
+#endif
+
+#ifdef CHAISCRIPT_MSVC
+#define CHAISCRIPT_NOEXCEPT throw()
+#define CHAISCRIPT_CONSTEXPR 
+#else
+#define CHAISCRIPT_NOEXCEPT noexcept
+#define CHAISCRIPT_CONSTEXPR constexpr
+#endif
+
+namespace chaiscript {
+  static const int version_major = 5;
+  static const int version_minor = 3;
+  static const int version_patch = 1;
+}
+
+#endif
+

include/chaiscript/chaiscript_stdlib.hpp

@@ -0,0 +1,50 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// 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 "dispatchkit/dispatchkit.hpp"
+#include "dispatchkit/bootstrap.hpp"
+#include "dispatchkit/bootstrap_stl.hpp"
+#include "dispatchkit/boxed_value.hpp"
+
+/// @file
+///
+/// This file generates the standard library that normal ChaiScript usage requires.
+
+namespace chaiscript
+{
+  class Std_Lib
+  {
+    public:
+
+      static ModulePtr library()
+      {
+        using namespace bootstrap;
+
+        ModulePtr lib = Bootstrap::bootstrap();
+
+        lib->add(standard_library::vector_type<std::vector<Boxed_Value> >("Vector"));
+        lib->add(standard_library::string_type<std::string>("string"));
+        lib->add(standard_library::map_type<std::map<std::string, Boxed_Value> >("Map"));
+        lib->add(standard_library::pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair"));
+
+        return lib;
+      }
+
+  };
+}
+
+#endif
+

include/chaiscript/chaiscript_threading.hpp

@@ -7,17 +7,11 @@
 #ifndef CHAISCRIPT_THREADING_HPP_
 #define CHAISCRIPT_THREADING_HPP_
 
-#ifndef CHAISCRIPT_NO_THREADS
+#include <unordered_map>
 
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wc++11-long-long"
-#pragma clang diagnostic ignored "-Wshadow"
-#endif
-#include <boost/thread.hpp>
-#ifdef __llvm__
-#pragma clang diagnostic pop
-#endif
+#ifndef CHAISCRIPT_NO_THREADS
+#include <thread>
+#include <mutex>
 #else
 #pragma message ("ChaiScript is compiling without thread safety.")
 #endif
@@ -34,51 +28,129 @@ namespace chaiscript
 {
   namespace detail
   {
-    /// If threading is enabled, then this namespace contains boost::thread classes.
+    /// If threading is enabled, then this namespace contains std thread classes.
     /// If threading is not enabled, then stubbed in wrappers that do nothing are provided.
     /// This allows us to avoid \#ifdef code in the sections that need thread safety.
     namespace threading
     {
 
 #ifndef CHAISCRIPT_NO_THREADS
-      using boost::unique_lock; 
-      using boost::shared_lock;
-      using boost::lock_guard;
-      using boost::shared_mutex;
-      using boost::recursive_mutex;
 
+      template<typename T>
+      class unique_lock : public std::unique_lock<T>
+      {
+        public:
+          unique_lock(T &t) : std::unique_lock<T>(t) {}
+      };
 
-      /// Typesafe thread specific storage. If threading is enabled, this class uses boost::thread_specific_ptr<T>. If
+      template<typename T>
+      class shared_lock : public std::unique_lock<T>
+      {
+        public:
+          shared_lock(T &t) : std::unique_lock<T>(t) {}
+          void unlock() {}
+      };
+
+      template<typename T>
+      class lock_guard : public std::lock_guard<T>
+      {
+        public:
+          lock_guard(T &t) : std::lock_guard<T>(t) {}
+      };
+
+      class shared_mutex : public std::mutex { };
+
+      using std::mutex;
+
+      using std::recursive_mutex;
+
+#ifdef CHAISCRIPT_HAS_THREAD_LOCAL
+      /// Typesafe thread specific storage. If threading is enabled, this class uses a mutex protected map. If
       /// threading is not enabled, the class always returns the same data, regardless of which thread it is called from.
       template<typename T>
         class Thread_Storage
         {
           public:
+
+            Thread_Storage(void *t_key)
+              : m_key(t_key)
+            {
+            }
+
             ~Thread_Storage()
             {
-              m_thread_storage.reset();
+              t().erase(m_key);
             }
 
             inline T *operator->() const
             {
-              if (!m_thread_storage.get())
-              {
-                m_thread_storage.reset(new T());
-              }
-
-              return m_thread_storage.get();
+              return &(t()[m_key]);
             }
 
             inline T &operator*() const
             {
-              return *(this->operator->());
+              return t()[m_key];
             }
 
+            void *m_key;
+
           private:
-            mutable boost::thread_specific_ptr<T> m_thread_storage;
+            static std::unordered_map<void*, T> &t()
+            {
+              thread_local static std::unordered_map<void *, T> my_t;
+              return my_t;
+            }
         };
 
 #else
+
+      /// Typesafe thread specific storage. If threading is enabled, this class uses a mutex protected map. If
+      /// threading is not enabled, the class always returns the same data, regardless of which thread it is called from.
+      /// 
+      /// This version is used if the compiler does not support thread_local
+      template<typename T>
+        class Thread_Storage
+        {
+          public:
+
+            Thread_Storage(void *)
+            {
+            }
+
+            inline T *operator->() const
+            {
+              return get_tls().get();
+            }
+
+            inline T &operator*() const
+            {
+              return *get_tls();
+            }
+
+
+          private:
+            std::shared_ptr<T> get_tls() const
+            {
+              unique_lock<mutex> lock(m_mutex);
+
+              auto itr = m_instances.find(std::this_thread::get_id());
+
+              if (itr != m_instances.end()) { return itr->second; }
+
+              std::shared_ptr<T> new_instance(new T());
+
+              m_instances.insert(std::make_pair(std::this_thread::get_id(), new_instance));
+
+              return new_instance;
+            }
+
+
+            mutable mutex m_mutex;
+            mutable std::unordered_map<std::thread::id, std::shared_ptr<T> > m_instances;
+        };
+#endif // threading enabled but no tls
+
+#else // threading disabled
       template<typename T>
       class unique_lock 
       {
@@ -113,6 +185,10 @@ namespace chaiscript
         class Thread_Storage
         {
           public:
+            Thread_Storage(void *)
+            {
+            }
+
             inline T *operator->() const
             {
               return &obj;

include/chaiscript/dispatchkit/any.hpp

@@ -0,0 +1,169 @@
+// 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() CHAISCRIPT_NOEXCEPT
+            : m_what("bad any cast")
+          {
+          }
+
+          virtual ~bad_any_cast() CHAISCRIPT_NOEXCEPT {}
+
+          /// \brief Description of what error occured
+          virtual const char * what() const CHAISCRIPT_NOEXCEPT CHAISCRIPT_OVERRIDE
+          {
+            return m_what.c_str();
+          }
+
+        private:
+          std::string m_what;
+      };
+    }
+  
+
+    class Any {
+      private:
+        struct Data
+        {
+          virtual ~Data() {}
+          virtual void *data() = 0;
+          virtual const std::type_info &type() const = 0;
+          virtual std::shared_ptr<Data> clone() const = 0;
+        };
+
+        template<typename T>
+          struct Data_Impl : Data
+          {
+            Data_Impl(T t_type)
+              : m_type(typeid(T)),
+                m_data(std::move(t_type))
+            {
+            }
+
+            virtual ~Data_Impl() {}
+
+            virtual void *data() CHAISCRIPT_OVERRIDE
+            {
+              return &m_data;
+            }
+
+            const std::type_info &type() const CHAISCRIPT_OVERRIDE
+            {
+              return m_type;
+            }
+
+            std::shared_ptr<Data> clone() const CHAISCRIPT_OVERRIDE
+            {
+              return std::shared_ptr<Data>(new Data_Impl<T>(m_data));
+            }
+
+            Data_Impl &operator=(const Data_Impl&) = delete;
+              
+            const std::type_info &m_type;
+            T m_data;
+          };
+
+        std::shared_ptr<Data> m_data;
+
+      public:
+        // construct/copy/destruct
+        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> 
+        Any(const ValueType &t_value)
+          : m_data(std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value)))
+        {
+        }
+
+        Any & operator=(const Any &t_any)
+        {
+          Any copy(t_any);
+          swap(copy);
+          return *this; 
+        }
+
+        template<typename ValueType> 
+          Any & operator=(const ValueType &t_value)
+        {
+          m_data = std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value));
+          return *this;
+        }
+
+        template<typename ToType>
+          ToType &cast() const
+          {
+            if (m_data && typeid(ToType) == m_data->type())
+            {
+              return *static_cast<ToType *>(m_data->data());
+            } else {
+              throw chaiscript::detail::exception::bad_any_cast();
+            }
+ 
+          }
+
+
+        ~Any()
+        {
+        }
+
+        // modifiers
+        Any & swap(Any &t_other)
+        {
+          std::shared_ptr<Data> data = t_other.m_data;
+          t_other.m_data = m_data;
+          m_data = 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

@@ -7,8 +7,15 @@
 #ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
 #define CHAISCRIPT_BAD_BOXED_CAST_HPP_
 
+#include <string>
+#include <typeinfo>
+
 #include "type_info.hpp"
 
+namespace chaiscript {
+class Type_Info;
+}  // namespace chaiscript
+
 namespace chaiscript 
 {
   namespace exception
@@ -22,25 +29,25 @@ namespace chaiscript
     {
       public:
         bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) throw()
-          : from(t_from), to(&t_to), m_what(t_what)
+            std::string t_what) CHAISCRIPT_NOEXCEPT
+          : from(t_from), to(&t_to), m_what(std::move(t_what))
         {
         }
 
-        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
+        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
           : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
         {
         }
 
-        bad_boxed_cast(const std::string &t_what) throw()
-          : to(0), m_what(t_what)
+        bad_boxed_cast(std::string t_what) CHAISCRIPT_NOEXCEPT
+          : to(nullptr), m_what(std::move(t_what))
         {
         }
 
-        virtual ~bad_boxed_cast() throw() {}
+        virtual ~bad_boxed_cast() CHAISCRIPT_NOEXCEPT {} 
 
         /// \brief Description of what error occured
-        virtual const char * what() const throw()
+        virtual const char * what() const CHAISCRIPT_NOEXCEPT CHAISCRIPT_OVERRIDE
         {
           return m_what.c_str();
         }

include/chaiscript/dispatchkit/bind_first.hpp

@@ -4,91 +4,130 @@
 // Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-
-#define param(z,n,text) BOOST_PP_CAT(text, BOOST_PP_INC(n)) 
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_BIND_FIRST_HPP_
 #define CHAISCRIPT_BIND_FIRST_HPP_
 
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/ref.hpp>
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 8 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/bind_first.hpp>
-
-#include BOOST_PP_ITERATE()
-
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-# define m BOOST_PP_INC(n)
+#include <functional>
 
 namespace chaiscript
 {
   namespace detail
-  { 
-    /// \brief Helper function for binding the first parameter of a class method pointer. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
-      bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const O &o)
+  {
+
+    template<int>
+      struct Placeholder
       {
-        return boost::bind(boost::mem_fn(f), o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+      };
+
+    template<>
+      struct Placeholder<1>
+      {
+        static decltype(std::placeholders::_1) value() { return std::placeholders::_1; }
+      };
+
+    template<>
+      struct Placeholder<2>
+      {
+        static decltype(std::placeholders::_2) value() { return std::placeholders::_2; }
+      };
+
+    template<>
+      struct Placeholder<3>
+      {
+        static decltype(std::placeholders::_3) value() { return std::placeholders::_3; }
+      };
+
+    template<>
+      struct Placeholder<4>
+      {
+        static decltype(std::placeholders::_4) value() { return std::placeholders::_4; }
+      };
+
+    template<>
+      struct Placeholder<5>
+      {
+        static decltype(std::placeholders::_5) value() { return std::placeholders::_5; }
+      };
+
+    template<>
+      struct Placeholder<6>
+      {
+        static decltype(std::placeholders::_6) value() { return std::placeholders::_6; }
+      };
+
+    template<>
+      struct Placeholder<7>
+      {
+        static decltype(std::placeholders::_7) value() { return std::placeholders::_7; }
+      };
+
+    template<>
+      struct Placeholder<8>
+      {
+        static decltype(std::placeholders::_8) value() { return std::placeholders::_8; }
+      };
+
+    template<>
+      struct Placeholder<9>
+      {
+        static decltype(std::placeholders::_9) value() { return std::placeholders::_9; }
+      };
+
+    template<>
+      struct Placeholder<10>
+      {
+        static decltype(std::placeholders::_10) value() { return std::placeholders::_10; }
+      };
+
+
+    template<int count, int maxcount, typename Sig>
+      struct Bind_First
+      {
+        template<typename F, typename ... InnerParams>
+          static std::function<Sig> bind(F f, InnerParams ... innerparams)
+          {
+            return Bind_First<count - 1, maxcount, Sig>::bind(f, innerparams..., Placeholder<maxcount - count + 1>::value());
+          } 
+      };
+
+    template<int maxcount, typename Sig>
+      struct Bind_First<0, maxcount, Sig>
+      {
+        template<typename F, typename ... InnerParams>
+          static std::function<Sig> bind(F f, InnerParams ... innerparams)
+          {
+            return std::bind(f, innerparams...);
+          }
+      };
+
+
+    template<typename O, typename Ret, typename P1, typename ... Param>
+      std::function<Ret (Param...)> bind_first(Ret (*f)(P1, Param...), O o)
+      {
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
       }
 
-    /// \brief Helper function for binding the first parameter of a const class method pointer. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
-      bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)) const, const O &o)
+    template<typename O, typename Ret, typename Class, typename ... Param>
+      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...), O o)
       {
-        return boost::bind(boost::mem_fn(f), o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
       }
 
-    /// \brief Helper function for binding the first parameter of a function pointer. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
-      bind_first(Ret (*f)(BOOST_PP_ENUM_PARAMS(m, Param)), const O &o)
+    template<typename O, typename Ret, typename Class, typename ... Param>
+      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...) const, O o)
       {
-        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
       }
 
-    /// \brief Helper function for binding the first parameter of a boost::function object. Used in chaiscript::fun overloads
-    ///        that take 1 or 2 parameters to pre-bind to the function.
-    ///
-    /// \param[in] f method pointer to bind
-    /// \param[in] o object to bind as first parameter 
-    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
-    template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
-      boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
-      bind_first(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(m, Param))> &f, const O &o)
+    template<typename O, typename Ret, typename P1, typename ... Param>
+      std::function<Ret (Param...)> bind_first(const std::function<Ret (P1, Param...)> &f, O o)
       {
-        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
       }
 
+
   }
 }
 
-#undef n
-#undef m
-#undef param
 
 #endif

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -7,13 +7,31 @@
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
 #define CHAISCRIPT_BOOTSTRAP_HPP_
 
-#include "dispatchkit.hpp"
-#include "dynamic_object.hpp"
-#include "register_function.hpp"
-#include "operators.hpp"
-#include "boxed_number.hpp"
-#include <boost/function_types/result_type.hpp>
+#include <cstdint>
+#include <exception>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
 #include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "bad_boxed_cast.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+#include "dispatchkit.hpp"
+#include "dynamic_cast_conversion.hpp"
+#include "dynamic_object.hpp"
+#include "operators.hpp"
+#include "proxy_constructors.hpp"
+#include "proxy_functions.hpp"
+#include "proxy_functions_detail.hpp"
+#include "register_function.hpp"
+#include "type_info.hpp"
 
 namespace chaiscript 
 {
@@ -26,9 +44,9 @@ namespace chaiscript
       /// \param[in] v Boxed_Number to copy into the new object
       /// \returns The newly created object.
       template<typename P1>
-      boost::shared_ptr<P1> construct_pod(Boxed_Number v)
+      std::shared_ptr<P1> construct_pod(Boxed_Number v)
       {
-        boost::shared_ptr<P1> p(new P1());
+        std::shared_ptr<P1> p(new P1());
         Boxed_Value bv(p);
         Boxed_Number nb(bv);
         nb = v;
@@ -97,29 +115,25 @@ namespace chaiscript
      * to_string function for internal use. Uses ostream operator<<
      */
     template<typename Input>
-      std::string to_string(Input i)
-      {
-        std::stringstream ss;
-        ss << i;
-        return ss.str();
-      }
+    std::string to_string(Input i)
+    {
+      std::stringstream ss;
+      ss << i;
+      return ss.str();
+    }
 
     /**
      * Internal function for converting from a string to a value
      * uses ostream operator >> to perform the conversion
      */
     template<typename Input>
-      Input parse_string(const std::string &i)
-      {
-        std::stringstream ss(i);
-        Input t;
-        ss >> t;
-        return t;
-      }
-
-
-
-     
+    Input parse_string(const std::string &i)
+    {
+      std::stringstream ss(i);
+      Input t;
+      ss >> t;
+      return t;
+    }
       
             
     /**
@@ -147,7 +161,7 @@ namespace chaiscript
     * function variables.
     */
     template<typename Type>
-    boost::shared_ptr<Type> shared_ptr_clone(const boost::shared_ptr<Type> &p)
+    std::shared_ptr<Type> shared_ptr_clone(const std::shared_ptr<Type> &p)
     {
       return p;
     }
@@ -156,10 +170,10 @@ namespace chaiscript
      * Specific version of shared_ptr_clone just for Proxy_Functions
      */
     template<typename Type>
-    boost::shared_ptr<typename boost::remove_const<Type>::type> 
-        shared_ptr_unconst_clone(const boost::shared_ptr<typename boost::add_const<Type>::type> &p)
+    std::shared_ptr<typename std::remove_const<Type>::type> 
+        shared_ptr_unconst_clone(const std::shared_ptr<typename std::add_const<Type>::type> &p)
     {
-      return boost::const_pointer_cast<typename boost::remove_const<Type>::type>(p);
+      return std::const_pointer_cast<typename std::remove_const<Type>::type>(p);
     }
 
 
@@ -170,7 +184,7 @@ namespace chaiscript
     * Similar to shared_ptr_clone. Used for Proxy_Function.
     */
     template<typename Type>
-    Boxed_Value ptr_assign(Boxed_Value lhs, const boost::shared_ptr<Type> &rhs)
+    Boxed_Value ptr_assign(Boxed_Value lhs, const std::shared_ptr<Type> &rhs)
     {
       if (lhs.is_undef() 
           || (!lhs.get_type_info().is_const() && lhs.get_type_info().bare_equal(chaiscript::detail::Get_Type_Info<Type>::get())))
@@ -276,7 +290,7 @@ namespace chaiscript
 
       static bool has_guard(const Const_Proxy_Function &t_pf)
       {
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
           if (pf->get_guard()) {
@@ -291,7 +305,7 @@ namespace chaiscript
 
       static Const_Proxy_Function get_guard(const Const_Proxy_Function &t_pf)
       {
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
           if (pf->get_guard())
@@ -308,12 +322,6 @@ namespace chaiscript
       static void throw_exception(const Boxed_Value &bv) {
         throw bv;
       }
-      
-      static boost::shared_ptr<chaiscript::detail::Dispatch_Engine> bootstrap2(boost::shared_ptr<chaiscript::detail::Dispatch_Engine> e = boost::shared_ptr<chaiscript::detail::Dispatch_Engine> (new chaiscript::detail::Dispatch_Engine()))
-      {
-        e->add(user_type<void>(), "void");
-        return e;
-      }
 
       static std::string what(const std::exception &e)
       {
@@ -337,24 +345,22 @@ namespace chaiscript
         static std::vector<Boxed_Value> do_return_boxed_value_vector(FunctionType f,
             const dispatch::Proxy_Function_Base *b)
         {
-          typedef typename boost::function_types::result_type<FunctionType>::type Vector;
-          Vector v = (b->*f)();
+          auto v = (b->*f)();
  
           std::vector<Boxed_Value> vbv;
-          for (typename Vector::const_iterator itr = v.begin();
-               itr != v.end();
-               ++itr)
+
+          for (const auto &o: v)
           {
-            vbv.push_back(const_var(*itr));
+            vbv.push_back(const_var(o));
           }
 
           return vbv;
         }
 
       template<typename Function>
-      static boost::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
+      static std::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
       {
-        return boost::bind(&do_return_boxed_value_vector<Function>, f, _1);
+        return std::bind(&do_return_boxed_value_vector<Function>, f, std::placeholders::_1);
       }
 
     public:
@@ -384,7 +390,7 @@ namespace chaiscript
  
 
         m->add(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
-        m->add(fun(boost::function<std::string (const std::runtime_error &)>(&what)), "what");     
+        m->add(fun(std::function<std::string (const std::runtime_error &)>(&what)), "what");     
 
         m->add(user_type<dispatch::Dynamic_Object>(), "Dynamic_Object");
         m->add(constructor<dispatch::Dynamic_Object (const std::string &)>(), "Dynamic_Object");
@@ -392,7 +398,7 @@ namespace chaiscript
         m->add(fun(&dispatch::Dynamic_Object::get_attrs), "get_attrs");
         m->add(fun(&dispatch::Dynamic_Object::get_attr), "get_attr");
 
-        m->eval("def Dynamic_Object::clone() { var new_o := Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
+        m->eval("def Dynamic_Object::clone() { auto &new_o = Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
 
         m->add(fun(&has_guard), "has_guard");
         m->add(fun(&get_guard), "get_guard");
@@ -440,14 +446,14 @@ namespace chaiscript
         bootstrap_pod_type<unsigned long>("unsigned_long", m);
         bootstrap_pod_type<size_t>("size_t", m);
         bootstrap_pod_type<char>("char", m);
-        bootstrap_pod_type<boost::int8_t>("int8_t", m);
-        bootstrap_pod_type<boost::int16_t>("int16_t", m);
-        bootstrap_pod_type<boost::int32_t>("int32_t", m);
-        bootstrap_pod_type<boost::int64_t>("int64_t", m);
-        bootstrap_pod_type<boost::uint8_t>("uint8_t", m);
-        bootstrap_pod_type<boost::uint16_t>("uint16_t", m);
-        bootstrap_pod_type<boost::uint32_t>("uint32_t", m);
-        bootstrap_pod_type<boost::uint64_t>("uint64_t", m);
+        bootstrap_pod_type<std::int8_t>("int8_t", m);
+        bootstrap_pod_type<std::int16_t>("int16_t", m);
+        bootstrap_pod_type<std::int32_t>("int32_t", m);
+        bootstrap_pod_type<std::int64_t>("int64_t", m);
+        bootstrap_pod_type<std::uint8_t>("uint8_t", m);
+        bootstrap_pod_type<std::uint16_t>("uint16_t", m);
+        bootstrap_pod_type<std::uint32_t>("uint32_t", m);
+        bootstrap_pod_type<std::uint64_t>("uint64_t", m);
 
         operators::logical_compliment<bool>(m);
 
@@ -457,14 +463,14 @@ namespace chaiscript
         m->add(fun(&print), "print_string");
         m->add(fun(&println), "println_string");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&bind_function, _1))), 
+        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&bind_function, std::placeholders::_1))), 
           "bind");
 
         m->add(fun(&shared_ptr_unconst_clone<dispatch::Proxy_Function_Base>), "clone");
-        m->add(fun(&ptr_assign<boost::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
-        m->add(fun(&ptr_assign<boost::add_const<dispatch::Proxy_Function_Base>::type>), "=");
+        m->add(fun(&ptr_assign<std::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
+        m->add(fun(&ptr_assign<std::add_const<dispatch::Proxy_Function_Base>::type>), "=");
 
-        m->add(fun(&type_match), "type_match");
+        m->add(fun(&Boxed_Value::type_match), "type_match");
 
         return m;
       }

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -13,8 +13,21 @@
 #ifndef CHAISCRIPT_BOOTSTRAP_STL_HPP_
 #define CHAISCRIPT_BOOTSTRAP_STL_HPP_
 
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+#include "bootstrap.hpp"
+#include "boxed_value.hpp"
 #include "dispatchkit.hpp"
+#include "operators.hpp"
+#include "proxy_constructors.hpp"
 #include "register_function.hpp"
+#include "type_info.hpp"
 
 namespace chaiscript 
 {
@@ -143,89 +156,13 @@ namespace chaiscript
         };
 
       namespace detail {
-        template<typename T>
-          int return_int_impl(const boost::function<typename T::size_type (const T *)> &t_func, const T *t_obj)
-          {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4267)
-#endif
-            return t_func(t_obj);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-          }
 
         template<typename T>
-        boost::function<int (const T *)> return_int(size_t (T::*t_func)() const)
-          {
-            return boost::bind(&return_int_impl<T>, boost::function<size_t (const T *)>(boost::mem_fn(t_func)), _1);
-          }
-
-        template<typename T, typename P1>
-          int return_int_impl(const boost::function<typename T::size_type (const T *, P1)> &t_func, const T *t_obj, P1 p1)
-          {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4267)
-#endif
-            return t_func(t_obj, p1);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-          }
-
-        template<typename T, typename P1>
-          int return_int_impl_non_const(const boost::function<typename T::size_type (T *, P1)> &t_func, T *t_obj, P1 p1)
-          {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4267)
-#endif
-            return t_func(t_obj, p1);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-          }
-
-        template<typename T, typename P1>
-        boost::function<int (const T *, P1)> return_int(size_t (T::*t_func)(P1) const)
-          {
-            return boost::bind(&return_int_impl<T, P1>, boost::function<size_t (const T *, P1)>(boost::mem_fn(t_func)), _1, _2);
-          }
-
-        template<typename T, typename P1>
-        boost::function<int (T *, P1)> return_int(size_t (T::*t_func)(P1) )
-          {
-            return boost::bind(&return_int_impl_non_const<T, P1>, boost::function<size_t (T*, P1)>(boost::mem_fn(t_func)), _1, _2);
-          }
-
-
-        template<typename T, typename P1, typename P2>
-          int return_int_impl(const boost::function<typename T::size_type (const T *, P1, P2)> &t_func, const T *t_obj, P1 p1, P2 p2)
-          {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4267)
-#endif
-            return t_func(t_obj, p1, p2);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-          }
-
-        template<typename StringType, StringType (StringType::*Func)(typename StringType::size_type, typename StringType::size_type) const >
-        StringType substr_helper(const StringType &str, int begin, int end)
+        size_t count(const T &t_target, const typename T::key_type &t_key)
         {
-          return (str.*Func)(begin, end);
+          return t_target.count(t_key);
         }
 
-        template<typename T, typename P1, typename P2>
-        boost::function<int (const T *, P1, P2)> return_int(size_t (T::*t_func)(P1, P2) const)
-          {
-            return boost::bind(&return_int_impl<T, P1, P2>, boost::function<size_t (const T *, P1, P2)>(boost::mem_fn(t_func)), _1, _2, _3);
-          }
-
         template<typename T>
           void insert(T &t_target, const T &t_other)
           {
@@ -240,8 +177,6 @@ namespace chaiscript
 
 
 
-
-
         /// Add Bidir_Range support for the given ContainerType
         template<typename Bidir_Type>
           ModulePtr input_range_type_impl(const std::string &type, ModulePtr m = ModulePtr(new Module()))
@@ -266,8 +201,8 @@ namespace chaiscript
         template<typename Type>
           void insert_at(Type &container, int pos, const typename Type::value_type &v)
           {
-            typename Type::iterator itr = container.begin();
-            typename Type::iterator end = container.end();
+            auto itr = container.begin();
+            auto end = container.end();
 
             if (pos < 0 || std::distance(itr, end) < pos)
             {
@@ -283,8 +218,8 @@ namespace chaiscript
         template<typename Type>
           void erase_at(Type &container, int pos)
           {
-            typename Type::iterator itr = container.begin();
-            typename Type::iterator end = container.end();
+            auto itr = container.begin();
+            auto end = container.end();
 
             if (pos < 0 || std::distance(itr, end) < (pos-1))
             {
@@ -294,7 +229,7 @@ namespace chaiscript
             std::advance(itr, pos);
             container.erase(itr);
           }      
-        
+
       }
 
       template<typename ContainerType>
@@ -317,11 +252,11 @@ namespace chaiscript
           //In the interest of runtime safety for the m, we prefer the at() method for [] access,
           //to throw an exception in an out of bounds condition.
           m->add(
-              fun(boost::function<typename ContainerType::reference (ContainerType *, int)>
-                (boost::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
+              fun(std::function<typename ContainerType::reference (ContainerType *, int)>
+                (std::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
           m->add(
-              fun(boost::function<typename ContainerType::const_reference (const ContainerType *, int)>
-                (boost::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
+              fun(std::function<typename ContainerType::const_reference (const ContainerType *, int)>
+                (std::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
 
           return m;
         }
@@ -343,10 +278,9 @@ namespace chaiscript
       template<typename ContainerType>
         ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          boost::function<int (const ContainerType *)> f = detail::return_int(&ContainerType::size);
-          m->add(fun(f), "size");
-          m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
-          m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
+          m->add(fun( std::function<size_t (const ContainerType *)>( [](const ContainerType *a) { return a->size(); } ) ), "size");
+          m->add(fun( std::function<bool (const ContainerType *)>( [](const ContainerType *a) { return a->empty(); } ) ), "empty");
+          m->add(fun( std::function<void (ContainerType *)>( [](ContainerType *a) { a->clear(); } ) ), "clear");
           return m;
         }
 
@@ -400,8 +334,8 @@ namespace chaiscript
             push_back_name = "push_back";
           }
 
-          typedef void (ContainerType::*pushback)(const typename ContainerType::value_type &);
-          m->add(fun(static_cast<pushback>(&ContainerType::push_back)), push_back_name);
+          typedef void (ContainerType::*push_back)(const typename ContainerType::value_type &);
+          m->add(fun(static_cast<push_back>(&ContainerType::push_back)), push_back_name);
           m->add(fun(&ContainerType::pop_back), "pop_back");
           return m;
         }
@@ -472,13 +406,11 @@ namespace chaiscript
       template<typename ContainerType>
         ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(boost::function<int (const ContainerType *, const typename ContainerType::key_type &)>(detail::return_int(&ContainerType::count))), "count");
+          m->add(fun(detail::count<ContainerType>), "count");
 
+          typedef size_t (ContainerType::*erase_ptr)(const typename ContainerType::key_type &);
 
-          typedef size_t (ContainerType::*erase)(const typename ContainerType::key_type &);
-          erase eraseptr(&ContainerType::erase);
-
-          m->add(fun(boost::function<int (ContainerType *, const typename ContainerType::key_type &)>(detail::return_int(eraseptr))), "erase");
+          m->add(fun(static_cast<erase_ptr>(&ContainerType::erase)), "erase");
 
           m->add(fun(&detail::insert<ContainerType>), "insert");
 
@@ -560,8 +492,8 @@ namespace chaiscript
                        if ( rhs.size() != this.size() ) {    \
                          return false;  \
                        } else {  \
-                         var r1 = range(this); \
-                         var r2 = range(rhs);  \
+                         auto r1 = range(this); \
+                         auto r2 = range(rhs);  \
                          while (!r1.empty()) \
                          {  \
                            if (!eq(r1.front(), r2.front())) \
@@ -579,32 +511,6 @@ namespace chaiscript
           return m;
         }
 
-        namespace detail {
-          template<typename String>
-          struct apple_string_workarounds
-          {
-            /// The latest version of MacOS has a broken std::string implementation which will not allow
-            /// us to take pointers to the members. Code compiles, but does not link
-            /// \todo re-evaluate at some point
-
-            static size_t find(const String *s, const String &w, int pos) { return s->find(w, pos); }
-            static size_t rfind(const String *s, const String &w, size_t pos) { return s->rfind(w, pos); }
-            static size_t find_first_of(const String *s, const String &w, size_t pos) { return s->find_first_of(w, pos); }
-            static size_t find_last_of(const String *s, const String &w, size_t pos) { return s->find_last_of(w, pos); }
-            static size_t find_first_not_of(const String *s, const String &w, size_t pos) { return s->find_first_not_of(w, pos); }
-            static size_t find_last_not_of(const String *s, const String &w, size_t pos) { return s->find_last_not_of(w, pos); }
-
-            static void clear(String *s) { s->clear(); }
-            static bool empty(const String *s) { return s->empty(); }
-            static size_t size(const String *s) { return s->size(); }
- 
-            static std::string substr(const String *s, size_t pos, size_t len) { return s->substr(pos,len); }
-            static const char *c_str(const String *s) {  return s->c_str(); }
-            static const char *data(const String *s) { return s->data(); }
-          };
-        }
-
-
       /// Add a String container
       /// http://www.sgi.com/tech/stl/basic_string.html
       template<typename String>
@@ -631,21 +537,24 @@ namespace chaiscript
           }
           m->add(fun(&String::push_back), push_back_name);
 
-            
-          m->add(fun(&detail::apple_string_workarounds<String>::find), "find");
-          m->add(fun(&detail::apple_string_workarounds<String>::rfind), "rfind");
-          m->add(fun(&detail::apple_string_workarounds<String>::find_first_of), "find_first_of");
-          m->add(fun(&detail::apple_string_workarounds<String>::find_last_of), "find_last_of");
-          m->add(fun(&detail::apple_string_workarounds<String>::find_first_not_of), "find_first_not_of");
-          m->add(fun(&detail::apple_string_workarounds<String>::find_last_not_of), "find_last_not_of");
-          m->add(fun(&detail::apple_string_workarounds<String>::clear), "clear");
-          m->add(fun(&detail::apple_string_workarounds<String>::size), "size");
-          m->add(fun(&detail::apple_string_workarounds<String>::empty), "empty");
-          m->add(fun(&detail::apple_string_workarounds<String>::substr), "substr");
-          m->add(fun(&detail::apple_string_workarounds<String>::c_str), "c_str");
-          m->add(fun(&detail::apple_string_workarounds<String>::data), "data");
+          typedef std::function<size_t (const String *, const String &, size_t)> find_func;
 
 
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find(f, pos); } )), "find");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->rfind(f, pos); } ) ), "rfind");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_first_of(f, pos); } ) ), "find_first_of");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_last_of(f, pos); } ) ), "find_last_of");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_last_not_of(f, pos); } ) ), "find_last_not_of");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_first_not_of(f, pos); } ) ), "find_first_not_of");
+
+          m->add(fun( std::function<void (String *)>( [](String *s) { return s->clear(); } ) ), "clear");
+          m->add(fun( std::function<bool (const String *)>( [](const String *s) { return s->empty(); } ) ), "empty");
+          m->add(fun( std::function<size_t (const String *)>( [](const String *s) { return s->size(); } ) ), "size");
+
+          m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->c_str(); } ) ), "c_str");
+          m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->data(); } ) ), "data");
+          m->add(fun( std::function<String (const String *, size_t, size_t)>( [](const String *s, size_t pos, size_t len) { return s->substr(pos, len); } ) ), "substr");
+
           return m;
         }
     }
@@ -654,3 +563,5 @@ namespace chaiscript
 
 
 #endif
+
+

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -7,20 +7,24 @@
 #ifndef CHAISCRIPT_BOXED_CAST_HPP_
 #define CHAISCRIPT_BOXED_CAST_HPP_
 
-#include "type_info.hpp"
-#include "boxed_value.hpp"
-#include "boxed_cast_helper.hpp"
-#include "dynamic_cast_conversion.hpp"
+#include <type_traits>
 
+#include "../chaiscript_defines.hpp"
 #include "../chaiscript_threading.hpp"
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/integer_traits.hpp>
+#include "bad_boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "dynamic_cast_conversion.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+namespace detail {
+namespace exception {
+class bad_any_cast;
+}  // namespace exception
+}  // namespace detail
+}  // namespace chaiscript
 
 namespace chaiscript 
 {
@@ -31,64 +35,72 @@ namespace chaiscript
   /// \returns Type equivalent to the requested type 
   /// \throws exception::bad_boxed_cast If the requested conversion is not possible
   /// 
-  /// boxed_cast will attempt to make conversions between value, &, *, boost::shared_ptr, boost::reference_wrapper,
-  /// and boost::function (const and non-const) where possible. boxed_cast is used internally during function
+  /// boxed_cast will attempt to make conversions between value, &, *, std::shared_ptr, std::reference_wrapper,
+  /// and std::function (const and non-const) where possible. boxed_cast is used internally during function
   /// dispatch. This means that all of these conversions will be attempted automatically for you during
   /// ChaiScript function calls.
   ///
   /// \li non-const values can be extracted as const or non-const
   /// \li const values can be extracted only as const
-  /// \li Boxed_Value constructed from pointer or boost::reference_wrapper can be extracted as reference,
+  /// \li Boxed_Value constructed from pointer or std::reference_wrapper can be extracted as reference,
   ///     pointer or value types
-  /// \li Boxed_Value constructed from boost::shared_ptr or value types can be extracted as reference,
-  ///     pointer, value, or boost::shared_ptr types
+  /// \li Boxed_Value constructed from std::shared_ptr or value types can be extracted as reference,
+  ///     pointer, value, or std::shared_ptr types
   ///
-  /// Conversions to boost::function objects are attempted as well
+  /// Conversions to std::function objects are attempted as well
   ///
   /// Example:
   /// \code
   /// // All of the following should succeed
   /// chaiscript::Boxed_Value bv(1);
-  /// boost::shared_ptr<int> spi = chaiscript::boxed_cast<boost::shared_ptr<int> >(bv);
+  /// std::shared_ptr<int> spi = chaiscript::boxed_cast<std::shared_ptr<int> >(bv);
   /// int i = chaiscript::boxed_cast<int>(bv);
   /// int *ip = chaiscript::boxed_cast<int *>(bv);
   /// int &ir = chaiscript::boxed_cast<int &>(bv);
-  /// boost::shared_ptr<const int> cspi = chaiscript::boxed_cast<boost::shared_ptr<const int> >(bv);
+  /// std::shared_ptr<const int> cspi = chaiscript::boxed_cast<std::shared_ptr<const int> >(bv);
   /// const int ci = chaiscript::boxed_cast<const int>(bv);
   /// const int *cip = chaiscript::boxed_cast<const int *>(bv);
   /// const int &cir = chaiscript::boxed_cast<const int &>(bv);
   /// \endcode
   ///
-  /// boost::function conversion example
+  /// std::function conversion example
   /// \code
   /// chaiscript::ChaiScript chai;
   /// Boxed_Value bv = chai.eval("`+`"); // Get the functor for the + operator which is built in 
-  /// boost::function<int (int, int)> f = chaiscript::boxed_cast<boost::function<int (int, int)> >(bv);
+  /// std::function<int (int, int)> f = chaiscript::boxed_cast<std::function<int (int, int)> >(bv);
   /// int i = f(2,3);
   /// assert(i == 5);
   /// \endcode
   template<typename Type>
-  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions = 0)
+  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions = nullptr)
   {
     try {
       return detail::Cast_Helper<Type>::cast(bv, t_conversions);
-    } catch (const boost::bad_any_cast &) {
+    } catch (const chaiscript::detail::exception::bad_any_cast &) {
 
-#ifdef BOOST_MSVC
+
+#ifdef CHAISCRIPT_MSVC
       //Thank you MSVC, yes we know that a constant value is being used in the if
       // statment in THIS VERSION of the template instantiation
 #pragma warning(push)
 #pragma warning(disable : 4127)
 #endif
 
-      if (boost::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value && t_conversions)
+      if (std::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value && t_conversions)
       {
         try {
+          // std::cout << "trying an up conversion " << typeid(Type).name() << std::endl;
           // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
           // either way, we are not responsible if it doesn't work
           return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_cast<Type>(bv), t_conversions);
-        } catch (const boost::bad_any_cast &) {
-          throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+        } catch (...) {
+          try {
+          //  std::cout << "trying a down conversion " << typeid(Type).name() << std::endl;
+            // try going the other way - down the inheritance graph
+            return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_down_cast<Type>(bv), t_conversions);
+          } catch (const chaiscript::detail::exception::bad_any_cast &) {
+            throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+          }
         }
       } else {
         // If it's not polymorphic, just throw the error, don't waste the time on the 
@@ -96,7 +108,7 @@ namespace chaiscript
         throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
       }
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
 

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -7,13 +7,13 @@
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 #define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 
-#include "type_info.hpp"
-#include "boxed_value.hpp"
+#include <functional>
+#include <memory>
+#include <type_traits>
+
+#include "boxed_value.hpp"
+#include "type_info.hpp"
 
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/ref.hpp>
-#include <boost/type_traits/add_const.hpp>
 
 namespace chaiscript 
 {
@@ -29,7 +29,7 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner
       {
-        typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
+        typedef typename std::reference_wrapper<typename std::add_const<Result>::type > Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
@@ -37,25 +37,25 @@ namespace chaiscript
           {
             if (!ob.get_type_info().is_const())
             {
-              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
+              return std::cref((ob.get().cast<std::reference_wrapper<Result> >()).get());
             } else {
-              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
+              return ob.get().cast<std::reference_wrapper<const Result> >();
             }
           } else {
             if (!ob.get_type_info().is_const())
             {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
+              return std::cref(*(ob.get().cast<std::shared_ptr<Result> >()));   
             } else {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
+              return std::cref(*(ob.get().cast<std::shared_ptr<const Result> >()));   
             }
           }
         }
       };
 
-	template<typename Result>
-	  struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
-	  {
-	  };
+    template<typename Result>
+      struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
+      {
+      };
 
     /**
      * Cast_Helper_Inner for casting to a const & type
@@ -79,16 +79,16 @@ namespace chaiscript
           {
             if (!ob.get_type_info().is_const())
             {
-              return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+              return &(ob.get().cast<std::reference_wrapper<Result> >()).get();
             } else {
-              return (boost::any_cast<boost::reference_wrapper<const Result> >(ob.get())).get_pointer();
+              return &(ob.get().cast<std::reference_wrapper<const Result> >()).get();
             }
           } else {
             if (!ob.get_type_info().is_const())
             {
-              return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+              return (ob.get().cast<std::shared_ptr<Result> >()).get();
             } else {
-              return (boost::any_cast<boost::shared_ptr<const Result> >(ob.get())).get();
+              return (ob.get().cast<std::shared_ptr<const Result> >()).get();
             }
           }
         }
@@ -106,9 +106,9 @@ namespace chaiscript
         {
           if (ob.is_ref())
           {
-            return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+            return &(ob.get().cast<std::reference_wrapper<Result> >()).get();
           } else {
-            return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+            return (ob.get().cast<std::shared_ptr<Result> >()).get();
           }
         }
       };
@@ -119,76 +119,77 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner<Result &>
       {
-        typedef typename boost::reference_wrapper<Result> Result_Type;
+        typedef Result& Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
-            return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
+            return ob.get().cast<std::reference_wrapper<Result> >();
           } else {
-            return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
+            Result &r = *(ob.get().cast<std::shared_ptr<Result> >());
+            return r;
           }
         }
       };
 
     /**
-     * Cast_Helper_Inner for casting to a boost::shared_ptr<> type
+     * Cast_Helper_Inner for casting to a std::shared_ptr<> type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<typename boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<typename std::shared_ptr<Result> >
       {
-        typedef typename boost::shared_ptr<Result> Result_Type;
+        typedef typename std::shared_ptr<Result> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
-          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
+          return ob.get().cast<std::shared_ptr<Result> >();
         }
       };
 
     /**
-     * Cast_Helper_Inner for casting to a boost::shared_ptr<const> type
+     * Cast_Helper_Inner for casting to a std::shared_ptr<const> type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<typename boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<typename std::shared_ptr<const Result> >
       {
-        typedef typename boost::shared_ptr<const Result> Result_Type;
+        typedef typename std::shared_ptr<const Result> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (!ob.get_type_info().is_const())
           {
-            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
+            return std::const_pointer_cast<const Result>(ob.get().cast<std::shared_ptr<Result> >());
           } else {
-            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
+            return ob.get().cast<std::shared_ptr<const Result> >();
           }
         }
       };
 
     /**
-     * Cast_Helper_Inner for casting to a const boost::shared_ptr<> & type
+     * Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<Result> > : Cast_Helper_Inner<boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<Result> > : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<Result> &> : Cast_Helper_Inner<boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<Result> &> : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
       };
 
 
     /**
-     * Cast_Helper_Inner for casting to a const boost::shared_ptr<const> & type
+     * Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<const Result> > : Cast_Helper_Inner<boost::shared_ptr<const 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 boost::shared_ptr<const Result> &> : Cast_Helper_Inner<boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<const Result> &> : Cast_Helper_Inner<std::shared_ptr<const Result> >
       {
       };
 
@@ -220,38 +221,38 @@ namespace chaiscript
       struct Cast_Helper_Inner<const Boxed_Value &> : Cast_Helper_Inner<Boxed_Value>
       {
       };
-    
 
-	/**
-     * Cast_Helper_Inner for casting to a boost::reference_wrapper type
+
+    /**
+     * Cast_Helper_Inner for casting to a std::reference_wrapper type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> & > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<const Result> & > : Cast_Helper_Inner<const Result &>
       {
       };
 
@@ -262,7 +263,7 @@ namespace chaiscript
       struct Cast_Helper
       {
         typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
-        
+
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           return Cast_Helper_Inner<T>::cast(ob, t_conversions);

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -7,17 +7,30 @@
 #ifndef CHAISCRIPT_BOXED_NUMERIC_HPP_
 #define CHAISCRIPT_BOXED_NUMERIC_HPP_
 
-#include "boxed_value.hpp"
-#include "../language/chaiscript_algebraic.hpp"
-#include <boost/cstdint.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 Dynamic_Cast_Conversions;
+}  // namespace chaiscript
 
 namespace chaiscript 
 {
- 
-#ifdef BOOST_MSVC
+
+// 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)
+#pragma warning(disable : 4244 4018 4389 4146 4365)
 #endif
 
   /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values
@@ -48,7 +61,7 @@ namespace chaiscript
             case Operators::not_equal:
               return const_var(t != u);
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
         }
       };
@@ -82,7 +95,7 @@ namespace chaiscript
               t -= u;
               break;
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
 
           return t_lhs;
@@ -115,7 +128,7 @@ namespace chaiscript
               t ^= u;
               break;
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
           return t_lhs;
         }
@@ -143,7 +156,7 @@ namespace chaiscript
             case Operators::bitwise_complement:
               return const_var(~t);
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
         }
       };
@@ -168,7 +181,7 @@ namespace chaiscript
             case Operators::unary_plus:
               return const_var(+t);
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
         }
       };
@@ -190,7 +203,7 @@ namespace chaiscript
           } else if (t_oper > Operators::const_flag) {
             return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
           } else {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -206,13 +219,13 @@ namespace chaiscript
           } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
             return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
           } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag) {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           } else if (t_oper > Operators::const_flag) {
             return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
           } else {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -238,24 +251,24 @@ namespace chaiscript
             return Go<LHS, long, Float>::go(t_oper, t_lhs, t_rhs);
           } else if (inp_ == typeid(unsigned long)) {
             return Go<LHS, unsigned long, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int8_t)) {
-            return Go<LHS, boost::int8_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int16_t)) {
-            return Go<LHS, boost::int16_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int32_t)) {
-            return Go<LHS, boost::int32_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int64_t)) {
-            return Go<LHS, boost::int64_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint8_t)) {
-            return Go<LHS, boost::uint8_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint16_t)) {
-            return Go<LHS, boost::uint16_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint32_t)) {
-            return Go<LHS, boost::uint32_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint64_t)) {
-            return Go<LHS, boost::uint64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int8_t)) {
+            return Go<LHS, std::int8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int16_t)) {
+            return Go<LHS, std::int16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int32_t)) {
+            return Go<LHS, std::int32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int64_t)) {
+            return Go<LHS, std::int64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint8_t)) {
+            return Go<LHS, std::uint8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint16_t)) {
+            return Go<LHS, std::uint16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint32_t)) {
+            return Go<LHS, std::uint32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint64_t)) {
+            return Go<LHS, std::uint64_t, Float>::go(t_oper, t_lhs, t_rhs);
           } else {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         } 
 
@@ -279,24 +292,24 @@ namespace chaiscript
             return oper_rhs<long, false>(t_oper, t_lhs, t_rhs);
           } else if (inp_ == typeid(unsigned long)) {
             return oper_rhs<unsigned long, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int8_t)) {
-            return oper_rhs<boost::int8_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int16_t)) {
-            return oper_rhs<boost::int16_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int32_t)) {
-            return oper_rhs<boost::int32_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int64_t)) {
-            return oper_rhs<boost::int64_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint8_t)) {
-            return oper_rhs<boost::uint8_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint16_t)) {
-            return oper_rhs<boost::uint16_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint32_t)) {
-            return oper_rhs<boost::uint32_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint64_t)) {
-            return oper_rhs<boost::uint64_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int8_t)) {
+            return oper_rhs<std::int8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int16_t)) {
+            return oper_rhs<std::int16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int32_t)) {
+            return oper_rhs<std::int32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int64_t)) {
+            return oper_rhs<std::int64_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint8_t)) {
+            return oper_rhs<std::uint8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint16_t)) {
+            return oper_rhs<std::uint16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint32_t)) {
+            return oper_rhs<std::uint32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint64_t)) {
+            return oper_rhs<std::uint64_t, false>(t_oper, t_lhs, t_rhs);
           } else  {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
 
@@ -307,7 +320,7 @@ namespace chaiscript
         }
 
         template<typename Source>
-          std::string to_string_aux(const Boxed_Value &v) const
+         static std::string to_string_aux(const Boxed_Value &v)
         {
           std::ostringstream oss;
           oss << *static_cast<const Source *>(v.get_const_ptr());
@@ -351,24 +364,24 @@ namespace chaiscript
           return Boxed_Number(get_as<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(boost::int8_t))) {
-          return Boxed_Number(get_as<boost::int8_t>());
-        } else if (inp_.bare_equal_type_info(typeid(boost::int16_t))) {
-          return Boxed_Number(get_as<boost::int16_t>());
-        } else if (inp_.bare_equal_type_info(typeid(boost::int32_t))) {
-          return Boxed_Number(get_as<boost::int32_t>());
-        } else if (inp_.bare_equal_type_info(typeid(boost::int64_t))) {
-          return Boxed_Number(get_as<boost::int64_t>());
-        } else if (inp_.bare_equal_type_info(typeid(boost::uint8_t))) {
-          return Boxed_Number(get_as<boost::uint8_t>());
-        } else if (inp_.bare_equal_type_info(typeid(boost::uint16_t))) {
-          return Boxed_Number(get_as<boost::uint16_t>());
-        } else if (inp_.bare_equal_type_info(typeid(boost::uint32_t))) {
-          return Boxed_Number(get_as<boost::uint32_t>());
-        } else if (inp_.bare_equal_type_info(typeid(boost::uint64_t))) {
-          return Boxed_Number(get_as<boost::uint64_t>());
+        } 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 boost::bad_any_cast();
+          throw chaiscript::detail::exception::bad_any_cast();
         }
 
       }
@@ -393,24 +406,24 @@ namespace chaiscript
           return get_as_aux<Target, long>();
         } else if (inp_ == typeid(unsigned long)) {
           return get_as_aux<Target, unsigned long>();
-        } else if (inp_ == typeid(boost::int8_t)) {
-          return get_as_aux<Target, boost::int8_t>();
-        } else if (inp_ == typeid(boost::int16_t)) {
-          return get_as_aux<Target, boost::int16_t>();
-        } else if (inp_ == typeid(boost::int32_t)) {
-          return get_as_aux<Target, boost::int32_t>();
-        } else if (inp_ == typeid(boost::int64_t)) {
-          return get_as_aux<Target, boost::int64_t>();
-        } else if (inp_ == typeid(boost::uint8_t)) {
-          return get_as_aux<Target, boost::uint8_t>();
-        } else if (inp_ == typeid(boost::uint16_t)) {
-          return get_as_aux<Target, boost::uint16_t>();
-        } else if (inp_ == typeid(boost::uint32_t)) {
-          return get_as_aux<Target, boost::uint32_t>();
-        } else if (inp_ == typeid(boost::uint64_t)) {
-          return get_as_aux<Target, boost::uint64_t>();
+        } else if (inp_ == typeid(std::int8_t)) {
+          return get_as_aux<Target, std::int8_t>();
+        } else if (inp_ == typeid(std::int16_t)) {
+          return get_as_aux<Target, std::int16_t>();
+        } else if (inp_ == typeid(std::int32_t)) {
+          return get_as_aux<Target, std::int32_t>();
+        } else if (inp_ == typeid(std::int64_t)) {
+          return get_as_aux<Target, std::int64_t>();
+        } else if (inp_ == typeid(std::uint8_t)) {
+          return get_as_aux<Target, std::uint8_t>();
+        } else if (inp_ == typeid(std::uint16_t)) {
+          return get_as_aux<Target, std::uint16_t>();
+        } else if (inp_ == typeid(std::uint32_t)) {
+          return get_as_aux<Target, std::uint32_t>();
+        } else if (inp_ == typeid(std::uint64_t)) {
+          return get_as_aux<Target, std::uint64_t>();
         } else {
-          throw boost::bad_any_cast();
+          throw chaiscript::detail::exception::bad_any_cast();
         }
       }
 
@@ -434,24 +447,24 @@ namespace chaiscript
           return to_string_aux<long>(bv);
         } else if (inp_ == typeid(unsigned long)) {
           return to_string_aux<unsigned long>(bv);
-        } else if (inp_ == typeid(boost::int8_t)) {
-          return to_string_aux<int>(Boxed_Value(get_as_aux<int, boost::int8_t>()));
-        } else if (inp_ == typeid(boost::int16_t)) {
-          return to_string_aux<boost::int16_t>(bv);
-        } else if (inp_ == typeid(boost::int32_t)) {
-          return to_string_aux<boost::int32_t>(bv);
-        } else if (inp_ == typeid(boost::int64_t)) {
-          return to_string_aux<boost::int64_t>(bv);
-        } else if (inp_ == typeid(boost::uint8_t)) {
-          return to_string_aux<unsigned int>(Boxed_Value(get_as_aux<unsigned int, boost::uint8_t>()));
-        } else if (inp_ == typeid(boost::uint16_t)) {
-          return to_string_aux<boost::uint16_t>(bv);
-        } else if (inp_ == typeid(boost::uint32_t)) {
-          return to_string_aux<boost::uint32_t>(bv);
-        } else if (inp_ == typeid(boost::uint64_t)) {
-          return to_string_aux<boost::uint64_t>(bv);
+        } else if (inp_ == typeid(std::int8_t)) {
+          return to_string_aux<int>(Boxed_Value(get_as_aux<int, std::int8_t>()));
+        } else if (inp_ == typeid(std::int16_t)) {
+          return to_string_aux<std::int16_t>(bv);
+        } else if (inp_ == typeid(std::int32_t)) {
+          return to_string_aux<std::int32_t>(bv);
+        } else if (inp_ == typeid(std::int64_t)) {
+          return to_string_aux<std::int64_t>(bv);
+        } else if (inp_ == typeid(std::uint8_t)) {
+          return to_string_aux<unsigned int>(Boxed_Value(get_as_aux<unsigned int, std::uint8_t>()));
+        } else if (inp_ == typeid(std::uint16_t)) {
+          return to_string_aux<std::uint16_t>(bv);
+        } else if (inp_ == typeid(std::uint32_t)) {
+          return to_string_aux<std::uint32_t>(bv);
+        } else if (inp_ == typeid(std::uint64_t)) {
+          return to_string_aux<std::uint64_t>(bv);
         } else {
-          throw boost::bad_any_cast();
+          throw chaiscript::detail::exception::bad_any_cast();
         }
       }
 
@@ -520,17 +533,17 @@ namespace chaiscript
         return oper(Operators::assign_bitwise_and, this->bv, t_rhs.bv);
       }
 
-      void validate_boxed_number(const Boxed_Value &v)
+      static void validate_boxed_number(const Boxed_Value &v)
       {
         const Type_Info &inp_ = v.get_type_info();
         if (inp_ == typeid(bool))
         {
-          throw boost::bad_any_cast();
+          throw chaiscript::detail::exception::bad_any_cast();
         }
 
         if (!inp_.is_arithmetic())
         {
-          throw boost::bad_any_cast();
+          throw chaiscript::detail::exception::bad_any_cast();
         }
       }
 
@@ -844,7 +857,7 @@ namespace chaiscript
       };  
   }
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
 

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -7,32 +7,14 @@
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
 #define CHAISCRIPT_BOXED_VALUE_HPP_
 
-#include "type_info.hpp"
+#include <functional>
+#include <map>
+#include <memory>
+#include <type_traits>
 
 #include "../chaiscript_threading.hpp"
-
-#include <map>
-#include <boost/shared_ptr.hpp>
-
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wshadow"
-#pragma clang diagnostic ignored "-Wunused-parameter"
-#endif
-
-#include <boost/make_shared.hpp>
-
-#ifdef __llvm__
-#pragma clang diagnostic pop
-#endif
-
-#include <boost/any.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-#include <boost/bind.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/integer_traits.hpp>
+#include "any.hpp"
+#include "type_info.hpp"
 
 namespace chaiscript 
 {
@@ -42,24 +24,21 @@ namespace chaiscript
   class Boxed_Value
   {
     public:
-      /**
-       * used for explicitly creating a "void" object
-       */
+      /// used for explicitly creating a "void" object
       struct Void_Type
       {
       };
 
     private:
-      /**
-       * structure which holds the internal state of a Boxed_Value
-       */
+      /// structure which holds the internal state of a Boxed_Value
+      /// \todo Get rid of Any and merge it with this, reducing an allocation in the process
       struct Data
       {
         Data(const Type_Info &ti,
-            const boost::any &to,
+            const chaiscript::detail::Any &to,
             bool tr,
             const void *t_void_ptr)
-          : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?0:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
+          : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?nullptr:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
             m_is_ref(tr)
         {
         }
@@ -80,7 +59,7 @@ namespace chaiscript
         }
 
         Type_Info m_type_info;
-        boost::any m_obj;
+        chaiscript::detail::Any m_obj;
         void *m_data_ptr;
         const void *m_const_data_ptr;
         bool m_is_ref;
@@ -88,92 +67,91 @@ namespace chaiscript
 
       struct Object_Data
       {
-        static boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
+        static std::shared_ptr<Data> get(Boxed_Value::Void_Type)
         {
-          return boost::make_shared<Data>(
+          return std::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
-                boost::any(), 
+                chaiscript::detail::Any(), 
                 false,
-                static_cast<void *>(0));
+                nullptr)
+              ;
         }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> *obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> *obj)
           {
             return get(*obj);
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> &obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> &obj)
           {
-            return boost::make_shared<Data>(
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(obj), 
+                  chaiscript::detail::Any(obj), 
                   false,
-                  obj.get());
+                  obj.get()
+                );
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(T *t)
+          static std::shared_ptr<Data> get(T *t)
           {
-            return get(boost::ref(*t));
+            return get(std::ref(*t));
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
+          static std::shared_ptr<Data> get(std::reference_wrapper<T> obj)
           {
-            return boost::make_shared<Data>(
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
-                  boost::any(obj),
+                  chaiscript::detail::Any(obj),
                   true,
-                  obj.get_pointer());
+                  &obj.get()
+                );
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const T& t)
+          static std::shared_ptr<Data> get(const T& t)
           {
-            boost::shared_ptr<T> p(new T(t));
-            return boost::make_shared<Data>(
+            auto p = std::make_shared<T>(t);
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(p), 
+                  chaiscript::detail::Any(p), 
                   false,
-                  p.get());
+                  p.get()
+                );
           }
 
-        static boost::shared_ptr<Data> get()
+        static std::shared_ptr<Data> get()
         {
-          return boost::make_shared<Data>(
+          return std::make_shared<Data>(
                 Type_Info(),
-                boost::any(),
+                chaiscript::detail::Any(),
                 false,
-                static_cast<void *>(0));
+                nullptr 
+              );
         }
 
       };
 
     public:
-      /**
-       * Basic Boxed_Value constructor
-       */
+      /// Basic Boxed_Value constructor
       template<typename T>
         explicit Boxed_Value(T t)
         : m_data(Object_Data::get(t))
         {
         }
 
-      /**
-       * Copy constructor - each copy shares the same data pointer
-       */
+      /// Copy constructor - each copy shares the same data pointer
       Boxed_Value(const Boxed_Value &t_so)
         : m_data(t_so.m_data)
       {
       }
 
-      /**
-       * Unknown-type constructor
-       */
+      /// Unknown-type constructor
       Boxed_Value()
-        : m_data(Object_Data::get())    
+        : m_data(Object_Data::get())
       {
       }
 
@@ -186,19 +164,15 @@ namespace chaiscript
         std::swap(m_data, rhs.m_data);
       }
 
-      /**
-       * copy the values stored in rhs.m_data to m_data
-       * m_data pointers are not shared in this case
-       */
+      /// Copy the values stored in rhs.m_data to m_data.
+      /// m_data pointers are not shared in this case
       Boxed_Value assign(const Boxed_Value &rhs)
       {
         (*m_data) = (*rhs.m_data);
         return *this;
       }
 
-      /**
-       * shared data assignment, same as copy construction
-       */
+      /// shared data assignment, same as copy construction
       Boxed_Value &operator=(const Boxed_Value &rhs)
       {
         Boxed_Value temp(rhs);
@@ -211,9 +185,7 @@ namespace chaiscript
         return m_data->m_type_info;
       }
 
-      /**
-       * return true if the object is uninitialized
-       */
+      /// return true if the object is uninitialized
       bool is_undef() const
       {
         return m_data->m_type_info.is_undef();
@@ -231,10 +203,10 @@ namespace chaiscript
 
       bool is_null() const
       {
-        return (m_data->m_data_ptr == 0 && m_data->m_const_data_ptr == 0);
+        return (m_data->m_data_ptr == nullptr && m_data->m_const_data_ptr == nullptr);
       }
 
-      const boost::any & get() const
+      const chaiscript::detail::Any & get() const
       {
         return m_data->m_obj;
       }
@@ -259,23 +231,30 @@ namespace chaiscript
         return m_data->m_const_data_ptr;
       }
 
+      /// \returns true if the two Boxed_Values share the same internal type
+      static bool type_match(Boxed_Value l, Boxed_Value r)
+      {
+        return l.get_type_info() == r.get_type_info();
+      }
+
     private:
-      boost::shared_ptr<Data> m_data;
+      std::shared_ptr<Data> m_data;
   };
 
-  /// \brief Creates a Boxed_Value. If the object passed in is a value type, it is copied. If it is a pointer, boost::shared_ptr, or boost::reference_type
+  /// @brief Creates a Boxed_Value. If the object passed in is a value type, it is copied. If it is a pointer, std::shared_ptr, or std::reference_type
   ///        a copy is not made.
-  /// \param t The value to box
-  /// 
+  /// @param t The value to box
+  ///
   /// Example:
-  /// \code
+  ///
+  /// ~~~{.cpp}
   /// int i;
   /// chaiscript::ChaiScript chai;
   /// chai.add(chaiscript::var(i), "i");
   /// chai.add(chaiscript::var(&i), "ip");
-  /// \endcode
-  /// 
-  /// \sa \ref addingobjects
+  /// ~~~
+  ///
+  /// @sa @ref adding_objects
   template<typename T>
     Boxed_Value var(T t)
     {
@@ -290,7 +269,7 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(const T &t)
       {
-        return Boxed_Value(boost::shared_ptr<typename boost::add_const<T>::type >(new T(t)));
+        return Boxed_Value(std::shared_ptr<typename std::add_const<T>::type >(new T(t)));
       }
 
     /// \brief Takes a pointer to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
@@ -301,33 +280,33 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(T *t)
       {
-        return Boxed_Value( const_cast<typename boost::add_const<T>::type *>(t) );
+        return Boxed_Value( const_cast<typename std::add_const<T>::type *>(t) );
       }
 
-    /// \brief Takes a boost::shared_ptr to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
+    /// \brief Takes a std::shared_ptr to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
     ///        Does not copy the pointed to value.
     /// \param[in] t Pointer to make immutable
     /// \returns Immutable Boxed_Value
     /// \sa Boxed_Value::is_const
     template<typename T>
-      Boxed_Value const_var_impl(const boost::shared_ptr<T> &t)
+      Boxed_Value const_var_impl(const std::shared_ptr<T> &t)
       {
-        return Boxed_Value( boost::const_pointer_cast<typename boost::add_const<T>::type>(t) );
+        return Boxed_Value( std::const_pointer_cast<typename std::add_const<T>::type>(t) );
       }
 
-    /// \brief Takes a boost::reference_wrapper value, adds const to the referenced type and returns an immutable Boxed_Value.
+    /// \brief Takes a std::reference_wrapper value, adds const to the referenced type and returns an immutable Boxed_Value.
     ///        Does not copy the referenced value.
     /// \param[in] t Reference object to make immutable
     /// \returns Immutable Boxed_Value
     /// \sa Boxed_Value::is_const
     template<typename T>
-      Boxed_Value const_var_impl(const boost::reference_wrapper<T> &t)
+      Boxed_Value const_var_impl(const std::reference_wrapper<T> &t)
       {
-        return Boxed_Value( boost::cref(t.get()) );
+        return Boxed_Value( std::cref(t.get()) );
       }
   }
 
-  /// \brief Takes an object and returns an immutable Boxed_Value. If the object is a boost::reference or pointer type
+  /// \brief Takes an object and returns an immutable Boxed_Value. If the object is a std::reference or pointer type
   ///        the value is not copied. If it is an object type, it is copied.
   /// \param[in] t Object to make immutable
   /// \returns Immutable Boxed_Value
@@ -348,7 +327,8 @@ namespace chaiscript
   /// chai.add(chaiscript::const_var(Green), "Green");
   /// \endcode
   /// 
-  /// \sa \ref addingobjects
+  /// \todo support C++11 strongly typed enums
+  /// \sa \ref adding_objects
   template<typename T>
     Boxed_Value const_var(const T &t)
     {
@@ -357,11 +337,6 @@ namespace chaiscript
 
 
 
-  /// \returns true if the two Boxed_Values share the same internal type
-  static bool type_match(Boxed_Value l, Boxed_Value r)
-  {
-    return l.get_type_info() == r.get_type_info();
-  }
 }
 
 #endif

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -7,23 +7,43 @@
 #ifndef CHAISCRIPT_DISPATCHKIT_HPP_
 #define CHAISCRIPT_DISPATCHKIT_HPP_
 
-#include <typeinfo>
-#include <string>
-#include <map>
-#include <set>
-#include <boost/shared_ptr.hpp>
-#include <stdexcept>
-#include <vector>
-#include <iostream>
+#include <algorithm>
+#include <cassert>
 #include <deque>
+#include <iostream>
+#include <iterator>
 #include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <utility>
+#include <vector>
 
-#include "boxed_value.hpp"
-#include "type_info.hpp"
-#include "proxy_functions.hpp"
-#include "proxy_constructors.hpp"
-#include "dynamic_object.hpp"
+#include "../chaiscript_defines.hpp"
 #include "../chaiscript_threading.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "dynamic_cast_conversion.hpp"
+#include "dynamic_object.hpp"
+#include "proxy_constructors.hpp"
+#include "proxy_functions.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Boxed_Number;
+}  // namespace chaiscript
+
+namespace chaiscript {
+namespace dispatch {
+class Dynamic_Proxy_Function;
+class Proxy_Function_Base;
+struct Placeholder_Object;
+}  // namespace dispatch
+}  // namespace chaiscript
 
 
 /// \namespace chaiscript::dispatch
@@ -39,12 +59,12 @@ namespace chaiscript
     class reserved_word_error : public std::runtime_error
     {
       public:
-        reserved_word_error(const std::string &t_word) throw()
+        reserved_word_error(const std::string &t_word) CHAISCRIPT_NOEXCEPT
           : std::runtime_error("Reserved word not allowed in object name: " + t_word), m_word(t_word)
         {
         }
 
-        virtual ~reserved_word_error() throw() {}
+        virtual ~reserved_word_error() CHAISCRIPT_NOEXCEPT {}
 
         std::string word() const
         {
@@ -108,12 +128,12 @@ namespace chaiscript
     class global_non_const : public std::runtime_error
     {
       public:
-        global_non_const() throw()
+        global_non_const() CHAISCRIPT_NOEXCEPT
           : std::runtime_error("a global object must be const")
         {
         }
 
-        virtual ~global_non_const() throw() {}
+        virtual ~global_non_const() CHAISCRIPT_NOEXCEPT {}
     };
   }
 
@@ -145,7 +165,7 @@ namespace chaiscript
       {
         if (!t_bv.is_const())
         {
-          throw exception::global_non_const();
+          throw chaiscript::exception::global_non_const();
         }
 
         m_globals.push_back(std::make_pair(t_bv, t_name));
@@ -160,7 +180,7 @@ namespace chaiscript
         return *this;
       }
 
-      Module &add(const boost::shared_ptr<Module> &m)
+      Module &add(const std::shared_ptr<Module> &m)
       {
         m->apply(*this, *this);
         return *m;
@@ -176,6 +196,10 @@ namespace chaiscript
           apply_globals(m_globals.begin(), m_globals.end(), t_engine);
         }
 
+      ~Module()
+      {
+      }
+
     private:
       std::vector<std::pair<Type_Info, std::string> > m_typeinfos;
       std::vector<std::pair<Proxy_Function, std::string> > m_funcs;
@@ -184,13 +208,13 @@ namespace chaiscript
       std::vector<Dynamic_Cast_Conversion> m_conversions;
 
       template<typename T, typename InItr>
-        void apply(InItr begin, InItr end, T &t) const
+        static void apply(InItr begin, InItr end, T &t) 
         {
           while (begin != end)
           {
             try {
               t.add(begin->first, begin->second);
-            } catch (const exception::name_conflict_error &) {
+            } catch (const chaiscript::exception::name_conflict_error &) {
               /// \todo Should we throw an error if there's a name conflict 
               ///       while applying a module?
             }
@@ -199,7 +223,7 @@ namespace chaiscript
         }
 
       template<typename T, typename InItr>
-        void apply_globals(InItr begin, InItr end, T &t) const
+        static void apply_globals(InItr begin, InItr end, T &t)
         {
           while (begin != end)
           {
@@ -209,7 +233,7 @@ namespace chaiscript
         }
 
       template<typename T, typename InItr>
-        void apply_single(InItr begin, InItr end, T &t) const
+        static void apply_single(InItr begin, InItr end, T &t)
         {
           while (begin != end)
           {
@@ -219,7 +243,7 @@ namespace chaiscript
         }
 
       template<typename T, typename InItr>
-        void apply_eval(InItr begin, InItr end, T &t) const
+        static void apply_eval(InItr begin, InItr end, T &t)
         {
           while (begin != end)
           {
@@ -230,7 +254,7 @@ namespace chaiscript
   };
 
   /// Convenience typedef for Module objects to be added to the ChaiScript runtime
-  typedef boost::shared_ptr<Module> ModulePtr;
+  typedef std::shared_ptr<Module> ModulePtr;
 
   namespace detail
   {
@@ -248,7 +272,7 @@ namespace chaiscript
         {
         }
 
-        virtual bool operator==(const dispatch::Proxy_Function_Base &rhs) const
+        virtual bool operator==(const dispatch::Proxy_Function_Base &rhs) const CHAISCRIPT_OVERRIDE
         {
           try {
             const Dispatch_Function &dispatchfun = dynamic_cast<const Dispatch_Function &>(rhs);
@@ -260,17 +284,17 @@ namespace chaiscript
 
         virtual ~Dispatch_Function() {}
 
-        virtual std::vector<Const_Proxy_Function> get_contained_functions() const
+        virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
         {
           return std::vector<Const_Proxy_Function>(m_funcs.begin(), m_funcs.end());
         }
 
 
-        virtual int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           typedef std::vector<Proxy_Function> function_vec;
 
-          function_vec::const_iterator begin = m_funcs.begin();
+          auto begin = m_funcs.begin();
           const function_vec::const_iterator end = m_funcs.end();
 
           if (begin != end)
@@ -296,12 +320,10 @@ namespace chaiscript
           return -1; // unknown arity
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
-          typedef std::vector<Proxy_Function> function_vec;
-
-          function_vec::const_iterator begin = m_funcs.begin();
-          function_vec::const_iterator end = m_funcs.end();
+          auto begin = m_funcs.begin();
+          auto end = m_funcs.end();
 
           while (begin != end)
           {
@@ -316,13 +338,13 @@ namespace chaiscript
           return false;
         }
 
-        virtual std::string annotation() const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return "Multiple method dispatch function wrapper.";
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return dispatch::dispatch(m_funcs.begin(), m_funcs.end(), params, t_conversions);
         }
@@ -334,7 +356,7 @@ namespace chaiscript
         {
           typedef std::vector<Proxy_Function> function_vec;
 
-          function_vec::const_iterator begin = t_funcs.begin();
+          auto begin = t_funcs.begin();
           const function_vec::const_iterator end = t_funcs.end();
 
           if (begin != end)
@@ -343,7 +365,7 @@ namespace chaiscript
 
             ++begin;
 
-            bool sizemismatch = false;
+            bool size_mismatch = false;
 
             while (begin != end)
             {
@@ -351,7 +373,7 @@ namespace chaiscript
 
               if (param_types.size() != type_infos.size())
               {
-                sizemismatch = true;
+                size_mismatch = true;
               }
 
               for (size_t i = 0; i < type_infos.size() && i < param_types.size(); ++i)
@@ -367,7 +389,7 @@ namespace chaiscript
 
             assert(type_infos.size() > 0 && " type_info vector size is < 0, this is only possible if something else is broken");
 
-            if (sizemismatch)
+            if (size_mismatch)
             {
               type_infos.resize(1);
             }
@@ -393,7 +415,7 @@ namespace chaiscript
         typedef std::map<std::string, chaiscript::Type_Info> Type_Name_Map;
         typedef std::map<std::string, Boxed_Value> Scope;
         typedef std::deque<Scope> StackData;
-        typedef boost::shared_ptr<StackData> Stack;
+        typedef std::shared_ptr<StackData> Stack;
 
         struct State
         {
@@ -402,10 +424,14 @@ namespace chaiscript
           std::map<std::string, Boxed_Value> m_global_objects;
           Type_Name_Map m_types;
           std::set<std::string> m_reserved_words;
+
+          State &operator=(const State &) = default;
         };
 
         Dispatch_Engine()
-          : m_place_holder(boost::shared_ptr<dispatch::Placeholder_Object>(new dispatch::Placeholder_Object()))
+          : m_stack_holder(this),
+            m_place_holder(std::shared_ptr<dispatch::Placeholder_Object>(new dispatch::Placeholder_Object()))
+            
         {
         }
 
@@ -458,21 +484,21 @@ namespace chaiscript
 
           add_object(name, obj);
         }
-        
+
 
         /**
          * Adds a named object to the current scope
          */
-        void add_object(const std::string &name, const Boxed_Value &obj)
+        void add_object(const std::string &name, const Boxed_Value &obj) const
         {
           StackData &stack = get_stack_data();
           validate_object_name(name);
-          
+
           Scope &scope = stack.back();
-          Scope::iterator itr = scope.find(name);
+          auto itr = scope.find(name);
           if (itr != stack.back().end())
           {
-            throw exception::name_conflict_error(name);
+            throw chaiscript::exception::name_conflict_error(name);
           } else {
             stack.back().insert(std::make_pair(name, obj));
           }
@@ -486,14 +512,14 @@ namespace chaiscript
           validate_object_name(name);
           if (!obj.is_const())
           {
-            throw exception::global_non_const();
+            throw chaiscript::exception::global_non_const();
           }
 
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
 
           if (m_state.m_global_objects.find(name) != m_state.m_global_objects.end())
           {
-            throw exception::name_conflict_error(name);
+            throw chaiscript::exception::name_conflict_error(name);
           } else {
             m_state.m_global_objects.insert(std::make_pair(name, obj));
           }
@@ -511,7 +537,7 @@ namespace chaiscript
 
           if (m_state.m_global_objects.find(name) != m_state.m_global_objects.end())
           {
-            throw exception::name_conflict_error(name);
+            throw chaiscript::exception::name_conflict_error(name);
           } else {
             m_state.m_global_objects.insert(std::make_pair(name, obj));
           }
@@ -590,7 +616,7 @@ namespace chaiscript
           {
             chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
 
-            std::map<std::string, Boxed_Value>::const_iterator itr = m_state.m_global_objects.find(name);
+            auto itr = m_state.m_global_objects.find(name);
             if (itr != m_state.m_global_objects.end())
             {
               return itr->second;
@@ -620,7 +646,7 @@ namespace chaiscript
         {
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
-          Type_Name_Map::const_iterator itr = m_state.m_types.find(name);
+          auto itr = m_state.m_types.find(name);
 
           if (itr != m_state.m_types.end())
           {
@@ -639,13 +665,11 @@ namespace chaiscript
         {
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
-          for (Type_Name_Map::const_iterator itr = m_state.m_types.begin();
-              itr != m_state.m_types.end();
-              ++itr)
+          for (const auto & elem : m_state.m_types)
           {
-            if (itr->second.bare_equal(ti))
+            if (elem.second.bare_equal(ti))
             {
-              return itr->first;
+              return elem.first;
             }
           }
 
@@ -672,7 +696,7 @@ namespace chaiscript
 
             const std::map<std::string, std::vector<Proxy_Function> > &funs = get_functions_int();
 
-            std::map<std::string, std::vector<Proxy_Function> >::const_iterator itr 
+            auto itr 
               = funs.find(t_name);
 
             if (itr != funs.end())
@@ -691,7 +715,7 @@ namespace chaiscript
 
           const std::map<std::string, Proxy_Function> &funs = get_function_objects_int();
 
-          std::map<std::string, Proxy_Function>::const_iterator itr = funs.find(t_name);
+          auto itr = funs.find(t_name);
 
           if (itr != funs.end())
           {
@@ -739,14 +763,16 @@ namespace chaiscript
         ///
         std::map<std::string, Boxed_Value> get_scripting_objects() const
         {
+          Stack_Holder &s = *m_stack_holder;
+
           // We don't want the current context, but one up if it exists
-          StackData &stack = (m_stack_holder->stacks.size()==1)?(*(m_stack_holder->stacks.back())):(*m_stack_holder->stacks[m_stack_holder->stacks.size()-2]);
+          StackData &stack = (s.stacks.size()==1)?(*(s.stacks.back())):(*s.stacks[s.stacks.size()-2]);
 
           std::map<std::string, Boxed_Value> retval;
 
           // note: map insert doesn't overwrite existing values, which is why this works
          
-          for (StackData::reverse_iterator itr = stack.rbegin(); itr != stack.rend(); ++itr)
+          for (auto itr = stack.rbegin(); itr != stack.rend(); ++itr)
           {
             retval.insert(itr->begin(), itr->end());
           } 
@@ -773,11 +799,9 @@ namespace chaiscript
 
           std::map<std::string, Boxed_Value> objs;
 
-          for (std::map<std::string, Proxy_Function>::const_iterator itr = funs.begin();
-               itr != funs.end();
-               ++itr)
+          for (const auto & fun : funs)
           {
-            objs.insert(std::make_pair(itr->first, const_var(itr->second)));
+            objs.insert(std::make_pair(fun.first, const_var(fun.second)));
           }
 
           return objs;
@@ -795,15 +819,11 @@ namespace chaiscript
 
           const std::map<std::string, std::vector<Proxy_Function> > &functions = get_functions_int();
 
-          for (std::map<std::string, std::vector<Proxy_Function> >::const_iterator itr = functions.begin();
-              itr != functions.end();
-              ++itr)
+          for (const auto & function : functions)
           {
-            for (std::vector<Proxy_Function>::const_iterator itr2 = itr->second.begin();
-                itr2 != itr->second.end();
-                ++itr2)
+            for (const auto & internal_func : function.second)
             {
-              rets.push_back(std::make_pair(itr->first, *itr2));
+              rets.push_back(std::make_pair(function.first, internal_func));
             }
           }
 
@@ -903,7 +923,7 @@ namespace chaiscript
         {
           if (params.size() < 1)
           {
-            throw exception::arity_error(static_cast<int>(params.size()), 1);
+            throw chaiscript::exception::arity_error(static_cast<int>(params.size()), 1);
           }
 
           Const_Proxy_Function f = this->boxed_cast<Const_Proxy_Function>(params[0]);
@@ -967,7 +987,7 @@ namespace chaiscript
           return get_type_name(obj.get_type_info());
         }
 
-        State get_state()
+        State get_state() const
         {
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l2(m_global_object_mutex);
@@ -985,7 +1005,8 @@ namespace chaiscript
 
         void save_function_params(const std::vector<Boxed_Value> &t_params)
         {
-          m_stack_holder->call_params.insert(m_stack_holder->call_params.begin(), t_params.begin(), t_params.end());
+          Stack_Holder &s = *m_stack_holder;
+          s.call_params.insert(s.call_params.begin(), t_params.begin(), t_params.end());
         }
 
         void new_function_call()
@@ -995,15 +1016,16 @@ namespace chaiscript
 
         void pop_function_call()
         {
-          --m_stack_holder->call_depth;
+          Stack_Holder &s = *m_stack_holder;
+          --s.call_depth;
 
-          assert(m_stack_holder->call_depth >= 0);
+          assert(s.call_depth >= 0);
 
-          if (m_stack_holder->call_depth == 0)
+          if (s.call_depth == 0)
           {
             /// \todo Critical: this needs to be smarter, memory can expand quickly
             ///       in tight loops involving function calls
-            m_stack_holder->call_params.clear();
+            s.call_params.clear();
           }
         }
 
@@ -1048,8 +1070,8 @@ namespace chaiscript
           const Type_Info boxed_type = user_type<Boxed_Value>();
           const Type_Info boxed_pod_type = user_type<Boxed_Number>();
 
-          boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_lhs(boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(lhs));
-          boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_rhs(boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(rhs));
+          std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_lhs(std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(lhs));
+          std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_rhs(std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(rhs));
 
           if (dynamic_lhs && dynamic_rhs)
           {
@@ -1138,14 +1160,14 @@ namespace chaiscript
         void validate_object_name(const std::string &name) const
         {
           if (name.find("::") != std::string::npos) {
-            throw exception::illegal_name_error(name);
+            throw chaiscript::exception::illegal_name_error(name);
           }
 
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
           if (m_state.m_reserved_words.find(name) != m_state.m_reserved_words.end())
           {
-            throw exception::reserved_word_error(name);
+            throw chaiscript::exception::reserved_word_error(name);
           }
         }
 
@@ -1159,7 +1181,7 @@ namespace chaiscript
 
           std::map<std::string, std::vector<Proxy_Function> > &funcs = get_functions_int();
 
-          std::map<std::string, std::vector<Proxy_Function> >::iterator itr
+          auto itr
             = funcs.find(t_name);
 
           std::map<std::string, Proxy_Function> &func_objs = get_function_objects_int();
@@ -1173,7 +1195,7 @@ namespace chaiscript
             {
               if ((*t_f) == *(*itr2))
               {
-                throw exception::name_conflict_error(t_name);
+                throw chaiscript::exception::name_conflict_error(t_name);
               }
             }
 

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

@@ -7,13 +7,18 @@
 #ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
 #define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
 
-#include "type_info.hpp"
-#include "boxed_value.hpp"
-#include "boxed_cast_helper.hpp"
+#include <memory>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+
+#include "../chaiscript_threading.hpp"
 #include "bad_boxed_cast.hpp"
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/is_base_of.hpp>
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "type_info.hpp"
 
 namespace chaiscript
 {
@@ -23,22 +28,22 @@ namespace chaiscript
     {
       public:
         bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) throw()
+            const std::string &t_what) CHAISCRIPT_NOEXCEPT
           : bad_boxed_cast(t_from, t_to, t_what)
         {
         }
 
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
           : bad_boxed_cast(t_from, t_to)
         {
         }
 
-        bad_boxed_dynamic_cast(const std::string &w) throw()
+        bad_boxed_dynamic_cast(const std::string &w) CHAISCRIPT_NOEXCEPT
           : bad_boxed_cast(w)
         {
         }
 
-        virtual ~bad_boxed_dynamic_cast() throw() {}
+        virtual ~bad_boxed_dynamic_cast() CHAISCRIPT_NOEXCEPT {}
     };
   }
 
@@ -48,12 +53,13 @@ namespace chaiscript
     {
       public:
         virtual Boxed_Value convert(const Boxed_Value &derived) const = 0;
+        virtual Boxed_Value convert_down(const Boxed_Value &base) const = 0;
 
-        const Type_Info &base()
+        const Type_Info &base() const
         {
           return m_base;
         }
-        const Type_Info &derived()
+        const Type_Info &derived() const
         {
           return m_derived;
         }
@@ -72,6 +78,57 @@ namespace chaiscript
 
     };
 
+    template<typename From, typename To> 
+      class Dynamic_Caster
+      {
+        public: 
+          static Boxed_Value cast(const Boxed_Value &t_from)
+          {
+            if (t_from.get_type_info().bare_equal(user_type<From>()))
+            {
+              if (t_from.is_pointer())
+              {
+                // Dynamic cast out the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  std::shared_ptr<const To> data
+                    = std::dynamic_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr));
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                } else {
+                  std::shared_ptr<To> data
+                    = std::dynamic_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr));
+
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                }
+              } else {
+                // Pull the reference out of the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  const From &d = detail::Cast_Helper<const From &>::cast(t_from, nullptr);
+                  const To &data = dynamic_cast<const To &>(d);
+                  return Boxed_Value(std::cref(data));
+                } else {
+                  From &d = detail::Cast_Helper<From &>::cast(t_from, nullptr);
+                  To &data = dynamic_cast<To &>(d);
+                  return Boxed_Value(std::ref(data));
+                }
+              }
+            } else {
+              throw chaiscript::exception::bad_boxed_dynamic_cast(t_from.get_type_info(), typeid(To), "Unknown dynamic_cast_conversion");
+            }
+          }
+      };
+
     template<typename Base, typename Derived>
       class Dynamic_Conversion_Impl : public Dynamic_Conversion
     {
@@ -81,50 +138,14 @@ namespace chaiscript
         {
         }
 
-        virtual Boxed_Value convert(const Boxed_Value &t_derived) const
+        virtual Boxed_Value convert_down(const Boxed_Value &t_base) const CHAISCRIPT_OVERRIDE
         {
-          if (t_derived.get_type_info().bare_equal(user_type<Derived>()))
-          {
-            if (t_derived.is_pointer())
-            {
-              // Dynamic cast out the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                boost::shared_ptr<const Base> data 
-                  = boost::dynamic_pointer_cast<const Base>(detail::Cast_Helper<boost::shared_ptr<const Derived> >::cast(t_derived, 0));
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
+          return Dynamic_Caster<Base, Derived>::cast(t_base);
+        }
 
-                return Boxed_Value(data);
-              } else {
-                boost::shared_ptr<Base> data 
-                  = boost::dynamic_pointer_cast<Base>(detail::Cast_Helper<boost::shared_ptr<Derived> >::cast(t_derived, 0));
-
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
-
-                return Boxed_Value(data);
-              }
-            } else {
-              // Pull the reference out of the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                const Derived &d = detail::Cast_Helper<const Derived &>::cast(t_derived, 0);
-                const Base &data = dynamic_cast<const Base &>(d);
-                return Boxed_Value(boost::cref(data));
-              } else {
-                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived, 0);
-                Base &data = dynamic_cast<Base &>(d);
-                return Boxed_Value(boost::ref(data));
-              }
-            }
-          } else {
-            throw exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
-          }
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
+        {
+          return Dynamic_Caster<Derived, Base>::cast(t_derived);
         }
     };
   }
@@ -141,7 +162,7 @@ namespace chaiscript
       {
       }
 
-      void add_conversion(const boost::shared_ptr<detail::Dynamic_Conversion> &conversion)
+      void add_conversion(const std::shared_ptr<detail::Dynamic_Conversion> &conversion)
       {
         chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
         m_conversions.insert(conversion);
@@ -155,7 +176,7 @@ namespace chaiscript
 
       bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived) const
       {
-        return has_conversion(base, derived);
+        return has_conversion(base, derived) || has_conversion(derived, base);
       }
 
       template<typename Base>
@@ -170,17 +191,30 @@ namespace chaiscript
           }
         }
 
+      template<typename Derived>
+        Boxed_Value boxed_dynamic_down_cast(const Boxed_Value &base) const
+        {
+          try {
+            return get_conversion(base.get_type_info(), user_type<Derived>())->convert_down(base);
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "Unable to perform dynamic_cast operation");
+          }
+        }
+
+
       bool has_conversion(const Type_Info &base, const Type_Info &derived) const
       {
         chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
         return find(base, derived) != m_conversions.end();
       }
 
-      boost::shared_ptr<detail::Dynamic_Conversion> get_conversion(const Type_Info &base, const Type_Info &derived) const
+      std::shared_ptr<detail::Dynamic_Conversion> get_conversion(const Type_Info &base, const Type_Info &derived) const
       {
         chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
-        std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr =
+        auto itr =
           find(base, derived);
 
         if (itr != m_conversions.end())
@@ -192,10 +226,10 @@ namespace chaiscript
       }
 
     private:
-      std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
           const Type_Info &base, const Type_Info &derived) const
       {
-        for (std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr = m_conversions.begin();
+        for (auto itr = m_conversions.begin();
             itr != m_conversions.end();
             ++itr)
         {
@@ -208,7 +242,7 @@ namespace chaiscript
         return m_conversions.end();
       }
 
-      std::set<boost::shared_ptr<detail::Dynamic_Conversion> > get_conversions() const
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> > get_conversions() const
       {
         chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
@@ -216,10 +250,10 @@ namespace chaiscript
       }
 
       mutable chaiscript::detail::threading::shared_mutex m_mutex;
-      std::set<boost::shared_ptr<detail::Dynamic_Conversion> > m_conversions;
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> > m_conversions;
   };
 
-  typedef boost::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
+  typedef std::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
 
   /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
   ///        want automatic conversions up your inheritance hierarchy.
@@ -242,19 +276,17 @@ namespace chaiscript
   /// chai.add(chaiscript::base_class<Base, Derived>());
   /// \endcode
   /// 
-  /// \todo Move share static type registration code into a mechanism that allows it to be properly
-  ///       shared by all modules
   template<typename Base, typename Derived>
-    Dynamic_Cast_Conversion base_class()
-    {
-      //Can only be used with related polymorphic types
-      //may be expanded some day to support conversions other than child -> parent
-      BOOST_STATIC_ASSERT((boost::is_base_of<Base,Derived>::value));
-      BOOST_STATIC_ASSERT(boost::is_polymorphic<Base>::value);
-      BOOST_STATIC_ASSERT(boost::is_polymorphic<Derived>::value);
+  Dynamic_Cast_Conversion base_class()
+  {
+    //Can only be used with related polymorphic types
+    //may be expanded some day to support conversions other than child -> parent
+    static_assert(std::is_base_of<Base,Derived>::value, "Classes are not related by inheritance");
+    static_assert(std::is_polymorphic<Base>::value, "Base class must be polymorphic");
+    static_assert(std::is_polymorphic<Derived>::value, "Derived class must be polymorphic");
 
-      return boost::shared_ptr<detail::Dynamic_Conversion>(new detail::Dynamic_Conversion_Impl<Base, Derived>());
-    }
+    return std::shared_ptr<detail::Dynamic_Conversion>(new detail::Dynamic_Conversion_Impl<Base, Derived>());
+  }
 
 }
 

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -7,7 +7,27 @@
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 #define CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 
-#include <boost/optional.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"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+namespace dispatch {
+class Proxy_Function_Base;
+}  // namespace dispatch
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -16,8 +36,8 @@ namespace chaiscript
     class Dynamic_Object
     {
       public:
-        Dynamic_Object(const std::string &t_type_name)
-          : m_type_name(t_type_name)
+        Dynamic_Object(std::string t_type_name)
+          : m_type_name(std::move(t_type_name))
         {
         }
 
@@ -31,7 +51,7 @@ namespace chaiscript
           return m_attrs[t_attr_name];
         }
 
-        std::map<std::string, Boxed_Value> get_attrs()
+        std::map<std::string, Boxed_Value> get_attrs() const
         {
           return m_attrs;
         }
@@ -53,11 +73,21 @@ namespace chaiscript
       {
         public:
           Dynamic_Object_Function(
-              const std::string &t_type_name,
+              std::string t_type_name,
+              const Proxy_Function &t_func)
+            : Proxy_Function_Base(t_func->get_param_types()),
+            m_type_name(std::move(t_type_name)), m_func(t_func), m_doti(user_type<Dynamic_Object>())
+          {
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
+
+          Dynamic_Object_Function(
+              std::string t_type_name,
               const Proxy_Function &t_func,
-              const boost::optional<Type_Info> &t_ti = boost::optional<Type_Info>())
+              const Type_Info &t_ti)
             : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti)),
-              m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
+              m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>())
           {
             assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
                 && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
@@ -65,7 +95,9 @@ namespace chaiscript
 
           virtual ~Dynamic_Object_Function() {}
 
-          virtual bool operator==(const Proxy_Function_Base &f) const
+          Dynamic_Object_Function &operator=(const Dynamic_Object_Function) = delete;
+
+          virtual bool operator==(const Proxy_Function_Base &f) const CHAISCRIPT_OVERRIDE
           {
             const Dynamic_Object_Function *df = dynamic_cast<const Dynamic_Object_Function *>(&f);
             if (df)
@@ -76,7 +108,7 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
             {
@@ -86,27 +118,25 @@ namespace chaiscript
             }
           }    
 
-          virtual std::vector<Const_Proxy_Function> get_contained_functions() const
+          virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
           {
-            std::vector<Const_Proxy_Function> fs;
-            fs.push_back(m_func);
-            return fs;
+            return {m_func};
           }
 
 
-          virtual int get_arity() const
+          virtual int get_arity() const CHAISCRIPT_OVERRIDE
           {
             return m_func->get_arity();
           }
 
-          virtual std::string annotation() const
+          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
           {
             return m_func->annotation();
           }
 
 
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
             {
@@ -116,33 +146,27 @@ namespace chaiscript
             } 
           }
 
-          virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             return dynamic_object_typename_match(bv, m_type_name, m_ti, t_conversions);
           }
 
         private:
           static std::vector<Type_Info> build_param_types(
-              const std::vector<Type_Info> &t_inner_types, boost::optional<Type_Info> t_objectti)
+              const std::vector<Type_Info> &t_inner_types, const Type_Info& t_objectti)
           {
-            if (t_objectti)
-            {
-              std::vector<Type_Info> types(t_inner_types);
+            std::vector<Type_Info> types(t_inner_types);
 
-              assert(types.size() > 1);
-              assert(types[1].bare_equal(user_type<Boxed_Value>()));
-              types[1] = *t_objectti;
-              return types;
-            } else {
-              return t_inner_types;
-            }
+            assert(types.size() > 1);
+            assert(types[1].bare_equal(user_type<Boxed_Value>()));
+            types[1] = t_objectti;
+            return types;
           }
 
-          static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const boost::optional<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions)
+          bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
+              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) const
           {
-            static Type_Info doti = user_type<Dynamic_Object>();
-            if (bv.get_type_info().bare_equal(doti))
+            if (bv.get_type_info().bare_equal(m_doti))
             {
               try {
                 const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
@@ -161,8 +185,8 @@ namespace chaiscript
 
           }
 
-          static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const boost::optional<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) 
+          bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) const
           {
             if (bvs.size() > 0)
             {
@@ -174,7 +198,9 @@ namespace chaiscript
 
           std::string m_type_name;
           Proxy_Function m_func;
-          boost::optional<Type_Info> m_ti;
+          std::shared_ptr<Type_Info> m_ti;
+          const Type_Info m_doti;
+
 
       };
 
@@ -189,10 +215,10 @@ namespace chaiscript
       {
         public:
           Dynamic_Object_Constructor(
-              const std::string &t_type_name,
+              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)
+              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)");
@@ -200,8 +226,8 @@ namespace chaiscript
 
           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();
+            auto begin = tl.begin();
+            auto end = tl.end();
 
             if (begin != end)
             {
@@ -213,7 +239,7 @@ namespace chaiscript
 
           virtual ~Dynamic_Object_Constructor() {}
 
-          virtual bool operator==(const Proxy_Function_Base &f) const
+          virtual bool operator==(const Proxy_Function_Base &f) const CHAISCRIPT_OVERRIDE
           {
             const Dynamic_Object_Constructor *dc = dynamic_cast<const Dynamic_Object_Constructor*>(&f);
             if (dc)
@@ -224,7 +250,7 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             std::vector<Boxed_Value> new_vals;
             new_vals.push_back(Boxed_Value(Dynamic_Object(m_type_name)));
@@ -234,19 +260,19 @@ namespace chaiscript
           }    
 
 
-          virtual int get_arity() const
+          virtual int get_arity() const CHAISCRIPT_OVERRIDE
           {
             // "this" is not considered part of the arity
             return m_func->get_arity() - 1; 
           }
 
-          virtual std::string annotation() const
+          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
           {
             return m_func->annotation();
           }
 
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             std::vector<Boxed_Value> new_params;
             chaiscript::Boxed_Value bv = var(Dynamic_Object(m_type_name));

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -7,8 +7,18 @@
 #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
@@ -23,7 +33,7 @@ namespace chaiscript
         template<typename T>
         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 exception::bad_boxed_cast &) {}
+          try { T t = t_engine.boxed_cast<T>(bv); throw t; } catch (const chaiscript::exception::bad_boxed_cast &) {}
         }
     };
 
@@ -32,7 +42,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl1() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
         }
@@ -42,7 +52,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl2() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);
@@ -54,7 +64,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl3() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);
@@ -66,7 +76,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl4() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);
@@ -79,7 +89,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl5() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);
@@ -140,7 +150,7 @@ namespace chaiscript
   ///
   /// \sa chaiscript::exception_specification for creation of chaiscript::Exception_Handler objects
   /// \sa \ref exceptions
-  typedef boost::shared_ptr<detail::Exception_Handler_Base> Exception_Handler;
+  typedef std::shared_ptr<detail::Exception_Handler_Base> Exception_Handler;
 
   /// \brief creates a chaiscript::Exception_Handler which handles one type of exception unboxing
   /// \sa \ref exceptions

include/chaiscript/dispatchkit/function_call.hpp

@@ -7,16 +7,22 @@
 #ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_HPP_
 
-#include <boost/shared_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
+#include <functional>
+#include <iostream>
 #include <string>
 #include <vector>
-#include "proxy_functions.hpp"
+
+#include "boxed_cast.hpp"
 #include "function_call_detail.hpp"
+#include "proxy_functions.hpp"
 
-
-#include <iostream>
+namespace chaiscript {
+class Boxed_Value;
+class Dynamic_Cast_Conversions;
+namespace detail {
+template <typename T> struct Cast_Helper;
+}  // namespace detail
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -25,16 +31,16 @@ namespace chaiscript
     /**
      * Build a function caller that knows how to dispatch on a set of functions
      * example: 
-     * boost::function<void (int)> f = 
+     * std::function<void (int)> f = 
      *      build_function_caller(dispatchkit.get_function("print"));
-     * \returns A boost::function object for dispatching
+     * \returns A std::function object for dispatching
      * \param[in] funcs the set of functions to dispatch on.
      */
     template<typename FunctionType>
-      boost::function<FunctionType>
+      std::function<FunctionType>
       functor(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
       {
-        FunctionType *p=0;
+        FunctionType *p=nullptr;
         return detail::build_function_caller_helper(p, funcs, t_conversions);
       }
 
@@ -45,14 +51,14 @@ namespace chaiscript
      * example: 
      * void my_function(Proxy_Function f)
      * {
-     *   boost::function<void (int)> local_f = 
+     *   std::function<void (int)> local_f = 
      *      build_function_caller(f);
      * }
-     * \returns A boost::function object for dispatching
+     * \returns A std::function object for dispatching
      * \param[in] func A function to execute.
      */
     template<typename FunctionType>
-      boost::function<FunctionType>
+      std::function<FunctionType>
       functor(Const_Proxy_Function func, const Dynamic_Cast_Conversions *t_conversions)
       {
         std::vector<Const_Proxy_Function> funcs;
@@ -65,7 +71,7 @@ namespace chaiscript
      * and creating a typesafe C++ function caller from it.
      */
     template<typename FunctionType>
-      boost::function<FunctionType>
+      std::function<FunctionType>
       functor(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions)
       {
         return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
@@ -74,12 +80,12 @@ namespace chaiscript
 
   namespace detail{
     /**
-     * Cast helper to handle automatic casting to const boost::function &
+     * Cast helper to handle automatic casting to const std::function &
      */
     template<typename Signature>
-      struct Cast_Helper<const boost::function<Signature> &>
+      struct Cast_Helper<const std::function<Signature> &>
       {
-        typedef boost::function<Signature> Result_Type;
+        typedef std::function<Signature> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
@@ -87,18 +93,18 @@ namespace chaiscript
           {
             return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> &>::cast(ob, t_conversions);
+            return Cast_Helper_Inner<const std::function<Signature> &>::cast(ob, t_conversions);
           }
         }
       };
 
     /**
-     * Cast helper to handle automatic casting to boost::function
+     * Cast helper to handle automatic casting to std::function
      */
     template<typename Signature>
-      struct Cast_Helper<boost::function<Signature> >
+      struct Cast_Helper<std::function<Signature> >
       {
-        typedef boost::function<Signature> Result_Type;
+        typedef std::function<Signature> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
@@ -106,18 +112,18 @@ namespace chaiscript
           {
             return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<boost::function<Signature> >::cast(ob, t_conversions);
+            return Cast_Helper_Inner<std::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };
 
     /**
-     * Cast helper to handle automatic casting to const boost::function
+     * Cast helper to handle automatic casting to const std::function
      */
     template<typename Signature>
-      struct Cast_Helper<const boost::function<Signature> >
+      struct Cast_Helper<const std::function<Signature> >
       {
-        typedef boost::function<Signature> Result_Type;
+        typedef std::function<Signature> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
@@ -125,7 +131,7 @@ namespace chaiscript
           {
             return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> >::cast(ob, t_conversions);
+            return Cast_Helper_Inner<const std::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -4,21 +4,20 @@
 // Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#define addparam(z,n,text)  params.push_back((boost::is_reference<Param ## n>::value&&!(boost::is_same<chaiscript::Boxed_Value, typename boost::remove_const<typename boost::remove_reference<Param ## n>::type>::type>::value))?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
-#define curry(z,n,text)  BOOST_PP_CAT(_, BOOST_PP_INC(n))
-
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 
-#include <boost/shared_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
+#include <algorithm>
+#include <functional>
+#include <memory>
 #include <string>
+#include <type_traits>
 #include <vector>
+
+#include "boxed_cast.hpp"
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+#include "dynamic_cast_conversion.hpp"
 #include "proxy_functions.hpp"
 
 namespace chaiscript
@@ -27,12 +26,11 @@ namespace chaiscript
   {
     namespace detail
     {
-
       /**
        * Internal helper class for handling the return
        * value of a build_function_caller
        */
-      template<typename Ret>
+      template<typename Ret, bool is_arithmetic>
         struct Function_Caller_Ret
         {
           static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
@@ -42,11 +40,25 @@ namespace chaiscript
           }
         };
 
+      /**
+       * 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 Dynamic_Cast_Conversions &t_conversions)
+          {
+            return Boxed_Number(dispatch::dispatch(t_funcs, params, t_conversions)).get_as<Ret>();
+          }
+        };
+
+
       /**
        * Specialization for void return types
        */
       template<>
-        struct Function_Caller_Ret<void>
+        struct Function_Caller_Ret<void, false>
         {
           static void call(const std::vector<Const_Proxy_Function> &t_funcs, 
               const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
@@ -54,51 +66,43 @@ namespace chaiscript
             dispatch::dispatch(t_funcs, params, t_conversions);
           }
         };
-    }
-  }
-}
 
-#define BOOST_PP_ITERATION_LIMITS ( 0, 9 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/function_call_detail.hpp>
-#include BOOST_PP_ITERATE()
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
-  namespace dispatch
-  {
-    namespace detail
-    {
       /**
        * used internally for unwrapping a function call's types
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        Ret function_caller(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions &t_conversions 
-            BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
+      template<typename Ret, typename ... Param>
+        struct Build_Function_Caller_Helper
         {
-          std::vector<Boxed_Value> params;
+          Build_Function_Caller_Helper(std::vector<Const_Proxy_Function> t_funcs, const Dynamic_Cast_Conversions &t_conversions)
+            : m_funcs(std::move(t_funcs)),
+              m_conversions(t_conversions)
+          {
+          }
 
-          BOOST_PP_REPEAT(n, addparam, ~);
+          Ret operator()(Param...param)
+          {
+            return Function_Caller_Ret<Ret, std::is_arithmetic<Ret>::value>::call(m_funcs, { 
+                (std::is_reference<Param>::value&&!(std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<Param>::type>::type>::value))?Boxed_Value(std::ref(param)):Boxed_Value(param)... 
+                }, m_conversions
 
-          return Function_Caller_Ret<Ret>::call(funcs, params, t_conversions);
-        }
+                );
 
-      /**
-       * used internally for unwrapping a function call's types
-       */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
-        build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<Const_Proxy_Function> &funcs, 
-            const Dynamic_Cast_Conversions *t_conversions)
+          }
+
+          std::vector<Const_Proxy_Function> m_funcs;
+          Dynamic_Cast_Conversions m_conversions;
+        };
+
+
+
+      template<typename Ret, typename ... Params>
+        std::function<Ret (Params...)> build_function_caller_helper(Ret (Params...), const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (funcs.size() == 1)
           {
-            boost::shared_ptr<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> > pfi = 
-              boost::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> >
-              (funcs[0]);
+            std::shared_ptr<const Proxy_Function_Impl<Ret (Params...)>> pfi = 
+              std::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (Params...)> >
+                (funcs[0]);
 
             if (pfi)
             {
@@ -108,15 +112,11 @@ namespace chaiscript
             // we cannot make any other guesses or assumptions really, so continuing
           }
 
-          return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs, (t_conversions?*t_conversions:Dynamic_Cast_Conversions())
-              BOOST_PP_ENUM_TRAILING(n, curry, ~));
+          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions?*t_conversions:Dynamic_Cast_Conversions()));
         }
     }
   }
 }
-#undef n
-#undef addparam
-#undef curry 
 
 #endif
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -7,15 +7,20 @@
 #ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
 #define CHAISCRIPT_HANDLE_RETURN_HPP_
 
-#include "boxed_value.hpp"
-#include "boxed_number.hpp"
-#include "type_info.hpp"
-#include <string>
-#include <boost/function.hpp>
-
+#include <functional>
+#include <memory>
 #include <stdexcept>
+#include <string>
 #include <vector>
 
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Boxed_Number;
+}  // namespace chaiscript
+
 namespace chaiscript
 {
   namespace dispatch
@@ -44,27 +49,27 @@ namespace chaiscript
         };
 
       template<typename Ret>
-        struct Handle_Return<boost::shared_ptr<Ret> &>
+        struct Handle_Return<std::shared_ptr<Ret> &>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
             return Boxed_Value(r);
           }
         };
 
       template<typename Ret>
-        struct Handle_Return<boost::shared_ptr<Ret> >
+        struct Handle_Return<std::shared_ptr<Ret> >
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
             return Boxed_Value(r);
           }
         };
 
       template<typename Ret>
-        struct Handle_Return<const boost::shared_ptr<Ret> &>
+        struct Handle_Return<const std::shared_ptr<Ret> &>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
             return Boxed_Value(r);
           }
@@ -75,7 +80,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const Ret &r)
           {
-            return Boxed_Value(boost::cref(r));
+            return Boxed_Value(std::cref(r));
           }
         };
 
@@ -88,12 +93,12 @@ namespace chaiscript
         {
           static Boxed_Value handle(Ret &r)
           {
-            return Boxed_Value(boost::ref(r));
+            return Boxed_Value(std::ref(r));
           }
 
           static Boxed_Value handle(const Ret &r)
           {
-            return Boxed_Value(boost::cref(r));
+            return Boxed_Value(std::cref(r));
           }
         };
 

include/chaiscript/dispatchkit/operators.hpp

@@ -7,6 +7,8 @@
 #ifndef CHAISCRIPT_OPERATORS_HPP_
 #define CHAISCRIPT_OPERATORS_HPP_
 
+#include "../chaiscript_defines.hpp"
+
 namespace chaiscript 
 {
   namespace bootstrap
@@ -154,7 +156,7 @@ namespace chaiscript
       template<typename Ret, typename L>
         Ret unary_minus(L l)
         {
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4146)
           return (-l);

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -4,24 +4,36 @@
 // Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
 
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 #define CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 
-#include <boost/shared_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
-
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_constructors.hpp>
-#include BOOST_PP_ITERATE()
-# endif
-
 namespace chaiscript
 {
+  namespace dispatch
+  {
+    namespace detail
+    {
+      /**
+       * A constructor function, used for creating a new object
+       * of a given type with a given set of params
+       */
+      template<typename Class, typename ... Params>
+        std::shared_ptr<Class> constructor_(Params ... params)
+        {
+          return std::shared_ptr<Class>(new Class(params...));
+        }
+
+      template<typename Class, typename ... Params  >
+        Proxy_Function build_constructor_(Class (*)(Params...))
+        {
+          typedef std::shared_ptr<Class> (sig)(Params...);
+          return Proxy_Function(new Proxy_Function_Impl<sig>(std::function<sig>(&(constructor_<Class, Params...>))));
+        }
+    }
+  }
+
+
   /// \brief Generates a constructor function for use with ChaiScript
   /// 
   /// \tparam T The signature of the constructor to generate. In the form of: ClassType (ParamType1, ParamType2, ...)
@@ -36,46 +48,11 @@ namespace chaiscript
   template<typename T>
     Proxy_Function constructor()
     {
-      T *f = 0;
+      T *f = nullptr;
       return (dispatch::detail::build_constructor_(f));
     }
+
 }
 
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
-  namespace dispatch
-  {
-    namespace detail
-    {
-      /**
-       * A constructor function, used for creating a new object
-       * of a given type with a given set of params
-       */
-      template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        boost::shared_ptr<Class> constructor_( BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
-        {
-          return boost::shared_ptr<Class>(new Class( BOOST_PP_ENUM_PARAMS(n, p) ));
-        }
-
-      /**
-       * Helper function for build a constructor function
-       * example:
-       * dispatchengine.register_function(build_constructor<MyClass, int, const std::string&>, "MyClass");
-       * \todo See if it is possible to make this not be a variadic function
-       */
-      template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        Proxy_Function build_constructor_(Class (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
-        {
-          typedef boost::shared_ptr<Class> (sig)(BOOST_PP_ENUM_PARAMS(n, Param));
-          return Proxy_Function(new Proxy_Function_Impl<sig>(boost::function<sig>(&(constructor_<Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>))));
-        }
-    }
-  }
-}
-#undef n
-
 #endif
 

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -9,55 +9,39 @@
 #define CHAISCRIPT_PROXY_FUNCTIONS_HPP_
 
 
-#include "boxed_value.hpp"
-#include "type_info.hpp"
-#include <string>
-#include <boost/function.hpp>
-#include <boost/type_traits/add_reference.hpp>
+#include <algorithm>
+#include <cassert>
+#include <functional>
+#include <memory>
 #include <stdexcept>
+#include <string>
+#include <type_traits>
 #include <vector>
+
+#include "../chaiscript_defines.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
 #include "proxy_functions_detail.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+namespace exception {
+class bad_boxed_cast;
+struct arity_error;
+}  // namespace exception
+}  // namespace chaiscript
 
 namespace chaiscript
 {
   class Boxed_Number;
   struct AST_Node;
 
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<AST_Node> AST_NodePtr;
 
   namespace dispatch
   {
-    /**
-     * Helper for building a list of parameters for calling a Proxy_Function
-     * it does automatic conversion to Boxed_Value types via operator<<
-     *
-     * example usage:
-     * Boxed_Value retval = dispatch(dispatchengine.get_function("+"), 
-     *                               chaiscript::Param_List_Builder() << 5 << 6);
-     */
-    struct Param_List_Builder
-    {
-      Param_List_Builder &operator<<(const Boxed_Value &so)
-      {
-        objects.push_back(so);
-        return *this;
-      }
-
-      template<typename T>
-        Param_List_Builder &operator<<(T t)
-        {
-          objects.push_back(Boxed_Value(t));
-          return *this;
-        }
-
-      operator const std::vector<Boxed_Value> &() const
-      {
-        return objects;
-      }
-
-      std::vector<Boxed_Value> objects;
-    };
-
     /**
      * Pure virtual base class for all Proxy_Function implementations
      * Proxy_Functions are a type erasure of type safe C++
@@ -70,6 +54,7 @@ namespace chaiscript
     {
       public:
         virtual ~Proxy_Function_Base() {}
+
         Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Dynamic_Cast_Conversions &t_conversions) const
         {
           Boxed_Value bv = do_call(params, t_conversions);
@@ -80,7 +65,7 @@ namespace chaiscript
         /// if the function is variadic or takes no arguments (arity of 0 or -1), the returned
         /// value containes exactly 1 Type_Info object: the return type
         /// \returns the types of all parameters. 
-        std::vector<Type_Info> get_param_types() const { return m_types; }
+        const std::vector<Type_Info> &get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
         virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
@@ -90,12 +75,11 @@ namespace chaiscript
           return m_has_arithmetic_param;
         }
 
-        virtual std::vector<boost::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
+        virtual std::vector<std::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
         {
-          return std::vector<boost::shared_ptr<const Proxy_Function_Base> >();
+          return std::vector<std::shared_ptr<const Proxy_Function_Base> >();
         }
 
-
         //! Return true if the function is a possible match
         //! to the passed in values
         bool filter(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
@@ -129,7 +113,7 @@ namespace chaiscript
               || (!bv.get_type_info().is_undef()
                 && (ti.bare_equal(user_type<Boxed_Number>())
                   || ti.bare_equal(bv.get_type_info())
-                  || bv.get_type_info().bare_equal(user_type<boost::shared_ptr<const Proxy_Function_Base> >())
+                  || bv.get_type_info().bare_equal(user_type<std::shared_ptr<const Proxy_Function_Base> >())
                   || t_conversions.dynamic_cast_converts(ti, bv.get_type_info()) 
                   )
                 )
@@ -143,8 +127,8 @@ namespace chaiscript
       protected:
         virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
-        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
-          : m_types(t_types), m_has_arithmetic_param(false)
+        Proxy_Function_Base(std::vector<Type_Info> t_types)
+          : m_types(std::move(t_types)), m_has_arithmetic_param(false)
         {
           for (size_t i = 1; i < m_types.size(); ++i)
           {
@@ -196,11 +180,11 @@ namespace chaiscript
   }
 
   /// \brief Common typedef used for passing of any registered function in ChaiScript
-  typedef boost::shared_ptr<dispatch::Proxy_Function_Base> Proxy_Function;
+  typedef std::shared_ptr<dispatch::Proxy_Function_Base> Proxy_Function;
 
   /// \brief Const version of Proxy_Function chaiscript. Points to a const Proxy_Function. This is how most registered functions
   ///        are handled internally.
-  typedef boost::shared_ptr<const dispatch::Proxy_Function_Base> Const_Proxy_Function;
+  typedef std::shared_ptr<const dispatch::Proxy_Function_Base> Const_Proxy_Function;
 
   namespace exception
   {
@@ -208,11 +192,11 @@ namespace chaiscript
     class guard_error : public std::runtime_error
     {
       public:
-        guard_error() throw()
+        guard_error() CHAISCRIPT_NOEXCEPT
           : std::runtime_error("Guard evaluation failed")
         { }
 
-        virtual ~guard_error() throw()
+        virtual ~guard_error() CHAISCRIPT_NOEXCEPT
         { }
     };
   }
@@ -227,17 +211,19 @@ namespace chaiscript
     {
       public:
         Dynamic_Proxy_Function(
-            const boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, 
+            std::function<Boxed_Value (const std::vector<Boxed_Value> &)> t_f, 
             int t_arity=-1,
-            const AST_NodePtr &t_parsenode = AST_NodePtr(),
-            const std::string &t_description = "",
-            const Proxy_Function &t_guard = Proxy_Function())
+            AST_NodePtr t_parsenode = AST_NodePtr(),
+            std::string t_description = "",
+            Proxy_Function t_guard = Proxy_Function())
           : Proxy_Function_Base(build_param_type_list(t_arity)),
-            m_f(t_f), m_arity(t_arity), m_description(t_description), m_guard(t_guard), m_parsenode(t_parsenode)
+            m_f(std::move(t_f)), m_arity(t_arity), m_description(std::move(t_description)), m_guard(std::move(t_guard)), m_parsenode(std::move(t_parsenode))
         {
         }
 
-        virtual bool operator==(const Proxy_Function_Base &rhs) const
+        virtual ~Dynamic_Proxy_Function() {}
+
+        virtual bool operator==(const Proxy_Function_Base &rhs) const CHAISCRIPT_OVERRIDE
         {
           const Dynamic_Proxy_Function *prhs = dynamic_cast<const Dynamic_Proxy_Function *>(&rhs);
 
@@ -247,16 +233,13 @@ namespace chaiscript
                 && !this->m_guard && !prhs->m_guard);
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return (m_arity < 0 || vals.size() == size_t(m_arity))
             && test_guard(vals, t_conversions);
         }    
 
-        virtual ~Dynamic_Proxy_Function() {}
-
-
-        virtual int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return m_arity;
         }
@@ -271,13 +254,13 @@ namespace chaiscript
           return m_parsenode;
         }
 
-        virtual std::string annotation() const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return m_description;
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (m_arity < 0 || params.size() == size_t(m_arity))
           {
@@ -318,7 +301,7 @@ namespace chaiscript
           // For the return type
           types.push_back(chaiscript::detail::Get_Type_Info<Boxed_Value>::get());
 
-          if (arity >= 0)
+          if (arity > 0)
           {
             for (int i = 0; i < arity; ++i)
             {
@@ -329,7 +312,7 @@ namespace chaiscript
           return types;
         }
 
-        boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
+        std::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
         int m_arity;
         std::string m_description;
         Proxy_Function m_guard;
@@ -361,19 +344,19 @@ namespace chaiscript
           assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
         }
 
-        virtual bool operator==(const Proxy_Function_Base &t_f) const
+        virtual bool operator==(const Proxy_Function_Base &t_f) const CHAISCRIPT_OVERRIDE
         {
           return &t_f == this;
         }
 
         virtual ~Bound_Function() {}
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return m_f->call_match(build_param_list(vals), t_conversions);
         }
 
-        virtual std::vector<Const_Proxy_Function> get_contained_functions() const
+        virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
         {
           std::vector<Const_Proxy_Function> fs;
           fs.push_back(m_f);
@@ -383,10 +366,8 @@ namespace chaiscript
 
         std::vector<Boxed_Value> build_param_list(const std::vector<Boxed_Value> &params) const
         {
-          typedef std::vector<Boxed_Value>::const_iterator pitr;
-
-          pitr parg = params.begin();
-          pitr barg = m_args.begin();
+          auto parg = params.begin();
+          auto barg = m_args.begin();
 
           std::vector<Boxed_Value> args;
 
@@ -414,12 +395,12 @@ namespace chaiscript
           return args;
         }
 
-        virtual int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return m_arity;
         }
 
-        virtual std::string annotation() const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return "Bound: " + m_f->annotation();
         }
@@ -429,6 +410,7 @@ namespace chaiscript
             const std::vector<Boxed_Value> &t_args)
         {
           assert(t_f->get_arity() < 0 || t_f->get_arity() == static_cast<int>(t_args.size()));
+
           if (t_f->get_arity() < 0) { return std::vector<Type_Info>(); }
 
           std::vector<Type_Info> types = t_f->get_param_types();
@@ -447,7 +429,7 @@ namespace chaiscript
           return retval;
         }
 
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return (*m_f)(build_param_list(params), t_conversions);
         }
@@ -460,35 +442,33 @@ namespace chaiscript
 
     /**
      * The standard typesafe function call implementation of Proxy_Function
-     * It takes a boost::function<> object and performs runtime 
+     * It takes a std::function<> object and performs runtime 
      * type checking of Boxed_Value parameters, in a type safe manner
      */
     template<typename Func>
       class Proxy_Function_Impl : public Proxy_Function_Base
     {
       public:
-        Proxy_Function_Impl(const boost::function<Func> &f)
-          : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(0))),
-          m_f(f), m_dummy_func(0)
+        Proxy_Function_Impl(std::function<Func> f)
+          : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(nullptr))),
+          m_f(std::move(f)), m_dummy_func(nullptr)
         {
         }
 
         virtual ~Proxy_Function_Impl() {}
 
-        virtual bool operator==(const Proxy_Function_Base &t_func) const
+        virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
         {
           const Proxy_Function_Impl *pimpl = dynamic_cast<const Proxy_Function_Impl<Func> *>(&t_func);
-          return pimpl != 0;
+          return pimpl != nullptr;
         }
 
-
-        virtual int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return static_cast<int>(m_types.size()) - 1;
         }
 
-
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (int(vals.size()) != get_arity()) 
           {
@@ -498,24 +478,24 @@ namespace chaiscript
           return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals, t_conversions);
         }
 
-        virtual std::string annotation() const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return "";
         }
 
-        boost::function<Func> internal_function() const
+        std::function<Func> internal_function() const
         {
           return m_f;
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
-          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params, t_conversions);
+          return detail::Do_Call<typename std::function<Func>::result_type>::go(m_f, params, t_conversions);
         }
 
       private:
-        boost::function<Func> m_f;
+        std::function<Func> m_f;
         Func *m_dummy_func;
     };
 
@@ -534,10 +514,11 @@ namespace chaiscript
 
         virtual ~Attribute_Access() {}
 
-        virtual bool operator==(const Proxy_Function_Base &t_func) const
+        virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
         {
           const Attribute_Access<T, Class> * aa 
             = dynamic_cast<const Attribute_Access<T, Class> *>(&t_func);
+
           if (aa) {
             return m_attr == aa->m_attr;
           } else {
@@ -546,12 +527,12 @@ namespace chaiscript
         }
 
 
-        virtual int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return 1;
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const CHAISCRIPT_OVERRIDE
         {
           if (vals.size() != 1)
           {
@@ -561,13 +542,13 @@ namespace chaiscript
           return vals[0].get_type_info().bare_equal(user_type<Class>());
         }
 
-        virtual std::string annotation() const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return "";
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (params.size() == 1)
           {
@@ -575,10 +556,10 @@ namespace chaiscript
             if (bv.is_const())
             {
               const Class *o = boxed_cast<const Class *>(bv, &t_conversions);
-              return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
+              return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
             } else {
               Class *o = boxed_cast<Class *>(bv, &t_conversions);
-              return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
+              return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
             }
           } else {
             throw exception::arity_error(static_cast<int>(params.size()), 1);
@@ -588,11 +569,9 @@ namespace chaiscript
       private:
         static std::vector<Type_Info> param_types()
         {
-          std::vector<Type_Info> v;
-          v.push_back(user_type<T>());
-          v.push_back(user_type<Class>());
-          return v;
+          return {user_type<T>(), user_type<Class>()};
         }
+
         T Class::* m_attr;
     };
   }
@@ -607,13 +586,13 @@ namespace chaiscript
     class dispatch_error : public std::runtime_error
     {
       public:
-        dispatch_error(const std::vector<Boxed_Value> &t_parameters, 
-            const std::vector<Const_Proxy_Function> &t_functions)
-          : std::runtime_error("Error with function dispatch"), parameters(t_parameters), functions(t_functions)
+        dispatch_error(std::vector<Boxed_Value> t_parameters, 
+            std::vector<Const_Proxy_Function> t_functions)
+          : std::runtime_error("Error with function dispatch"), parameters(std::move(t_parameters)), functions(std::move(t_functions))
         {
         }
 
-        virtual ~dispatch_error() throw() {}
+        virtual ~dispatch_error() CHAISCRIPT_NOEXCEPT {}
 
         std::vector<Boxed_Value> parameters;
         std::vector<Const_Proxy_Function> functions;

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -4,27 +4,28 @@
 // Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#define gettypeinfo(z,n,text)  ti.push_back(chaiscript::detail::Get_Type_Info<Param ## n>::get());
-#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n], &t_conversions)
-#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n], &t_conversions);
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
-#include "boxed_value.hpp"
-#include "boxed_cast.hpp"
-#include "type_info.hpp"
-#include "handle_return.hpp"
-#include <string>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-
+#include <algorithm>
+#include <functional>
 #include <stdexcept>
+#include <string>
 #include <vector>
 
+#include "../chaiscript_defines.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_value.hpp"
+#include "handle_return.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+namespace exception {
+class bad_boxed_cast;
+}  // namespace exception
+}  // namespace chaiscript
+
 namespace chaiscript
 {
   namespace exception
@@ -41,109 +42,91 @@ namespace chaiscript
       {
       }
 
-      virtual ~arity_error() throw() {}
+      virtual ~arity_error() CHAISCRIPT_NOEXCEPT {}
 
       int got;
       int expected;
     };
   }
 
-}
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_functions_detail.hpp>
-#include BOOST_PP_ITERATE()
-
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
   namespace dispatch
   {
     namespace detail
     {
+      template<typename ... Rest>
+      struct Build_Param_Type_List;
+
+      template<typename Param, typename ... Rest>
+      struct Build_Param_Type_List<Param, Rest...>
+      {
+        static void build(std::vector<Type_Info> &t_params)
+        {
+          t_params.push_back(chaiscript::detail::Get_Type_Info<Param>::get());
+          Build_Param_Type_List<Rest...>::build(t_params);
+        }
+      };
+
+      // 0th case
+      template<>
+      struct Build_Param_Type_List<>
+      {
+        static void build(std::vector<Type_Info> &)
+        {
+        }
+      };
+
+
       /**
        * Used by Proxy_Function_Impl to return a list of all param types
        * it contains.
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        std::vector<Type_Info> build_param_type_list(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
+      template<typename Ret, typename ... Params>
+        std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
         {
-          std::vector<Type_Info> ti;
-          ti.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
-
-          BOOST_PP_REPEAT(n, gettypeinfo, ~) 
-
-          return ti;
+          /// \todo this code was previously using { chaiscript::detail::Get_Type_Info<Ret>::get()... }
+          ///       but this seems to indicate another bug with MSVC's uniform initializer lists
+          std::vector<Type_Info> params;
+          params.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
+          Build_Param_Type_List<Params...>::build(params);
+          return params;
         }
 
-      /**
-       * 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.
-       */
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
 
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-parameter"
-#endif
+      // Forward declaration
+      template<typename ... Rest> 
+        struct Try_Cast; 
 
-      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, const Dynamic_Cast_Conversions & BOOST_PP_IF(n, t_conversions, BOOST_PP_EMPTY))
-
-#ifdef __llvm__
-#pragma clang diagnostic pop
-#endif
+      template<typename Param, typename ... Rest>
+        struct Try_Cast<Param, Rest...>
         {
-          if (params.size() != n)
+          static void do_try(const std::vector<Boxed_Value> &params, int generation, const Dynamic_Cast_Conversions &t_conversions)
           {
-            throw exception::arity_error(static_cast<int>(params.size()), n);
-          } else {
-            return f(BOOST_PP_REPEAT(n, casthelper, ~));
+            boxed_cast<Param>(params[generation], &t_conversions);
+            Try_Cast<Rest...>::do_try(params, generation+1, t_conversions);
           }
-        }
+        };
+
+      // 0th case
+      template<>
+        struct Try_Cast<>
+        {
+          static void do_try(const std::vector<Boxed_Value> &, int, const Dynamic_Cast_Conversions &)
+          {
+          }
+        };
 
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
 
       /**
        * 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
        */
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-parameter"
-#endif
-
-       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, BOOST_PP_EMPTY), const Dynamic_Cast_Conversions &t_conversions)
-
-
-#ifdef __llvm__
-#pragma clang diagnostic pop
-#endif
-        {
+      template<typename Ret, typename ... Params>
+        bool compare_types_cast(Ret (*)(Params...),
+             const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+       {
           try {
-            (void)t_conversions;
-            BOOST_PP_REPEAT(n, trycast, ~);
+            Try_Cast<Params...>::do_try(params, 0, t_conversions);
           } catch (const exception::bad_boxed_cast &) {
             return false;
           }
@@ -151,24 +134,59 @@ namespace chaiscript
           return true;
         }
 
-#ifdef BOOST_MSVC
+      template<typename Ret, int count, typename ... Params>
+        struct Call_Func
+        {
+
+          template<typename ... InnerParams>
+          static Ret do_call(const std::function<Ret (Params...)> &f,
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions, InnerParams &&... innerparams)
+          {
+            return Call_Func<Ret, count - 1, Params...>::do_call(f, params, t_conversions, std::forward<InnerParams>(innerparams)..., params[sizeof...(Params) - count]);
+          } 
+        };
+
+      template<typename Ret, typename ... Params>
+        struct Call_Func<Ret, 0, Params...>
+        {
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4100) /// Disable unreferenced formal parameter warning, which only shows up in MSVC I don't think there's any way around it \todo evaluate this
+#endif
+          template<typename ... InnerParams>
+            static Ret do_call(const std::function<Ret (Params...)> &f,
+                const std::vector<Boxed_Value> &, const Dynamic_Cast_Conversions &t_conversions, InnerParams &&... innerparams)
+            {
+              return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams), &t_conversions)...);
+            }
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
+        };
+
+      /**
+       * Used by Proxy_Function_Impl to perform typesafe execution of a function.
+       * The function attempts to unbox each 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, typename ... Params>
+        Ret call_func(const std::function<Ret (Params...)> &f,
+            const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+        {
+          if (params.size() == sizeof...(Params))
+          {
+            return Call_Func<Ret, sizeof...(Params), Params...>::do_call(f, params, t_conversions);
+          }
+
+          throw exception::arity_error(static_cast<int>(params.size()), sizeof...(Params));
+        }
 
     }
   }
+
 }
 
-#undef n
-#undef gettypeinfo
-#undef casthelper
-#undef trycast
-
-
-#endif
-
-
-#ifndef BOOST_PP_IS_ITERATING
 
 namespace chaiscript
 {
@@ -180,7 +198,7 @@ namespace chaiscript
       struct Do_Call
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
             return Handle_Return<Ret>::handle(call_func(fun, params, t_conversions));
           }
@@ -190,7 +208,7 @@ namespace chaiscript
       struct Do_Call<void>
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
             call_func(fun, params, t_conversions);
             return Handle_Return<void>::handle();

include/chaiscript/dispatchkit/register_function.hpp

@@ -7,14 +7,12 @@
 #ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_
 #define CHAISCRIPT_REGISTER_FUNCTION_HPP_
 
-#include "dispatchkit.hpp"
+#include <functional>
+#include <type_traits>
+
 #include "bind_first.hpp"
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/function_types/components.hpp>
-#include <boost/function_types/function_type.hpp>
-#include <boost/function_types/is_member_object_pointer.hpp>
-#include <boost/function_types/is_member_function_pointer.hpp>
+#include "dispatchkit.hpp"
+#include "proxy_functions.hpp"
 
 namespace chaiscript
 {
@@ -22,39 +20,53 @@ namespace chaiscript
   {
     namespace detail
     {
-      template<bool Object, bool MemFn>
+      template<typename T>
+        struct FunctionSignature
+        {
+        };
+
+      template<typename Sig>
+        struct FunctionSignature<std::function<Sig> >
+        {
+          typedef Sig Signature;
+        };
+
+      template<typename Ret, typename ... Args> 
+        std::function<Ret (Args...) > to_function(Ret (*func)(Args...))
+        {
+          return std::function<Ret (Args...)>(func);
+        }
+
+      template<typename Ret, typename Class, typename ... Args> 
+        std::function<Ret (Class &, Args...) > to_function(Ret (Class::*func)(Args...))
+        {
+          /// \todo this std::mem_fn wrap shouldn't be necessary but type conversions for 
+          ///       std::function for member function pointers seems to be broken in MSVC
+          return std::function<Ret(Class &, Args...)>(std::mem_fn(func));
+        }
+
+      template<typename Ret, typename Class, typename ... Args> 
+        std::function<Ret (const Class &, Args...) > to_function(Ret (Class::*func)(Args...) const)
+        {
+          /// \todo this std::mem_fn wrap shouldn't be necessary but type conversions for 
+          ///       std::function for member function pointers seems to be broken in MSVC
+          return std::function<Ret (const Class &, Args...)>(std::mem_fn(func));
+        }
+
+      template<bool Object>
         struct Fun_Helper
         {
           template<typename T>
             static Proxy_Function go(T t)
             {
+              /// \todo is it possible to reduce the number of templates generated here?
               return Proxy_Function(
-                  new Proxy_Function_Impl<
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(t)));
+                  new Proxy_Function_Impl<typename FunctionSignature<decltype(to_function(t)) >::Signature>(to_function(t)));
             }      
         };
 
       template<>
-        struct Fun_Helper<false, true>
-        {
-          template<typename T>
-            static Proxy_Function go(T t)
-            {
-              return Proxy_Function(
-                  new Proxy_Function_Impl<
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(boost::mem_fn(t))));
-            }      
-        };
-
-
-      template<>
-        struct Fun_Helper<true, false>
+        struct Fun_Helper<true>
         {
           template<typename T, typename Class>
             static Proxy_Function go(T Class::* m)
@@ -65,23 +77,6 @@ namespace chaiscript
     }
   }
 
-  /// \brief Creates a new Proxy_Function object from a boost::function object
-  /// \param[in] f boost::function to expose to ChaiScript
-  ///
-  /// \b Example:
-  /// \code
-  /// boost::function<int (char, float, std::string)> f = get_some_function();
-  /// chaiscript::ChaiScript chai;
-  /// chai.add(fun(f), "some_function");
-  /// \endcode
-  /// 
-  /// \sa \ref addingfunctions
-  template<typename T>
-    Proxy_Function fun(const boost::function<T> &f)
-    {
-      return Proxy_Function(new dispatch::Proxy_Function_Impl<T>(f));
-    }
-
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member
   /// \param[in] t Function / member to expose
   ///
@@ -101,13 +96,32 @@ namespace chaiscript
   /// chai.add(fun(&MyClass::memberdata), "memberdata");
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T>
     Proxy_Function fun(T t)
     {
-      return dispatch::detail::Fun_Helper<boost::function_types::is_member_object_pointer<T>::value, boost::function_types::is_member_function_pointer<T>::value>::go(t);
+      return dispatch::detail::Fun_Helper<std::is_member_object_pointer<T>::value>::go(t);
     }
 
+
+  /// \brief Creates a new Proxy_Function object from a std::function object
+  /// \param[in] f std::function to expose to ChaiScript
+  ///
+  /// \b Example:
+  /// \code
+  /// std::function<int (char, float, std::string)> f = get_some_function();
+  /// chaiscript::ChaiScript chai;
+  /// chai.add(fun(f), "some_function");
+  /// \endcode
+  /// 
+  /// \sa \ref adding_functions
+  template<typename T>
+    Proxy_Function fun(const std::function<T> &f)
+    {
+      return Proxy_Function(new dispatch::Proxy_Function_Impl<T>(f));
+    }
+
+  
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member and binds the first parameter of it
   /// \param[in] t Function / member to expose
   /// \param[in] q Value to bind to first parameter
@@ -122,10 +136,10 @@ namespace chaiscript
   /// MyClass obj;
   /// chaiscript::ChaiScript chai;
   /// // Add function taking only one argument, an int, and permanently bound to "obj"
-  /// chai.add(fun(&MyClass::memberfunction, boost::ref(obj)), "memberfunction"); 
+  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj)), "memberfunction"); 
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T, typename Q>
     Proxy_Function fun(T t, const Q &q)
     {
@@ -148,10 +162,10 @@ namespace chaiscript
   /// chaiscript::ChaiScript chai;
   /// // Add function taking only no arguments, and permanently bound to "obj" and "1"
   /// // memberfunction() will be equivalent to obj.memberfunction(1)
-  /// chai.add(fun(&MyClass::memberfunction, boost::ref(obj), 1), "memberfunction"); 
+  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj), 1), "memberfunction"); 
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T, typename Q, typename R>
     Proxy_Function fun(T t, const Q &q, const R &r)
     {

include/chaiscript/dispatchkit/type_info.hpp

@@ -7,19 +7,11 @@
 #ifndef CHAISCRIPT_TYPE_INFO_HPP_
 #define CHAISCRIPT_TYPE_INFO_HPP_
 
+#include <functional>
+#include <memory>
 #include <string>
+#include <type_traits>
 #include <typeinfo>
-#include <boost/shared_ptr.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/ref.hpp>
 
 namespace chaiscript
 {
@@ -29,7 +21,7 @@ namespace chaiscript
     template<typename T>
       struct Bare_Type
       {
-        typedef typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type type;
+        typedef typename std::remove_cv<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::type type;
       };
   }
 
@@ -37,7 +29,7 @@ namespace chaiscript
   class Type_Info
   {
     public:
-      Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
+      CHAISCRIPT_CONSTEXPR Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
           bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
         : m_type_info(t_ti), m_bare_type_info(t_bareti),
         m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
@@ -47,7 +39,7 @@ namespace chaiscript
       }
 
       Type_Info()
-        : m_type_info(0), m_bare_type_info(0),
+        : m_type_info(nullptr), m_bare_type_info(nullptr),
         m_is_const(false), m_is_reference(false), m_is_pointer(false),
         m_is_void(false), m_is_arithmetic(false), 
         m_is_undef(true)
@@ -90,7 +82,7 @@ namespace chaiscript
 
       bool operator==(const std::type_info &ti) const
       {
-        return m_type_info != 0 && (*m_type_info) == ti;
+        return m_type_info != nullptr && (*m_type_info) == ti;
       }
 
       bool bare_equal(const Type_Info &ti) const
@@ -101,7 +93,7 @@ namespace chaiscript
 
       bool bare_equal_type_info(const std::type_info &ti) const
       {
-        return m_bare_type_info != 0 
+        return m_bare_type_info != nullptr 
           && (*m_bare_type_info) == ti;
       }
 
@@ -109,7 +101,7 @@ namespace chaiscript
       bool is_reference() const { return m_is_reference; }
       bool is_void() const { return m_is_void; }
       bool is_arithmetic() const { return m_is_arithmetic; }
-      bool is_undef() const { return m_is_undef || m_bare_type_info == 0; }
+      bool is_undef() const { return m_is_undef || m_bare_type_info == nullptr; }
       bool is_pointer() const { return m_is_pointer; }
 
       std::string name() const
@@ -153,72 +145,72 @@ namespace chaiscript
       {
         typedef T type;
 
-        static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
-          return Type_Info(boost::is_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
+          return Type_Info(std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
               &typeid(T), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<boost::shared_ptr<T> >
+      struct Get_Type_Info<std::shared_ptr<T> >
       {
         typedef T type;
 
-        static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(boost::shared_ptr<T> ), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(std::shared_ptr<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<const boost::shared_ptr<T> &>
+      struct Get_Type_Info<const std::shared_ptr<T> &>
       {
         typedef T type;
 
-        static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(const boost::shared_ptr<T> &), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(const std::shared_ptr<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<boost::reference_wrapper<T> >
+      struct Get_Type_Info<std::reference_wrapper<T> >
       {
         typedef T type;
 
-        static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(boost::reference_wrapper<T> ), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(std::reference_wrapper<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<const boost::reference_wrapper<T> &>
+      struct Get_Type_Info<const std::reference_wrapper<T> &>
       {
         typedef T type;
 
-        static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(const boost::reference_wrapper<T> &), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(const std::reference_wrapper<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
@@ -240,7 +232,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type(i);
   /// \endcode
   template<typename T>
-  Type_Info user_type(const T &/*t*/)
+  CHAISCRIPT_CONSTEXPR Type_Info user_type(const T &/*t*/)
   {
     return detail::Get_Type_Info<T>::get();
   }
@@ -255,7 +247,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
   /// \endcode
   template<typename T>
-  Type_Info user_type()
+  CHAISCRIPT_CONSTEXPR Type_Info user_type()
   {
     return detail::Get_Type_Info<T>::get();
   }

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -5,10 +5,11 @@
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ALGEBRAIC_HPP_
-#define	CHAISCRIPT_ALGEBRAIC_HPP_
+#define CHAISCRIPT_ALGEBRAIC_HPP_
 
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
-#include <boost/enable_shared_from_this.hpp>
+#include <string>
+
+#include "../dispatchkit/dispatchkit.hpp"
 
 namespace chaiscript
 {
@@ -127,5 +128,5 @@ namespace chaiscript
   };
 }
 
-#endif	/* _CHAISCRIPT_ALGEBRAIC_HPP */
+#endif /* _CHAISCRIPT_ALGEBRAIC_HPP */
 

include/chaiscript/language/chaiscript_common.hpp

@@ -5,10 +5,24 @@
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
-#define	CHAISCRIPT_COMMON_HPP_
+#define CHAISCRIPT_COMMON_HPP_
 
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
-#include <boost/enable_shared_from_this.hpp>
+#include <algorithm>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../chaiscript_defines.hpp"
+#include "../dispatchkit/boxed_value.hpp"
+#include "../dispatchkit/dispatchkit.hpp"
+#include "../dispatchkit/proxy_functions.hpp"
+#include "../dispatchkit/type_info.hpp"
+
+namespace chaiscript {
+struct AST_Node;
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -23,7 +37,7 @@ namespace chaiscript
                 Comparison, Addition, Subtraction, Multiplication, Division, Modulus, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
                 Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Continue, Map_Pair, Value_Range,
                 Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl, Shift, Equality, Bitwise_And, Bitwise_Xor, Bitwise_Or, 
-                Logical_And, Logical_Or, Switch, Case, Default, Ternary_Cond, Noop
+                Logical_And, Logical_Or, Reference, Switch, Case, Default, Ternary_Cond, Noop
     };
   };
 
@@ -36,7 +50,7 @@ namespace chaiscript
                                     "Comparison", "Addition", "Subtraction", "Multiplication", "Division", "Modulus", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
                                     "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Continue", "Map_Pair", "Value_Range",
                                     "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Shift", "Equality", "Bitwise_And", "Bitwise_Xor", "Bitwise_Or", 
-                                    "Logical_And", "Logical_Or", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
+                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
 
       return ast_node_types[ast_node_type];
     }
@@ -54,7 +68,7 @@ namespace chaiscript
   };
 
   /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<AST_Node> AST_NodePtr;
 
 
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
@@ -73,26 +87,26 @@ namespace chaiscript
       eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
           bool t_dot_notation,
-          const chaiscript::detail::Dispatch_Engine &t_ss)  :
+          const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_NOEXCEPT :
         std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_dot_notation, t_ss)),
-        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss))
+        reason(t_why), start_position(t_where), end_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) :
+           const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_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) :
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) CHAISCRIPT_NOEXCEPT :
         std::runtime_error(format(t_why, t_where, t_fname)),
         reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
       {}
 
-      eval_error(const std::string &t_why) throw()
+      eval_error(const std::string &t_why) CHAISCRIPT_NOEXCEPT
         : std::runtime_error("Error: \"" + t_why + "\" "),
         reason(t_why) 
       {}
@@ -119,7 +133,7 @@ namespace chaiscript
         return ss.str();
       }
 
-      virtual ~eval_error() throw() {}
+      virtual ~eval_error() CHAISCRIPT_NOEXCEPT {}
 
     private:
 
@@ -203,8 +217,8 @@ namespace chaiscript
         }
 
 
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfun 
-          = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_func);
+        std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfun 
+          = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_func);
 
         if (dynfun)
         {
@@ -212,8 +226,8 @@ namespace chaiscript
 
           if (f)
           {
-            boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfunguard 
-              = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(f);
+            std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfunguard 
+              = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(f);
             if (dynfunguard)
             {
               retval += " : " + format_guard(dynfunguard->get_parse_tree());
@@ -253,11 +267,9 @@ namespace chaiscript
         } else {
           ss << "  " << t_functions.size() << " overloads available:" << std::endl;
 
-          for (std::vector<chaiscript::Const_Proxy_Function>::const_iterator itr = t_functions.begin();
-               itr != t_functions.end();
-               ++itr)
+          for (const auto & t_function : t_functions)
           {
-            ss << "      " << format_types((*itr), t_dot_notation, t_ss) << std::endl;
+            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << std::endl;
           }
 
         }
@@ -277,7 +289,7 @@ namespace chaiscript
         {
           std::string paramstr;
 
-          for (std::vector<Boxed_Value>::const_iterator itr = t_parameters.begin();
+          for (auto itr = t_parameters.begin();
                itr != t_parameters.end();
                ++itr)
           {
@@ -378,22 +390,22 @@ namespace chaiscript
 
     /// Errors generated when loading a file
     struct file_not_found_error : public std::runtime_error {
-      file_not_found_error(const std::string &t_filename) throw()
+      file_not_found_error(const std::string &t_filename) CHAISCRIPT_NOEXCEPT
         : std::runtime_error("File Not Found: " + t_filename)
       { }
 
-      virtual ~file_not_found_error() throw() {}
+      virtual ~file_not_found_error() CHAISCRIPT_NOEXCEPT {}
     };
 
   }
 
  
   /// \brief Struct that doubles as both a parser ast_node and an AST node.
-  struct AST_Node : boost::enable_shared_from_this<AST_Node> {
+  struct AST_Node : std::enable_shared_from_this<AST_Node> {
     public:
       const std::string text;
-      const int identifier;
-      boost::shared_ptr<const std::string> filename;
+      const int identifier; //< \todo shouldn't this be a strongly typed enum value?
+      std::shared_ptr<const std::string> filename;
       File_Position start, end;
       std::vector<AST_NodePtr> children;
       AST_NodePtr annotation;
@@ -404,8 +416,8 @@ namespace chaiscript
 
         oss << text;
 
-        for (unsigned int j = 0; j < this->children.size(); ++j) {
-          oss << this->children[j]->pretty_print();
+        for (auto & elem : this->children) {
+          oss << elem->pretty_print();
         }
 
         return oss.str();
@@ -413,13 +425,13 @@ namespace chaiscript
 
 
       /// Prints the contents of an AST node, including its children, recursively
-      std::string to_string(std::string t_prepend = "") {
+      std::string to_string(const std::string &t_prepend = "") {
         std::ostringstream oss;
 
         oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
             << this->text << " : " << this->start.line << ", " << this->start.column << std::endl;
         
-        for (unsigned int j = 0; j < this->children.size(); ++j) {
+        for (size_t j = 0; j < this->children.size(); ++j) {
           oss << this->children[j]->to_string(t_prepend + "  ");
         }
         return oss.str();
@@ -435,7 +447,7 @@ namespace chaiscript
           return eval_internal(t_e);
         } catch (exception::eval_error &ee) {
           ee.call_stack.push_back(shared_from_this());
-          throw ee;
+          throw;
         }
       }
 
@@ -446,15 +458,15 @@ namespace chaiscript
       }
 
     protected:
-      AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname, 
+      AST_Node(std::string t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname, 
           int t_start_line, int t_start_col, int t_end_line, int t_end_col) :
-        text(t_ast_node_text), identifier(t_id), filename(t_fname),
+        text(std::move(t_ast_node_text)), identifier(t_id), filename(t_fname),
         start(t_start_line, t_start_col), end(t_end_line, t_end_col)
       {
       }
 
-      AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname) :
-        text(t_ast_node_text), identifier(t_id), filename(t_fname) {}
+      AST_Node(std::string t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname) :
+        text(std::move(t_ast_node_text)), identifier(t_id), filename(t_fname) {}
 
       virtual ~AST_Node() {}
 
@@ -518,7 +530,7 @@ namespace chaiscript
         chaiscript::detail::Dispatch_Engine &m_de;
       };
 
-      /// Creates a new functon call and pops it on destruction
+      /// Creates a new function call and pops it on destruction
       struct Function_Push_Pop
       {
         Function_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
@@ -572,5 +584,5 @@ namespace chaiscript
   }
 }
 
-#endif	/* _CHAISCRIPT_COMMON_HPP */
+#endif /* _CHAISCRIPT_COMMON_HPP */
 

include/chaiscript/language/chaiscript_engine.hpp

@@ -7,15 +7,37 @@
 #ifndef CHAISCRIPT_ENGINE_HPP_
 #define CHAISCRIPT_ENGINE_HPP_
 
+#include <cassert>
+#include <cstring>
+#include <algorithm>
 #include <exception>
 #include <fstream>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <vector>
 
+#include "../chaiscript_defines.hpp"
+#include "../chaiscript_threading.hpp"
+#include "../dispatchkit/boxed_cast_helper.hpp"
+#include "../dispatchkit/boxed_value.hpp"
+#include "../dispatchkit/dispatchkit.hpp"
+#include "../dispatchkit/dynamic_cast_conversion.hpp"
+#include "../dispatchkit/proxy_functions.hpp"
 #include "chaiscript_common.hpp"
 
-#ifdef _POSIX_VERSION
+#if defined(__linux__) || defined(__unix__) || defined(__APPLE__) || defined(__HAIKU__)
+#include <unistd.h>
+#endif
+
+#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
 #include <dlfcn.h>
 #else
-#ifdef BOOST_WINDOWS
+#ifdef CHAISCRIPT_WINDOWS
 #define VC_EXTRA_LEAN
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
@@ -23,9 +45,9 @@
 #endif
 
 
-#include "chaiscript_prelude.hpp"
-#include "chaiscript_parser.hpp"
 #include "../dispatchkit/exception_specification.hpp"
+#include "chaiscript_parser.hpp"
+#include "chaiscript_prelude.chai"
 
 namespace chaiscript
 {
@@ -34,12 +56,12 @@ namespace chaiscript
     /// \brief Thrown if an error occurs while attempting to load a binary module
     struct load_module_error : std::runtime_error
     {
-      load_module_error(const std::string &t_reason) throw()
+      load_module_error(const std::string &t_reason) CHAISCRIPT_NOEXCEPT
         : std::runtime_error(t_reason)
       {
       }
 
-      virtual ~load_module_error() throw()
+      virtual ~load_module_error() CHAISCRIPT_NOEXCEPT
       {
       }
     };
@@ -47,7 +69,7 @@ namespace chaiscript
 
   namespace detail
   {
-#ifdef _POSIX_VERSION
+#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
     struct Loadable_Module
     {
       struct DLModule
@@ -57,7 +79,7 @@ namespace chaiscript
         {
           if (!m_data)
           {
-            throw exception::load_module_error(dlerror());
+            throw chaiscript::exception::load_module_error(dlerror());
           }
         }
 
@@ -80,7 +102,7 @@ namespace chaiscript
           {
             if (!m_symbol)
             {
-              throw exception::load_module_error(dlerror());
+              throw chaiscript::exception::load_module_error(dlerror());
             }
           }
 
@@ -118,32 +140,32 @@ namespace chaiscript
     struct Loadable_Module
     {
       template<typename T>
-        static std::wstring towstring(const T &t_str) 
+        static std::wstring to_wstring(const T &t_str) 
         {
           return std::wstring(t_str.begin(), t_str.end());
         }
 
       template<typename T>
-        static std::string tostring(const T &t_str)
+        static std::string to_string(const T &t_str)
         {
           return std::string(t_str.begin(), t_str.end());
         }
 
 #ifdef _UNICODE
       template<typename T>
-        static std::wstring toproperstring(const T &t_str)
+        static std::wstring to_proper_string(const T &t_str)
         {
-          return towstring(t_str);
+          return to_wstring(t_str);
         }
 #else
       template<typename T>
-        static std::string toproperstring(const T &t_str)
+        static std::string to_proper_string(const T &t_str)
         {
-          return tostring(t_str);
+          return to_string(t_str);
         }
 #endif
 
-      static std::string GetErrorMessage(DWORD t_err)
+      static std::string get_error_message(DWORD t_err)
       {
 #ifdef _UNICODE
         typedef LPWSTR StringType;
@@ -152,9 +174,9 @@ namespace chaiscript
         typedef LPSTR StringType;
         std::string retval = "Unknown Error";
 #endif
-        StringType lpMsgBuf = 0;
+        StringType lpMsgBuf = nullptr;
 
-        FormatMessage(
+        if (FormatMessage(
             FORMAT_MESSAGE_ALLOCATE_BUFFER | 
             FORMAT_MESSAGE_FROM_SYSTEM |
             FORMAT_MESSAGE_IGNORE_INSERTS,
@@ -162,25 +184,23 @@ namespace chaiscript
             t_err,
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
             (StringType)&lpMsgBuf,
-            0, NULL );        
-
-        if (lpMsgBuf)
+            0, NULL ) != 0 && lpMsgBuf)
         {
           retval = lpMsgBuf;
+          LocalFree(lpMsgBuf);
         }
 
-        LocalFree(lpMsgBuf);
-        return tostring(retval);
+        return to_string(retval);
       }
 
       struct DLModule
       {
         DLModule(const std::string &t_filename)
-          : m_data(LoadLibrary(toproperstring(t_filename).c_str()))
+          : m_data(LoadLibrary(to_proper_string(t_filename).c_str()))
         {
           if (!m_data)
           {
-            throw exception::load_module_error(GetErrorMessage(GetLastError()));
+            throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
           }
         }
 
@@ -200,7 +220,7 @@ namespace chaiscript
           {
             if (!m_symbol)
             {
-              throw exception::load_module_error(GetErrorMessage(GetLastError()));
+              throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
             }
           }
 
@@ -223,7 +243,7 @@ namespace chaiscript
     {
       Loadable_Module(const std::string &, const std::string &)
       {
-        throw exception::load_module_error("Loadable module support not available for your platform");
+        throw chaiscript::exception::load_module_error("Loadable module support not available for your platform");
       }
 
       ModulePtr m_moduleptr;
@@ -231,7 +251,7 @@ namespace chaiscript
 #endif
 #endif
 
-    typedef boost::shared_ptr<Loadable_Module> Loadable_Module_Ptr;
+    typedef std::shared_ptr<Loadable_Module> Loadable_Module_Ptr;
   }
 
 
@@ -250,8 +270,6 @@ namespace chaiscript
 
     chaiscript::detail::Dispatch_Engine m_engine;
 
-
-
     /// Evaluates the given string in by parsing it and running the results through the evaluator
     Boxed_Value do_eval(const std::string &t_input, const std::string &t_filename = "__EVAL__", bool /* t_internal*/  = false) 
     {
@@ -291,18 +309,13 @@ namespace chaiscript
       }
     }
 
-
-
     /// Returns the current evaluation m_engine
     chaiscript::detail::Dispatch_Engine &get_eval_engine() {
       return m_engine;
     }
 
-
     /// Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
-    void build_eval_system() {
-      using namespace bootstrap;
-      m_engine.add_reserved_word("auto");
+    void build_eval_system(const ModulePtr &t_lib) {
       m_engine.add_reserved_word("def");
       m_engine.add_reserved_word("fun");
       m_engine.add_reserved_word("while");
@@ -312,59 +325,60 @@ namespace chaiscript
       m_engine.add_reserved_word("&&");
       m_engine.add_reserved_word("||");
       m_engine.add_reserved_word(",");
-      m_engine.add_reserved_word(":=");
-      m_engine.add_reserved_word("var");
+      m_engine.add_reserved_word("auto");
       m_engine.add_reserved_word("return");
       m_engine.add_reserved_word("break");
       m_engine.add_reserved_word("true");
       m_engine.add_reserved_word("false");
       m_engine.add_reserved_word("_");
 
-      add(Bootstrap::bootstrap());
+      if (t_lib)
+      {
+        add(t_lib);
+      }
 
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_system, boost::ref(m_engine)), "dump_system");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_object, boost::ref(m_engine)), "dump_object");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::is_type, boost::ref(m_engine)), "is_type");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::type_name, boost::ref(m_engine)), "type_name");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::function_exists, boost::ref(m_engine)), "function_exists");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_function_objects, boost::ref(m_engine)), "get_functions");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_scripting_objects, boost::ref(m_engine)), "get_objects");
-
-
-      m_engine.add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&chaiscript::detail::Dispatch_Engine::call_exists, boost::ref(m_engine), _1))), 
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_system, std::ref(m_engine)), "dump_system");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_object, std::ref(m_engine)), "dump_object");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::is_type, std::ref(m_engine)), "is_type");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::type_name, std::ref(m_engine)), "type_name");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::function_exists, std::ref(m_engine)), "function_exists");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_function_objects, std::ref(m_engine)), "get_functions");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_scripting_objects, std::ref(m_engine)), "get_objects");
+      m_engine.add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&chaiscript::detail::Dispatch_Engine::call_exists, std::ref(m_engine), std::placeholders::_1))), 
           "call_exists");
-      m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base *, const std::vector<Boxed_Value> &)>(boost::bind(&chaiscript::dispatch::Proxy_Function_Base::operator(), _1, _2, boost::ref(m_engine.conversions()))), "call");
+      m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base *, const std::vector<Boxed_Value> &)>(std::bind(&chaiscript::dispatch::Proxy_Function_Base::operator(), std::placeholders::_1, std::placeholders::_2, std::ref(m_engine.conversions()))), "call");
+
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::ref(m_engine)), "name");
 
 
-
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, boost::ref(m_engine)), "name");
-
-
-      typedef void (ChaiScript::*load_mod_1)(const std::string&);
+      typedef std::string (ChaiScript::*load_mod_1)(const std::string&);
       typedef void (ChaiScript::*load_mod_2)(const std::string&, const std::string&);
 
       m_engine.add(fun(static_cast<load_mod_1>(&ChaiScript::load_module), this), "load_module");
       m_engine.add(fun(static_cast<load_mod_2>(&ChaiScript::load_module), this), "load_module");
 
-      add(standard_library::vector_type<std::vector<Boxed_Value> >("Vector"));
-      add(standard_library::string_type<std::string>("string"));
-      add(standard_library::map_type<std::map<std::string, Boxed_Value> >("Map"));
-      add(standard_library::pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair"));
-
       m_engine.add(fun(&ChaiScript::use, this), "use");
       m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
       m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
 
-      do_eval(chaiscript_prelude, "standard prelude");
+      m_engine.add(fun(&ChaiScript::version_major, this), "version_major");
+      m_engine.add(fun(&ChaiScript::version_minor, this), "version_minor");
+      m_engine.add(fun(&ChaiScript::version_patch, this), "version_patch");
+      m_engine.add(fun(&ChaiScript::version, this), "version");
+
+      m_engine.add(fun(&ChaiScript::add_global_const, this), "add_global_const");
+      m_engine.add(fun(&ChaiScript::add_global, this), "add_global");
+
+      do_eval(ChaiScript_Prelude::chaiscript_prelude(), "standard prelude");
     }
 
 
     /// Helper function for loading a file
-    std::string load_file(const std::string &t_filename) {
+    static std::string load_file(const std::string &t_filename) {
       std::ifstream infile(t_filename.c_str(), std::ios::in | std::ios::ate | std::ios::binary );
 
       if (!infile.is_open()) {
-        throw exception::file_not_found_error(t_filename);
+        throw chaiscript::exception::file_not_found_error(t_filename);
       }
 
       std::streampos size = infile.tellg();
@@ -384,11 +398,13 @@ namespace chaiscript
 
   public:
     /// \brief Constructor for ChaiScript
+    /// \param[in] t_lib Standard library to apply to this ChaiScript instance
     /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
     /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
-    ChaiScript(const std::vector<std::string> &t_modulepaths = std::vector<std::string>(),
-                      const std::vector<std::string> &t_usepaths = std::vector<std::string>())
-      : m_modulepaths(t_modulepaths), m_usepaths(t_usepaths) 
+    ChaiScript(const ModulePtr &t_lib,
+               std::vector<std::string> t_modulepaths = std::vector<std::string>(),
+                      std::vector<std::string> t_usepaths = std::vector<std::string>())
+      : m_modulepaths(std::move(t_modulepaths)), m_usepaths(std::move(t_usepaths)) 
     {
       if (m_modulepaths.empty())
       {
@@ -400,7 +416,91 @@ namespace chaiscript
         m_usepaths.push_back("");
       }
 
-      build_eval_system();
+      build_eval_system(t_lib);
+    }
+
+    /// \brief Constructor for ChaiScript.
+    /// 
+    /// This version of the ChaiScript constructor attempts to find the stdlib module to load
+    /// at runtime generates an error if it cannot be found.
+    ///
+    /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
+    /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
+    ChaiScript( std::vector<std::string> t_modulepaths = std::vector<std::string>(),
+                      std::vector<std::string> t_usepaths = std::vector<std::string>())
+      : m_modulepaths(std::move(t_modulepaths)), m_usepaths(std::move(t_usepaths)) 
+    {
+      if (m_modulepaths.empty())
+      {
+        m_modulepaths.push_back("");
+      }
+
+      if (m_usepaths.empty())
+      {
+        m_usepaths.push_back("");
+      }
+
+#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
+      // If on Unix, add the path of the current executable to the module search path
+      // as windows would do
+
+      union cast_union
+      {
+        void (ChaiScript::*in_ptr)(const std::string&);
+        void *out_ptr;
+      };
+
+      Dl_info rInfo; 
+      memset( &rInfo, 0, sizeof(rInfo) ); 
+      cast_union u;
+      u.in_ptr = &ChaiScript::use;
+      if ( dladdr((void*)(u.out_ptr), &rInfo) && rInfo.dli_fname ) { 
+        std::string dllpath(rInfo.dli_fname);
+        size_t lastslash = dllpath.rfind('/');
+        if (lastslash != std::string::npos)
+        {
+          dllpath.erase(lastslash);
+        }
+
+        // Let's see if this is a link that we should expand
+        std::vector<char> buf(2048);
+        size_t pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
+        if (pathlen > 0 && pathlen < buf.size())
+        {
+          dllpath = std::string(&buf.front(), pathlen);
+        }
+
+        m_modulepaths.insert(m_modulepaths.begin(), dllpath+"/");
+      } 
+#endif    
+
+
+      // attempt to load the stdlib
+      load_module("chaiscript_stdlib-" + version());
+
+      build_eval_system(ModulePtr());
+    }
+
+    int version_major() const
+    {
+      return chaiscript::version_major;
+    }
+
+    int version_minor() const
+    {
+      return chaiscript::version_minor;
+    }
+
+    int version_patch() const
+    {
+      return chaiscript::version_patch;
+    }
+
+    std::string version() const
+    {
+      std::stringstream ss;
+      ss << version_major() << "." << version_minor() << "." << version_patch();
+      return ss.str();
     }
 
     /// \brief Loads and parses a file. If the file is already, it is not reloaded
@@ -441,7 +541,7 @@ namespace chaiscript
     /// \brief Adds a constant object that is available in all contexts and to all threads
     /// \param[in] t_bv Boxed_Value to add as a global
     /// \param[in] t_name Name of the value to add
-    /// \throw exception::global_non_const If t_bv is not a constant object
+    /// \throw chaiscript::exception::global_non_const If t_bv is not a constant object
     /// \sa Boxed_Value::is_const
     ChaiScript &add_global_const(const Boxed_Value &t_bv, const std::string &t_name)
     {
@@ -549,7 +649,7 @@ namespace chaiscript
     /// chai.add(chaiscript::var(&obj), "obj"); // Add a pointer to a locally defined object
     /// \endcode
     ///
-    /// \sa \ref addingitems
+    /// \sa \ref adding_items
     template<typename T>
     ChaiScript &add(const T &t_t, const std::string &t_name)
     {
@@ -592,13 +692,20 @@ namespace chaiscript
     /// If no file can be found matching the search criteria and containing the appropriate entry point 
     /// (the symbol mentioned above), an exception is thrown.
     ///
-    /// \throw exception::load_module_error In the event that no matching module can be found.
-    void load_module(const std::string &t_module_name)
+    /// \throw chaiscript::exception::load_module_error In the event that no matching module can be found.
+    std::string load_module(const std::string &t_module_name)
     {
       std::vector<exception::load_module_error> errors;
+      std::string version_stripped_name = t_module_name;
+      size_t version_pos = version_stripped_name.find("-"+version());
+      if (version_pos != std::string::npos)
+      {
+        version_stripped_name.erase(version_pos);
+      }
 
       std::vector<std::string> prefixes;
       prefixes.push_back("lib");
+      prefixes.push_back("cyg");
       prefixes.push_back("");
 
       std::vector<std::string> postfixes;
@@ -606,23 +713,25 @@ namespace chaiscript
       postfixes.push_back(".so");
       postfixes.push_back("");
 
-      for (size_t i = 0; i < m_modulepaths.size(); ++i)
+      for (auto & elem : m_modulepaths) 
+      {
+        for (auto & prefix : prefixes)
         {
-          for (size_t j = 0; j < prefixes.size(); ++j)
-            {
-              for (size_t k = 0; k < postfixes.size(); ++k)
-                {
-                  try {
-                    std::string name = m_modulepaths[i] + prefixes[j] + t_module_name + postfixes[k];
-                    load_module(t_module_name, name);
-                    return;
-                  } catch (const exception::load_module_error &e) {
-                    errors.push_back(e);
-                    // Try next set
-                  }
-                }
+          for (auto & postfix : postfixes)
+          {
+            try {
+              std::string name = elem + prefix + t_module_name + postfix;
+              // std::cerr << "trying location: " << name << std::endl;
+              load_module(version_stripped_name, name);
+              return name;
+            } catch (const chaiscript::exception::load_module_error &e) {
+              // std::cerr << "error: " << e.what() << std::endl;
+              errors.push_back(e);
+              // Try next set
             }
+          }
         }
+      }
 
       std::string errstring;
 
@@ -638,7 +747,7 @@ namespace chaiscript
         errstring += itr->what();
       }
 
-      throw exception::load_module_error("Unable to find module: " + t_module_name + " Errors: " + errstring);
+      throw chaiscript::exception::load_module_error("Unable to find module: " + t_module_name + " Errors: " + errstring);
     }
 
     /// \brief Load a binary module from a dynamic library. Works on platforms that support
@@ -672,7 +781,7 @@ namespace chaiscript
     ///
     /// \return result of the script execution
     /// 
-    /// \throw exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
     Boxed_Value operator()(const std::string &t_script, const Exception_Handler &t_handler = Exception_Handler())
     {
       try {
@@ -681,7 +790,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -695,8 +804,8 @@ namespace chaiscript
     ///
     /// \return result of the script execution
     /// 
-    /// \throw exception::eval_error In the case that evaluation fails.
-    /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
     ///        to the requested type.
     template<typename T>
     T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
@@ -707,7 +816,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -737,7 +846,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -745,7 +854,7 @@ namespace chaiscript
     /// \param[in] t_filename File to load and parse.
     /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
     /// \return result of the script execution
-    /// \throw exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
     Boxed_Value eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
       try {
         return do_eval(load_file(t_filename), t_filename);
@@ -753,7 +862,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -762,8 +871,8 @@ namespace chaiscript
     /// \param[in] t_filename File to load and parse.
     /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
     /// \return result of the script execution
-    /// \throw exception::eval_error In the case that evaluation fails.
-    /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
     ///        to the requested type.
     template<typename T>
     T eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
@@ -773,7 +882,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
   };

include/chaiscript/language/chaiscript_parser.hpp

@@ -7,11 +7,17 @@
 #ifndef CHAISCRIPT_PARSER_HPP_
 #define CHAISCRIPT_PARSER_HPP_
 
+#include <cstdint>
+#include <cstring>
 #include <exception>
 #include <fstream>
+#include <iostream>
+#include <memory>
 #include <sstream>
+#include <string>
+#include <vector>
 
-#include "chaiscript_prelude.hpp"
+#include "../dispatchkit/boxed_value.hpp"
 #include "chaiscript_common.hpp"
 
 namespace chaiscript
@@ -47,7 +53,7 @@ namespace chaiscript
       std::string m_multiline_comment_begin;
       std::string m_multiline_comment_end;
       std::string m_singleline_comment;
-      boost::shared_ptr<std::string> m_filename;
+      std::shared_ptr<std::string> m_filename;
       std::vector<AST_NodePtr> m_match_stack;
       bool m_alphabet[detail::max_alphabet][detail::lengthof_alphabet];
 
@@ -56,7 +62,8 @@ namespace chaiscript
 
       public:
       ChaiScript_Parser()
-        : m_multiline_comment_begin("/*"),
+        : m_line(-1), m_col(-1),
+        m_multiline_comment_begin("/*"),
           m_multiline_comment_end("*/"),
           m_singleline_comment("//")
       {
@@ -134,8 +141,8 @@ namespace chaiscript
         m_operator_matches.push_back(multiplication);
 
         for ( int c = 0 ; c < detail::lengthof_alphabet ; ++c ) {
-          for ( int a = 0 ; a < detail::max_alphabet ; a ++ ) {
-            m_alphabet[a][c]=false;
+          for (auto & elem : m_alphabet) {
+            elem[c]=false;
           }
         }
         m_alphabet[detail::symbol_alphabet][static_cast<int>('?')]=true;
@@ -193,7 +200,7 @@ namespace chaiscript
       /**
        * test a char in an m_alphabet
        */
-      bool char_in_alphabet(unsigned char c, detail::Alphabet a) { return m_alphabet[a][c]; }
+      bool char_in_alphabet(char c, detail::Alphabet a) { return m_alphabet[a][static_cast<int>(c)]; }
 
       /**
        * Prints the parsed ast_nodes as a tree
@@ -210,10 +217,10 @@ namespace chaiscript
       /**
        * Shows the current stack of matched ast_nodes
        */
-      void show_match_stack() {
-        for (unsigned int i = 0; i < m_match_stack.size(); ++i) {
+      void show_match_stack() const {
+        for (auto & elem : m_match_stack) {
           //debug_print(match_stack[i]);
-          std::cout << m_match_stack[i]->to_string();
+          std::cout << elem->to_string();
         }
       }
 
@@ -273,7 +280,7 @@ namespace chaiscript
       /**
        * Check to see if there is more text parse
        */
-      inline bool has_more_input() {
+      inline bool has_more_input() const {
         return (m_input_pos != m_input_end);
       }
 
@@ -317,13 +324,21 @@ namespace chaiscript
 
       /**
        * Skips ChaiScript whitespace, which means space and tab, but not cr/lf
+       * jespada: Modified SkipWS to skip optionally CR ('\n')
        */
-      bool SkipWS() {
+      bool SkipWS(bool skip_cr=false) {
         bool retval = false;
         while (has_more_input()) {
-          if ( char_in_alphabet(*m_input_pos,detail::white_alphabet) ) {
+          if ( char_in_alphabet(*m_input_pos,detail::white_alphabet) || (skip_cr && (*m_input_pos == '\n'))) {
+            if(*m_input_pos == '\n') {
+              m_col = 1;
+              ++m_line;
+            }
+            else {
+              ++m_col;
+            }
             ++m_input_pos;
-            ++m_col;
+
             retval = true;
           }
           else if (SkipComment()) {
@@ -451,7 +466,7 @@ namespace chaiscript
         return retval;
       }
 
-      Boxed_Value buildFloat(const std::string &t_val)
+      static Boxed_Value buildFloat(const std::string &t_val)
       {
         bool float_ = false;
         bool long_ = false;
@@ -493,7 +508,7 @@ namespace chaiscript
 
 
       template<typename IntType>
-      Boxed_Value buildInt(const IntType &t_type, const std::string &t_val)
+      static Boxed_Value buildInt(const IntType &t_type, const std::string &t_val)
       {
         bool unsigned_ = false;
         bool long_ = false;
@@ -524,7 +539,7 @@ namespace chaiscript
         ss >> t_type;
 
         std::stringstream testu(t_val.substr(0, i));
-        boost::uint64_t u;
+        uint64_t u;
         testu >> t_type >> u;
 
         bool unsignedrequired = false;
@@ -536,28 +551,19 @@ namespace chaiscript
           long_ = true;
         }
 
-        BOOST_ASSERT(sizeof(long) == sizeof(boost::uint64_t) || sizeof(long) * 2 == sizeof(boost::uint64_t));
+        static_assert(sizeof(long) == sizeof(uint64_t) || sizeof(long) * 2 == sizeof(uint64_t), "Unexpected sizing of integer types");
 
-#ifdef BOOST_MSVC
-		//Thank you MSVC, yes we know that a constant value is being used in the if
-		// statment in this compiler / architecture
-#pragma warning(push)
-#pragma warning(disable : 4127)
-#endif
-
-        if ( sizeof(long) < sizeof(boost::uint64_t) && (u >> ((sizeof(boost::uint64_t) - sizeof(long)) * 8)) > 0)
+        if ((sizeof(long) < sizeof(uint64_t)) 
+            && (u >> ((sizeof(uint64_t) - sizeof(long)) * 8)) > 0)
         {
           //requires something bigger than long
           longlong_ = true;
         }
 
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
 
         if (longlong_)
         {
-          size = sizeof(boost::int64_t) * 8;
+          size = sizeof(int64_t) * 8;
         } else if (long_) {
           size = sizeof(long) * 8;
         } 
@@ -588,7 +594,7 @@ namespace chaiscript
         {
           if (longlong_)
           {
-            boost::uint64_t val;
+            uint64_t val;
             ss >> val;   
             return Boxed_Value(const_var(val));
           } else if (long_) {
@@ -603,7 +609,7 @@ namespace chaiscript
         } else {
           if (longlong_)
           {
-            boost::int64_t val;
+            int64_t val;
             ss >> val;   
             return Boxed_Value(const_var(val));
           } else if (long_) {
@@ -641,7 +647,7 @@ namespace chaiscript
             }
             if (Binary_()) {
               std::string match(start, m_input_pos);
-			  boost::int64_t temp_int = 0;
+              int64_t temp_int = 0;
               size_t pos = 0, end = match.length();
 
               while ((pos < end) && (pos < (2 + sizeof(int) * 8))) {
@@ -804,10 +810,9 @@ namespace chaiscript
        */
       bool Quoted_String_() {
         bool retval = false;
-        char prev_char = 0;
         if (has_more_input() && (*m_input_pos == '\"')) {
           retval = true;
-          prev_char = *m_input_pos;
+          char prev_char = *m_input_pos;
           ++m_input_pos;
           ++m_col;
 
@@ -981,10 +986,9 @@ namespace chaiscript
          */
         bool Single_Quoted_String_() {
           bool retval = false;
-          char prev_char = 0;
           if (has_more_input() && (*m_input_pos == '\'')) {
             retval = true;
-            prev_char = *m_input_pos;
+            char prev_char = *m_input_pos;
             ++m_input_pos;
             ++m_col;
 
@@ -1111,11 +1115,11 @@ namespace chaiscript
          */
         bool Keyword_(const char *t_s) {
           bool retval = false;
-          int len = static_cast<int>(strlen(t_s));
+          size_t len = strlen(t_s);
 
-          if ((m_input_end - m_input_pos) >= len) {
+          if ((m_input_end - m_input_pos) >= static_cast<std::make_signed<size_t>::type>(len)) {
             std::string::const_iterator tmp = m_input_pos;
-            for (int i = 0; i < len; ++i) {
+            for (size_t i = 0; i < len; ++i) {
               if (*tmp != t_s[i]) {
                 return false;
               }
@@ -1159,11 +1163,11 @@ namespace chaiscript
          */
         bool Symbol_(const char *t_s) {
           bool retval = false;
-          int len = static_cast<int>(strlen(t_s));
+          size_t len = strlen(t_s);
 
-          if ((m_input_end - m_input_pos) >= len) {
+          if ((m_input_end - m_input_pos) >= static_cast<std::make_signed<size_t>::type>(len)) {
             std::string::const_iterator tmp = m_input_pos;
-            for (int i = 0; i < len; ++i) {
+            for (size_t i = 0; i < len; ++i) {
               if (*tmp != t_s[i]) {
                 return false;
               }
@@ -1250,6 +1254,8 @@ namespace chaiscript
          * Reads a comma-separated list of values from input
          */
         bool Arg_List() {
+
+          SkipWS(true);
           bool retval = false;
 
           size_t prev_stack_top = m_match_stack.size();
@@ -1268,6 +1274,8 @@ namespace chaiscript
             build_match(AST_NodePtr(new eval::Arg_List_AST_Node()), prev_stack_top);
           }
 
+          SkipWS(true);
+
           return retval;
         }
 
@@ -1276,6 +1284,7 @@ namespace chaiscript
          */
         bool Container_Arg_List() {
           bool retval = false;
+          SkipWS(true);
 
           size_t prev_stack_top = m_match_stack.size();
 
@@ -1310,6 +1319,8 @@ namespace chaiscript
             build_match(AST_NodePtr(new eval::Arg_List_AST_Node()), prev_stack_top);
           }
 
+          SkipWS(true);
+
           return retval;
 
         }
@@ -1350,7 +1361,6 @@ namespace chaiscript
         bool Def() {
           bool retval = false;
           bool is_annotated = false;
-          bool is_method = false;
           AST_NodePtr annotation;
 
           if (Annotation()) {
@@ -1369,6 +1379,8 @@ namespace chaiscript
               throw exception::eval_error("Missing function name in definition", File_Position(m_line, m_col), *m_filename);
             }
 
+            bool is_method = false;
+
             if (Symbol("::", false)) {
               //We're now a method
               is_method = true;
@@ -1475,7 +1487,7 @@ namespace chaiscript
         }
 
         /**
-         * Reads an if/elseif/else block from input
+         * Reads an if/else if/else block from input
          */
         bool If() {
           bool retval = false;
@@ -1724,7 +1736,7 @@ namespace chaiscript
           }
 
         }
-      
+
         /**
          * Reads a curly-brace C-style block from input
          */
@@ -1868,10 +1880,10 @@ namespace chaiscript
 
           size_t prev_stack_top = m_match_stack.size();
 
-          if (Keyword("var")) {
+          if (Keyword("auto") || Keyword("var")) {
             retval = true;
 
-            if (!Id(true)) {
+            if (!(Reference() || Id(true))) {
               throw exception::eval_error("Incomplete variable declaration", File_Position(m_line, m_col), *m_filename);
             }
 
@@ -1926,6 +1938,7 @@ namespace chaiscript
           if (Char('[')) {
             retval = true;
             Container_Arg_List();
+
             if (!Char(']')) {
               throw exception::eval_error("Missing closing square bracket ']' in container initializer", File_Position(m_line, m_col), *m_filename);
             }
@@ -1948,6 +1961,25 @@ namespace chaiscript
           return retval;
         }
 
+        bool Reference() {
+          bool retval = false;
+
+          size_t prev_stack_top = m_match_stack.size();
+
+          if (Symbol("&", false)) {
+            retval = true;
+
+            if (!Id(true)) {
+              throw exception::eval_error("Incomplete '&' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            build_match(AST_NodePtr(
+                  new eval::Reference_AST_Node()), prev_stack_top);
+          }
+
+          return retval;
+        }
+
         /**
          * Reads a unary prefixed expression from input
          */
@@ -2010,6 +2042,15 @@ namespace chaiscript
 
             build_match(AST_NodePtr(new eval::Prefix_AST_Node()), prev_stack_top);
           }
+          else if (Char('&', true)) {
+            retval = true;
+
+            if (!Operator(m_operators.size()-1)) {
+              throw exception::eval_error("Incomplete '~' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            build_match(AST_NodePtr(new eval::Prefix_AST_Node()), prev_stack_top);
+          }
 
           return retval;
         }
@@ -2027,8 +2068,8 @@ namespace chaiscript
         }
 
         bool Operator_Helper(size_t t_precedence) {
-          for (size_t i = 0; i < m_operator_matches[t_precedence].size(); ++i) {
-            if (Symbol(m_operator_matches[t_precedence][i].c_str(), true)) {
+          for (auto & elem : m_operator_matches[t_precedence]) {
+            if (Symbol(elem.c_str(), true)) {
               return true;
             }
           }
@@ -2209,6 +2250,7 @@ namespace chaiscript
                 Symbol("-=", true, true) || Symbol("*=", true, true) || Symbol("/=", true, true) ||
                 Symbol("%=", true, true) || Symbol("<<=", true, true) || Symbol(">>=", true, true) ||
                 Symbol("&=", true, true) || Symbol("^=", true, true) || Symbol("|=", true, true)) {
+              SkipWS(true);
               if (!Equation()) {
                 throw exception::eval_error("Incomplete equation", File_Position(m_line, m_col), *m_filename);
               }
@@ -2304,6 +2346,11 @@ namespace chaiscript
               retval = true;
               saw_eol = false;
             }
+            else if (Block()) {
+              has_more = true;
+              retval = true;
+              saw_eol = true;
+            }
             else if (Equation()) {
               if (!saw_eol) {
                 throw exception::eval_error("Two expressions missing line separator", File_Position(prev_line, prev_col), *m_filename);
@@ -2317,11 +2364,6 @@ namespace chaiscript
               retval = true;
               saw_eol = true;
             }
-            else if (Block()) {
-              has_more = true;
-              retval = true;
-              saw_eol = true;
-            }
             else {
               has_more = false;
             }
@@ -2338,7 +2380,7 @@ namespace chaiscript
           m_input_end = t_input.end();
           m_line = 1;
           m_col = 1;
-          m_filename = boost::shared_ptr<std::string>(new std::string(t_fname));
+          m_filename = std::shared_ptr<std::string>(new std::string(t_fname));
 
           if ((t_input.size() > 1) && (t_input[0] == '#') && (t_input[1] == '!')) {
             while ((m_input_pos != m_input_end) && (!Eol())) {

include/chaiscript/language/chaiscript_prelude.chai

@@ -0,0 +1,531 @@
+// 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_PRELUDE_HPP_
+#define CHAISCRIPT_PRELUDE_HPP_
+
+namespace chaiscript {
+struct ChaiScript_Prelude { 
+  static std::string chaiscript_prelude() {  return R""(
+
+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(x) : function_exists(type_name(x)) && call_exists(eval(type_name(x)), x)  
+{ 
+  eval(type_name(x))(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(", ") + "]"; 
+}
+
+# Basic to_string function
+def to_string(x) { 
+  internal_to_string(x); 
+}
+
+# Prints to console with no carriage return
+def puts(x) { 
+  print_string(x.to_string()); 
+}
+
+# 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 
+  } 
+} 
+
+
+# Pushes the second value onto the container first value while making a clone of the value
+def push_back(container, x) : call_exists(push_back_ref, container, x) 
+{ 
+  container.push_back_ref(clone(x))
+} 
+
+# Pushes the second value onto the front of the container first value while making a clone of the value
+def push_front(container, x) : call_exists(push_front_ref, container, x) 
+{ 
+  container.push_front_ref(clone(x)) 
+} 
+
+# Inserts the third value at the position of the second value into the container of the first
+# while making a clone. 
+def insert_at(container, pos, x) 
+{ 
+  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; 
+}
+
+# Return a range from a range 
+def range(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) 
+{ 
+  return clone(r); 
+}
+
+
+# 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 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(); 
+  } 
+  return false; 
+} 
+
+def contains(container, item) { 
+  return 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(substr) : is_type(substr, "string") { 
+  find(this, substr, size_t(0)); 
+}
+
+
+# Returns the position of last match of the second value string in the first value string
+def string::rfind(substr) : is_type(substr, "string") { 
+  rfind(this, substr, size_t(-1)); 
+}
+
+
+# Returns the position of the first match of elements in the second value string in the first value string
+def string::find_first_of(list) : is_type(list, "string") { 
+  find_first_of(this, list, size_t(0)); 
+} 
+
+
+# Returns the position of the last match of elements in the second value string in the first value string
+def string::find_last_of(list) : is_type(list, "string") { 
+  find_last_of(this, list, size_t(-1)); 
+} 
+
+
+# Returns the position of the first non-matching element in the second value string in the first value string
+def string::find_first_not_of(list) : is_type(list, "string") { 
+  find_first_not_of(this, list, size_t(0)); 
+} 
+
+
+# Returns the position of the last non-matching element in the second value string in the first value string
+def string::find_last_not_of(list) : is_type(list, "string") { 
+  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, compare_func) : call_exists(range, container) && is_type(compare_func, "Function") { 
+  auto range = range(container); 
+  while (!range.empty()) { 
+    if (compare_func(range.front(), value)) { 
+      return range; 
+    } else { 
+      range.pop_front(); 
+    } 
+  } 
+  return range; 
+} 
+
+
+def find(container, value) { 
+  return find(container, value, eq) 
+} 
+
+
+)"";
+}
+
+};
+}
+
+#endif /* CHAISCRIPT_PRELUDE_HPP_ */

include/chaiscript/language/chaiscript_prelude.hpp

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

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -5,7 +5,7 @@
 namespace ChaiScript_Language
 {
 
-/// \page LangStandardLibraryRef ChaiScript Language Standard Libary Reference
+/// \page LangStandardLibraryRef ChaiScript Language Standard Library Reference
 ///
 /// ChaiScript, at its core, has some very functional programming-inspired habits. Few places show this off as clearly 
 /// as the prelude, itself a name taken as a nod to the popular functional language Haskell. This prelude is available 

include/chaiscript/utility/utility.hpp

@@ -7,91 +7,42 @@
 #ifndef CHAISCRIPT_UTILITY_UTILITY_HPP_
 #define CHAISCRIPT_UTILITY_UTILITY_HPP_
 
-#include "../chaiscript.hpp"
-#include <boost/preprocessor.hpp>
 #include <string>
+#include <utility>
+#include <vector>
 
-#define CHAISCRIPT_MODULE(_info) BOOST_PP_SEQ_ELEM(0, _info)
+#include "../chaiscript.hpp"
+#include "../dispatchkit/proxy_functions.hpp"
+#include "../dispatchkit/type_info.hpp"
 
-#define CHAISCRIPT_CLASS_ELEM(_info) BOOST_PP_SEQ_ELEM(1, _info)
-
-#define CHAISCRIPT_METHOD(_info, _method) & CHAISCRIPT_CLASS_ELEM(_info) :: BOOST_PP_SEQ_ELEM(0, _method)
-
-#define CHAISCRIPT_METHOD_NAME(_info, _method) \
-  BOOST_PP_SEQ_ELEM(3, _info) (BOOST_PP_STRINGIZE(BOOST_PP_SEQ_ELEM(0, _method ) ) )
-
-#define CHAISCRIPT_CLASS_NAME(_info) \
-  BOOST_PP_SEQ_ELEM(2, _info) (BOOST_PP_STRINGIZE(CHAISCRIPT_CLASS_ELEM(_info) ) )
-
-#define CHAISCRIPT_METHOD_SIGNATURE_PART(_r, _info, _i, _method_part) \
-  BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(_i, 1), < _method_part > )
-
-#define CHAISCRIPT_METHOD_SIGNATURE(_info, _method) \
-  BOOST_PP_SEQ_FOR_EACH_I(CHAISCRIPT_METHOD_SIGNATURE_PART, _info, _method)
-
-#define CHAISCRIPT_CLASS_CONSTRUCTOR(_r, _info, _constructor) \
-  CHAISCRIPT_MODULE(_info) ->add BOOST_PP_LPAREN() chaiscript::constructor<_constructor>() BOOST_PP_COMMA() CHAISCRIPT_CLASS_NAME(_info) BOOST_PP_RPAREN() ;
-
-#define CHAISCRIPT_CLASS_METHOD(_r, _info, _method) \
-  CHAISCRIPT_MODULE(_info) ->add BOOST_PP_LPAREN() chaiscript::fun CHAISCRIPT_METHOD_SIGNATURE(_info, _method) \
-      BOOST_PP_LPAREN() CHAISCRIPT_METHOD(_info, _method) BOOST_PP_RPAREN() BOOST_PP_COMMA() CHAISCRIPT_METHOD_NAME(_info, _method)BOOST_PP_RPAREN() ;
-  
-#define CHAISCRIPT_CLASS_CONSTRUCTORS(_info, _constructors) \
-  BOOST_PP_SEQ_FOR_EACH(CHAISCRIPT_CLASS_CONSTRUCTOR, _info, _constructors)
-
-#define CHAISCRIPT_CLASS_METHODS(_info, _methods) \
-  BOOST_PP_SEQ_FOR_EACH(CHAISCRIPT_CLASS_METHOD, _info, _methods)
-
-#define CHAISCRIPT_CLASS_EX(_module, _class_name, _class_name_translator, _method_name_translator, _constructors, _methods) \
-  { \
-    _module->add(chaiscript::user_type<_class_name>(), _class_name_translator (BOOST_PP_STRINGIZE(_class_name))); \
-    CHAISCRIPT_CLASS_CONSTRUCTORS((_module)(_class_name)(_class_name_translator), _constructors) \
-    CHAISCRIPT_CLASS_METHODS((_module)(_class_name)(_class_name_translator)(_method_name_translator), _methods) \
-  }
-
-#define CHAISCRIPT_CLASS_NO_CONSTRUCTOR_EX(_module, _class_name, _class_name_translator, _method_name_translator, _methods) \
-  { \
-    _module->add(chaiscript::user_type<_class_name>(), _class_name_translator (BOOST_PP_STRINGIZE(_class_name))); \
-    CHAISCRIPT_CLASS_METHODS((_module)(_class_name)(_class_name_translator)(_method_name_translator), _methods) \
-  }
-
-#define CHAISCRIPT_CLASS(_module, _class_name, _constructors, _methods) \
-  CHAISCRIPT_CLASS_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
-      chaiscript::utility::method_name_translator, _constructors, _methods)
-
-#define CHAISCRIPT_CLASS_NO_CONSTRUCTOR(_module, _class_name, _methods) \
-  CHAISCRIPT_CLASS_NO_CONSTRUCTOR_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
-      chaiscript::utility::method_name_translator, _methods)
 
 namespace chaiscript 
 {
-  /// \brief Classes and functions which provide general utility to the end user.
   namespace utility
   {
-    inline std::string class_name_translator(const std::string &t_name)
-    {
-      size_t colon = t_name.rfind("::");
-      if (colon != std::string::npos)
+
+    /// \todo Use of this utility, and uniform initializer lists, is causing memory errors in MSVC
+    
+    template<typename Class, typename ModuleType>
+      void add_class(ModuleType &t_module,
+          const std::string &t_class_name,
+          const std::vector<chaiscript::Proxy_Function> &t_constructors,
+          const std::vector<std::pair<chaiscript::Proxy_Function, std::string>> &t_funcs)
       {
-        return t_name.substr(colon+2, std::string::npos);
-      } else {
-        return t_name;
+        t_module.add(chaiscript::user_type<Class>(), t_class_name); 
+
+        for(const chaiscript::Proxy_Function &ctor: t_constructors)
+        {
+          t_module.add(ctor, t_class_name);
+        }
+
+        for(auto fun: t_funcs)
+        {
+          t_module.add(fun.first, fun.second);
+        }
+        
       }
-    }
-
-    inline std::string method_name_translator(const std::string &t_name)
-    {
-      size_t namestart = t_name.rfind("operator");
-      namestart = (namestart == std::string::npos)?0:namestart+strlen("operator");
-
-      if (namestart == 0)
-      {
-        namestart = t_name.rfind("::");
-        namestart = (namestart == std::string::npos)?0:namestart+strlen("::");
-      } 
-
-      return t_name.substr(namestart, std::string::npos);
-    }
+      
   }
 }
 

readme.md

@@ -1,3 +1,8 @@
+Master Status: [![Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=master)](https://travis-ci.org/ChaiScript/ChaiScript) [![Coverage Status](https://coveralls.io/repos/ChaiScript/ChaiScript/badge.png?branch=master)](https://coveralls.io/r/ChaiScript/ChaiScript?branch=master)
+
+Develop Status: [![Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=develop)](https://travis-ci.org/ChaiScript/ChaiScript) [![Coverage Status](https://coveralls.io/repos/ChaiScript/ChaiScript/badge.png?branch=develop)](https://coveralls.io/r/ChaiScript/ChaiScript?branch=develop)
+
+
 ChaiScript
 
 http://www.chaiscript.com
@@ -7,6 +12,7 @@ http://www.chaiscript.com
 
 Release under the BSD license, see "license.txt" for details.
 
+
 Introduction
 ============
 
@@ -16,26 +22,33 @@ 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 
+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 
+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.
+ChaiScript requires a C++11 compiler to build with support for variadic 
+templates.  It has been tested with gcc 4.7 and clang 3.1 (with libcxx). MacOS 
+10.8 (Mountain Lion) is also known to support the C++11 build with Apple's 
+clang 4.0.
 
 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`
+* 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 
+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)`
 
@@ -81,3 +94,26 @@ The shortest complete example possible follows:
     }
 
 
+
+Or, if you want to compile the std lib into your code, which reduces
+runtime requirements.
+
+    /// main.cpp
+
+    #include <chaiscript/chaiscript.hpp>
+    #include <chaiscript/chaiscript_stdlib.hpp>
+
+    double function(int i, double j)
+    {
+      return i * j;
+    }
+
+    int main()
+    {
+      chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
+      chai.add(chaiscript::fun(&function), "function");
+
+      double d = chai.eval<double>("function(3, 4.75);");
+    }
+
+

releasenotes.md

@@ -1,6 +1,25 @@
-Current Version: 4.3.0
+Notes:
+=======
+Current Version: 5.3.1
 
-Note: this is scheduled to be the last release that requires boost, new releases after this will require a C++11 compiler.
+### 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
@@ -18,20 +37,22 @@ Note: this is scheduled to be the last release that requires boost, new releases
 * 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 4.1.1
+### Changes since 5.1.0
 * Add support for automatic conversion of arithmetic types when possible
   and when no ambiguous method dispatch exists.
 
-### Changes since 4.1.0
-* Fix missed gcc build error in 4.1.0
-
-Changes since 4.0.0
+### 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 3.1.0
+### 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)

samples/example.cpp

@@ -5,32 +5,20 @@
 // http://www.chaiscript.com
 
 #include <iostream>
+#include <ctime>
 
 #include <chaiscript/chaiscript.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
 #include <chaiscript/dispatchkit/function_call.hpp>
-#include <boost/function.hpp>
-
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-parameter"
-#endif
-
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-#ifdef __llvm__
-#pragma clang diagnostic pop
-#endif
-
-#include <boost/regex.hpp>
 
 void log(const std::string &msg)
 {
-  std::cout << "[" << boost::posix_time::microsec_clock::local_time() << "] " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] " << msg << std::endl;
 }
 
 void log(const std::string &module, const std::string &msg)
 {
-  std::cout << "[" << boost::posix_time::microsec_clock::local_time() << "] <" << module << "> " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << std::endl;
 }
 
 void bound_log(const std::string &msg)
@@ -51,10 +39,10 @@ void hello_constructor(const chaiscript::Boxed_Value & /*o*/)
 
 struct System
 {
-  std::map<std::string, boost::function<std::string (const std::string &) > > m_callbacks;
+  std::map<std::string, std::function<std::string (const std::string &) > > m_callbacks;
 
   void add_callback(const std::string &t_name, 
-      const boost::function<std::string (const std::string &)> &t_func)
+      const std::function<std::string (const std::string &)> &t_func)
   {
     m_callbacks[t_name] = t_func;
   }
@@ -63,7 +51,7 @@ struct System
   void do_callbacks(const std::string &inp)
   {
     log("Running Callbacks: " + inp);
-    for (std::map<std::string, boost::function<std::string (const std::string &)> >::iterator itr = m_callbacks.begin();
+    for (std::map<std::string, std::function<std::string (const std::string &)> >::iterator itr = m_callbacks.begin();
          itr != m_callbacks.end();
          ++itr)
     {
@@ -72,7 +60,7 @@ struct System
   }
 };
 
-void take_shared_ptr(const boost::shared_ptr<const std::string> &p)
+void take_shared_ptr(const std::shared_ptr<const std::string> &p)
 {
   std::cout << *p << std::endl;
 }
@@ -98,7 +86,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   // Let's use chaiscript to add a new lambda callback to our system. 
   // The function "{ 'Callback1' + x }" is created in chaiscript and passed into our C++ application
   // in the "add_callback" function of struct System the chaiscript function is converted into a 
-  // boost::function, so it can be handled and called easily and type-safely
+  // std::function, so it can be handled and called easily and type-safely
   chai.eval("system.add_callback(\"#1\", fun(x) { \"Callback1 \" + x });");
   
   // Because we are sharing the "system" object with the chaiscript engine we have equal
@@ -119,14 +107,14 @@ int main(int /*argc*/, char * /*argv*/[]) {
   // A shortcut to using eval is just to use the chai operator()
   chai("log(\"Test Module\", \"Test Message\");");
 
-  //Finally, it is possible to register any boost::function as a system function, in this 
+  //Finally, it is possible to register any std::function as a system function, in this 
   //way, we can, for instance add a bound member function to the system
-  chai.add(fun(&System::do_callbacks, boost::ref(system), std::string("Bound Test")), "do_callbacks");
+  chai.add(fun(&System::do_callbacks, std::ref(system), std::string("Bound Test")), "do_callbacks");
 
   //Call bound version of do_callbacks
   chai("do_callbacks()");
 
-  boost::function<void ()> caller = chai.eval<boost::function<void ()> >("fun() { system.do_callbacks(\"From Functor\"); }");
+  std::function<void ()> caller = chai.eval<std::function<void ()> >("fun() { system.do_callbacks(\"From Functor\"); }");
   caller();
 
 
@@ -149,14 +137,14 @@ int main(int /*argc*/, char * /*argv*/[]) {
 
   //To do: Add examples of handling Boxed_Values directly when needed
 
-  //Creating a functor on the stack and using it immediatly 
-  int x = chai.eval<boost::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
+  //Creating a functor on the stack and using it immediately 
+  int x = chai.eval<std::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
 
   std::stringstream ss;
   ss << x;
   log("Functor test output", ss.str());
 
-  chai.add(var(boost::shared_ptr<int>()), "nullvar");
+  chai.add(var(std::shared_ptr<int>()), "nullvar");
   chai("print(\"This should be true.\"); print(nullvar.is_var_null())");
 
   // test the global const action
@@ -178,7 +166,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //Dynamic objects test
   chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Function("TestType", fun(&hello_world))), "hello_world");
   chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Constructor("TestType", fun(&hello_constructor))), "TestType");
-//  chai.add(fun(boost::function<Boxed_Value (dispatch::Dynamic_Object &)>(boost::bind(&dispatch::detail::Dynamic_Object_Attribute::func, "TestType", "attr", _1))), "attr");
+//  chai.add(fun(std::function<Boxed_Value (dispatch::Dynamic_Object &)>(std::bind(&dispatch::detail::Dynamic_Object_Attribute::func, "TestType", "attr", std::placeholders::_1))), "attr");
 
   chai.eval("var x = TestType()");
 //  chai.eval("x.attr = \"hi\"");

samples/for.chai

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

samples/fun.chai

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

samples/if.chai

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

samples/loop_break.chai

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

samples/memory_leak_test.cpp

@@ -1,13 +1,14 @@
 #include <iostream>
 
-#include "chaiscript/chaiscript.hpp"
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+
 #ifdef READLINE_AVAILABLE
 #include <readline/readline.h>
 #include <readline/history.h>
 #endif
 
 
-using namespace chaiscript;
 
 std::string get_next_command() {
 #ifdef READLINE_AVAILABLE
@@ -23,18 +24,20 @@ std::string get_next_command() {
 #endif
 }
 
-void fuction(void)
+void function(void)
 {
   // do nothing
 }
 
 class test
 {
-  ChaiScript chai;
-  ChaiScript::State backupState;
+  chaiscript::ChaiScript chai;
+  chaiscript::ChaiScript::State backupState;
+
   public:
   test()
-  {		
+    : chai(chaiscript::Std_Lib::library())
+  {
     backupState = chai.get_state();
   }
   ~test(){}
@@ -42,7 +45,7 @@ class test
   void ResetState()
   {
     chai.set_state(backupState);
-    chai.add(fun(&fuction),"Whatever()");
+    chai.add(chaiscript::fun(&function),"Whatever()");
   }
 
   void RunFile(std::string sFile)
@@ -67,7 +70,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   std::string command = "";
 
   //
-  // this loop increases memoryusage, if RunFile is not called (just hittin enter)
+  // this loop increases memoryusage, if RunFile is not called (just hitting enter)
   // as soon RunFile gets called, memory will be freed.
   //
   // scenario1 - RunFile gets called every Loop: memoryusage does not change

samples/oper.chai

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

samples/scope.chai

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

samples/vector.chai

@@ -11,6 +11,6 @@ var size = vec.size()
 print("Vector Size: " + size.to_string());
 
 while (i < size) {
-	print(i.to_string() + ": " + to_string(vec[i]))
-	i = i + 1
+  print(i.to_string() + ": " + to_string(vec[i]))
+  i = i + 1
 }

samples/while.chai

@@ -1,5 +1,5 @@
 var i = 0
 while (i < 10) {
-	print("i: " + i.to_string())
-	i = i + 1
+  print("i: " + i.to_string())
+  i = i + 1
 }

src/chaiscript_stdlib.cpp

@@ -0,0 +1,30 @@
+
+#include <chaiscript/chaiscript_stdlib.hpp>
+
+
+// MSVC doesn't like that we are using C++ return types from our C declared module
+// but this is the best way to do it for cross platform compatibility
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4190)
+#endif
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
+
+
+CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_chaiscript_stdlib()
+{
+  return chaiscript::Std_Lib::library();
+}
+
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif

src/main.cpp

@@ -6,7 +6,7 @@
 
 #include <iostream>
 #include <list>
-#include <boost/algorithm/string/trim.hpp>
+#include <regex>
 
 #define _CRT_SECURE_NO_WARNINGS
 #include <chaiscript/chaiscript.hpp>
@@ -15,27 +15,40 @@
 #include <readline/readline.h>
 #include <readline/history.h>
 #else
+
+char *mystrdup (const char *s) {
+  size_t len = strlen(s) + 1; // Space for length plus nul
+  char *d = static_cast<char*>(malloc (len));   
+  if (d == nullptr) return nullptr;          // No memory
+#ifdef CHAISCRIPT_MSVC
+  strcpy_s(d, len, s);                        // Copy the characters
+#else
+  strncpy(d,s,len);                        // Copy the characters
+  d[len] = '\0';
+#endif
+  return d;                            // Return the new string
+}
+
 char* readline(const char* p)
 {
   std::string retval;
   std::cout << p ;
   std::getline(std::cin, retval);
-#ifdef BOOST_MSVC
-  return std::cin.eof() ? NULL : _strdup(retval.c_str());
-#else
-  return std::cin.eof() ? NULL : strdup(retval.c_str());
-#endif
+  return std::cin.eof() ? nullptr : mystrdup(retval.c_str());
 }
+
+
 void add_history(const char*){}
 void using_history(){}
 #endif
 
 
-void *cast_module_symbol(std::string (*t_path)())
+
+void *cast_module_symbol(std::vector<std::string> (*t_path)())
 {
   union cast_union
   {
-    std::string (*in_ptr)();
+    std::vector<std::string> (*in_ptr)();
     void *out_ptr;
   };
 
@@ -44,22 +57,27 @@ void *cast_module_symbol(std::string (*t_path)())
   return c.out_ptr;
 }
 
-std::string default_search_path()
+std::vector<std::string> default_search_paths()
 {
-#ifdef BOOST_WINDOWS  // force no unicode
+  std::vector<std::string> paths;
+
+#ifdef CHAISCRIPT_WINDOWS  // force no unicode
   CHAR path[4096];
   int size = GetModuleFileNameA(0, path, sizeof(path)-1);
 
   std::string exepath(path, size);
 
-  size_t secondtolastslash = exepath.rfind('\\', exepath.rfind('\\') - 1);
-  if (secondtolastslash != std::string::npos)
+  size_t lastslash = exepath.rfind('\\');
+  size_t secondtolastslash = exepath.rfind('\\', lastslash - 1);
+  if (lastslash != std::string::npos)
   {
-    return exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\";
-  } else {
-    return "";
+    paths.push_back(exepath.substr(0, lastslash));
   }
 
+  if (secondtolastslash != std::string::npos)
+  {
+    return {exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\"};
+  }
 #else
 
   std::string exepath;
@@ -90,25 +108,31 @@ std::string default_search_path()
 
   if (exepath.empty())
   {
-    Dl_info rInfo; 
+    Dl_info rInfo;
     memset( &rInfo, 0, sizeof(rInfo) ); 
-    if ( !dladdr(cast_module_symbol(&default_search_path), &rInfo)  || !rInfo.dli_fname ) { 
-      return "";
+    if ( !dladdr(cast_module_symbol(&default_search_paths), &rInfo)  || !rInfo.dli_fname ) { 
+      return paths;
     }
 
     exepath = std::string(rInfo.dli_fname);
   }
 
-  size_t secondtolastslash = exepath.rfind('/', exepath.rfind('/') - 1);
+  size_t lastslash = exepath.rfind('/');
+
+  size_t secondtolastslash = exepath.rfind('/', lastslash - 1);
+  if (lastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, lastslash));
+  }
+
   if (secondtolastslash != std::string::npos)
   {
-    return exepath.substr(0, secondtolastslash) + "/lib/chaiscript/";
-  } else {
-    return "";
+    paths.push_back(exepath.substr(0, secondtolastslash) + "/lib/chaiscript/");
   }
 #endif
-}
 
+  return paths;
+}
 
 void help(int n) {
   if ( n >= 0 ) {
@@ -132,7 +156,7 @@ void version(int){
   std::cout << "chai: compiled " << __TIME__ << " " << __DATE__ << std::endl;
 }
 
-bool throws_exception(const boost::function<void ()> &f)
+bool throws_exception(const std::function<void ()> &f)
 {
   try {
     f();
@@ -143,7 +167,7 @@ bool throws_exception(const boost::function<void ()> &f)
   return false;
 }
 
-chaiscript::exception::eval_error get_eval_error(const boost::function<void ()> &f)
+chaiscript::exception::eval_error get_eval_error(const std::function<void ()> &f)
 {
   try {
     f();
@@ -160,18 +184,21 @@ std::string get_next_command() {
     char *input_raw = readline("eval> ");
     if ( input_raw ) {
       add_history(input_raw);
-      std::string val(input_raw);     
-      size_t pos = val.find_first_not_of("\t \n");    
-      if (pos != std::string::npos)   
-      {      
-        val.erase(0, pos);  
-      }    
-      pos = val.find_last_not_of("\t \n");   
-      if (pos != std::string::npos)   
-      {      
-        val.erase(pos+1, std::string::npos);    
-      }   
+
+      std::string val(input_raw);
+      size_t pos = val.find_first_not_of("\t \n");
+      if (pos != std::string::npos)
+      {
+        val.erase(0, pos);
+      }
+      pos = val.find_last_not_of("\t \n");
+      if (pos != std::string::npos)
+      {
+        val.erase(pos+1, std::string::npos);
+      }
+
       retval = val;
+
       ::free(input_raw);
     }
   }
@@ -204,7 +231,7 @@ void interactive(chaiscript::ChaiScript& chai)
       //Then, we try to print the result of the evaluation to the user
       if (!val.get_type_info().bare_equal(chaiscript::user_type<void>())) {
         try {
-          std::cout << chai.eval<boost::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
+          std::cout << chai.eval<std::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
         }
         catch (...) {} //If we can't, do nothing
       }
@@ -225,11 +252,9 @@ void interactive(chaiscript::ChaiScript& chai)
 
 int main(int argc, char *argv[])
 {
-  std::vector<std::string> usepaths;
-  std::vector<std::string> modulepaths;
 
   // Disable deprecation warning for getenv call.
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4996)
 #endif
@@ -237,18 +262,20 @@ int main(int argc, char *argv[])
   const char *usepath = getenv("CHAI_USE_PATH");
   const char *modulepath = getenv("CHAI_MODULE_PATH");
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
 
+  std::vector<std::string> usepaths;
   usepaths.push_back("");
   if (usepath)
   {
     usepaths.push_back(usepath);
   }
 
-  std::string searchpath = default_search_path();
-  modulepaths.push_back(searchpath);
+  std::vector<std::string> modulepaths;
+  std::vector<std::string> searchpaths = default_search_paths();
+  modulepaths.insert(modulepaths.end(), searchpaths.begin(), searchpaths.end());
   modulepaths.push_back("");
   if (modulepath)
   {

src/reflection.cpp

@@ -6,13 +6,15 @@
 
 
 #include <chaiscript/chaiscript.hpp>
+#include <chaiscript/dispatchkit/bootstrap.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
 #include <chaiscript/utility/utility.hpp>
 #include <string>
 
 
 // MSVC doesn't like that we are using C++ return types from our C declared module
 // but this is the best way to do it for cross platform compatibility
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4190)
 #endif
@@ -20,8 +22,8 @@
 
 bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
 {
-  boost::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf
-    = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+  std::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf
+    = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
   if (pf)
   {
     if (pf->get_parse_tree())
@@ -37,8 +39,8 @@ bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
 
 chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
 {
-  boost::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf 
-    = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+  std::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf 
+    = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
   if (pf)
   {
     if (pf->get_parse_tree())
@@ -68,40 +70,49 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
 
   m->add(chaiscript::base_class<std::exception, chaiscript::exception::eval_error>());
 
-  chaiscript::bootstrap::standard_library::vector_type<std::vector<boost::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
+  chaiscript::bootstrap::standard_library::vector_type<std::vector<std::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
 
-  CHAISCRIPT_CLASS_NO_CONSTRUCTOR( m,
-      chaiscript::exception::eval_error,
-      ((reason))
-      ((call_stack))
-    );
-
-  CHAISCRIPT_CLASS( m,
-      chaiscript::File_Position,
-      (chaiscript::File_Position())
-      (chaiscript::File_Position(int,int)),
-      ((line))
-      ((column))
-    );
-
-  CHAISCRIPT_CLASS_NO_CONSTRUCTOR( m, 
-      chaiscript::AST_Node,
-      ((text))
-      ((identifier))
-      ((filename))
-      ((start))
-      ((end))
-      ((internal_to_string))
-      ((children))
-      ((replace_child))
-    );
-
-  CHAISCRIPT_CLASS( m, 
-      chaiscript::parser::ChaiScript_Parser,
-      (chaiscript::parser::ChaiScript_Parser ()),
-      ((parse))
-      ((ast))
-    );
+  using namespace chaiscript;
+  
+  chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
+      "eval_error",
+      { },
+      { {fun(&chaiscript::exception::eval_error::reason), "reason"},
+        {fun(&chaiscript::exception::eval_error::call_stack), "call_stack"} }
+      );
+      
+  
+  chaiscript::utility::add_class<chaiscript::File_Position>(*m,
+      "File_Position",
+      { constructor<File_Position()>(),
+        constructor<File_Position(int, int)>() },
+      { {fun(&File_Position::line), "line"},
+        {fun(&File_Position::column), "column"} }
+      );
+      
+  
+  chaiscript::utility::add_class<AST_Node>(*m, 
+  "AST_Node",
+  {  },
+  { {fun(&AST_Node::text), "text"},
+    {fun(&AST_Node::identifier), "identifier"},
+    {fun(&AST_Node::filename), "filename"},
+    {fun(&AST_Node::start), "start"},
+    {fun(&AST_Node::end), "end"},
+    {fun(&AST_Node::internal_to_string), "internal_to_string"},
+    {fun(&AST_Node::children), "children"},
+    {fun(&AST_Node::replace_child), "replace_child"}
+  }
+  );
+  
+  
+  chaiscript::utility::add_class<parser::ChaiScript_Parser>(*m,
+      "ChaiScript_Parser",
+      { constructor<parser::ChaiScript_Parser ()>() },
+      { {fun(&parser::ChaiScript_Parser::parse), "parse"},
+        {fun(&parser::ChaiScript_Parser::ast), "ast"} }
+      );
+      
 
 
   return m;
@@ -113,6 +124,6 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
 
 
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

src/stl_extra.cpp

@@ -5,12 +5,13 @@
 // http://www.chaiscript.com
 
 #include <chaiscript/chaiscript.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
 #include <list>
 #include <string>
 
 // MSVC doesn't like that we are using C++ return types from our C declared module
 // but this is the best way to do it for cross platform compatibility
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4190)
 #endif
@@ -29,6 +30,6 @@ CHAISCRIPT_MODULE_EXPORT chaiscript::ModulePtr create_chaiscript_module_stl_extr
 #pragma clang diagnostic pop
 #endif
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

src/test_module.cpp

@@ -11,6 +11,8 @@ class TestBaseType
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
 
+    int base_only_func() { return -9; }
+
     const TestBaseType &constMe() const { return *this; }
 
     int val;
@@ -34,12 +36,29 @@ class TestDerivedType : public TestBaseType
 {
   public:
     virtual ~TestDerivedType() {}
-    virtual int func() { return 1; }
+    virtual int func() CHAISCRIPT_OVERRIDE { return 1; }
+    int derived_only_func() { return 19; }
 
   private:
     TestDerivedType &operator=(const TestDerivedType &);
 };
 
+class TestMoreDerivedType : public TestDerivedType
+{
+  public:
+    virtual ~TestMoreDerivedType() {}
+};
+
+std::shared_ptr<TestBaseType> derived_type_factory()
+{
+  return std::shared_ptr<TestBaseType>(new TestDerivedType());
+}
+
+std::shared_ptr<TestBaseType> more_derived_type_factory()
+{
+  return std::shared_ptr<TestBaseType>(new TestMoreDerivedType());
+}
+
 std::string hello_world()
 {
   return "Hello World";
@@ -52,7 +71,7 @@ int *get_new_int()
 
 // MSVC doesn't like that we are using C++ return types from our C declared module
 // but this is the best way to do it for cross platform compatibility
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4190)
 #endif
@@ -70,6 +89,7 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
 
   m->add(chaiscript::user_type<TestBaseType>(), "TestBaseType");
   m->add(chaiscript::user_type<TestDerivedType>(), "TestDerivedType");
+  m->add(chaiscript::user_type<TestMoreDerivedType>(), "TestMoreDerivedType");
 
   m->add(chaiscript::constructor<TestBaseType ()>(), "TestBaseType");
 //  m->add(chaiscript::constructor<TestBaseType (int)>(), "TestBaseType");
@@ -79,14 +99,29 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::constructor<TestDerivedType ()>(), "TestDerivedType");
   m->add(chaiscript::constructor<TestDerivedType (const TestDerivedType &)>(), "TestDerivedType");
 
+  m->add(chaiscript::constructor<TestMoreDerivedType ()>(), "TestMoreDerivedType");
+  m->add(chaiscript::constructor<TestMoreDerivedType (const TestMoreDerivedType &)>(), "TestMoreDerivedType");
+
+  /// \todo automatic chaining of base classes?
   m->add(chaiscript::base_class<TestBaseType, TestDerivedType>());
+  m->add(chaiscript::base_class<TestBaseType, TestMoreDerivedType>());
+  m->add(chaiscript::base_class<TestDerivedType, TestMoreDerivedType>());
+
+  m->add(chaiscript::fun(&TestDerivedType::derived_only_func), "derived_only_func");
+
+  m->add(chaiscript::fun(&derived_type_factory), "derived_type_factory");
+  m->add(chaiscript::fun(&more_derived_type_factory), "more_derived_type_factory");
+
+  m->add(chaiscript::fun(&TestDerivedType::func), "func");
 
   m->add(chaiscript::fun(&TestBaseType::func), "func");
   m->add(chaiscript::fun(&TestBaseType::val), "val");
   m->add(chaiscript::fun(&TestBaseType::const_val), "const_val");
+  m->add(chaiscript::fun(&TestBaseType::base_only_func), "base_only_func");
 
   m->add(chaiscript::fun(&get_new_int), "get_new_int");
 
+
   m->add_global_const(chaiscript::const_var(TestValue1), "TestValue1");
 
   m->add(chaiscript::user_type<TestEnum>(), "TestEnum");
@@ -103,6 +138,6 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
 #pragma clang diagnostic pop
 #endif
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

unittests/3.x/assign_const.chai

@@ -0,0 +1,2 @@
+assert_throws("Mismatched types in equation, lhs is const.", fun() { 1 = 2 } );
+assert_throws("Mismatched types in equation, lhs is const.", fun() { 1 + 2 = 2 } );

unittests/3.x/bind.chai

@@ -0,0 +1,2 @@
+var prod = bind(foldl, _, `*`, 1.0)
+assert_equal(60, prod([3, 4, 5]))

unittests/3.x/bind2.chai

@@ -0,0 +1,34 @@
+
+def add(x, y)
+{
+  return x + y;
+}
+
+assert_equal(2, add.get_arity());
+
+var b = bind(add, 2, _);
+
+assert_equal(1, b.get_arity());
+
+var c = bind(b, 3);
+
+assert_equal(0, c.get_arity());
+
+assert_equal(6, b(4));
+assert_equal(5, c());
+
+def concat2(a,b,c,d)
+{
+  return to_string(a) + to_string(b) + to_string(c) + to_string(d);
+}
+
+var d = bind(concat2, _, " Hello ", _, " World");
+assert_equal(2, d.get_arity());
+
+assert_equal("1 Hello 3 World", d(1,3));
+
+var e = bind(`<`, _, 5);
+var types = e.get_param_types();
+assert_equal(2, types.size());
+assert_equal(true, types[0].bare_equal(bool_type));
+

unittests/3.x/block_start.chai

@@ -0,0 +1 @@
+{print("hello")}

unittests/3.x/bool_not.chai

@@ -0,0 +1 @@
+assert_equal(false, !true)

unittests/3.x/break_while.chai

@@ -0,0 +1,7 @@
+var i = 0
+while (i < 10) {
+  if (++i == 5) {
+    break
+  }
+}
+assert_equal(5, i);

unittests/3.x/char_init.chai

@@ -0,0 +1 @@
+assert_equal("b", to_string('b'))

unittests/3.x/classification.chai

@@ -0,0 +1,7 @@
+assert_equal(true, 1.is_var_const());
+assert_equal(false, 1.is_var_reference());
+assert_equal(true, 1.is_var_pointer());
+assert_equal(false, 1.is_var_null());
+assert_equal(false, 1.is_var_undef());
+var i;
+assert_equal(true, i.is_var_undef());

unittests/3.x/collate.chai

@@ -0,0 +1,3 @@
+var v = collate(1, 2)
+assert_equal(1, v[0])
+assert_equal(2, v[1])

unittests/3.x/compare_gt.chai

@@ -0,0 +1 @@
+assert_equal(false, 1 > 2);

unittests/3.x/compare_lt.chai

@@ -0,0 +1 @@
+assert_equal(true, 1 < 2)

unittests/3.x/concat.chai

@@ -0,0 +1,5 @@
+var v = concat([1, 2], [3, 4]);
+
+assert_equal(4, v.size());
+assert_equal(1, v[0]);
+assert_equal(4, v[3]);

unittests/3.x/const_range_test.chai

@@ -0,0 +1,4 @@
+//If the following succeeds, the test passes
+
+
+"Hello World".for_each(fun(x) { print(x) } )

unittests/3.x/convert_double_string.chai

@@ -0,0 +1 @@
+assert_equal("3.5bob", 3.5.to_string() + "bob");

unittests/3.x/convert_int_string.chai

@@ -0,0 +1 @@
+assert_equal("3bob", 3.to_string + "bob")

unittests/3.x/convert_string_double.chai

@@ -0,0 +1 @@
+assert_equal(6.8, "3.5".to_double() + 3.3)

unittests/3.x/convert_string_int.chai

@@ -0,0 +1 @@
+assert_equal(8, "4".to_int() + 4)

unittests/3.x/deep_array_lookup.chai

@@ -0,0 +1,11 @@
+var a = [1,2,3, [4,5,6] ]
+
+assert_equal(a[3][0], 4)
+
+
+def Test::Test() { this.a = [1,2,3]; }
+attr Test::a;
+
+var t = Test();
+
+assert_equal(t.a[0], 1)

unittests/3.x/dispatch_functions.chai

@@ -0,0 +1,11 @@
+assert_equal(`==`, `==`);
+assert_not_equal(`==`, `<`);
+assert_equal(`<`.get_arity(), 2);
+assert_equal(`+`.get_annotation(), "Multiple method dispatch function wrapper.");
+assert_equal(get_arity.get_contained_functions().size(), 0);
+assert_equal(get_arity.get_arity(), 1);
+assert_equal(get_arity.get_param_types().size(), 2);
+
+var paramtypes = get_arity.get_param_types();
+
+assert_equal(true, paramtypes[1].bare_equal(Function_type));

unittests/3.x/drop.chai

@@ -0,0 +1 @@
+assert_equal([3,4], drop([1, 2, 3, 4], 2))

unittests/3.x/drop_while.chai

@@ -0,0 +1 @@
+assert_equal([2, 3], drop_while([1, 2, 3], odd))

unittests/3.x/equ_shortform.chai

@@ -0,0 +1,4 @@
+var x=.5
+assert_equal(.5, x)
+var y=-.5
+assert_equal(-.5, y)

unittests/3.x/eval.chai

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

unittests/3.x/eval_error.chai

@@ -0,0 +1,39 @@
+load_module("reflection")
+
+def deep()
+{
+  try {
+  } catch {
+
+  } finally {
+    if (2)
+    {
+    }
+
+  }
+}
+
+def func()
+{
+  deep();
+}
+
+def doing()
+{
+  for (var i = 0; i < 10; ++i)
+  {
+    func();
+  }
+}
+
+def while_doing()
+{
+  while (true)
+  {
+    doing();
+  }
+}
+
+var f = fun() { while_doing(); }
+
+assert_equal(get_eval_error(f).call_stack.size(), 16)