Merge pull request #135 from ChaiScript/develop

Develop

.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
-option(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
+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)" 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")
@@ -13,24 +50,23 @@ list(APPEND CPACK_SOURCE_IGNORE_FILES ".swp")
 list(APPEND CPACK_SOURCE_IGNORE_FILES ".*~")
 
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt")
-set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.txt")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
 
-set(CPACK_PACKAGE_VERSION_MAJOR 3)
+set(CPACK_PACKAGE_VERSION_MAJOR 5)
-set(CPACK_PACKAGE_VERSION_MINOR 0)
+set(CPACK_PACKAGE_VERSION_MINOR 4)
 set(CPACK_PACKAGE_VERSION_PATCH 0)
+
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
 set(CPACK_PACKAGE_CONTACT "contact@chaiscript.com")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "An embedded scripting language for C++")
 
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libboost-dev (>=1.36.0)")
 set(CPACK_DEBIAN_PACKAGE_SECTION "devel")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 
 set(CPACK_RPM_PACKAGE_LICENSE "BSD")
 set(CPACK_RPM_PACKAGE_GROUP "Programming")
-set(CPACK_RPM_PACKAGE_REQUIRES "boost-devel >= 1.36.0, boost-thread >= 1.36.0")
 
 set(CHAI_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
 
@@ -39,71 +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")
+message(STATUS "Detecting readline support")
-if (READLINE_LIBRARY)
+if(READLINE_LIBRARY)
-    MESSAGE(STATUS "Found: ${READLINE_LIBRARY}")
+  message(STATUS "Found: ${READLINE_LIBRARY}")
-    SET (READLINE_LIB readline)
+  set(READLINE_LIB readline)
-    ADD_DEFINITIONS(/DREADLINE_AVAILABLE)
+  add_definitions(/DREADLINE_AVAILABLE)
-else(READLINE_LIBRARY)
+else()
-    MESSAGE(STATUS "Not Found")
+  message(STATUS "Not Found")
-    SET (READLINE_LIB )
+  set(READLINE_LIB)
-    SET (READLINE_FLAG )
+  set(READLINE_FLAG)
-endif(READLINE_LIBRARY)
+endif()
 
-IF(MSVC)
+if(CMAKE_COMPILER_IS_GNUCC)
-  ADD_DEFINITIONS(/W4)
+  execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-  IF(CMAKE_CL_64)
+
-    ADD_DEFINITIONS(/bigobj)
+  if(GCC_VERSION VERSION_LESS 4.8)
-   ENDIF()
+    set(CPP11_FLAG "-std=c++0x")
-ELSE()
+  else()
-  # -Wno-missing-field-initializers is for boost on macos
+    set(CPP11_FLAG "-std=c++11")
-  ADD_DEFINITIONS(-Wall -Wextra -Wno-missing-field-initializers -Wshadow) 
+  endif()
-ENDIF()
+else()
+  set(CPP11_FLAG "-std=c++11")
+endif()
+
+if(MSVC)
+  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 -Wnon-virtual-dtor -pedantic ${CPP11_FLAG})
+
+  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)
 
-if (MULTITHREAD_SUPPORT_ENABLED)
-  find_package(Boost 1.36.0 COMPONENTS thread)
 
-  if (Boost_FOUND)
+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)
-    link_directories( ${Boost_LIBRARY_DIRS} )
+
-  else()
+set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
-    message(FATAL_ERROR "Can not find Boost")
+
-  endif(Boost_FOUND)
+if(NOT MULTITHREAD_SUPPORT_ENABLED)
-else()
+  add_definitions(-DCHAISCRIPT_NO_THREADS)
-  ADD_DEFINITIONS(-DCHAISCRIPT_NO_THREADS)
 endif()
 
-if (CMAKE_HOST_UNIX)
+if(CMAKE_HOST_UNIX)
-  SET(DYNAMIC_LOADER "dl")
+  if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-endif(CMAKE_HOST_UNIX)
+    list(APPEND LIBS "dl")
+  endif()
+
+  if(MULTITHREAD_SUPPORT_ENABLED)
+    if(CMAKE_COMPILER_IS_GNUCC)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE GCC_FULL_VERSION)
+      if(GCC_FULL_VERSION MATCHES "4.8.1.*ubuntu")
+        set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--no-as-needed -pthread")
+      else()
+        set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
+      endif()
+    else()
+      set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
+    endif()
+
+    add_definitions(-pthread)
+  endif()
 
-if (MSVC)
-  # Boost on MSVC does automatic linking
-  SET(LIBS ${DYNAMIC_LOADER} ${READLINE_LIB})
-else()
-  SET(LIBS ${DYNAMIC_LOADER} ${Boost_LIBRARIES} ${READLINE_LIB})
 endif()
 
-if (CMAKE_COMPILER_2005)
+list(APPEND LIBS ${READLINE_LIB})
-  # vs2005 is a bit too loud about possible loss of data warnings
-#  ADD_DEFINITIONS(/wd4244)
-endif()
 
-include_directories(${Boost_INCLUDE_DIRS})
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
-include_directories(${Boost_INCLUDE_DIR})
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
-add_executable(chai src/main.cpp)
+set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
+
+
+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)
@@ -111,34 +206,41 @@ 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})
 
-  add_library(reflection MODULE src/reflection.cpp)
+  set(MODULES stl_extra)
-  target_link_libraries(reflection ${LIBS})
-  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)
+if(BUILD_TESTING)
   option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
 
-  foreach(filename ${UNIT_TESTS})
+  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) }")
-    message(STATUS "Adding test ${filename}")
+  set_property(TEST version_check
-    add_test(${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
+    PROPERTY ENVIRONMENT
-  endforeach(filename)
-
-  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)
+
+  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)
@@ -154,7 +256,7 @@ IF(BUILD_TESTING)
     add_executable(functor_cast_test unittests/functor_cast_test.cpp)
     target_link_libraries(functor_cast_test ${LIBS})
     add_test(NAME Functor_Cast_Test COMMAND functor_cast_test)
-    
+
     add_executable(boxed_cast_test unittests/boxed_cast_test.cpp)
     target_link_libraries(boxed_cast_test ${LIBS})
     add_test(NAME Boxed_Cast_Test COMMAND boxed_cast_test)
@@ -171,12 +273,68 @@ IF(BUILD_TESTING)
     target_link_libraries(type_info_test ${LIBS})
     add_test(NAME Type_Info_Test COMMAND type_info_test)
 
+    add_executable(type_name_test unittests/type_name_test.cpp)
+    target_link_libraries(type_name_test ${LIBS})
+    add_test(NAME Type_Name_Test COMMAND type_name_test)
+
     add_executable(eval_catch_exception_test unittests/eval_catch_exception_test.cpp)
     target_link_libraries(eval_catch_exception_test ${LIBS})
     add_test(NAME Eval_Catch_Exception_Test COMMAND eval_catch_exception_test)
 
-    add_executable(multifile_test unittests/multifile_test_main.cpp unittests/multifile_test_chai.cpp
+    add_executable(short_comparison_test unittests/short_comparison_test.cpp)
-      unittests/multifile_test_module.cpp)
+    target_link_libraries(short_comparison_test ${LIBS})
+    add_test(NAME Short_Comparison_Test COMMAND short_comparison_test)
+
+    add_executable(cpp_lambda_test unittests/cpp_lambda_test.cpp)
+    target_link_libraries(cpp_lambda_test ${LIBS})
+    add_test(NAME cpp_lambda_test COMMAND cpp_lambda_test)
+
+    add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
+    target_link_libraries(expected_eval_errors_test ${LIBS})
+    add_test(NAME Expected_Eval_Errors_Test COMMAND expected_eval_errors_test)
+
+    add_executable(set_state_test unittests/set_state_test.cpp)
+    target_link_libraries(set_state_test ${LIBS})
+    add_test(NAME Set_State_Test COMMAND set_state_test)
+
+    add_executable(simultaneous_chaiscript_test unittests/simultaneous_chaiscript_test.cpp)
+    target_link_libraries(simultaneous_chaiscript_test ${LIBS})
+    add_test(NAME Simultaneous_ChaiScript_Test COMMAND simultaneous_chaiscript_test)
+
+    add_executable(heap_allocated_chaiscript_test unittests/heap_allocated_chaiscript_test.cpp)
+    target_link_libraries(heap_allocated_chaiscript_test ${LIBS})
+    add_test(NAME Heap_Allocated_ChaiScript_Test COMMAND heap_allocated_chaiscript_test)
+
+    add_executable(c_linkage_test unittests/c_linkage_test.cpp)
+    target_link_libraries(c_linkage_test ${LIBS})
+    add_test(NAME C_Linkage_Test COMMAND c_linkage_test)
+
+    add_executable(integer_literal_test unittests/integer_literal_test.cpp)
+    target_link_libraries(integer_literal_test ${LIBS})
+    add_test(NAME Integer_Literal_Test COMMAND integer_literal_test)
+
+    add_executable(arithmetic_conversions_test unittests/arithmetic_conversions_test.cpp)
+    target_link_libraries(arithmetic_conversions_test ${LIBS})
+    add_test(NAME Arithmetic_Conversions_Test COMMAND arithmetic_conversions_test)
+
+    if(MULTITHREAD_SUPPORT_ENABLED)
+      add_executable(multithreaded_test unittests/multithreaded_test.cpp)
+      target_link_libraries(multithreaded_test ${LIBS})
+      add_test(NAME Multithreaded_Test COMMAND multithreaded_test)
+      set_property(TEST Multithreaded_Test
+        PROPERTY ENVIRONMENT
+        "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
+        "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+      )
+
+    endif()
+
+
+    add_executable(multifile_test
+      unittests/multifile_test_main.cpp
+      unittests/multifile_test_chai.cpp
+      unittests/multifile_test_module.cpp
+    )
     target_link_libraries(multifile_test ${LIBS})
     add_test(NAME MultiFile_Test COMMAND multifile_test)
 
@@ -184,29 +342,29 @@ IF(BUILD_TESTING)
     target_link_libraries(test_module ${LIBS})
 
     install(TARGETS test_module RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
-  ENDIF()
+  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"
+install(DIRECTORY include/chaiscript DESTINATION include
-   PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*.hpp"
-   PATTERN "*/.git*" EXCLUDE
+  PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*/.git*" EXCLUDE
-install(DIRECTORY unittests DESTINATION share/chaiscript 
+  PATTERN "*~" EXCLUDE)
-   PATTERN "*.chai" 
+install(DIRECTORY unittests DESTINATION share/chaiscript
-   PATTERN "*.inc"
+  PATTERN "*.chai"
-   PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*.inc"
-   PATTERN "*/.git*" EXCLUDE
+  PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*/.git*" EXCLUDE
-install(DIRECTORY samples DESTINATION share/chaiscript 
+  PATTERN "*~" EXCLUDE)
-   PATTERN "*.chai"
+install(DIRECTORY samples DESTINATION share/chaiscript
-   PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*.chai"
-   PATTERN "*/.git*" EXCLUDE
+  PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*~" 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" 
+install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc"
-	DESTINATION lib/pkgconfig)
+        DESTINATION lib/pkgconfig)
 

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

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

contrib/codeanalysis/is_prime.chai

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

contrib/codeanalysis/profile_math.chai

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

contrib/codeanalysis/runcppcheck.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+pushd ..
+wget http://sourceforge.net/projects/cppcheck/files/cppcheck/1.66/cppcheck-1.66.tar.bz2
+tar -xvf cppcheck-1.66.tar.bz2
+cd cppcheck-1.66
+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
@@ -48,10 +48,10 @@ $language_data = array (
     'ESCAPE_CHAR' => '\\',
     'KEYWORDS' => array(
         1 => array(
-            'break', 'else', 'else if', 'eval', 'for', 'if', 'return', 'while', 'try', 'catch', 'finally',
+            '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

@@ -7,6 +7,9 @@ if exists("b:current_syntax")
   finish
 end
 
+let s:cpo_save = &cpo
+set cpo&vim
+
 syn case match
 
 " syncing method
@@ -16,11 +19,11 @@ syn sync fromstart
 syn region chaiscriptString        start=+"+ end=+"+ skip=+\\\\\|\\"+ contains=chaiscriptSpecial,chaiscriptEval,@Spell
 
 " Escape characters
-syn match  chaiscriptSpecial       contained "\\[\\abfnrtv\'\"]\|\\\d\{,3}" 
+syn match  chaiscriptSpecial       contained "\\[\\abfnrtv\'\"]\|\\\d\{,3}"
 
 " String evals
-syn region chaiscriptEval          contained start="${" end="}" 
+syn region chaiscriptEval          contained start="${" end="}"
- 
+
 " integer number
 syn match  chaiscriptNumber        "\<\d\+\>"
 
@@ -42,14 +45,14 @@ syn match  chaiscriptNumber        "\<0b[01]\+\>"
 " Various language features
 syn keyword chaiscriptCond         if else
 syn keyword chaiscriptRepeat       while for do
-syn keyword chaiscriptStatement    break continue return
+syn keyword chaiscriptStatement    break continue return switch case default
 syn keyword chaiscriptExceptions   try catch throw
 
 "Keyword
 syn keyword chaiscriptKeyword      def true false attr
 
 "Built in types
-syn keyword chaiscriptType         fun var
+syn keyword chaiscriptType         fun var auto
 
 "Built in funcs, keep it simple
 syn keyword chaiscriptFunc         eval throw
@@ -91,4 +94,6 @@ hi def link chaiscriptEval	        Special
 
 let b:current_syntax = "chaiscript"
 
+let &cpo = s:cpo_save
+unlet s:cpo_save
 " vim: nowrap sw=2 sts=2 ts=8 noet

include/chaiscript/chaiscript.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HPP_
@@ -9,8 +9,8 @@
 
 
 
-/// \mainpage
+/// @mainpage
-/// <a href="http://www.chaiscript.com">ChaiScript</a> is a scripting language designed specifically for integration with C++. It provides
+/// [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,38 +18,43 @@
 ///
 /// 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
-/// \sa chaiscript::ChaiScript
+/// @sa chaiscript::ChaiScript
-/// \sa \ref LangKeywordRef
+/// @sa ChaiScript_Language for Built in Functions
-/// \sa \ref LangInPlaceRef
+/// @sa @ref LangGettingStarted
-/// \sa \ref LangObjectSystemRef
+/// @sa @ref LangKeywordRef
-/// \sa http://www.chaiscript.com
+/// @sa @ref LangInPlaceRef
-/// \sa http://www.github.com/ChaiScript/ChaiScript
+/// @sa @ref LangObjectSystemRef
+/// @sa http://www.chaiscript.com
+/// @sa http://www.github.com/ChaiScript/ChaiScript
 ///
-/// <hr>
+/// -----------------------------------------------------------
 ///
-/// \section gettingstarted Getting Started
+/// @section gettingstarted API Getting Started
 ///
-/// \li \ref basics
+/// - @ref basics
-/// \li \ref eval
+/// - @ref compiling
-/// \li \ref addingitems
+/// - @ref eval
-/// \li \ref helpermacro
+/// - @ref adding_items
-/// \li \ref pointerconversions
+/// - @ref operatoroverloading
-/// \li \ref baseclasses
+/// - @ref add_class
-/// \li \ref functionobjects
+/// - @ref pointer_conversions
-/// \li \ref threading
+/// - @ref baseclasses
-/// \li \ref exceptions
+/// - @ref functionobjects
+/// - @ref threading
+/// - @ref exceptions
 /// 
 /// 
-/// \subsection basics Basics
+/// @subsection basics Basics
 /// 
 /// Basic simple example:
 ///
-/// \code
+/// ~~~~~~~{.cpp}
+/// //main.cpp
 /// #include <chaiscript/chaiscript.hpp>
 /// 
 /// double function(int i, double j)
@@ -64,87 +69,115 @@
 ///
 ///   double d = chai.eval<double>("function(3, 4.75);");
 /// } 
-/// \endcode
+/// ~~~~~~~
 ///
-/// <hr>
+/// ------------------------------------------------------
-/// \subsection eval Evaluating Scripts
+///
+/// @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
+/// 
+/// To compile the above application on a Unix like operating system (MacOS, Linux) with GCC you need to link
+/// the dynamic loader. For example:
+///
+/// ~~~~~~~~
+/// gcc main.cpp -I/path/to/chaiscript/headers -ldl 
+/// ~~~~~~~~
+///
+/// Alternatively, you may compile without threading support.
+///
+/// ~~~~~~~~
+/// gcc main.cpp -I/path/to/chaiscript/headers -ldl -DCHAISCRIPT_NO_THREADS
+/// ~~~~~~~~
+///
+/// ------------------------------------------
+///
+/// @subsection eval Evaluating Scripts
 ///
 /// Scripts can be evaluated with the () operator, eval method or eval_file method.
 ///
-/// \subsubsection parenoperator () Operator
+/// @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 #var function.
+/// 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 {
@@ -161,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::*)()>(&MyClass::overloadedmethod), "overloadedmethod");
-/// chai.add(fun<void (MyClass::*)(const std::string &)>(&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 
@@ -190,28 +223,54 @@
 ///
 /// 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
+///
+/// -----------------------------------------------------------------------
+///
+/// @subsection operatoroverloading Operator Overloading
 /// 
-/// <hr>
+/// Operators are just like any other function in ChaiScript, to overload an operator, simply register it.
-/// \subsection helpermacro Class Helper Macro
+/// 
+/// ~~~~~~~~{.cpp} 
+/// class MyClass {
+///   MyClass operator+(const MyClass &) const;
+/// };
+///
+/// chai.add(fun(&MyClass::operator+), "+");
+///
+/// std::string append_string_int(const std::string &t_lhs, int t_rhs)
+/// {
+///   std::stringstream ss;
+///   ss << t_lhs << t_rhs;
+///   return ss.str();
+/// }
+///
+/// chai.add(fun(append_string_int), "+");
+/// ~~~~~~~~
+///
+/// @sa @ref adding_functions
+///
+/// -----------------------------------------------------------------------
+///
+/// @subsection add_class Class Helper Utility
 /// 
 /// Much of the work of adding new classes to ChaiScript can be reduced with the help
-/// of the CHAISCRIPT_CLASS helper macro.
+/// of the add_class helper utility.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// class Test
 /// {
 ///   public:
@@ -224,51 +283,51 @@
 ///
 /// int main()
 /// {
-///
 ///   chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
 ///
-///   CHAISCRIPT_CLASS( m, 
+///   chaiscript::utility::add_class<chaiscript::Test>(*m,
-///       Test,
+///      "Test",
-///       (Test ())
+///      { constructor<Test()>(),
-///       (Test (const Test &)),
+///        constructor<Test(const Test &)>() },
-///       ((function))
+///      { {fun(&Test::function), "function"},
-///       ((function2))
+///        {fun(&Test::function2), "function2"},
-///       ((function3))
+///        {fun(&Test::function2), "function3"} 
-///       ((functionOverload)(std::string (Test::*)(double)))
+///        {fun(static_cast<std::string Test::*(double)>(&Test::functionOverload)), "functionOverload"} 
-///       ((functionOverload)(std::string (Test::*)(int)))
+///        {fun(static_cast<std::string Test::*(int)>(&Test::functionOverload)), "functionOverload"} }
-///       ((operator=))
+///      );
-///     );
+///
-/// 
+///
 ///   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>,
+/// @subsection pointer_conversions Pointer / Object Conversions
-/// boost::shared_ptr<const T>, boost::reference_wrapper<T>, boost::reference_wrapper<const T> and value types automatically.
 ///
-/// If a var object was created in C++ from a pointer, it cannot be convered to a shared_ptr (this would add invalid reference counting).
+/// 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 fun5(std::shared_ptr<int>);
-/// void fun6(boost::shared_ptr<const int>);
+/// void fun6(std::shared_ptr<const int>);
-/// void fun7(const boost::shared_ptr<int> &);
+/// void fun7(const std::shared_ptr<int> &);
-/// void fun8(const boost::shared_ptr<const int> &);
+/// void fun8(const std::shared_ptr<const int> &);
-/// void fun9(boost::reference_wrapper<int>);
+/// void fun9(std::reference_wrapper<int>);
-/// void fun10(boost::reference_wrapper<const int>);
+/// void fun10(std::reference_wrapper<const int>);
 ///
 /// int main()
 /// {
@@ -297,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);
@@ -322,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
+/// @subsection functionobjects Function Objects
-/// between ChaiScript functions and boost::function objects.
 ///
-/// \code
+/// Functions are first class objects in ChaiScript and ChaiScript supports automatic conversion
-/// void callafunc(const boost::function<void (const std::string &)> &t_func)
+/// between ChaiScript functions and std::function objects.
+///
+/// ~~~~~~~~{.cpp}
+/// void callafunc(const std::function<void (const std::string &)> &t_func)
 /// {
 ///   t_func("bob");
 /// }
@@ -342,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
@@ -359,16 +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
+///
 /// 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");
@@ -376,10 +441,12 @@
 /// 
 /// int main()
 /// {
+///   // Throw in C++, catch in ChaiScript
 ///   chaiscript::ChaiScript chai;
 ///   chai.add(chaiscript::fun(&throwexception), "throwexception");
 ///   chai("try { throwexception(); } catch (e) { print(e.what()); }"); // prints "err"
 /// 
+///   // Throw in ChaiScript, catch in C++
 ///   try {
 ///     chai("throw(1)");
 ///   } catch (chaiscript::Boxed_Value bv) {
@@ -387,14 +454,39 @@
 ///     // i == 1
 ///   }
 /// }
-/// \endcode
+/// ~~~~~~~~
+/// 
+/// @subsubsection exceptionsautomatic Exception Handling Automatic Unboxing
+///
+/// As an alternative to the manual unboxing of exceptions shown above, exception specifications allow the user to tell 
+/// ChaiScript what possible exceptions are expected from the script being executed. 
+///
+/// Example:
+/// ~~~~~~~~{.cpp}
+/// chaiscript::ChaiScript chai;
+///
+/// try {
+///   chai.eval("throw(runtime_error(@"error@"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+/// } catch (const double e) {
+/// } catch (int) {
+/// } catch (float) {
+/// } catch (const std::string &) {
+/// } catch (const std::exception &e) {
+///   // This is the one what will be called in the specific throw() above
+/// }
+/// ~~~~~~~~
+///
+/// @sa chaiscript::Exception_Handler for details on automatic exception unboxing 
+/// @sa chaiscript::exception_specification
 
-/// \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 }
@@ -403,65 +495,196 @@
 /// var rect = Rectangle()
 /// rect.height = 30
 /// print(rect.area())
-/// \endcode
+/// ~~~~~~~~~
 ///
-/// \sa \ref keywordattr
+/// Since ChaiScript 5.4.0 it has been possible to use the "class" keyword to simplify this code.
-/// \sa \ref keyworddef
+///
+/// ~~~~~~~~~
+/// class Rectangle {
+///   attr height
+///   attr width
+///   def Rectangle() { this.height = 10; this.width = 20 }
+///   def area() { this.height * this.width }
+/// }
+///
+/// var rect = Rectangle()
+/// rect.height = 30
+/// print(rect.area())
+/// ~~~~~~~~~
+///
+/// @sa @ref keywordattr
+/// @sa @ref keyworddef
 
-/// \page LangInPlaceRef ChaiScript Language In-Place Creation Reference
+/// @page LangInPlaceRef ChaiScript Language In-Place Creation Reference
-/// \section inplacevector Vector
+/// @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 LangKeywordRef ChaiScript Language Keyword Reference
+/// @page LangGettingStarted ChaiScript Language Getting Started
+/// 
+/// ChaiScript is a simple language that should feel familiar to anyone who knows
+/// C++ or ECMAScript (JavaScript). 
+///
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptloops Loops
+///
+/// Common looping constructs exist in ChaiScript
+///
+/// ~~~~~~~~
+/// var i = 0;
+/// while (i < 10)
+/// {
+///   // do something
+///   ++i;
+/// }
+/// ~~~~~~~~
+///
+/// ~~~~~~~~
+/// for (var i = 0; i < 10; ++i)
+/// {
+///   // do something
+/// }
+/// ~~~~~~~~
+///
+/// @sa @ref keywordfor
+/// @sa @ref keywordwhile
+///
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptifs Conditionals
+///
+/// If statements work as expected
+/// 
+/// ~~~~~~~~
+/// var b = true;
+/// 
+/// if (b) {
+///   // do something
+/// } else if (c < 10) {
+///   // do something else
+/// } else {
+///   // or do this
+/// }
+/// ~~~~~~~~
+///
+/// @sa @ref keywordif
+///
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptfunctions Functions
+/// 
+/// Functions are defined with the def keyword
+/// 
+/// ~~~~~~~~
+/// def myfun(x) { print(x); }
+///
+/// myfun(10);
+/// ~~~~~~~~
+///
+/// Functions may have "guards" which determine if which is called.
+///
+/// ~~~~~~~~
+/// eval> def myfun2(x) : x < 10 { print("less than 10"); }
+/// eval> def myfun2(x) : x >= 10 { print("10 or greater"); }
+/// eval> myfun2(5)
+/// less than 10
+/// eval> myfun2(12)
+/// 10 or greater
+/// ~~~~~~~~
+/// 
+/// @sa @ref keyworddef
+/// @sa @ref keywordattr
+/// @sa @ref LangObjectSystemRef
+///
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptfunctionobjects Function Objects
+/// 
+/// Functions are first class types in ChaiScript and can be used as variables.
+///
+/// ~~~~~~~~
+/// eval> var p = print;
+/// eval> p(1);
+/// 1
+/// ~~~~~~~~
+/// 
+/// They can also be passed to functions. 
+///
+/// ~~~~~~~~
+/// eval> def callfunc(f, lhs, rhs) { return f(lhs, rhs); }
+/// eval> def do_something(lhs, rhs) { print("lhs: ${lhs}, rhs: ${rhs}"); }
+/// eval> callfunc(do_something, 1, 2);
+/// lhs: 1, rhs: 2
+/// ~~~~~~~~
+///
+/// Operators can also be treated as functions by using the back tick operator. Building on the above example:
+/// 
+/// ~~~~~~~~
+/// eval> callfunc(`+`, 1, 4);
+/// 5
+/// eval> callfunc(`*`, 3, 2);
+/// 6
+/// ~~~~~~~~
+///
+/// -----------------------------------------------------------------------
+///
+/// @sa @ref LangKeywordRef
+/// @sa ChaiScript_Language for Built in Functions
+
+
+/// @page LangKeywordRef ChaiScript Language Keyword Reference
 ///
 ///
-/// <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 keywordfor
-/// \sa \ref keywordwhile 
+/// @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.
@@ -477,50 +700,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) {
@@ -528,50 +757,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
+/// @namespace chaiscript
-/// \brief Namespace chaiscript contains every API call that the average user will be concerned with.
+/// @brief Namespace chaiscript contains every API call that the average user will be concerned with.
 
-/// \namespace chaiscript::detail
+/// @namespace chaiscript::detail
-/// \brief Classes and functions reserved for internal use. Items in this namespace are not supported.
+/// @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_pod_value.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 = 4;
+  static const int version_patch = 0;
+}
+
+#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

@@ -1,14 +1,17 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_THREADING_HPP_
 #define CHAISCRIPT_THREADING_HPP_
 
+#include <unordered_map>
+
 #ifndef CHAISCRIPT_NO_THREADS
-#include <boost/thread.hpp>
+#include <thread>
+#include <mutex>
 #else
 #pragma message ("ChaiScript is compiling without thread safety.")
 #endif
@@ -25,56 +28,136 @@ 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())
+              return &(t()[m_key]);
-              {
-                m_thread_storage.reset(new T());
-              }
-
-              return m_thread_storage.get();
             }
 
             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 
       {
         public:
           unique_lock(T &) {}
+          void lock() {}
+          void unlock() {}
       };
 
       template<typename T>
@@ -82,6 +165,7 @@ namespace chaiscript
       {
         public:
           shared_lock(T &) {}
+          void lock() {}
           void unlock() {}
       };
 
@@ -101,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,172 @@
+// 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
+        {
+          Data(const std::type_info &t_type) 
+            : m_type(t_type)
+          {
+          }
+
+          Data &operator=(const Data &) = delete;
+
+          virtual ~Data() {}
+          virtual void *data() = 0;
+          const std::type_info &type() const
+          {
+            return m_type;
+          }
+
+          virtual std::unique_ptr<Data> clone() const = 0;
+          const std::type_info &m_type;
+        };
+
+        template<typename T>
+          struct Data_Impl : Data
+          {
+            Data_Impl(T t_type)
+              : Data(typeid(T)),
+                m_data(std::move(t_type))
+            {
+            }
+
+            virtual ~Data_Impl() {}
+
+            virtual void *data() CHAISCRIPT_OVERRIDE
+            {
+              return &m_data;
+            }
+
+            std::unique_ptr<Data> clone() const CHAISCRIPT_OVERRIDE
+            {
+              return std::unique_ptr<Data>(new Data_Impl<T>(m_data));
+            }
+
+            Data_Impl &operator=(const Data_Impl&) = delete;
+
+            T m_data;
+          };
+
+        std::unique_ptr<Data> m_data;
+
+      public:
+        // construct/copy/destruct
+        Any() = default;
+
+        Any(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::unique_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::unique_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::swap(t_other.m_data, m_data);
+          return *this;
+        }
+
+        // queries
+        bool empty() const
+        {
+          return !bool(m_data);
+        }
+
+        const std::type_info & type() const
+        {
+          if (m_data)
+          {
+            return m_data->type();
+          } else {
+            return typeid(void);
+          }
+        }
+    };
+
+  }
+}
+
+#endif
+
+

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -1,14 +1,21 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
 #define CHAISCRIPT_BAD_BOXED_CAST_HPP_
 
+#include <string>
+#include <typeinfo>
+
 #include "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()
+            std::string t_what) CHAISCRIPT_NOEXCEPT
-          : from(t_from), to(&t_to), m_what(t_what)
+          : 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()
+        bad_boxed_cast(std::string t_what) CHAISCRIPT_NOEXCEPT
-          : m_what(t_what)
+          : 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

@@ -1,93 +1,133 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// 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 <functional>
-#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)
 
 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.
+    template<int>
-    ///
+      struct Placeholder
-    /// \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)
       {
-        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
+    template<typename O, typename Ret, typename Class, typename ... Param>
-    ///        that take 1 or 2 parameters to pre-bind to the function.
+      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...), O o)
-    ///
-    /// \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)
       {
-        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
+    template<typename O, typename Ret, typename Class, typename ... Param>
-    ///        that take 1 or 2 parameters to pre-bind to the function.
+      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...) const, O o)
-    ///
-    /// \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)
       {
-        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
+    template<typename O, typename Ret, typename P1, typename ... Param>
-    ///        that take 1 or 2 parameters to pre-bind to the function.
+      std::function<Ret (Param...)> bind_first(const std::function<Ret (P1, Param...)> &f, O o)
-    ///
-    /// \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)
       {
-        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
 
 #endif

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,18 +1,39 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
 #define CHAISCRIPT_BOOTSTRAP_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 "register_function.hpp"
 #include "operators.hpp"
-#include "boxed_pod_value.hpp"
+#include "proxy_constructors.hpp"
-#include <boost/function_types/result_type.hpp>
+#include "proxy_functions.hpp"
+#include "proxy_functions_detail.hpp"
+#include "register_function.hpp"
+#include "type_info.hpp"
+#include "../utility/utility.hpp"
+#include "../language/chaiscript_common.hpp"
 
 namespace chaiscript 
 {
@@ -21,189 +42,30 @@ namespace chaiscript
   {
     namespace detail
     {
-
+      /// \brief Constructs a new POD value object from a Boxed_Number
-      /// \brief Assigns a POD value from a Boxed_POD_Value. Helps support operators between
+      /// \param[in] v Boxed_Number to copy into the new object
-      ///        disparate POD types.
-      /// \param[in,out] p1 object to assign to
-      /// \param[in] v Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_pod(P1 &p1, const Boxed_POD_Value &v)
-      {
-        if (v.isfloat)
-        {
-          return (p1 = P1(v.d));
-        } else {
-          return (p1 = P1(v.i));
-        }
-      }
-
-      /// \brief Constructs a new POD value object from a Boxed_POD_Value
-      /// \param[in] v Boxed_POD_Value to copy into the new object
       /// \returns The newly created object.
       template<typename P1>
-      P1 construct_pod(Boxed_POD_Value v)
+      std::shared_ptr<P1> construct_pod(Boxed_Number v)
       {
-        if (v.isfloat)
+        std::shared_ptr<P1> p(new P1());
-        {
+        Boxed_Value bv(p);
-          return P1(v.d);
+        Boxed_Number nb(bv);
-        } else {
+        nb = v;
-          return P1(v.i);
+        return p;
-        }    
-      }
-
-      /// \brief Performs a bitwise and assignment (&=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to bitwise and assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_bitwise_and_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 &= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("&= only valid for integer types");
-      }
-
-      /// \brief Performs a xor assignment (^=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to xor assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_xor_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 ^= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("^= only valid for integer types");
-      }
-
-      /// \brief Performs a bitwise or assignment (|=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to bitwise or assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_bitwise_or_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 |= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("&= only valid for integer types");
-      }
-
-      /// \brief Performs an assign difference (-=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to difference assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_difference_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 -= P1(r.d);
-        } else {
-          return p1 -= P1(r.i);
-        }
-      }
-
-      /// \brief Performs an assign shift left (<<=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign shift left to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_left_shift_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 <<= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("<<= only valid for integer types");
-      }
-
-
-      /// \brief Performs an assign product (*=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign product to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_product_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 *= P1(r.d);
-        } else {
-          return p1 *= P1(r.i);
-        }
-      }
-
-      /// \brief Performs an assign quotient (/=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign quotient to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_quotient_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 /= P1(r.d);
-        } else {
-          return p1 /= P1(r.i);
-        }
-      }
-
-      /// \brief Performs an assign remainder (%=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign remainder to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_remainder_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 %= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("%= only valid for integer types");
-      }
-
-
-      /// \brief Performs an assign shift right (>>=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign shift right to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_right_shift_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 >>= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast(">>= only valid for integer types");
-      }
-
-      /// \brief Performs an assign sum (+=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to sum assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_sum_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 += P1(r.d);
-        } else {
-          return p1 += P1(r.i);
-        }
       }
+    }
 
+    /// \brief Adds a copy constructor for the given type to the given Model
+    /// \param[in] type The name of the type. The copy constructor will be named "type".
+    /// \param[in,out] m The Module to add the copy constructor to
+    /// \tparam T The type to add a copy constructor for
+    /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
+    template<typename T>
+    ModulePtr copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      m->add(constructor<T (const T &)>(), type);
+      return m;
     }
 
     /// \brief Add all comparison operators for the templated type. Used during bootstrap, also available to users.
@@ -223,76 +85,6 @@ namespace chaiscript
     }
 
 
-    /// \brief Add all arithmetic operators appropriate for integers for the templated type. 
-    ///        Used during bootstrap, also available to users.
-    /// \tparam T Type to create arithmetic operators for
-    /// \param[in,out] m module to add arithmetic operators to
-    /// \returns the passed in ModulePtr or the newly constructed one if the default params are used.
-    template<typename T>
-    ModulePtr opers_integer_arithmetic(ModulePtr m = ModulePtr(new Module()))
-    {
-      operators::assign_bitwise_and<T>(m);
-      operators::assign_xor<T>(m);
-      operators::assign_bitwise_or<T>(m);
-      operators::assign_difference<T>(m);
-      operators::assign_left_shift<T>(m);
-      operators::assign_product<T>(m);
-      operators::assign_quotient<T>(m);
-      operators::assign_remainder<T>(m);
-      operators::assign_right_shift<T>(m);
-      operators::assign_sum<T>(m);
-
-      operators::prefix_decrement<T>(m);
-      operators::prefix_increment<T>(m);
-      operators::addition<T>(m);
-      operators::unary_plus<T>(m);
-      operators::subtraction<T>(m);
-      operators::unary_minus<T>(m);
-      operators::bitwise_and<T>(m);
-      operators::bitwise_compliment<T>(m);
-      operators::bitwise_xor<T>(m);
-      operators::bitwise_or<T>(m);
-      operators::division<T>(m);
-      operators::left_shift<T>(m);
-      operators::multiplication<T>(m);
-      operators::remainder<T>(m);
-      operators::right_shift<T>(m);
-      return m;
-    }
-
-    /// \brief Add all arithmetic operators appropriate for floating point numbers for the templated type. 
-    ///        Used during bootstrap, also available to users.
-    /// \tparam T Type to create arithmetic operators for
-    /// \param[in,out] m module to add arithmetic operators to
-    /// \returns the passed in ModulePtr or the newly constructed one if the default params are used.
-    template<typename T>
-    ModulePtr opers_float_arithmetic(ModulePtr m = ModulePtr(new Module()))
-    {
-      operators::assign_difference<T>(m);
-      operators::assign_product<T>(m);
-      operators::assign_quotient<T>(m);
-      operators::assign_sum<T>(m);
-
-      operators::addition<T>(m);
-      operators::unary_plus<T>(m);
-      operators::subtraction<T>(m);
-      operators::unary_minus<T>(m);
-      operators::division<T>(m);
-      operators::multiplication<T>(m);
-      return m;
-    }
-
-    /// \brief Adds a copy constructor for the given type to the given Model
-    /// \param[in] type The name of the type. The copy constructor will be named "type".
-    /// \param[in,out] m The Module to add the copy constructor to
-    /// \tparam T The type to add a copy constructor for
-    /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
-    template<typename T>
-    ModulePtr copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(constructor<T (const T &)>(), type);
-      return m;
-    }
 
     /// \brief Adds default and copy constructors for the given type
     /// \param[in] type The name of the type to add the constructors for.
@@ -322,36 +114,30 @@ namespace chaiscript
 
 
     /**
-    * to_string function for internal use. Uses ostream operator<<
+     * to_string function for internal use. Uses ostream operator<<
-    */
+     */
     template<typename Input>
     std::string to_string(Input i)
     {
-      return boost::lexical_cast<std::string>(i);
+      std::stringstream ss;
+      ss << i;
+      return ss.str();
     }
 
-
     /**
-    * Internal function for converting from a string to a value
+     * Internal function for converting from a string to a value
-    * uses ostream operator >> to perform the conversion
+     * uses ostream operator >> to perform the conversion
-    */
+     */
     template<typename Input>
     Input parse_string(const std::string &i)
     {
-      return boost::lexical_cast<Input>(i);
+      std::stringstream ss(i);
+      Input t;
+      ss >> t;
+      return t;
     }
-
+      
-
+            
-    /**
-     * Add assignment operator for T = POD.
-     */
-    template<typename T>
-      ModulePtr oper_assign_pod(ModulePtr m = ModulePtr(new Module()))
-      {
-        m->add(fun(&detail::assign_pod<T>), "=");
-        return m;
-      }
-
     /**
     * Add all common functions for a POD type. All operators, and
     * common conversions
@@ -360,52 +146,14 @@ namespace chaiscript
     ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
     {
       m->add(user_type<T>(), name);
-      basic_constructors<T>(name, m);
+      m->add(constructor<T ()>(), name);
-      operators::assign<T>(m);
-      oper_assign_pod<T>(m);
       construct_pod<T>(name, m);
 
-      m->add(fun(&detail::assign_sum_pod<T>), "+=");
-      m->add(fun(&detail::assign_difference_pod<T>), "-=");
-      m->add(fun(&detail::assign_product_pod<T>), "*=");
-      m->add(fun(&detail::assign_quotient_pod<T>), "/=");
-
       m->add(fun(&to_string<T>), "to_string");
       m->add(fun(&parse_string<T>), "to_" + name);
       return m;
     }
 
-    /**
-    * Add all common functions for a POD type. All operators, and
-    * common conversions
-    */
-    template<typename T>
-    ModulePtr bootstrap_integer_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
-    {
-      bootstrap_pod_type<T>(name, m);
-
-      m->add(fun(&detail::assign_bitwise_and_pod<T>), "&=");
-      m->add(fun(&detail::assign_xor_pod<T>), "^=");
-      m->add(fun(&detail::assign_bitwise_or_pod<T>), "|=");
-      m->add(fun(&detail::assign_left_shift_pod<T>), "<<=");
-      m->add(fun(&detail::assign_remainder_pod<T>), "%=");
-      m->add(fun(&detail::assign_right_shift_pod<T>), ">>=");
-
-      opers_integer_arithmetic<T>(m);
-      return m;
-    }
-
-    /**
-    * Add all common functions for a POD type. All operators, and
-    * common conversions
-    */
-    template<typename T>
-    ModulePtr bootstrap_float_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
-    {
-      bootstrap_pod_type<T>(name, m);
-      opers_float_arithmetic<T>(m);
-      return m;
-    }
 
     /**
     * "clone" function for a shared_ptr type. This is used in the case
@@ -415,7 +163,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;
     }
@@ -424,10 +172,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> 
+    std::shared_ptr<typename std::remove_const<Type>::type> 
-        shared_ptr_unconst_clone(const boost::shared_ptr<typename boost::add_const<Type>::type> &p)
+        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);
     }
 
 
@@ -438,7 +186,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())))
@@ -480,22 +228,48 @@ namespace chaiscript
         std::cout << s << std::endl;
       }
 
+
       /**
       * Add all arithmetic operators for PODs
       */
       static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
       {
-        m->add(fun(&operators::addition<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "+");
+        m->add(fun(&Boxed_Number::equals), "==");
-        m->add(fun(&operators::subtraction<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "-");
+        m->add(fun(&Boxed_Number::less_than), "<");
-        m->add(fun(&operators::bitwise_and<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "&");
+        m->add(fun(&Boxed_Number::greater_than), ">");
-        m->add(fun(&operators::bitwise_xor<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "^");
+        m->add(fun(&Boxed_Number::greater_than_equal), ">=");
-        m->add(fun(&operators::bitwise_or<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "|");
+        m->add(fun(&Boxed_Number::less_than_equal), "<=");
-        m->add(fun(&operators::division<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "/");
+        m->add(fun(&Boxed_Number::not_equal), "!=");
-        m->add(fun(&operators::left_shift<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "<<");
+
-        m->add(fun(&operators::multiplication<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "*");
+        m->add(fun(&Boxed_Number::pre_decrement), "--");
-        m->add(fun(&operators::remainder<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "%");
+        m->add(fun(&Boxed_Number::pre_increment), "++");
-        m->add(fun(&operators::right_shift<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), ">>");
+        m->add(fun(&Boxed_Number::sum), "+");
-      }
+        m->add(fun(&Boxed_Number::unary_plus), "+");
+        m->add(fun(&Boxed_Number::unary_minus), "-");
+        m->add(fun(&Boxed_Number::difference), "-");
+        m->add(fun(&Boxed_Number::assign_bitwise_and), "&=");
+        m->add(fun(&Boxed_Number::assign), "=");
+        m->add(fun(&Boxed_Number::assign_bitwise_or), "|=");
+        m->add(fun(&Boxed_Number::assign_bitwise_xor), "^=");
+        m->add(fun(&Boxed_Number::assign_remainder), "%=");
+        m->add(fun(&Boxed_Number::assign_shift_left), "<<=");
+        m->add(fun(&Boxed_Number::assign_shift_right), ">>=");
+        m->add(fun(&Boxed_Number::bitwise_and), "&");
+        m->add(fun(&Boxed_Number::bitwise_complement), "~");
+        m->add(fun(&Boxed_Number::bitwise_xor), "^");
+        m->add(fun(&Boxed_Number::bitwise_or), "|");
+        m->add(fun(&Boxed_Number::assign_product), "*=");
+        m->add(fun(&Boxed_Number::assign_quotient), "/=");
+        m->add(fun(&Boxed_Number::assign_sum), "+=");
+        m->add(fun(&Boxed_Number::assign_difference), "-=");
+        m->add(fun(&Boxed_Number::quotient), "/");
+        m->add(fun(&Boxed_Number::shift_left), "<<");
+        m->add(fun(&Boxed_Number::product), "*");
+        m->add(fun(&Boxed_Number::remainder), "%");
+        m->add(fun(&Boxed_Number::shift_right), ">>");
+
+
+     }
 
       /**
       * Create a bound function object. The first param is the function to bind
@@ -515,28 +289,17 @@ namespace chaiscript
           std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
       }
 
-      /**
-      * Returns true if a call can be made that consists of the first parameter
-      * (the function) with the remaining parameters as its arguments.
-      */
-      static Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
-      {
-        if (params.size() < 1)
-        {
-          throw exception::arity_error(static_cast<int>(params.size()), 1);
-        }
-
-        Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
-
-        return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end())));
-      }
 
       static bool has_guard(const Const_Proxy_Function &t_pf)
       {
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
-          return pf->get_guard();
+          if (pf->get_guard()) {
+            return true;
+          } else {
+            return false;
+          }
         } else {
           return false;
         }
@@ -544,7 +307,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())
@@ -561,12 +324,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)
       {
@@ -590,26 +347,60 @@ 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;
+          auto v = (b->*f)();
-          Vector v = (b->*f)();
  
           std::vector<Boxed_Value> vbv;
-          for (typename Vector::const_iterator itr = v.begin();
+
-               itr != v.end();
+          for (const auto &o: v)
-               ++itr)
           {
-            vbv.push_back(const_var(*itr));
+            vbv.push_back(const_var(o));
           }
 
           return vbv;
         }
 
-      template<typename Function>
+
-      static boost::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
+      static bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
       {
-        return boost::bind(&do_return_boxed_value_vector<Function>, f, _1);
+        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())
+          {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
       }
 
+      static chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_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())
+          {
+            return pf->get_parse_tree();
+          } else {
+            throw std::runtime_error("Function does not have a parse tree");
+          }
+        } else {
+          throw std::runtime_error("Function does not have a parse tree");
+        }
+      }
+
+      template<typename Function>
+      static std::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
+      {
+        return std::bind(&do_return_boxed_value_vector<Function>, f, std::placeholders::_1);
+      }
+
+
     public:
       /// \brief perform all common bootstrap functions for std::string, void and POD types
       /// \param[in,out] m Module to add bootstrapped functions to
@@ -619,16 +410,15 @@ namespace chaiscript
         m->add(user_type<void>(), "void");
         m->add(user_type<bool>(), "bool");
         m->add(user_type<Boxed_Value>(), "Object");
-        m->add(user_type<Boxed_POD_Value>(), "PODObject");
+        m->add(user_type<Boxed_Number>(), "Number");
         m->add(user_type<Proxy_Function>(), "Function");
         m->add(user_type<std::exception>(), "exception");
 
         m->add(fun(&dispatch::Proxy_Function_Base::get_arity), "get_arity");
         m->add(fun(&dispatch::Proxy_Function_Base::annotation), "get_annotation");
-        m->add(fun(&dispatch::Proxy_Function_Base::operator()), "call");
         m->add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
 
-        
+
         m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_param_types)), "get_param_types");
         m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_contained_functions)), "get_contained_functions");
 
@@ -638,7 +428,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");
@@ -646,7 +436,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");
@@ -657,9 +447,12 @@ namespace chaiscript
         m->add(fun(&Boxed_Value::is_ref), "is_var_reference");
         m->add(fun(&Boxed_Value::is_pointer), "is_var_pointer");
         m->add(fun(&Boxed_Value::is_type), "is_type");
+        m->add(fun(&Boxed_Value::get_attr), "get_var_attr");
+        m->add(fun(&Boxed_Value::copy_attrs), "copy_var_attrs");
 
         m->add(fun(&Boxed_Value::get_type_info), "get_type_info");
         m->add(user_type<Type_Info>(), "Type_Info");
+        m->add(constructor<Type_Info (const Type_Info &)>(), "Type_Info");
 
 
         operators::equal<Type_Info>(m);
@@ -669,49 +462,118 @@ namespace chaiscript
         m->add(fun(&Type_Info::is_void), "is_type_void");
         m->add(fun(&Type_Info::is_undef), "is_type_undef");
         m->add(fun(&Type_Info::is_pointer), "is_type_pointer");
+        m->add(fun(&Type_Info::is_arithmetic), "is_type_arithmetic");
         m->add(fun(&Type_Info::name), "cpp_name");
         m->add(fun(&Type_Info::bare_name), "cpp_bare_name");
         m->add(fun(&Type_Info::bare_equal), "bare_equal");
-        typedef bool (Type_Info::*typeinfocompare)(const Type_Info &) const;
-        m->add(fun(typeinfocompare(&Type_Info::operator==)), "==");
-        m->add(fun(&Type_Info::bare_equal), "bare_equal");
 
 
         basic_constructors<bool>("bool", m);
         operators::assign<bool>(m);
+        operators::equal<bool>(m);
 
-        m->add(fun(&to_string<const std::string &>), "internal_to_string");
+        m->add(fun(&to_string<const std::string &>), "to_string");
-        m->add(fun(&Bootstrap::bool_to_string), "internal_to_string");
+        m->add(fun(&Bootstrap::bool_to_string), "to_string");
         m->add(fun(&unknown_assign), "=");
         m->add(fun(&throw_exception), "throw");
         m->add(fun(&what), "what");
 
-        bootstrap_float_type<double>("double", m);
+        bootstrap_pod_type<double>("double", m);
-        bootstrap_integer_type<int>("int", m);
+        bootstrap_pod_type<long double>("long_double", m);
-        bootstrap_integer_type<size_t>("size_t", m);
+        bootstrap_pod_type<float>("float", m);
-        bootstrap_integer_type<char>("char", m);
+        bootstrap_pod_type<int>("int", m);
-        bootstrap_integer_type<boost::int64_t>("int64_t", m);
+        bootstrap_pod_type<long>("long", m);
+        bootstrap_pod_type<unsigned int>("unsigned_int", m);
+        bootstrap_pod_type<unsigned long>("unsigned_long", m);
+        bootstrap_pod_type<size_t>("size_t", m);
+        bootstrap_pod_type<char>("char", m);
+        bootstrap_pod_type<std::int8_t>("int8_t", m);
+        bootstrap_pod_type<std::int16_t>("int16_t", m);
+        bootstrap_pod_type<std::int32_t>("int32_t", m);
+        bootstrap_pod_type<std::int64_t>("int64_t", m);
+        bootstrap_pod_type<std::uint8_t>("uint8_t", m);
+        bootstrap_pod_type<std::uint16_t>("uint16_t", m);
+        bootstrap_pod_type<std::uint32_t>("uint32_t", m);
+        bootstrap_pod_type<std::uint64_t>("uint64_t", m);
 
         operators::logical_compliment<bool>(m);
 
-        opers_comparison<Boxed_POD_Value>(m);
         opers_arithmetic_pod(m);
 
 
         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<std::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::add_const<dispatch::Proxy_Function_Base>::type>), "=");
+
+        m->add(fun(&Boxed_Value::type_match), "type_match");
+
+
+        m->add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
+        m->add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
+
+        m->add(chaiscript::base_class<std::exception, chaiscript::exception::eval_error>());
+
+//        chaiscript::bootstrap::standard_library::vector_type<std::vector<std::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
+
+
+        chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
+            "eval_error",
+            { },
+            { {fun(&chaiscript::exception::eval_error::reason), "reason"},
+            {fun(std::function<std::vector<Boxed_Value> (const chaiscript::exception::eval_error &t_eval_error)>([](const chaiscript::exception::eval_error &t_eval_error) { 
+                std::vector<Boxed_Value> retval;
+                std::transform(t_eval_error.call_stack.begin(), t_eval_error.call_stack.end(),
+                               std::back_inserter(retval),
+                               &chaiscript::var<std::shared_ptr<chaiscript::AST_Node>>);
+                return retval;
+              })), "call_stack"} }
+            );
+
+
+        chaiscript::utility::add_class<chaiscript::File_Position>(*m,
+            "File_Position",
+            { constructor<File_Position()>(),
+              constructor<File_Position(int, int)>() },
+            { {fun(&File_Position::line), "line"},
+              {fun(&File_Position::column), "column"} }
+            );
+
+
+        chaiscript::utility::add_class<AST_Node>(*m, 
+            "AST_Node",
+            {  },
+            { {fun(&AST_Node::text), "text"},
+              {fun(&AST_Node::identifier), "identifier"},
+              {fun(&AST_Node::filename), "filename"},
+              {fun(&AST_Node::start), "start"},
+              {fun(&AST_Node::end), "end"},
+              {fun(&AST_Node::to_string), "to_string"},
+              {fun(std::function<std::vector<Boxed_Value> (const chaiscript::AST_Node &t_node)>([](const chaiscript::AST_Node &t_node) { 
+                std::vector<Boxed_Value> retval;
+                std::transform(t_node.children.begin(), t_node.children.end(),
+                               std::back_inserter(retval),
+                               &chaiscript::var<std::shared_ptr<chaiscript::AST_Node>>);
+                return retval;
+              })), "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"} }
+            );
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), 
-          "call_exists");
 
-        m->add(fun(&type_match), "type_match");
 
         return m;
       }

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -1,23 +1,33 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-/**
+/// \file
- * \file
+/// This file contains utility functions for registration of STL container
- * This file contains utility functions for registration of STL container
+/// classes. The methodology used is based on the SGI STL concepts.
- * classes. The methodology used is based on the SGI STL concepts.
+/// http://www.sgi.com/tech/stl/table_of_contents.html
- * http://www.sgi.com/tech/stl/table_of_contents.html
- */
-
 
 
 #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 
 {
@@ -25,11 +35,10 @@ namespace chaiscript
   {
     namespace standard_library
     {
-      /**
+
-       * Bidir_Range, based on the D concept of ranges.
+      /// Bidir_Range, based on the D concept of ranges.
-       * \todo Update the Range code to base its capabilities on
+      /// \todo Update the Range code to base its capabilities on
-       *       the user_typetraits of the iterator passed in
+      ///       the user_typetraits of the iterator passed in
-       */
       template<typename Container>
         struct Bidir_Range
         {
@@ -147,9 +156,28 @@ namespace chaiscript
         };
 
       namespace detail {
-        /**
+
-         * Add Bidir_Range support for the given ContainerType
+        template<typename T>
-         */
+        size_t count(const T &t_target, const typename T::key_type &t_key)
+        {
+          return t_target.count(t_key);
+        }
+
+        template<typename T>
+          void insert(T &t_target, const T &t_other)
+          {
+            t_target.insert(t_other.begin(), t_other.end());
+          }
+
+        template<typename T>
+          void insert_ref(T &t_target, const typename T::value_type &t_val)
+          {
+            t_target.insert(t_val);
+          }
+
+
+
+        /// 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()))
           {
@@ -157,7 +185,7 @@ namespace chaiscript
 
             copy_constructor<Bidir_Type>(type + "_Range", m);
 
-            m->add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range");
+            m->add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range_internal");
 
             m->add(fun(&Bidir_Type::empty), "empty");
             m->add(fun(&Bidir_Type::pop_front), "pop_front");
@@ -168,14 +196,13 @@ namespace chaiscript
             return m;
           } 
 
-        /**
+
-         * Algorithm for inserting at a specific position into a container
+        /// Algorithm for inserting at a specific position into a container
-         */
         template<typename Type>
           void insert_at(Type &container, int pos, const typename Type::value_type &v)
           {
-            typename Type::iterator itr = container.begin();
+            auto itr = container.begin();
-            typename Type::iterator end = container.end();
+            auto end = container.end();
 
             if (pos < 0 || std::distance(itr, end) < pos)
             {
@@ -186,14 +213,13 @@ namespace chaiscript
             container.insert(itr, v);
           }
 
-        /**
+
-         * Algorithm for erasing a specific position from a container
+        /// Algorithm for erasing a specific position from a container
-         */
         template<typename Type>
           void erase_at(Type &container, int pos)
           {
-            typename Type::iterator itr = container.begin();
+            auto itr = container.begin();
-            typename Type::iterator end = container.end();
+            auto end = container.end();
 
             if (pos < 0 || std::distance(itr, end) < (pos-1))
             {
@@ -203,7 +229,7 @@ namespace chaiscript
             std::advance(itr, pos);
             container.erase(itr);
           }      
-        
+
       }
 
       template<typename ContainerType>
@@ -214,10 +240,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
+
-       * Add random_access_container concept to the given ContainerType
+      /// Add random_access_container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/RandomAccessContainer.html
+      /// http://www.sgi.com/tech/stl/RandomAccessContainer.html
-       */
       template<typename ContainerType>
         ModulePtr random_access_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -227,19 +252,18 @@ 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)>
+              fun(std::function<typename ContainerType::reference (ContainerType *, int)>
-                (boost::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
+                (std::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
           m->add(
-              fun(boost::function<typename ContainerType::const_reference (const ContainerType *, int)>
+              fun(std::function<typename ContainerType::const_reference (const ContainerType *, int)>
-                (boost::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
+                (std::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
 
           return m;
         }
 
-      /**
+
-       * Add assignable concept to the given ContainerType
+      /// Add assignable concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Assignable.html
+      /// http://www.sgi.com/tech/stl/Assignable.html
-       */
       template<typename ContainerType>
         ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -248,24 +272,21 @@ namespace chaiscript
           return m;
         }
 
-      /**
+
-       * Add container concept to the given ContainerType
+      /// Add container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Container.html
+      /// http://www.sgi.com/tech/stl/Container.html
-       */
       template<typename ContainerType>
         ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(boost::function<int (const ContainerType *)>(boost::mem_fn(&ContainerType::size))), "size");
+          m->add(fun( std::function<size_t (const ContainerType *)>( [](const ContainerType *a) { return a->size(); } ) ), "size");
-          m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
+          m->add(fun( std::function<bool (const ContainerType *)>( [](const ContainerType *a) { return a->empty(); } ) ), "empty");
-          m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
+          m->add(fun( std::function<void (ContainerType *)>( [](ContainerType *a) { a->clear(); } ) ), "clear");
-
           return m;
         }
 
-      /**
+
-       * Add default constructable concept to the given Type
+      /// Add default constructable concept to the given Type
-       * http://www.sgi.com/tech/stl/DefaultConstructible.html
+      /// http://www.sgi.com/tech/stl/DefaultConstructible.html
-       */
       template<typename Type>
         ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -275,10 +296,9 @@ namespace chaiscript
 
 
 
-      /**
+
-       * Add sequence concept to the given ContainerType
+      /// Add sequence concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Sequence.html
+      /// http://www.sgi.com/tech/stl/Sequence.html
-       */
       template<typename ContainerType>
         ModulePtr sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -296,10 +316,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
+
-       * Add back insertion sequence concept to the given ContainerType
+      /// Add back insertion sequence concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/BackInsertionSequence.html
+      /// http://www.sgi.com/tech/stl/BackInsertionSequence.html
-       */
       template<typename ContainerType>
         ModulePtr back_insertion_sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -315,25 +334,26 @@ namespace chaiscript
             push_back_name = "push_back";
           }
 
-          typedef void (ContainerType::*pushback)(const typename ContainerType::value_type &);
+          typedef void (ContainerType::*push_back)(const typename ContainerType::value_type &);
-          m->add(fun(static_cast<pushback>(&ContainerType::push_back)), push_back_name);
+          m->add(fun(static_cast<push_back>(&ContainerType::push_back)), push_back_name);
           m->add(fun(&ContainerType::pop_back), "pop_back");
           return m;
         }
 
 
-      /**
+
-       *Front insertion sequence
+      /// Front insertion sequence
-       *http://www.sgi.com/tech/stl/FrontInsertionSequence.html
+      /// http://www.sgi.com/tech/stl/FrontInsertionSequence.html
-       */
       template<typename ContainerType>
         ModulePtr front_insertion_sequence_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
         {
           typedef typename ContainerType::reference (ContainerType::*frontptr)();
+          typedef typename ContainerType::const_reference (ContainerType::*constfrontptr)() const;
           typedef void (ContainerType::*pushptr)(typename ContainerType::const_reference);
           typedef void (ContainerType::*popptr)();
 
           m->add(fun(static_cast<frontptr>(&ContainerType::front)), "front");
+          m->add(fun(static_cast<constfrontptr>(&ContainerType::front)), "front");
 
           std::string push_front_name;
           if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
@@ -348,10 +368,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
+
-       * bootstrap a given PairType
+      /// bootstrap a given PairType
-       * http://www.sgi.com/tech/stl/pair.html
+      /// http://www.sgi.com/tech/stl/pair.html
-       */
       template<typename PairType>
         ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -371,10 +390,10 @@ namespace chaiscript
         }
 
 
-      /**
+
-       * Add pair associative container concept to the given ContainerType
+      /// Add pair associative container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/PairAssociativeContainer.html
+      /// http://www.sgi.com/tech/stl/PairAssociativeContainer.html
-       */
+
       template<typename ContainerType>
         ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -383,22 +402,35 @@ namespace chaiscript
           return m;
         }
 
-      /**
+
-       * Add unique associative container concept to the given ContainerType
+      /// Add unique associative container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
+      /// http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
-       */
       template<typename ContainerType>
         ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(boost::function<int (const ContainerType *, const typename ContainerType::key_type &)>(boost::mem_fn(&ContainerType::count))), "count");
+          m->add(fun(detail::count<ContainerType>), "count");
 
+          typedef size_t (ContainerType::*erase_ptr)(const typename ContainerType::key_type &);
+
+          m->add(fun(static_cast<erase_ptr>(&ContainerType::erase)), "erase");
+
+          m->add(fun(&detail::insert<ContainerType>), "insert");
+
+          std::string insert_name;
+          if (typeid(typename ContainerType::mapped_type) == typeid(Boxed_Value))
+          {
+            insert_name = "insert_ref";
+          } else {
+            insert_name = "insert";
+          }
+
+          m->add(fun(&detail::insert_ref<ContainerType>), insert_name);
           return m;
         }
 
-      /**
+
-       * Add a MapType container
+      /// Add a MapType container
-       * http://www.sgi.com/tech/stl/Map.html
+      /// http://www.sgi.com/tech/stl/Map.html
-       */
       template<typename MapType>
         ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -417,10 +449,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
+
-       * hopefully working List type
+      /// hopefully working List type
-       * http://www.sgi.com/tech/stl/List.html
+      /// http://www.sgi.com/tech/stl/List.html
-       */
       template<typename ListType>
         ModulePtr list_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -437,17 +468,19 @@ namespace chaiscript
           return m;
         }
 
-      /**
+
-       * Create a vector type with associated concepts
+      /// Create a vector type with associated concepts
-       * http://www.sgi.com/tech/stl/Vector.html
+      /// http://www.sgi.com/tech/stl/Vector.html
-       */
       template<typename VectorType>
         ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
           m->add(user_type<VectorType>(), type);
 
           typedef typename VectorType::reference (VectorType::*frontptr)();
+          typedef typename VectorType::const_reference (VectorType::*constfrontptr)() const;
+
           m->add(fun(static_cast<frontptr>(&VectorType::front)), "front");
+          m->add(fun(static_cast<constfrontptr>(&VectorType::front)), "front");
 
 
           back_insertion_sequence_type<VectorType>(type, m);
@@ -464,8 +497,8 @@ namespace chaiscript
                        if ( rhs.size() != this.size() ) {    \
                          return false;  \
                        } else {  \
-                         var r1 = range(this); \
+                         auto r1 = range(this); \
-                         var r2 = range(rhs);  \
+                         auto r2 = range(rhs);  \
                          while (!r1.empty()) \
                          {  \
                            if (!eq(r1.front(), r2.front())) \
@@ -483,10 +516,8 @@ namespace chaiscript
           return m;
         }
 
-      /**
+      /// Add a String container
-       * Add a String container
+      /// http://www.sgi.com/tech/stl/basic_string.html
-       * http://www.sgi.com/tech/stl/basic_string.html
-       */
       template<typename String>
         ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -497,7 +528,7 @@ namespace chaiscript
           random_access_container_type<String>(type, m);
           sequence_type<String>(type, m);
           default_constructible_type<String>(type, m);
-          container_type<String>(type, m);
+          // container_type<String>(type, m);
           assignable_type<String>(type, m);
           input_range_type<String>(type, m);
 
@@ -511,20 +542,23 @@ namespace chaiscript
           }
           m->add(fun(&String::push_back), push_back_name);
 
-          typedef typename String::size_type (String::*find_func_ptr)(const String &, typename String::size_type) const;
+          typedef std::function<size_t (const String *, const String &, size_t)> find_func;
 
-          typedef boost::function<int (const String *, const String &, int)> find_func;
 
-          m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find)))), "find");
+          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(boost::mem_fn(static_cast<find_func_ptr>(&String::rfind)))), "rfind");
+          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(boost::mem_fn(static_cast<find_func_ptr>(&String::find_first_of)))), "find_first_of");
+          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(boost::mem_fn(static_cast<find_func_ptr>(&String::find_last_of)))), "find_last_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(boost::mem_fn(static_cast<find_func_ptr>(&String::find_first_not_of)))), "find_first_not_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(boost::mem_fn(static_cast<find_func_ptr>(&String::find_last_not_of)))), "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(&String::c_str), "c_str");
+          m->add(fun( std::function<void (String *)>( [](String *s) { return s->clear(); } ) ), "clear");
-          m->add(fun(&String::data), "data");
+          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;
         }
@@ -534,3 +568,5 @@ namespace chaiscript
 
 
 #endif
+
+

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -1,26 +1,30 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __boxed_cast_hpp__
+#ifndef CHAISCRIPT_BOXED_CAST_HPP_
-#define __boxed_cast_hpp__
+#define CHAISCRIPT_BOXED_CAST_HPP_
 
-#include "type_info.hpp"
+#include <type_traits>
-#include "boxed_value.hpp"
-#include "boxed_cast_helper.hpp"
-#include "dynamic_cast_conversion.hpp"
 
+#include "../chaiscript_defines.hpp"
 #include "../chaiscript_threading.hpp"
-#include <boost/shared_ptr.hpp>
+#include "bad_boxed_cast.hpp"
-#include <boost/any.hpp>
+#include "boxed_cast_helper.hpp"
-#include <boost/function.hpp>
+#include "boxed_value.hpp"
-#include <boost/ref.hpp>
+#include "dynamic_cast_conversion.hpp"
-#include <boost/cstdint.hpp>
+#include "type_info.hpp"
-#include <boost/type_traits/add_const.hpp>
+
-#include <boost/type_traits/is_polymorphic.hpp>
+namespace chaiscript {
-#include <boost/integer_traits.hpp>
+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,
+  /// boxed_cast will attempt to make conversions between value, &, *, std::shared_ptr, std::reference_wrapper,
-  /// and boost::function (const and non-const) where possible. boxed_cast is used internally during function
+  /// 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,
+  /// \li Boxed_Value constructed from std::shared_ptr or value types can be extracted as reference,
-  ///     pointer, value, or boost::shared_ptr types
+  ///     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)
+  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);
+      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)
+      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(detail::boxed_dynamic_cast<Type>(bv));
+          return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_cast<Type>(bv), t_conversions);
-        } catch (const boost::bad_any_cast &) {
+        } catch (...) {
-          throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+          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

@@ -1,22 +1,24 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 #define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 
-#include "type_info.hpp"
+#include <functional>
-#include "boxed_value.hpp"
+#include <memory>
+#include <type_traits>
+
+#include "boxed_value.hpp"
+#include "type_info.hpp"
 
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/ref.hpp>
-#include <boost/type_traits/add_const.hpp>
 
 namespace chaiscript 
 {
+  class Dynamic_Cast_Conversions;
+
   namespace detail
   {
     // Cast_Helper_Inner helper classes
@@ -27,33 +29,33 @@ 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)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
             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>
+    template<typename Result>
-	  struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
+      struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
-	  {
+      {
-	  };
+      };
 
     /**
      * Cast_Helper_Inner for casting to a const & type
@@ -71,22 +73,22 @@ namespace chaiscript
       {
         typedef const Result * Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
             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();
             }
           }
         }
@@ -100,13 +102,13 @@ namespace chaiscript
       {
         typedef Result * Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        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())).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();
           }
         }
       };
@@ -117,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)
+        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)
+        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)
+        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> >
       {
       };
 
@@ -200,12 +203,27 @@ namespace chaiscript
       {
         typedef const Boxed_Value & Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
-          return ob;    
+          return ob;
         }
       };
 
+    /**
+     * Cast_Helper_Inner for casting to a Boxed_Value & type
+     */
+    template<>
+      struct Cast_Helper_Inner<Boxed_Value &>
+      {
+        typedef Boxed_Value& Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          return const_cast<Boxed_Value &>(ob);
+        }
+      };
+
+
     /**
      * Cast_Helper_Inner for casting to a const Boxed_Value & type
      */
@@ -218,38 +236,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 &>
       {
       };
 
@@ -260,10 +278,10 @@ namespace chaiscript
       struct Cast_Helper
       {
         typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
-        
+
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
-          return Cast_Helper_Inner<T>::cast(ob);
+          return Cast_Helper_Inner<T>::cast(ob, t_conversions);
         }
       };
   }

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -0,0 +1,869 @@
+// 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_BOXED_NUMERIC_HPP_
+#define CHAISCRIPT_BOXED_NUMERIC_HPP_
+
+#include <cstdint>
+#include <sstream>
+#include <string>
+
+#include "../language/chaiscript_algebraic.hpp"
+#include "any.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+}  // namespace chaiscript
+
+namespace chaiscript 
+{
+
+// Due to the nature of generating every possible arithmetic operation, there
+// are going to be warnings generated on every platform regarding size and sign,
+// this is OK, so we're disabling size/and sign type warnings
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4244 4018 4389 4146 4365)
+#endif
+
+  /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values
+  class Boxed_Number
+  {
+    private:
+      struct boolean
+      {
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &)
+        {
+          switch (t_oper)
+          {
+            case Operators::equals:
+              return const_var(t == u);
+            case Operators::less_than:
+              return const_var(t < u);
+            case Operators::greater_than:
+              return const_var(t > u);
+            case Operators::less_than_equal:
+              return const_var(t <= u);
+            case Operators::greater_than_equal:
+              return const_var(t >= u);
+            case Operators::not_equal:
+              return const_var(t != u);
+            default:
+              throw chaiscript::detail::exception::bad_any_cast();        
+          }
+        }
+      };
+
+      struct binary 
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
+        {
+          switch (t_oper)
+          {
+            case Operators::assign:
+              t = u;
+              break;
+            case Operators::pre_increment:
+              ++t;
+              break;
+            case Operators::pre_decrement:
+              --t;
+              break;
+            case Operators::assign_product:
+              t *= u;
+              break;
+            case Operators::assign_sum:
+              t += u;
+              break;
+            case Operators::assign_quotient:
+              t /= u;
+              break;
+            case Operators::assign_difference:
+              t -= u;
+              break;
+            default:
+              throw chaiscript::detail::exception::bad_any_cast();        
+          }
+
+          return t_lhs;
+        }
+      };
+
+      struct binary_int
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
+        {
+          switch (t_oper)
+          {
+            case Operators::assign_bitwise_and:
+              t &= u;
+              break;
+            case Operators::assign_bitwise_or:
+              t |= u;
+              break;
+            case Operators::assign_shift_left:
+              t <<= u;
+              break;
+            case Operators::assign_shift_right:
+              t >>= u;
+              break;
+            case Operators::assign_remainder:
+              t %= u;
+              break;
+            case Operators::assign_bitwise_xor:
+              t ^= u;
+              break;
+            default:
+              throw chaiscript::detail::exception::bad_any_cast();        
+          }
+          return t_lhs;
+        }
+      };
+
+      struct const_binary_int
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &) 
+        {
+          switch (t_oper)
+          {
+            case Operators::shift_left:
+              return const_var(t << u);
+            case Operators::shift_right:
+              return const_var(t >> u);
+            case Operators::remainder:
+              return const_var(t % u);
+            case Operators::bitwise_and:
+              return const_var(t & u);
+            case Operators::bitwise_or:
+              return const_var(t | u);
+            case Operators::bitwise_xor:
+              return const_var(t ^ u);
+            case Operators::bitwise_complement:
+              return const_var(~t);
+            default:
+              throw chaiscript::detail::exception::bad_any_cast();        
+          }
+        }
+      };
+
+      struct const_binary
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &) 
+        {
+          switch (t_oper)
+          {
+            case Operators::sum:
+              return const_var(t + u);
+            case Operators::quotient:
+              return const_var(t / u);
+            case Operators::product:
+              return const_var(t * u);
+            case Operators::difference:
+              return const_var(t - u);
+            case Operators::unary_minus:
+              return const_var(-t);
+            case Operators::unary_plus:
+              return const_var(+t);
+            default:
+              throw chaiscript::detail::exception::bad_any_cast();        
+          }
+        }
+      };
+
+      template<typename LHS, typename RHS, bool Float>
+      struct Go
+      {
+        static Boxed_Value go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
+          {
+            return boolean::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
+            return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag && !t_lhs.is_const()) {
+            return binary_int::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
+            return const_binary_int::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::const_flag) {
+            return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else {
+            throw chaiscript::detail::exception::bad_any_cast();
+          }
+        }
+      };
+
+      template<typename LHS, typename RHS>
+      struct Go<LHS, RHS, true>
+      {
+        static Boxed_Value go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
+          {
+            return boolean::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
+            return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag) {
+            throw chaiscript::detail::exception::bad_any_cast();
+          } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
+            throw chaiscript::detail::exception::bad_any_cast();
+          } else if (t_oper > Operators::const_flag) {
+            return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else {
+            throw chaiscript::detail::exception::bad_any_cast();
+          }
+        }
+      };
+
+      template<typename LHS, bool Float>
+        static Boxed_Value oper_rhs(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          const Type_Info &inp_ = t_rhs.get_type_info();
+
+          if (inp_ == typeid(int)) {
+            return Go<LHS, int, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(double)) {
+            return Go<LHS, double, true>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(float)) {
+            return Go<LHS, float, true>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long double)) {
+            return Go<LHS, long double, true>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(char)) {
+            return Go<LHS, char, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned int)) {
+            return Go<LHS, unsigned int, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long)) {
+            return Go<LHS, long, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned long)) {
+            return Go<LHS, unsigned long, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int8_t)) {
+            return Go<LHS, std::int8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int16_t)) {
+            return Go<LHS, std::int16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int32_t)) {
+            return Go<LHS, std::int32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int64_t)) {
+            return Go<LHS, std::int64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint8_t)) {
+            return Go<LHS, std::uint8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint16_t)) {
+            return Go<LHS, std::uint16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint32_t)) {
+            return Go<LHS, std::uint32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint64_t)) {
+            return Go<LHS, std::uint64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else {
+            throw chaiscript::detail::exception::bad_any_cast();
+          }
+        } 
+
+        static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          const Type_Info &inp_ = t_lhs.get_type_info();
+
+          if (inp_ == typeid(int)) {
+            return oper_rhs<int, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(double)) {
+            return oper_rhs<double, true>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long double)) {
+            return oper_rhs<long double, true>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(float)) {
+            return oper_rhs<float, true>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(char)) {
+            return oper_rhs<char, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned int)) {
+            return oper_rhs<unsigned int, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long)) {
+            return oper_rhs<long, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned long)) {
+            return oper_rhs<unsigned long, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int8_t)) {
+            return oper_rhs<std::int8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int16_t)) {
+            return oper_rhs<std::int16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int32_t)) {
+            return oper_rhs<std::int32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int64_t)) {
+            return oper_rhs<std::int64_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint8_t)) {
+            return oper_rhs<std::uint8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint16_t)) {
+            return oper_rhs<std::uint16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint32_t)) {
+            return oper_rhs<std::uint32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint64_t)) {
+            return oper_rhs<std::uint64_t, false>(t_oper, t_lhs, t_rhs);
+          } else  {
+            throw chaiscript::detail::exception::bad_any_cast();
+          }
+        }
+
+        template<typename Target, typename Source>
+          Target get_as_aux() const
+        {
+          return static_cast<Target>(*static_cast<const Source *>(bv.get_const_ptr()));
+        }
+
+        template<typename Source>
+         static std::string to_string_aux(const Boxed_Value &v)
+        {
+          std::ostringstream oss;
+          oss << *static_cast<const Source *>(v.get_const_ptr());
+          return oss.str();
+        }
+
+      
+    public:
+      Boxed_Number()
+        : bv(Boxed_Value(0))
+      {
+      }
+
+      Boxed_Number(const Boxed_Value &v)
+        : bv(v)
+      {
+        validate_boxed_number(v);
+      }
+
+      template<typename T> explicit Boxed_Number(T t)
+        : bv(Boxed_Value(t))
+      {
+        validate_boxed_number(bv);
+      }
+
+      Boxed_Number get_as(const Type_Info &inp_) const
+      {
+        if (inp_.bare_equal_type_info(typeid(int))) {
+          return Boxed_Number(get_as<int>());
+        } else if (inp_.bare_equal_type_info(typeid(double))) {
+          return Boxed_Number(get_as<double>());
+        } else if (inp_.bare_equal_type_info(typeid(float))) {
+          return Boxed_Number(get_as<float>());
+        } else if (inp_.bare_equal_type_info(typeid(long double))) {
+          return Boxed_Number(get_as<long double>());
+        } else if (inp_.bare_equal_type_info(typeid(char))) {
+          return Boxed_Number(get_as<char>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned int))) {
+          return Boxed_Number(get_as<unsigned int>());
+        } else if (inp_.bare_equal_type_info(typeid(long))) {
+          return Boxed_Number(get_as<long>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned long))) {
+          return Boxed_Number(get_as<unsigned long>());
+        } else if (inp_.bare_equal_type_info(typeid(int8_t))) {
+          return Boxed_Number(get_as<int8_t>());
+        } else if (inp_.bare_equal_type_info(typeid(int16_t))) {
+          return Boxed_Number(get_as<int16_t>());
+        } else if (inp_.bare_equal_type_info(typeid(int32_t))) {
+          return Boxed_Number(get_as<int32_t>());
+        } else if (inp_.bare_equal_type_info(typeid(int64_t))) {
+          return Boxed_Number(get_as<int64_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint8_t))) {
+          return Boxed_Number(get_as<uint8_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint16_t))) {
+          return Boxed_Number(get_as<uint16_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint32_t))) {
+          return Boxed_Number(get_as<uint32_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint64_t))) {
+          return Boxed_Number(get_as<uint64_t>());
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+
+      }
+
+      template<typename Target> Target get_as() const
+      {
+        const Type_Info &inp_ = bv.get_type_info();
+
+        if (inp_ == typeid(int)) {
+          return get_as_aux<Target, int>();
+        } else if (inp_ == typeid(double)) {
+          return get_as_aux<Target, double>();
+        } else if (inp_ == typeid(float)) {
+          return get_as_aux<Target, float>();
+        } else if (inp_ == typeid(long double)) {
+          return get_as_aux<Target, long double>();
+        } else if (inp_ == typeid(char)) {
+          return get_as_aux<Target, char>();
+        } else if (inp_ == typeid(unsigned int)) {
+          return get_as_aux<Target, unsigned int>();
+        } else if (inp_ == typeid(long)) {
+          return get_as_aux<Target, long>();
+        } else if (inp_ == typeid(unsigned long)) {
+          return get_as_aux<Target, unsigned long>();
+        } else if (inp_ == typeid(std::int8_t)) {
+          return get_as_aux<Target, std::int8_t>();
+        } else if (inp_ == typeid(std::int16_t)) {
+          return get_as_aux<Target, std::int16_t>();
+        } else if (inp_ == typeid(std::int32_t)) {
+          return get_as_aux<Target, std::int32_t>();
+        } else if (inp_ == typeid(std::int64_t)) {
+          return get_as_aux<Target, std::int64_t>();
+        } else if (inp_ == typeid(std::uint8_t)) {
+          return get_as_aux<Target, std::uint8_t>();
+        } else if (inp_ == typeid(std::uint16_t)) {
+          return get_as_aux<Target, std::uint16_t>();
+        } else if (inp_ == typeid(std::uint32_t)) {
+          return get_as_aux<Target, std::uint32_t>();
+        } else if (inp_ == typeid(std::uint64_t)) {
+          return get_as_aux<Target, std::uint64_t>();
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      std::string to_string() const
+      {
+        const Type_Info &inp_ = bv.get_type_info();
+
+        if (inp_ == typeid(int)) {
+          return to_string_aux<int>(bv);
+        } else if (inp_ == typeid(double)) {
+          return to_string_aux<double>(bv);
+        } else if (inp_ == typeid(float)) {
+          return to_string_aux<float>(bv);
+        } else if (inp_ == typeid(long double)) {
+          return to_string_aux<long double>(bv);
+        } else if (inp_ == typeid(char)) {
+          return to_string_aux<int>(Boxed_Value(get_as_aux<int, char>()));
+        } else if (inp_ == typeid(unsigned int)) {
+          return to_string_aux<unsigned int>(bv);
+        } else if (inp_ == typeid(long)) {
+          return to_string_aux<long>(bv);
+        } else if (inp_ == typeid(unsigned long)) {
+          return to_string_aux<unsigned long>(bv);
+        } else if (inp_ == typeid(std::int8_t)) {
+          return to_string_aux<int>(Boxed_Value(get_as_aux<int, std::int8_t>()));
+        } else if (inp_ == typeid(std::int16_t)) {
+          return to_string_aux<std::int16_t>(bv);
+        } else if (inp_ == typeid(std::int32_t)) {
+          return to_string_aux<std::int32_t>(bv);
+        } else if (inp_ == typeid(std::int64_t)) {
+          return to_string_aux<std::int64_t>(bv);
+        } else if (inp_ == typeid(std::uint8_t)) {
+          return to_string_aux<unsigned int>(Boxed_Value(get_as_aux<unsigned int, std::uint8_t>()));
+        } else if (inp_ == typeid(std::uint16_t)) {
+          return to_string_aux<std::uint16_t>(bv);
+        } else if (inp_ == typeid(std::uint32_t)) {
+          return to_string_aux<std::uint32_t>(bv);
+        } else if (inp_ == typeid(std::uint64_t)) {
+          return to_string_aux<std::uint64_t>(bv);
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      bool operator==(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::equals, this->bv, t_rhs.bv));
+      }
+
+      bool operator<(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::less_than, this->bv, t_rhs.bv));
+      }
+
+      bool operator>(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than, this->bv, t_rhs.bv));
+      }
+
+      bool operator>=(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than_equal, this->bv, t_rhs.bv));
+      }
+
+      bool operator<=(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::less_than_equal, this->bv, t_rhs.bv));
+      }
+
+      bool operator!=(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::not_equal, this->bv, t_rhs.bv));
+      }
+
+      Boxed_Number operator--()
+      {
+        return oper(Operators::pre_decrement, this->bv, var(0));
+      }
+
+      Boxed_Number operator++() 
+      {
+        return oper(Operators::pre_increment, this->bv, var(0));
+      }
+
+      Boxed_Number operator+(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::sum, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator+() const
+      {
+        return oper(Operators::unary_plus, this->bv, Boxed_Value(0));
+      }
+
+      Boxed_Number operator-() const
+      {
+        return oper(Operators::unary_minus, this->bv, Boxed_Value(0));
+      }
+
+      Boxed_Number operator-(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::difference, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator&=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_and, this->bv, t_rhs.bv);
+      }
+
+      static void validate_boxed_number(const Boxed_Value &v)
+      {
+        const Type_Info &inp_ = v.get_type_info();
+        if (inp_ == typeid(bool))
+        {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+
+        if (!inp_.is_arithmetic())
+        {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      Boxed_Number operator=(const Boxed_Value &v)
+      {
+        validate_boxed_number(v);
+        bv = v;
+        return *this;
+      }
+
+      Boxed_Number operator=(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::assign, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator|=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_or, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator^=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_xor, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator%=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_remainder, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator<<=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_left, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator>>=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_right, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator&(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::bitwise_and, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator~() const
+      {
+        return oper(Operators::bitwise_complement, this->bv, Boxed_Value(0));
+      }
+
+      Boxed_Number operator^(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::bitwise_xor, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator|(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::bitwise_or, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator*=(const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::assign_product, this->bv, t_rhs.bv);
+      }
+      Boxed_Number operator/=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_quotient, this->bv, t_rhs.bv);
+      }
+      Boxed_Number operator+=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_sum, this->bv, t_rhs.bv);
+      }
+      Boxed_Number operator-=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_difference, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator/(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::quotient, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator<<(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::shift_left, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator*(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::product, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator%(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::remainder, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator>>(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::shift_right, this->bv, t_rhs.bv);
+      }
+
+
+
+      static bool equals(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::equals, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool less_than(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::less_than, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool greater_than(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool greater_than_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than_equal, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool less_than_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::less_than_equal, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool not_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return boxed_cast<bool>(oper(Operators::not_equal, t_lhs.bv, t_rhs.bv));
+      }
+
+      static Boxed_Number pre_decrement(Boxed_Number t_lhs)
+      {
+        return oper(Operators::pre_decrement, t_lhs.bv, var(0));
+      }
+
+      static Boxed_Number pre_increment(Boxed_Number t_lhs) 
+      {
+        return oper(Operators::pre_increment, t_lhs.bv, var(0));
+      }
+
+      static const Boxed_Number sum(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::sum, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number unary_plus(const Boxed_Number &t_lhs) 
+      {
+        return oper(Operators::unary_plus, t_lhs.bv, Boxed_Value(0));
+      }
+
+      static const Boxed_Number unary_minus(const Boxed_Number &t_lhs)
+      {
+        return oper(Operators::unary_minus, t_lhs.bv, Boxed_Value(0));
+      }
+
+      static const Boxed_Number difference(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::difference, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_bitwise_and(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_and, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign(Boxed_Number t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::assign, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_bitwise_or(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_or, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_bitwise_xor(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_xor, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_remainder(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_remainder, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_shift_left(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_left, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_shift_right(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_right, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number bitwise_and(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::bitwise_and, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number bitwise_complement(const Boxed_Number &t_lhs)
+      {
+        return oper(Operators::bitwise_complement, t_lhs.bv, Boxed_Value(0));
+      }
+
+      static const Boxed_Number bitwise_xor(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::bitwise_xor, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number bitwise_or(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::bitwise_or, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_product(Boxed_Number t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::assign_product, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_quotient(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_quotient, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_sum(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_sum, t_lhs.bv, t_rhs.bv);
+      }
+      static Boxed_Number assign_difference(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_difference, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number quotient(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::quotient, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number shift_left(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::shift_left, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number product(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::product, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number remainder(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::remainder, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number shift_right(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::shift_right, t_lhs.bv, t_rhs.bv);
+      }
+
+
+
+      static Boxed_Value do_oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+      {
+        return oper(t_oper, t_lhs, t_rhs);
+      }
+
+      static Boxed_Value do_oper(Operators::Opers t_oper, const Boxed_Value &t_lhs)
+      {
+        return oper(t_oper, t_lhs, const_var(0));
+      }
+
+
+
+      Boxed_Value bv;
+  };
+
+  namespace detail
+  {
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_Number
+     */
+    template<>
+      struct Cast_Helper<Boxed_Number>
+      {
+        typedef Boxed_Number Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          return Boxed_Number(ob);
+        }
+      };
+
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_Number
+     */
+    template<>
+      struct Cast_Helper<const Boxed_Number &> : Cast_Helper<Boxed_Number>
+      {
+      };
+      
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_Number
+     */
+    template<>
+      struct Cast_Helper<const Boxed_Number> : Cast_Helper<Boxed_Number>
+      {
+      };  
+  }
+
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif
+
+}
+
+
+
+#endif
+

include/chaiscript/dispatchkit/boxed_pod_value.hpp

@@ -1,260 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#ifndef CHAISCRIPT_BOXED_POD_VALUE_HPP_
-#define CHAISCRIPT_BOXED_POD_VALUE_HPP_
-
-#include "type_info.hpp"
-#include "boxed_value.hpp"
-#include "boxed_cast_helper.hpp"
-#include <boost/any.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/integer_traits.hpp>
-
-namespace chaiscript 
-{
- 
-  /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values
-  class Boxed_POD_Value
-  {
-    public:
-      Boxed_POD_Value(const Boxed_Value &v)
-        : d(0), i(0), isfloat(false)
-      {
-        if (v.get_type_info().is_undef())
-        {
-          throw boost::bad_any_cast();
-        }
-
-        const Type_Info &inp_ = v.get_type_info();
-
-        if (inp_ == typeid(double))
-        {
-          d = boxed_cast<double>(v);
-          isfloat = true;
-        } else if (inp_ == typeid(float)) {
-          d = boxed_cast<float>(v);
-          isfloat = true;
-        } else if (inp_ == typeid(bool)) {
-          i = boxed_cast<bool>(v);
-        } else if (inp_ == typeid(char)) {
-          i = boxed_cast<char>(v);
-        } else if (inp_ == typeid(int)) {
-          i = boxed_cast<int>(v);
-        } else if (inp_ == typeid(unsigned int)) {
-          i = boxed_cast<unsigned int>(v);
-        } else if (inp_ == typeid(long)) {
-          i = boxed_cast<long>(v);
-        } else if (inp_ == typeid(unsigned long)) {
-          i = boxed_cast<unsigned long>(v);
-        } else if (inp_ == typeid(boost::int8_t)) {
-          i = boxed_cast<boost::int8_t>(v);
-        } else if (inp_ == typeid(boost::int16_t)) {
-          i = boxed_cast<boost::int16_t>(v);
-        } else if (inp_ == typeid(boost::int32_t)) {
-          i = boxed_cast<boost::int32_t>(v);
-        } else if (inp_ == typeid(boost::int64_t)) {
-          i = boxed_cast<boost::int64_t>(v);
-        } else if (inp_ == typeid(boost::uint8_t)) {
-          i = boxed_cast<boost::uint8_t>(v);
-        } else if (inp_ == typeid(boost::uint16_t)) {
-          i = boxed_cast<boost::uint16_t>(v);
-        } else if (inp_ == typeid(boost::uint32_t)) {
-          i = boxed_cast<boost::uint32_t>(v);
-        } else {
-          throw boost::bad_any_cast();
-        }
-      }
-
-      bool operator==(const Boxed_POD_Value &r) const
-      {
-        return ((isfloat)?d:i) == ((r.isfloat)?r.d:r.i);
-      }
-
-      bool operator<(const Boxed_POD_Value &r) const
-      {
-        return ((isfloat)?d:i) < ((r.isfloat)?r.d:r.i);
-      }
-
-      bool operator>(const Boxed_POD_Value &r) const
-      {
-        return ((isfloat)?d:i) > ((r.isfloat)?r.d:r.i);
-      }
-
-      bool operator>=(const Boxed_POD_Value &r) const
-      {
-        return ((isfloat)?d:i) >= ((r.isfloat)?r.d:r.i);
-      }
-
-      bool operator<=(const Boxed_POD_Value &r) const
-      {
-        return ((isfloat)?d:i) <= ((r.isfloat)?r.d:r.i);
-      }
-
-      bool operator!=(const Boxed_POD_Value &r) const
-      {
-        return ((isfloat)?d:i) != ((r.isfloat)?r.d:r.i);
-      }
-
-      Boxed_Value operator+(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return smart_size(i + r.i);
-        }
-
-        return Boxed_Value(((isfloat)?d:i) + ((r.isfloat)?r.d:r.i));
-      }
-
-      Boxed_Value operator-(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return smart_size(i - r.i);
-        }
-
-        return Boxed_Value(((isfloat)?d:i) - ((r.isfloat)?r.d:r.i));
-      }
-
-      Boxed_Value operator&(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return Boxed_Value(i & r.i);
-        }
-
-        throw exception::bad_boxed_cast("& only valid for integer types");
-      }
-
-      Boxed_Value operator^(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return Boxed_Value(i ^ r.i);
-        }
-
-        throw exception::bad_boxed_cast("^ only valid for integer types");
-      }
-
-      Boxed_Value operator|(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return Boxed_Value(i | r.i);
-        }
-
-        throw exception::bad_boxed_cast("| only valid for integer types");
-      }
-
-      Boxed_Value operator/(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return smart_size(i / r.i);
-        }
-
-        return Boxed_Value(((isfloat)?d:i) / ((r.isfloat)?r.d:r.i));
-      }
-
-      Boxed_Value operator<<(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return smart_size(i << r.i);
-        }
-
-        throw exception::bad_boxed_cast("<< only valid for integer types");
-      }
-
-
-      Boxed_Value operator*(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return smart_size(i * r.i);
-        }
-
-        return Boxed_Value(((isfloat)?d:i) * ((r.isfloat)?r.d:r.i));
-      }
-
-
-      Boxed_Value operator%(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return smart_size(i % r.i);
-        }
-
-        throw exception::bad_boxed_cast("% only valid for integer types");
-      }
-
-      Boxed_Value operator>>(const Boxed_POD_Value &r) const
-      {
-        if (!isfloat && !r.isfloat)
-        {
-          return smart_size(i >> r.i);
-        }
-
-        throw exception::bad_boxed_cast(">> only valid for integer types");
-      }
-
-      Boxed_Value smart_size(boost::int64_t t_i) const
-      {
-        if (t_i < boost::integer_traits<int>::const_min
-            || t_i > boost::integer_traits<int>::const_max)
-        {
-          return Boxed_Value(t_i);
-        } else {
-          return Boxed_Value(static_cast<int>(t_i));
-        }
-      }
-
-
-      double d;
-      boost::int64_t i;
-
-      bool isfloat;
-  };
-
-  namespace detail
-  {
-    /**
-     * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
-     */
-    template<>
-      struct Cast_Helper<Boxed_POD_Value>
-      {
-        typedef Boxed_POD_Value Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          return Boxed_POD_Value(ob);
-        }
-      };
-
-    /**
-     * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
-     */
-    template<>
-      struct Cast_Helper<const Boxed_POD_Value &> : Cast_Helper<Boxed_POD_Value>
-      {
-      };
-      
-    /**
-     * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
-     */
-    template<>
-      struct Cast_Helper<const Boxed_POD_Value> : Cast_Helper<Boxed_POD_Value>
-      {
-      };  
-  }
-  
-}
-
-
-
-#endif
-

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,59 +1,45 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #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 "any.hpp"
-#include <map>
+#include "type_info.hpp"
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-#include <boost/bind.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/integer_traits.hpp>
 
 namespace chaiscript 
 {
+
   /// \brief A wrapper for holding any valid C++ type. All types in ChaiScript are Boxed_Value objects
   /// \sa chaiscript::boxed_cast
   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
       {
-        template<typename T>
-          static bool is_null(boost::any *a)
-          {
-            boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a);
-            return ptr->get() == 0;
-          }
-
         Data(const Type_Info &ti,
-            const boost::any &to,
+            const chaiscript::detail::Any &to,
             bool tr,
-            const boost::function<bool (boost::any*)> &t_is_null = boost::function<bool (boost::any*)>())
+            const void *t_void_ptr)
-          : m_type_info(ti), m_obj(to), 
+          : 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), m_is_null(t_is_null)
+            m_is_ref(tr)
         {
         }
 
@@ -62,111 +48,118 @@ namespace chaiscript
           m_type_info = rhs.m_type_info;
           m_obj = rhs.m_obj;
           m_is_ref = rhs.m_is_ref;
-          m_is_null = rhs.m_is_null;
+          m_data_ptr = rhs.m_data_ptr;
+          m_const_data_ptr = rhs.m_const_data_ptr;
+
+          if (rhs.m_attrs)
+          {
+            m_attrs = std::unique_ptr<std::map<std::string, Boxed_Value>>(new std::map<std::string, Boxed_Value>(*rhs.m_attrs));
+          }
 
           return *this;
         }
 
+        Data(const Data &) = delete;
+
         ~Data()
         {
         }
 
         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;
-        boost::function<bool (boost::any*)> m_is_null;
+        std::unique_ptr<std::map<std::string, Boxed_Value>> m_attrs;
-        std::vector<boost::shared_ptr<Data> > m_dependencies;
       };
 
       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::shared_ptr<Data> (new Data(
+          return std::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
-                boost::any(), 
+                chaiscript::detail::Any(), 
-                false)
+                false,
-              );
+                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::shared_ptr<Data>(new Data(
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(obj), 
+                  chaiscript::detail::Any(obj), 
                   false,
-                  boost::function<bool (boost::any *)>(&Data::is_null<T>))
+                  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::shared_ptr<Data>(new Data(
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
-                  boost::any(obj), 
+                  chaiscript::detail::Any(obj),
-                  true)
+                  true,
+                  &obj.get()
                 );
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const T& t)
+          static std::shared_ptr<Data> get(const T& t)
           {
-            return boost::shared_ptr<Data>(new Data(
+            auto p = std::make_shared<T>(t);
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(boost::shared_ptr<T>(new T(t))), 
+                  chaiscript::detail::Any(p), 
                   false,
-                  boost::function<bool (boost::any *)>(&Data::is_null<T>))
+                  p.get()
                 );
           }
 
-        static boost::shared_ptr<Data> get()
+        static std::shared_ptr<Data> get()
         {
-          return boost::shared_ptr<Data> (new Data(
+          return std::make_shared<Data>(
                 Type_Info(),
-                boost::any(),
+                chaiscript::detail::Any(),
-                false)
+                false,
+                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())
       {
       }
 
@@ -179,19 +172,15 @@ namespace chaiscript
         std::swap(m_data, rhs.m_data);
       }
 
-      /**
+      /// Copy the values stored in rhs.m_data to m_data.
-       * copy the values stored in rhs.m_data to m_data
+      /// m_data pointers are not shared in this case
-       * 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);
@@ -204,9 +193,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();
@@ -224,15 +211,10 @@ namespace chaiscript
 
       bool is_null() const
       {
-        if (m_data->m_is_null)
+        return (m_data->m_data_ptr == nullptr && m_data->m_const_data_ptr == nullptr);
-        {
-          return m_data->m_is_null(&m_data->m_obj);
-        } else {
-          return false;
-        }
       }
 
-      const boost::any & get() const
+      const chaiscript::detail::Any & get() const
       {
         return m_data->m_obj;
       }
@@ -247,42 +229,60 @@ namespace chaiscript
         return !is_ref();
       }
 
-      void clear_dependencies()
+      void *get_ptr() const
       {
-        m_data->m_dependencies.clear();
+        return m_data->m_data_ptr;
       }
 
-      template<typename InItr>
+      const void *get_const_ptr() const
-        void add_dependencies(InItr begin, const InItr &end)
+      {
+        return m_data->m_const_data_ptr;
+      }
+
+      Boxed_Value get_attr(const std::string &t_name)
+      {
+        if (!m_data->m_attrs)
         {
-          while (begin != end)
+          m_data->m_attrs = std::unique_ptr<std::map<std::string, Boxed_Value>>(new std::map<std::string, Boxed_Value>());
-          {
-            if (begin->m_data != m_data)
-            {
-              m_data->m_dependencies.push_back(begin->m_data);
-            }
-            ++begin;
-          }
         }
 
+        return (*m_data->m_attrs)[t_name];
+      }
+
+      Boxed_Value &copy_attrs(const Boxed_Value &t_obj)
+      {
+        if (t_obj.m_data->m_attrs)
+        {
+          m_data->m_attrs = std::unique_ptr<std::map<std::string, Boxed_Value>>(new std::map<std::string, Boxed_Value>(*t_obj.m_data->m_attrs));
+        }
+        return *this;
+      }
+
+
+      /// \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)
     {
@@ -297,7 +297,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.
@@ -308,33 +308,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
@@ -355,7 +355,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)
     {
@@ -364,11 +365,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

@@ -1,30 +1,49 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DISPATCHKIT_HPP_
 #define CHAISCRIPT_DISPATCHKIT_HPP_
 
-#include <typeinfo>
+#include <algorithm>
-#include <string>
+#include <cassert>
-#include <map>
-#include <set>
-#include <boost/shared_ptr.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <stdexcept>
-#include <vector>
-#include <iostream>
 #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 "../chaiscript_defines.hpp"
-#include "type_info.hpp"
-#include "proxy_functions.hpp"
-#include "proxy_constructors.hpp"
-#include "dynamic_object.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
@@ -32,6 +51,93 @@
 
 namespace chaiscript
 {
+  namespace exception
+  {
+    /**
+     * Exception thrown in the case that an object name is invalid because it is a reserved word
+     */
+    class reserved_word_error : public std::runtime_error
+    {
+      public:
+        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() CHAISCRIPT_NOEXCEPT {}
+
+        std::string word() const
+        {
+          return m_word;
+        }
+
+      private:
+        std::string m_word;
+    };
+
+    /**
+     * Exception thrown in the case that an object name is invalid because it contains illegal characters
+     */
+    class illegal_name_error : public std::runtime_error
+    {
+      public:
+        illegal_name_error(const std::string &t_name) throw()
+          : std::runtime_error("Reserved name not allowed in object name: " + t_name), m_name(t_name)
+        {
+        }
+
+        virtual ~illegal_name_error() throw() {}
+
+        std::string name() const
+        {
+          return m_name;
+        }
+
+      private:
+        std::string m_name;
+    };
+
+
+    /**
+     * Exception thrown in the case that an object name is invalid because it already exists in current context
+     */
+    class name_conflict_error : public std::runtime_error
+    {
+      public:
+        name_conflict_error(const std::string &t_name) throw()
+          : std::runtime_error("Name already exists in current context " + t_name), m_name(t_name)
+        {
+        }
+
+        virtual ~name_conflict_error() throw() {}
+
+        std::string name() const
+        {
+          return m_name;
+        }
+
+      private:
+        std::string m_name;
+
+    };
+
+
+    /**
+     * Exception thrown in the case that a non-const object was added as a shared object
+     */
+    class global_non_const : public std::runtime_error
+    {
+      public:
+        global_non_const() CHAISCRIPT_NOEXCEPT
+          : std::runtime_error("a global object must be const")
+        {
+        }
+
+        virtual ~global_non_const() CHAISCRIPT_NOEXCEPT {}
+    };
+  }
+
+
   /// \brief Holds a collection of ChaiScript settings which can be applied to the ChaiScript runtime.
   ///        Used to implement loadable module support.
   class Module
@@ -55,6 +161,17 @@ namespace chaiscript
         return *this;
       }
 
+      Module &add_global_const(const Boxed_Value &t_bv, const std::string &t_name)
+      {
+        if (!t_bv.is_const())
+        {
+          throw chaiscript::exception::global_non_const();
+        }
+
+        m_globals.push_back(std::make_pair(t_bv, t_name));
+        return *this;
+      }
+
 
       //Add a bit of chaiscript to eval during module implementation
       Module &eval(const std::string &str)
@@ -63,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;
@@ -76,26 +193,47 @@ namespace chaiscript
           apply(m_funcs.begin(), m_funcs.end(), t_engine);
           apply_eval(m_evals.begin(), m_evals.end(), t_eval);
           apply_single(m_conversions.begin(), m_conversions.end(), t_engine);
+          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;
+      std::vector<std::pair<Boxed_Value, std::string> > m_globals;
       std::vector<std::string> m_evals;
       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)
           {
-            t.add(begin->first, begin->second);
+            try {
+              t.add(begin->first, begin->second);
+            } catch (const chaiscript::exception::name_conflict_error &) {
+              /// \todo Should we throw an error if there's a name conflict 
+              ///       while applying a module?
+            }
             ++begin;
           }
         }
 
       template<typename T, typename InItr>
-        void apply_single(InItr begin, InItr end, T &t) const
+        static void apply_globals(InItr begin, InItr end, T &t)
+        {
+          while (begin != end)
+          {
+            t.add_global_const(begin->first, begin->second);
+            ++begin;
+          }
+        }
+
+      template<typename T, typename InItr>
+        static void apply_single(InItr begin, InItr end, T &t)
         {
           while (begin != end)
           {
@@ -105,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)
           {
@@ -116,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
   {
@@ -130,11 +268,11 @@ namespace chaiscript
       public:
         Dispatch_Function(const std::vector<Proxy_Function> &t_funcs)
           : Proxy_Function_Base(build_type_infos(t_funcs)),
-          m_funcs(t_funcs)
+            m_funcs(t_funcs)
-      {
+        {
-      }
+        }
 
-        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);
@@ -146,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)
@@ -182,16 +320,14 @@ namespace chaiscript
           return -1; // unknown arity
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) 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;
+          auto begin = m_funcs.begin();
-
+          auto end = m_funcs.end();
-          function_vec::const_iterator begin = m_funcs.begin();
-          function_vec::const_iterator end = m_funcs.end();
 
           while (begin != end)
           {
-            if ((*begin)->call_match(vals))
+            if ((*begin)->call_match(vals, t_conversions))
             {
               return true;
             } else {
@@ -202,15 +338,15 @@ 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
+        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);
+          return dispatch::dispatch(m_funcs.begin(), m_funcs.end(), params, t_conversions);
         }
 
       private:
@@ -220,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)
@@ -229,7 +365,7 @@ namespace chaiscript
 
             ++begin;
 
-            bool sizemismatch = false;
+            bool size_mismatch = false;
 
             while (begin != end)
             {
@@ -237,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)
@@ -253,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);
             }
@@ -266,48 +402,6 @@ namespace chaiscript
     };  
   }
 
-  namespace exception
-  {
-    /**
-     * Exception thrown in the case that a multi method dispatch fails
-     * because no matching function was found
-     * at runtime due to either an arity_error, a guard_error or a bad_boxed_cast
-     * exception
-     */
-    class reserved_word_error : public std::runtime_error
-    {
-      public:
-        reserved_word_error(const std::string &t_word) throw()
-          : std::runtime_error("Reserved word not allowed in object name: " + t_word), m_word(t_word)
-        {
-        }
-
-        virtual ~reserved_word_error() throw() {}
-
-        std::string word() const
-        {
-          return m_word;
-        }
-
-      private:
-        std::string m_word;
-
-    };
-
-    /**
-     * Exception thrown in the case that a non-const object was added as a shared object
-     */
-    class global_non_const : public std::runtime_error
-    {
-      public:
-        global_non_const() throw()
-          : std::runtime_error("a global object must be const")
-        {
-        }
-
-        virtual ~global_non_const() throw() {}
-    };
-  }
 
   namespace detail
   {
@@ -321,42 +415,52 @@ 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
         {
           std::map<std::string, std::vector<Proxy_Function> > m_functions;
+          std::map<std::string, Proxy_Function> m_function_objects;
           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()))
+            
         {
         }
 
         ~Dispatch_Engine()
         {
-          detail::Dynamic_Conversions::get().cleanup(m_conversions.begin(), m_conversions.end());
         }
 
+        /// \brief casts an object while applying any Dynamic_Conversion available
+        template<typename Type>
+          typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv) const
+          {
+            return chaiscript::boxed_cast<Type>(bv, &m_conversions);
+          }
+
         /**
          * Add a new conversion for upcasting to a base class
          */
         void add(const Dynamic_Cast_Conversion &d)
         {
-          m_conversions.push_back(d);
+          m_conversions.add_conversion(d);
-          return detail::Dynamic_Conversions::get().add_conversion(d);
         }
 
         /**
          * Add a new named Proxy_Function to the system
          */
-        bool add(const Proxy_Function &f, const std::string &name)
+        void add(const Proxy_Function &f, const std::string &name)
         {
           validate_object_name(name);
-          return add_function(f, name);
+          add_function(f, name);
         }
 
         /**
@@ -381,14 +485,23 @@ 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);
-          stack.back()[name] = obj;
+
+          Scope &scope = stack.back();
+          auto itr = scope.find(name);
+          if (itr != stack.back().end())
+          {
+            throw chaiscript::exception::name_conflict_error(name);
+          } else {
+            stack.back().insert(std::make_pair(name, obj));
+          }
         }
 
         /**
@@ -399,14 +512,38 @@ 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);
 
-          m_state.m_global_objects[name] = obj;
+          if (m_state.m_global_objects.find(name) != m_state.m_global_objects.end())
+          {
+            throw chaiscript::exception::name_conflict_error(name);
+          } else {
+            m_state.m_global_objects.insert(std::make_pair(name, obj));
+          }
         }
 
+
+        /**
+         * Adds a new global (non-const) shared object, between all the threads
+         */
+        void add_global(const Boxed_Value &obj, const std::string &name)
+        {
+          validate_object_name(name);
+
+          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 chaiscript::exception::name_conflict_error(name);
+          } else {
+            m_state.m_global_objects.insert(std::make_pair(name, obj));
+          }
+        }
+
+
         /**
          * Adds a new scope to the stack
          */
@@ -430,28 +567,24 @@ namespace chaiscript
           }
         }
 
-        /**
-         * Swaps out the stack with a new stack
-         * \returns the old stack
-         * \param[in] s The new stack
-         */
-        Stack set_stack(const Stack &s)
-        {
-          Stack old = m_stack_holder->stack;
-          m_stack_holder->stack = s;
-          return old;
-        }
 
-        Stack new_stack() const
+        /// Pushes a new stack on to the list of stacks
+        void new_stack()
         {
           Stack s(new Stack::element_type());
           s->push_back(Scope());
-          return s;
+          m_stack_holder->stacks.push_back(s);
         }
 
+        void pop_stack()
+        {
+          m_stack_holder->stacks.pop_back();
+        }
+
+        /// \returns the current stack
         Stack get_stack() const
         {
-          return m_stack_holder->stack;
+          return m_stack_holder->stacks.back();
         }
 
         /**
@@ -483,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;
@@ -491,21 +624,7 @@ namespace chaiscript
           }
 
           // If all that failed, then check to see if it's a function
-          std::vector<Proxy_Function> funcs = get_function(name);
+          return get_function_object(name);
-
-          if (funcs.empty())
-          {
-            throw std::range_error("Object not known: " + name);
-          } else {
-            if (funcs.size() == 1)
-            {
-              // Return the first item if there is only one,
-              // no reason to take the cast of the extra level of dispatch
-              return const_var(*funcs.begin());
-            } else {
-              return Boxed_Value(Const_Proxy_Function(new Dispatch_Function(funcs)));
-            }
-          }
         }
 
         /**
@@ -527,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())
           {
@@ -546,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();
+          for (const auto & elem : m_state.m_types)
-              itr != m_state.m_types.end();
-              ++itr)
           {
-            if (itr->second.bare_equal(ti))
+            if (elem.second.bare_equal(ti))
             {
-              return itr->first;
+              return elem.first;
             }
           }
 
@@ -579,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())
@@ -588,9 +705,26 @@ namespace chaiscript
             } else {
               return std::vector<Proxy_Function>();
             }
-
           }
 
+        /// \returns a function object (Boxed_Value wrapper) if it exists
+        /// \throws std::range_error if it does not
+        Boxed_Value get_function_object(const std::string &t_name) const
+        {
+          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+          const std::map<std::string, Proxy_Function> &funs = get_function_objects_int();
+
+          auto itr = funs.find(t_name);
+
+          if (itr != funs.end())
+          {
+            return const_var(itr->second);
+          } else {
+            throw std::range_error("Object not found: " + t_name);
+          }
+        }
+
         /**
          * Return true if a function exists
          */
@@ -602,6 +736,91 @@ namespace chaiscript
           return functions.find(name) != functions.end();
         }
 
+        /// \returns All values in the local thread state in the parent scope, or if it doesn't exist,
+        ///          the current scope.
+        std::map<std::string, Boxed_Value> get_parent_locals() const
+        {
+          StackData &stack = get_stack_data();
+          if (stack.size() > 1)
+          {
+            return stack[1];
+          } else {
+            return stack[0];
+          }
+        }
+
+        /// \returns All values in the local thread state, added through the add() function
+        std::map<std::string, Boxed_Value> get_locals() const
+        {
+          StackData &stack = get_stack_data();
+          Scope &scope = stack.front();
+          return scope;
+        }
+
+        /// \brief Sets all of the locals for the current thread state.
+        ///
+        /// \param[in] t_locals The map<name, value> set of variables to replace the current state with
+        ///
+        /// Any existing locals are removed and the given set of variables is added
+        void set_locals(const std::map<std::string, Boxed_Value> &t_locals)
+        {
+          StackData &stack = get_stack_data();
+          Scope &scope = stack.front();
+          scope = t_locals;
+        }
+
+
+
+        ///
+        /// Get a map of all objects that can be seen from the current scope in a scripting context
+        ///
+        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 = (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 (auto itr = stack.rbegin(); itr != stack.rend(); ++itr)
+          {
+            retval.insert(itr->begin(), itr->end());
+          } 
+
+          // add the global values
+          {
+            chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
+
+            retval.insert(m_state.m_global_objects.begin(), m_state.m_global_objects.end());
+          }
+
+          return retval;
+        }
+
+
+        ///
+        /// Get a map of all functions that can be seen from a scripting context
+        ///
+        std::map<std::string, Boxed_Value> get_function_objects() const
+        {
+          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+          const std::map<std::string, Proxy_Function> &funs = get_function_objects_int();
+
+          std::map<std::string, Boxed_Value> objs;
+
+          for (const auto & fun : funs)
+          {
+            objs.insert(std::make_pair(fun.first, const_var(fun.second)));
+          }
+
+          return objs;
+        }
+
+
         /**
          * Get a vector of all registered functions
          */
@@ -613,15 +832,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();
+          for (const auto & function : functions)
-              itr != functions.end();
-              ++itr)
           {
-            for (std::vector<Proxy_Function>::const_iterator itr2 = itr->second.begin();
+            for (const auto & internal_func : function.second)
-                itr2 != itr->second.end();
-                ++itr2)
             {
-              rets.push_back(std::make_pair(itr->first, *itr2));
+              rets.push_back(std::make_pair(function.first, internal_func));
             }
           }
 
@@ -635,11 +850,16 @@ namespace chaiscript
           m_state.m_reserved_words.insert(name);
         }
 
+        const Dynamic_Cast_Conversions &conversions() const
+        {
+          return m_conversions;
+        }
+
         Boxed_Value call_function(const std::string &t_name, const std::vector<Boxed_Value> &params) const
         {
           std::vector<Proxy_Function> functions = get_function(t_name);
 
-          return dispatch::dispatch(functions.begin(), functions.end(), params);
+          return dispatch::dispatch(functions.begin(), functions.end(), params, m_conversions);
         }
 
         Boxed_Value call_function(const std::string &t_name) const
@@ -665,10 +885,9 @@ namespace chaiscript
         /**
          * Dump object info to stdout
          */
-        void dump_object(Boxed_Value o) const
+        void dump_object(const Boxed_Value &o) const
         {
-          Type_Info ti = o.get_type_info();
+          std::cout << (o.is_const()?"const ":"") << type_name(o) << std::endl;
-          std::cout << (ti.is_const()?"const ":"") << get_type_name(ti) << std::endl;
         }
 
         /**
@@ -709,6 +928,22 @@ namespace chaiscript
           std::cout << ") " << std::endl;
         }
 
+        /**
+         * Returns true if a call can be made that consists of the first parameter
+         * (the function) with the remaining parameters as its arguments.
+         */
+        Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
+        {
+          if (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]);
+
+          return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end()), m_conversions));
+        }
+
         /**
          * Dump all system info to stdout
          */
@@ -760,12 +995,12 @@ namespace chaiscript
           return false;
         }
 
-        std::string type_name(Boxed_Value obj) const
+        std::string type_name(const Boxed_Value &obj) const
         {
           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);
@@ -781,6 +1016,31 @@ namespace chaiscript
           m_state = t_state;
         }
 
+        void save_function_params(const std::vector<Boxed_Value> &t_params)
+        {
+          Stack_Holder &s = *m_stack_holder;
+          s.call_params.insert(s.call_params.begin(), t_params.begin(), t_params.end());
+        }
+
+        void new_function_call()
+        {
+          ++m_stack_holder->call_depth;
+        }
+
+        void pop_function_call()
+        {
+          Stack_Holder &s = *m_stack_holder;
+          --s.call_depth;
+
+          assert(s.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
+            s.call_params.clear();
+          }
+        }
 
       private:
         /**
@@ -789,7 +1049,17 @@ namespace chaiscript
          */
         StackData &get_stack_data() const
         {
-          return *(m_stack_holder->stack);
+          return *(m_stack_holder->stacks.back());
+        }
+
+        const std::map<std::string, Proxy_Function> &get_function_objects_int() const
+        {
+          return m_state.m_function_objects;
+        }
+
+        std::map<std::string, Proxy_Function> &get_function_objects_int() 
+        {
+          return m_state.m_function_objects;
         }
 
         const std::map<std::string, std::vector<Proxy_Function> > &get_functions_int() const
@@ -811,10 +1081,10 @@ namespace chaiscript
           const size_t rhssize = rhsparamtypes.size();
 
           const Type_Info boxed_type = user_type<Boxed_Value>();
-          const Type_Info boxed_pod_type = user_type<Boxed_POD_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));
+          std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_lhs(std::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_rhs(std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(rhs));
 
           if (dynamic_lhs && dynamic_rhs)
           {
@@ -902,28 +1172,33 @@ namespace chaiscript
          */
         void validate_object_name(const std::string &name) const
         {
+          if (name.find("::") != std::string::npos) {
+            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);
           }
         }
 
         /**
-         * Implementation detail for adding a function. Returns
+         * Implementation detail for adding a function. 
-         * true if the function was added, false if a function with the
+         * \throws exception::name_conflict_error if there's a function matching the given one being added
-         * same signature and name already exists.
          */
-        bool add_function(const Proxy_Function &t_f, const std::string &t_name)
+        void add_function(const Proxy_Function &t_f, const std::string &t_name)
         {
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
           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();
+
           if (itr != funcs.end())
           {
             std::vector<Proxy_Function> &vec = itr->second;
@@ -933,19 +1208,29 @@ namespace chaiscript
             {
               if ((*t_f) == *(*itr2))
               {
-                return false;
+                throw chaiscript::exception::name_conflict_error(t_name);
               }
             }
 
             vec.push_back(t_f);
             std::stable_sort(vec.begin(), vec.end(), &function_less_than);
+            func_objs[t_name] = Proxy_Function(new Dispatch_Function(vec));
+          } else if (t_f->has_arithmetic_param()) {
+            // if the function is the only function but it also contains
+            // arithmetic operators, we must wrap it in a dispatch function
+            // to allow for automatic arithmetic type conversions
+            std::vector<Proxy_Function> vec;
+            vec.push_back(t_f);
+            funcs.insert(std::make_pair(t_name, vec));
+            func_objs[t_name] = Proxy_Function(new Dispatch_Function(vec));
           } else {
             std::vector<Proxy_Function> vec;
             vec.push_back(t_f);
             funcs.insert(std::make_pair(t_name, vec));
+            func_objs[t_name] = t_f;
           }
 
-          return true;
+
         }
 
         mutable chaiscript::detail::threading::shared_mutex m_mutex;
@@ -954,15 +1239,20 @@ namespace chaiscript
         struct Stack_Holder
         {
           Stack_Holder()
-            : stack(new StackData())
+            : call_depth(0)
           {
-            stack->push_back(Scope());
+            Stack s(new StackData());
+            s->push_back(Scope());
+            stacks.push_back(s);
           }
 
-          Stack stack;
+          std::deque<Stack> stacks;
+
+          std::list<Boxed_Value> call_params;
+          int call_depth;
         };  
 
-        std::vector<Dynamic_Cast_Conversion> m_conversions;
+        Dynamic_Cast_Conversions m_conversions;
         chaiscript::detail::threading::Thread_Storage<Stack_Holder> m_stack_holder;
 
 

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

@@ -1,19 +1,24 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
 #define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
 
-#include "type_info.hpp"
+#include <memory>
-#include "boxed_value.hpp"
+#include <set>
-#include "boxed_cast_helper.hpp"
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+
+#include "../chaiscript_threading.hpp"
 #include "bad_boxed_cast.hpp"
-#include <boost/static_assert.hpp>
+#include "boxed_cast_helper.hpp"
-#include <boost/type_traits/is_polymorphic.hpp>
+#include "boxed_value.hpp"
-#include <boost/type_traits/is_base_of.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 {}
     };
   }
 
@@ -47,12 +52,14 @@ namespace chaiscript
     class Dynamic_Conversion
     {
       public:
-        virtual Boxed_Value convert(const Boxed_Value &derived) = 0;
+        virtual Boxed_Value convert(const Boxed_Value &derived) const = 0;
-        const Type_Info &base()
+        virtual Boxed_Value convert_down(const Boxed_Value &base) const = 0;
+
+        const Type_Info &base() const
         {
           return m_base;
         }
-        const Type_Info &derived()
+        const Type_Info &derived() const
         {
           return m_derived;
         }
@@ -63,14 +70,67 @@ namespace chaiscript
         {
         }
 
+        virtual ~Dynamic_Conversion() {} 
+
       private:
         Type_Info m_base;
         Type_Info m_derived;
 
     };
 
+    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
+      class Dynamic_Conversion_Impl : public Dynamic_Conversion
     {
       public:
         Dynamic_Conversion_Impl()
@@ -78,148 +138,122 @@ namespace chaiscript
         {
         }
 
-        virtual Boxed_Value convert(const Boxed_Value &t_derived)
+        virtual Boxed_Value convert_down(const Boxed_Value &t_base) const CHAISCRIPT_OVERRIDE
         {
-          if (t_derived.get_type_info().bare_equal(user_type<Derived>()))
+          return Dynamic_Caster<Base, Derived>::cast(t_base);
-          {
-            if (t_derived.is_pointer())
-            {
-              // Dynamic cast out the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                boost::shared_ptr<const Base> data 
-                  = boost::dynamic_pointer_cast<const Base>(detail::Cast_Helper<boost::shared_ptr<const Derived> >::cast(t_derived));
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
-
-                return Boxed_Value(data);
-              } else {
-                boost::shared_ptr<Base> data 
-                  = boost::dynamic_pointer_cast<Base>(detail::Cast_Helper<boost::shared_ptr<Derived> >::cast(t_derived));
-
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
-
-                return Boxed_Value(data);
-              }
-            } else {
-              // Pull the reference out of the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                const Derived &d = detail::Cast_Helper<const Derived &>::cast(t_derived);
-                const Base &data = dynamic_cast<const Base &>(d);
-                return Boxed_Value(boost::cref(data));
-              } else {
-                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived);
-                Base &data = dynamic_cast<Base &>(d);
-                return Boxed_Value(boost::ref(data));
-              }
-            }
-          } else {
-            throw exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
-          }
-        }
-    };
-
-
-    class Dynamic_Conversions
-    {
-      public:
-        static inline Dynamic_Conversions &get()
-        {
-          static Dynamic_Conversions obj;
-          return obj;
         }
 
-        template<typename Base, typename Derived>
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
-        static boost::shared_ptr<Dynamic_Conversion> create()
         {
-          boost::shared_ptr<Dynamic_Conversion> conversion(new Dynamic_Conversion_Impl<Base, Derived>());
+          return Dynamic_Caster<Derived, Base>::cast(t_derived);
-
-          /// \todo this is a hack and a kludge. The idea is to make sure that
-          ///       the conversion is registered both in the module's notion of the static conversion object
-          ///       and in the global notion of the static conversion object
-          ///       someday this will almost certainly have to change. Maybe it is time for ChaiScript
-          ///       to become a library?
-          Dynamic_Conversions::get().add_conversion(conversion);
-          return conversion;
         }
-
-        template<typename InItr>
-        void cleanup(InItr begin, const InItr &end)
-        {
-          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          while (begin != end)
-          {
-            if (begin->unique())
-            {
-              m_conversions.erase(begin->get());
-            }
-
-            ++begin;
-          }
-        }
-
-        void add_conversion(const boost::shared_ptr<Dynamic_Conversion> &conversion)
-        {
-          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          m_conversions.insert(conversion.get());
-        }
-
-        bool has_conversion(const Type_Info &base, const Type_Info &derived) const
-        {
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          return find(base, derived) != m_conversions.end();
-        }
-
-
-        Dynamic_Conversion *get_conversion(const Type_Info &base, const Type_Info &derived) const
-        {
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          std::set<Dynamic_Conversion *>::const_iterator itr =
-            find(base, derived);
-
-          if (itr != m_conversions.end())
-          {
-            return *itr;
-          } else {
-            throw std::out_of_range("No such conversion exists from " + derived.bare_name() + " to " + base.bare_name());
-          }
-        }
-
-      private:
-        Dynamic_Conversions() {}
-
-        std::set<Dynamic_Conversion *>::const_iterator find(
-            const Type_Info &base, const Type_Info &derived) const
-        {
-          for (std::set<Dynamic_Conversion *>::const_iterator itr = m_conversions.begin();
-               itr != m_conversions.end();
-               ++itr)
-          {
-            if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
-            {
-              return itr;
-            }
-          }
-
-          return m_conversions.end();
-        }
-
-        mutable chaiscript::detail::threading::shared_mutex m_mutex;
-        std::set<Dynamic_Conversion *> m_conversions;
     };
   }
 
-  typedef boost::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
+  class Dynamic_Cast_Conversions
+  {
+    public:
+      Dynamic_Cast_Conversions()
+      {
+      }
+
+      Dynamic_Cast_Conversions(const Dynamic_Cast_Conversions &t_other)
+        : m_conversions(t_other.get_conversions())
+      {
+      }
+
+      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);
+      }
+
+      template<typename Base, typename Derived>
+        bool dynamic_cast_converts() const
+        {
+          return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
+        }
+
+      bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived) const
+      {
+        return has_conversion(base, derived) || has_conversion(derived, base);
+      }
+
+      template<typename Base>
+        Boxed_Value boxed_dynamic_cast(const Boxed_Value &derived) const
+        {
+          try {
+            return get_conversion(user_type<Base>(), derived.get_type_info())->convert(derived);
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
+          }
+        }
+
+      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();
+      }
+
+      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);
+
+        auto itr =
+          find(base, derived);
+
+        if (itr != m_conversions.end())
+        {
+          return *itr;
+        } else {
+          throw std::out_of_range("No such conversion exists from " + derived.bare_name() + " to " + base.bare_name());
+        }
+      }
+
+    private:
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
+          const Type_Info &base, const Type_Info &derived) const
+      {
+        for (auto itr = m_conversions.begin();
+            itr != m_conversions.end();
+            ++itr)
+        {
+          if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
+          {
+            return itr;
+          }
+        }
+
+        return m_conversions.end();
+      }
+
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> > get_conversions() const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        return m_conversions;
+      }
+
+      mutable chaiscript::detail::threading::shared_mutex m_mutex;
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> > m_conversions;
+  };
+
+  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,45 +276,18 @@ 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));
+    static_assert(std::is_base_of<Base,Derived>::value, "Classes are not related by inheritance");
-    BOOST_STATIC_ASSERT(boost::is_polymorphic<Base>::value);
+    static_assert(std::is_polymorphic<Base>::value, "Base class must be polymorphic");
-    BOOST_STATIC_ASSERT(boost::is_polymorphic<Derived>::value);
+    static_assert(std::is_polymorphic<Derived>::value, "Derived class must be polymorphic");
 
-    return detail::Dynamic_Conversions::create<Base, Derived>();
+    return std::shared_ptr<detail::Dynamic_Conversion>(new detail::Dynamic_Conversion_Impl<Base, Derived>());
   }
 
-  namespace detail
-  {
-    template<typename Base, typename Derived>
-      bool dynamic_cast_converts()
-      {
-        return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
-      }
-
-    static bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived)
-    {
-      return detail::Dynamic_Conversions::get().has_conversion(base, derived);
-    }
-
-    template<typename Base>
-      Boxed_Value boxed_dynamic_cast(const Boxed_Value &derived)
-      {
-        try {
-          return detail::Dynamic_Conversions::get().get_conversion(user_type<Base>(), derived.get_type_info())->convert(derived);
-        } catch (const std::out_of_range &) {
-          throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "No known conversion");
-        } catch (const std::bad_cast &) {
-          throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
-        }
-      }
-  }
 }
 
 

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,13 +1,33 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #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)
+        Dynamic_Object(std::string t_type_name)
-          : m_type_name(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;
         }
@@ -44,20 +64,6 @@ namespace chaiscript
 
     namespace detail
     {
-      struct Dynamic_Object_Attribute
-      {
-        static Boxed_Value func(const std::string &t_type_name, const std::string &t_attr_name,
-            Dynamic_Object &t_do)
-        {
-          if (t_do.get_type_name() != t_type_name) 
-          {
-            throw exception::bad_boxed_cast("Dynamic object type mismatch");
-          }
-
-          return t_do.get_attr(t_attr_name);
-        }
-      };
-
       /**
        * A Proxy_Function implementation designed for calling a function
        * that is automatically guarded based on the first param based on the
@@ -67,19 +73,31 @@ 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)
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-              && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-        }
+          }
 
           virtual ~Dynamic_Object_Function() {}
 
-          virtual bool operator==(const Proxy_Function_Base &f) const
+          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)
@@ -90,76 +108,68 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals) 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))
+            if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
             {
-              return m_func->call_match(vals);
+              return m_func->call_match(vals, t_conversions);
             } else {
               return false;
             }
           }    
 
-          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;
+            return {m_func};
-            fs.push_back(m_func);
-            return fs;
           }
 
 
-          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
+          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))
+            if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
             {
-              return (*m_func)(params);
+              return (*m_func)(params, t_conversions);
             } else {
               throw exception::guard_error();
             } 
           }
 
-          virtual bool compare_first_type(const Boxed_Value &bv) 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);
+            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.size() > 1);
-              assert(types[1].bare_equal(user_type<Boxed_Value>()));
+            assert(types[1].bare_equal(user_type<Boxed_Value>()));
-              types[1] = *t_objectti;
+            types[1] = t_objectti;
-              return types;
+            return types;
-            } else {
-              return t_inner_types;
-            }
           }
 
-          static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
+          bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const boost::optional<Type_Info> &ti)
+              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(m_doti))
-            if (bv.get_type_info().bare_equal(doti))
             {
               try {
-                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv);
+                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
                 return name == "Dynamic_Object" || d.get_type_name() == name;
               } catch (const std::bad_cast &) {
                 return false;
@@ -175,12 +185,12 @@ namespace chaiscript
 
           }
 
-          static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+          bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const boost::optional<Type_Info> &ti) 
+              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) const
           {
             if (bvs.size() > 0)
             {
-              return dynamic_object_typename_match(bvs[0], name, ti);
+              return dynamic_object_typename_match(bvs[0], name, ti, t_conversions);
             } else {
               return false;
             }
@@ -188,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;
+
 
       };
 
@@ -203,19 +215,19 @@ 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)
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-              && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-        }
+          }
 
           static std::vector<Type_Info> build_type_list(const std::vector<Type_Info> &tl)
           {
-            std::vector<Type_Info>::const_iterator begin = tl.begin();
+            auto begin = tl.begin();
-            std::vector<Type_Info>::const_iterator end = tl.end();
+            auto end = tl.end();
 
             if (begin != end)
             {
@@ -227,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)
@@ -238,36 +250,36 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals) 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)));
             new_vals.insert(new_vals.end(), vals.begin(), vals.end());
 
-            return m_func->call_match(new_vals);
+            return m_func->call_match(new_vals, t_conversions);
           }    
 
 
-          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
+          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));
             new_params.push_back(bv);
             new_params.insert(new_params.end(), params.begin(), params.end());
 
-            (*m_func)(new_params);
+            (*m_func)(new_params, t_conversions);
 
             return bv;
           }

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -0,0 +1,198 @@
+// 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_EXCEPTION_SPECIFICATION_HPP_
+#define CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
+
+#include <memory>
+
+#include "../chaiscript_defines.hpp"
+#include "boxed_cast.hpp"
+
+namespace chaiscript {
+class Boxed_Value;
+namespace exception {
+class bad_boxed_cast;
+}  // namespace exception
+}  // namespace chaiscript
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    struct Exception_Handler_Base
+    {
+      virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) = 0;
+
+      virtual ~Exception_Handler_Base() {}
+
+      protected:
+        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 chaiscript::exception::bad_boxed_cast &) {}
+        }
+    };
+
+    template<typename T1>
+      struct Exception_Handler_Impl1 : Exception_Handler_Base
+      {
+        virtual ~Exception_Handler_Impl1() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
+        {
+          throw_type<T1>(bv, t_engine);
+        }
+      };
+    template<typename T1, typename T2>
+      struct Exception_Handler_Impl2 : Exception_Handler_Base
+      {
+        virtual ~Exception_Handler_Impl2() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
+        {
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
+        }
+      };
+
+    template<typename T1, typename T2, typename T3>
+      struct Exception_Handler_Impl3 : Exception_Handler_Base
+      {
+        virtual ~Exception_Handler_Impl3() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
+        {
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
+          throw_type<T3>(bv, t_engine);
+        }
+      };
+    template<typename T1, typename T2, typename T3, typename T4>
+      struct Exception_Handler_Impl4 : Exception_Handler_Base
+      {
+        virtual ~Exception_Handler_Impl4() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
+        {
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
+          throw_type<T3>(bv, t_engine);
+          throw_type<T4>(bv, t_engine);
+        }
+      };
+    template<typename T1, typename T2, typename T3, typename T4, typename T5>
+      struct Exception_Handler_Impl5 : Exception_Handler_Base
+      {
+        virtual ~Exception_Handler_Impl5() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
+        {
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
+          throw_type<T3>(bv, t_engine);
+          throw_type<T4>(bv, t_engine);
+          throw_type<T5>(bv, t_engine);
+        }
+      };
+  }
+
+  /// \brief Used in the automatic unboxing of exceptions thrown during script evaluation
+  ///
+  /// Exception specifications allow the user to tell ChaiScript what possible exceptions are expected from the script
+  /// being executed. Exception_Handler objects are created with the chaiscript::exception_specification() function.
+  ///
+  /// Example:
+  /// \code
+  /// chaiscript::ChaiScript chai;
+  ///
+  /// try {
+  ///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+  /// } catch (const double e) {
+  /// } catch (int) {
+  /// } catch (float) {
+  /// } catch (const std::string &) {
+  /// } catch (const std::exception &e) {
+  ///   // This is the one what will be called in the specific throw() above
+  /// }
+  /// \endcode
+  ///
+  /// It is recommended that if catching the generic \c std::exception& type that you specifically catch
+  /// the chaiscript::exception::eval_error type, so that there is no confusion.
+  ///
+  /// \code
+  /// try {
+  ///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<const std::exception &>());
+  /// } catch (const chaiscript::exception::eval_error &) {
+  ///   // Error in script parsing / execution
+  /// } catch (const std::exception &e) {
+  ///   // Error explicitly thrown from script
+  /// }
+  /// \endcode
+  ///
+  /// Similarly, if you are using the ChaiScript::eval form that unboxes the return value, then chaiscript::exception::bad_boxed_cast
+  /// should be handled as well.
+  /// 
+  /// \code
+  /// try {
+  ///   chai.eval<int>("1.0", chaiscript::exception_specification<const std::exception &>());
+  /// } catch (const chaiscript::exception::eval_error &) {
+  ///   // Error in script parsing / execution
+  /// } catch (const chaiscript::exception::bad_boxed_cast &) {
+  ///   // Error unboxing return value
+  /// } catch (const std::exception &e) {
+  ///   // Error explicitly thrown from script
+  /// }
+  /// \endcode
+  ///
+  /// \sa chaiscript::exception_specification for creation of chaiscript::Exception_Handler objects
+  /// \sa \ref exceptions
+  typedef std::shared_ptr<detail::Exception_Handler_Base> Exception_Handler;
+
+  /// \brief creates a chaiscript::Exception_Handler which handles one type of exception unboxing
+  /// \sa \ref exceptions
+  template<typename T1>
+  Exception_Handler exception_specification()
+  {
+    return Exception_Handler(new detail::Exception_Handler_Impl1<T1>());
+  }
+
+  /// \brief creates a chaiscript::Exception_Handler which handles two types of exception unboxing
+  /// \sa \ref exceptions
+  template<typename T1, typename T2>
+  Exception_Handler exception_specification()
+  {
+    return Exception_Handler(new detail::Exception_Handler_Impl2<T1, T2>());
+  }
+
+  /// \brief creates a chaiscript::Exception_Handler which handles three types of exception unboxing
+  /// \sa \ref exceptions
+  template<typename T1, typename T2, typename T3>
+  Exception_Handler exception_specification()
+  {
+    return Exception_Handler(new detail::Exception_Handler_Impl3<T1, T2, T3>());
+  }
+
+  /// \brief creates a chaiscript::Exception_Handler which handles four types of exception unboxing
+  /// \sa \ref exceptions
+  template<typename T1, typename T2, typename T3, typename T4>
+  Exception_Handler exception_specification()
+  {
+    return Exception_Handler(new detail::Exception_Handler_Impl4<T1, T2, T3, T4>());
+  }
+
+  /// \brief creates a chaiscript::Exception_Handler which handles five types of exception unboxing
+  /// \sa \ref exceptions
+  template<typename T1, typename T2, typename T3, typename T4, typename T5>
+  Exception_Handler exception_specification()
+  {
+    return Exception_Handler(new detail::Exception_Handler_Impl5<T1, T2, T3, T4, T5>());
+  }
+}
+
+
+#endif
+

include/chaiscript/dispatchkit/function_call.hpp

@@ -1,22 +1,28 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_HPP_
 
-#include <boost/shared_ptr.hpp>
+#include <functional>
-#include <boost/bind.hpp>
+#include <iostream>
-#include <boost/function.hpp>
 #include <string>
 #include <vector>
-#include "proxy_functions.hpp"
+
+#include "boxed_cast.hpp"
 #include "function_call_detail.hpp"
+#include "proxy_functions.hpp"
 
-
+namespace chaiscript {
-#include <iostream>
+class Boxed_Value;
+class Dynamic_Cast_Conversions;
+namespace detail {
+template <typename T> struct Cast_Helper;
+}  // namespace detail
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -25,17 +31,17 @@ 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)
+      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);
+        return detail::build_function_caller_helper(p, funcs, t_conversions);
       }
 
     /**
@@ -45,19 +51,19 @@ 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)
+      functor(Const_Proxy_Function func, const Dynamic_Cast_Conversions *t_conversions)
       {
         std::vector<Const_Proxy_Function> funcs;
         funcs.push_back(func);
-        return functor<FunctionType>(funcs);
+        return functor<FunctionType>(funcs, t_conversions);
       }
 
     /**
@@ -65,67 +71,67 @@ 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)
+      functor(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions)
       {
-        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv));
+        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
       }
   }
 
   namespace detail{
     /**
-     * Cast helper to handle automatic casting to const boost::function &
+     * Cast helper to handle automatic casting to const std::function &
      */
     template<typename Signature>
-      struct Cast_Helper<const boost::function<Signature> &>
+      struct Cast_Helper<const std::function<Signature> &>
       {
-        typedef boost::function<Signature> Result_Type;
+        typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> &>::cast(ob);
+            return Cast_Helper_Inner<const std::function<Signature> &>::cast(ob, t_conversions);
           }
         }
       };
 
     /**
-     * Cast helper to handle automatic casting to boost::function
+     * Cast helper to handle automatic casting to std::function
      */
     template<typename Signature>
-      struct Cast_Helper<boost::function<Signature> >
+      struct Cast_Helper<std::function<Signature> >
       {
-        typedef boost::function<Signature> Result_Type;
+        typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<boost::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<std::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };
 
     /**
-     * Cast helper to handle automatic casting to const boost::function
+     * Cast helper to handle automatic casting to const std::function
      */
     template<typename Signature>
-      struct Cast_Helper<const boost::function<Signature> >
+      struct Cast_Helper<const std::function<Signature> >
       {
-        typedef boost::function<Signature> Result_Type;
+        typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<const std::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,24 +1,23 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// 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 <algorithm>
-#include <boost/bind.hpp>
+#include <functional>
-#include <boost/function.hpp>
+#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,77 +26,83 @@ 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, 
-              const std::vector<Boxed_Value> &params)
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params));
+            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, t_conversions));
           }
         };
 
+      /**
+       * Specialization for arithmetic return types
+       */
+      template<typename Ret>
+        struct Function_Caller_Ret<Ret, true>
+        {
+          static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
+              const std::vector<Boxed_Value> &params, const 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 std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            dispatch::dispatch(t_funcs, params);
+            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) >
+      template<typename Ret, typename ... Param>
-        Ret function_caller(const std::vector<Const_Proxy_Function> &funcs 
+        struct Build_Function_Caller_Helper
-            BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
         {
-          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);
+                );
-        }
 
-      /**
+          }
-       * used internally for unwrapping a function call's types
+
-       */
+          std::vector<Const_Proxy_Function> m_funcs;
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+          Dynamic_Cast_Conversions m_conversions;
-        boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
+        };
-        build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<Const_Proxy_Function> &funcs)
+
+
+
+      template<typename Ret, typename ... 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 = 
+            std::shared_ptr<const Proxy_Function_Impl<Ret (Params...)>> pfi = 
-              boost::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> >
+              std::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (Params...)> >
-              (funcs[0]);
+                (funcs[0]);
 
             if (pfi)
             {
@@ -107,13 +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
+          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions?*t_conversions:Dynamic_Cast_Conversions()));
-              BOOST_PP_ENUM_TRAILING(n, curry, ~));
         }
     }
   }
 }
-#undef n
 
 #endif
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,19 +1,25 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
 #define CHAISCRIPT_HANDLE_RETURN_HPP_
 
+#include <functional>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "boxed_number.hpp"
 #include "boxed_value.hpp"
 #include "type_info.hpp"
-#include <string>
-#include <boost/function.hpp>
 
-#include <stdexcept>
+namespace chaiscript {
-#include <vector>
+class Boxed_Number;
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -34,27 +40,36 @@ namespace chaiscript
         };
 
       template<typename Ret>
-        struct Handle_Return<boost::shared_ptr<Ret> &>
+        struct Handle_Return<Ret *>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(Ret *p)
+          {
+            return Boxed_Value(p);
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::shared_ptr<Ret> &>
+        {
+          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);
           }
@@ -65,7 +80,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const Ret &r)
           {
-            return Boxed_Value(boost::cref(r));
+            return Boxed_Value(std::cref(r));
           }
         };
 
@@ -78,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));
           }
         };
 
@@ -135,6 +150,30 @@ namespace chaiscript
           }
         };
 
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<Boxed_Number>
+        {
+          static Boxed_Value handle(const Boxed_Number &r)
+          {
+            return r.bv;
+          }
+        };
+
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<const Boxed_Number>
+        {
+          static Boxed_Value handle(const Boxed_Number &r)
+          {
+            return r.bv;
+          }
+        };
+
 
       /**
        * Used internally for handling a return value from a Proxy_Function call

include/chaiscript/dispatchkit/operators.hpp

@@ -1,12 +1,14 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #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

@@ -1,27 +1,39 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// 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

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 
@@ -9,56 +9,39 @@
 #define CHAISCRIPT_PROXY_FUNCTIONS_HPP_
 
 
-#include "boxed_value.hpp"
+#include <algorithm>
-#include "type_info.hpp"
+#include <cassert>
-#include <string>
+#include <functional>
-#include <boost/function.hpp>
+#include <memory>
-#include <boost/type_traits/add_reference.hpp>
 #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_POD_Value;
+  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++
@@ -71,10 +54,10 @@ namespace chaiscript
     {
       public:
         virtual ~Proxy_Function_Base() {}
-        Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+
+        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Dynamic_Cast_Conversions &t_conversions) const
         {
-          Boxed_Value bv = do_call(params);
+          Boxed_Value bv = do_call(params, t_conversions);
-          bv.add_dependencies(params.begin(), params.end());
           return bv;
         }
 
@@ -82,20 +65,24 @@ 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 = 0;
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
-        virtual std::vector<boost::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
+        bool has_arithmetic_param() const 
         {
-          return std::vector<boost::shared_ptr<const Proxy_Function_Base> >();
+          return m_has_arithmetic_param;
         }
 
+        virtual std::vector<std::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
+        {
+          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
+        bool filter(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           int arity = get_arity();
 
@@ -107,7 +94,7 @@ namespace chaiscript
             {
               return true;
             } else {
-              return compare_first_type(vals[0]);
+              return compare_first_type(vals[0], t_conversions);
             }
           } else {
             return false;
@@ -119,30 +106,15 @@ namespace chaiscript
 
         virtual std::string annotation() const = 0;
 
-      protected:
+        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions)
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const = 0;
-
-        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
-          : m_types(t_types)
         {
-        }
-
-        virtual bool compare_first_type(const Boxed_Value &bv) const
-        {
-          const std::vector<Type_Info> &types = get_param_types();
-
-          if (types.size() < 2)
-          {
-            return true;
-          }
-          const Type_Info &ti = types[1];
           if (ti.is_undef() 
               || ti.bare_equal(user_type<Boxed_Value>())
               || (!bv.get_type_info().is_undef()
-                && (ti.bare_equal(user_type<Boxed_POD_Value>())
+                && (ti.bare_equal(user_type<Boxed_Number>())
                   || ti.bare_equal(bv.get_type_info())
-                  || chaiscript::detail::dynamic_cast_converts(ti, bv.get_type_info()) 
+                  || bv.get_type_info().bare_equal(user_type<std::shared_ptr<const Proxy_Function_Base> >())
-                  || bv.get_type_info().bare_equal(user_type<boost::shared_ptr<const Proxy_Function_Base> >())
+                  || t_conversions.dynamic_cast_converts(ti, bv.get_type_info()) 
                   )
                 )
              )
@@ -152,8 +124,38 @@ namespace chaiscript
             return false;
           }
         }
+      protected:
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
-        bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs) const
+        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)
+          {
+            if (m_types[i].is_arithmetic())
+            {
+              m_has_arithmetic_param = true;
+              return;
+            }
+          }
+
+        }
+
+        virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
+        {
+          const std::vector<Type_Info> &types = get_param_types();
+
+          if (types.size() < 2)
+          {
+            return true;
+          }
+
+          const Type_Info &ti = types[1];
+          return compare_type_to_param(ti, bv, t_conversions);
+
+        }
+
+        static bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs)
         {
           if (tis.size() - 1 != bvs.size())
           {
@@ -172,15 +174,17 @@ namespace chaiscript
         }
 
         std::vector<Type_Info> m_types;
+        bool m_has_arithmetic_param;
+
     };
   }
 
   /// \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
   {
@@ -188,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
         { }
     };
   }
@@ -207,31 +211,35 @@ 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(),
+            AST_NodePtr t_parsenode = AST_NodePtr(),
-            const std::string &t_description = "",
+            std::string t_description = "",
-            const Proxy_Function &t_guard = Proxy_Function())
+            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
-        {
-          return this == &rhs;
-        }
-
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
-        {
-          return (m_arity < 0 || vals.size() == size_t(m_arity))
-            && test_guard(vals);
-        }    
-
         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);
 
-        virtual int get_arity() const
+          return this == &rhs
+            || (prhs
+                && this->m_arity == prhs->m_arity
+                && !this->m_guard && !prhs->m_guard);
+        }
+
+        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 int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return m_arity;
         }
@@ -246,18 +254,18 @@ 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
+        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))
           {
 
-            if (test_guard(params))
+            if (test_guard(params, t_conversions))
             {
               return m_f(params);
             } else {
@@ -270,12 +278,12 @@ namespace chaiscript
         }
 
       private:
-        bool test_guard(const std::vector<Boxed_Value> &params) const
+        bool test_guard(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (m_guard)
           {
             try {
-              return boxed_cast<bool>((*m_guard)(params));
+              return boxed_cast<bool>((*m_guard)(params, t_conversions));
             } catch (const exception::arity_error &) {
               return false;
             } catch (const exception::bad_boxed_cast &) {
@@ -293,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)
             {
@@ -304,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;
@@ -331,29 +339,24 @@ namespace chaiscript
         Bound_Function(const Const_Proxy_Function &t_f, 
             const std::vector<Boxed_Value> &t_args)
           : Proxy_Function_Base(build_param_type_info(t_f, t_args)),
-          m_f(t_f), m_args(t_args), m_arity(t_f->get_arity()<0?-1:static_cast<int>(get_param_types().size())-1)
+            m_f(t_f), m_args(t_args), m_arity(t_f->get_arity()<0?-1:static_cast<int>(get_param_types().size())-1)
         {
           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
+        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));
+          return m_f->call_match(build_param_list(vals), t_conversions);
         }
 
-        virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+        virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
-        {
-          return (*m_f)(build_param_list(params));
-        }
-
-        virtual std::vector<Const_Proxy_Function> get_contained_functions() const
         {
           std::vector<Const_Proxy_Function> fs;
           fs.push_back(m_f);
@@ -363,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;
+          auto parg = params.begin();
-
+          auto barg = m_args.begin();
-          pitr parg = params.begin();
-          pitr barg = m_args.begin();
 
           std::vector<Boxed_Value> args;
 
@@ -394,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();
         }
@@ -409,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();
@@ -427,9 +429,9 @@ namespace chaiscript
           return retval;
         }
 
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) 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));
+          return (*m_f)(build_param_list(params), t_conversions);
         }
 
       private:
@@ -438,64 +440,79 @@ namespace chaiscript
         int m_arity;
     };
 
-    /**
+    class Proxy_Function_Impl_Base : public Proxy_Function_Base
-     * The standard typesafe function call implementation of Proxy_Function
-     * It takes a boost::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_Impl_Base(std::vector<Type_Info> t_types)
-          : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(0))),
+          : Proxy_Function_Base(std::move(t_types))
-          m_f(f), m_dummy_func(0)
-      {
-      }
-
-        virtual ~Proxy_Function_Impl() {}
-
-        virtual bool operator==(const Proxy_Function_Base &t_func) const
         {
-          const Proxy_Function_Impl *pimpl = dynamic_cast<const Proxy_Function_Impl<Func> *>(&t_func);
-          return pimpl != 0;
         }
 
+        virtual ~Proxy_Function_Impl_Base() {}
 
-        virtual int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return static_cast<int>(m_types.size()) - 1;
         }
 
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
+        {
+          return "";
+        }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) 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()) 
           {
             return false;
           }
 
-          return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals);
+          return compare_types(m_types, vals) || compare_types_with_cast(vals, t_conversions);
         }
 
-        virtual std::string annotation() const
+        virtual bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
+    };
+
+    /**
+     * The standard typesafe function call implementation of Proxy_Function
+     * It takes a std::function<> object and performs runtime 
+     * type checking of Boxed_Value parameters, in a type safe manner
+     */
+    template<typename Func>
+      class Proxy_Function_Impl : public Proxy_Function_Impl_Base
+    {
+      public:
+        Proxy_Function_Impl(std::function<Func> f)
+          : Proxy_Function_Impl_Base(detail::build_param_type_list(static_cast<Func *>(nullptr))),
+            m_f(std::move(f)), m_dummy_func(nullptr)
         {
-          return "";
         }
 
-        boost::function<Func> internal_function() const
+        virtual ~Proxy_Function_Impl() {}
+
+        virtual bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        {
+          return detail::compare_types_cast(m_dummy_func, vals, t_conversions);
+        }
+
+        virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
+        {
+          return dynamic_cast<const Proxy_Function_Impl<Func> *>(&t_func) != nullptr;
+        }
+
+        std::function<Func> internal_function() const
         {
           return m_f;
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params);
+          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;
     };
 
@@ -509,15 +526,16 @@ namespace chaiscript
         Attribute_Access(T Class::* t_attr)
           : Proxy_Function_Base(param_types()),
           m_attr(t_attr)
-      {
+        {
-      }
+        }
 
         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 {
@@ -526,12 +544,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
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const CHAISCRIPT_OVERRIDE
         {
           if (vals.size() != 1)
           {
@@ -541,24 +559,24 @@ 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
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (params.size() == 1)
           {
             const Boxed_Value &bv = params[0];
             if (bv.is_const())
             {
-              const Class *o = boxed_cast<const Class *>(bv);
+              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);
+              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);
@@ -568,11 +586,9 @@ namespace chaiscript
       private:
         static std::vector<Type_Info> param_types()
         {
-          std::vector<Type_Info> v;
+          return {user_type<T>(), user_type<Class>()};
-          v.push_back(user_type<T>());
-          v.push_back(user_type<Class>());
-          return v;
         }
+
         T Class::* m_attr;
     };
   }
@@ -587,22 +603,109 @@ namespace chaiscript
     class dispatch_error : public std::runtime_error
     {
       public:
-        dispatch_error() throw()
+        dispatch_error(std::vector<Boxed_Value> t_parameters, 
-          : std::runtime_error("No matching function to dispatch to")
+            std::vector<Const_Proxy_Function> t_functions)
+          : std::runtime_error("Error with function dispatch"), parameters(std::move(t_parameters)), functions(std::move(t_functions))
         {
         }
 
-        dispatch_error(bool is_const) throw()
+        virtual ~dispatch_error() CHAISCRIPT_NOEXCEPT {}
-          : std::runtime_error(std::string("No matching function to dispatch to") + (is_const?", parameter is const":""))
-          {
-          }
 
-        virtual ~dispatch_error() throw() {}
+        std::vector<Boxed_Value> parameters;
+        std::vector<Const_Proxy_Function> functions;
     };
   } 
 
   namespace dispatch
   {
+    namespace detail 
+    {
+      template<typename FuncType>
+        bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          if (t_func->get_arity() != static_cast<int>(plist.size()))
+          {
+            return false;
+          }
+
+          const std::vector<Type_Info> &types = t_func->get_param_types();
+
+          assert(plist.size() == types.size() - 1);
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (Proxy_Function_Base::compare_type_to_param(types[i+1], plist[i], t_conversions)
+                || (types[i+1].is_arithmetic() && plist[i].get_type_info().is_arithmetic()))
+            {
+              // types continue to match
+            } else {
+              return false;
+            }
+          }
+
+          // all types match
+          return true;
+        }
+
+      template<typename InItr>
+        Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist, 
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          InItr orig(begin);
+
+          InItr matching_func(end);
+
+          while (begin != end)
+          {
+            if (types_match_except_for_arithmetic(*begin, plist, t_conversions))
+            {
+              if (matching_func == end)
+              {
+                matching_func = begin;
+              } else {
+                // More than one function matches, not attempting
+                throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+              }
+            }
+
+            ++begin;
+          }
+
+          if (matching_func == end)
+          {
+            // no appropriate function to attempt arithmetic type conversion on
+            throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+          }
+
+
+          std::vector<Boxed_Value> newplist;
+          const std::vector<Type_Info> &tis = (*matching_func)->get_param_types();
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (tis[i+1].is_arithmetic()
+                && plist[i].get_type_info().is_arithmetic()) {
+              newplist.push_back(Boxed_Number(plist[i]).get_as(tis[i+1]).bv);
+            } else {
+              newplist.push_back(plist[i]);
+            }
+          }
+
+          try {
+            return (*(*matching_func))(newplist, t_conversions);
+          } catch (const exception::bad_boxed_cast &) {
+            //parameter failed to cast
+          } catch (const exception::arity_error &) {
+            //invalid num params
+          } catch (const exception::guard_error &) {
+            //guard failed to allow the function to execute
+          }
+
+          throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+
+        }
+    }
 
     /**
      * Take a vector of functions and a vector of parameters. Attempt to execute
@@ -610,15 +713,16 @@ namespace chaiscript
      * function is found or throw dispatch_error if no matching function is found
      */
     template<typename InItr>
-      Boxed_Value dispatch(InItr begin, InItr end,
+      Boxed_Value dispatch(InItr begin, const InItr &end,
-          const std::vector<Boxed_Value> &plist)
+          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
       {
+        InItr orig(begin);
         while (begin != end)
         {
           try {
-            if ((*begin)->filter(plist))
+            if ((*begin)->filter(plist, t_conversions))
             {
-              return (*(*begin))(plist);
+              return (*(*begin))(plist, t_conversions);
             }
           } catch (const exception::bad_boxed_cast &) {
             //parameter failed to cast, try again
@@ -631,7 +735,7 @@ namespace chaiscript
           ++begin;
         }
 
-        throw exception::dispatch_error(plist.empty()?false:plist[0].is_const());
+        return detail::dispatch_with_conversions(orig, end, plist, t_conversions);
       }
 
     /**
@@ -641,9 +745,9 @@ namespace chaiscript
      */
     template<typename Funcs>
       Boxed_Value dispatch(const Funcs &funcs,
-          const std::vector<Boxed_Value> &plist)
+          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
       {
-        return dispatch::dispatch(funcs.begin(), funcs.end(), plist);
+        return dispatch::dispatch(funcs.begin(), funcs.end(), plist, t_conversions);
       }
   }
 }

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -1,31 +1,31 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// 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])
-#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n]);
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
-#include "boxed_value.hpp"
+#include <algorithm>
-#include "boxed_cast.hpp"
+#include <functional>
-#include "type_info.hpp"
-#include "handle_return.hpp"
-#include <string>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
-
 #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
@@ -42,90 +42,151 @@ 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) >
+      template<typename Ret, typename ... Params>
-        std::vector<Type_Info> build_param_type_list(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
+        std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
         {
-          std::vector<Type_Info> ti;
+          /// \todo this code was previously using { chaiscript::detail::Get_Type_Info<Ret>::get()... }
-          ti.push_back(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;
-          BOOST_PP_REPEAT(n, gettypeinfo, ~) 
+          params.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
-
+          Build_Param_Type_List<Params...>::build(params);
-          return ti;
+          return params;
         }
 
+
+      // Forward declaration
+      template<typename ... Rest> 
+        struct Try_Cast; 
+
+      template<typename Param, typename ... Rest>
+        struct Try_Cast<Param, Rest...>
+        {
+          static void do_try(const std::vector<Boxed_Value> &params, int generation, const Dynamic_Cast_Conversions &t_conversions)
+          {
+            boxed_cast<Param>(params[generation], &t_conversions);
+            Try_Cast<Rest...>::do_try(params, generation+1, t_conversions);
+          }
+        };
+
+      // 0th case
+      template<>
+        struct Try_Cast<>
+        {
+          static void do_try(const std::vector<Boxed_Value> &, int, const Dynamic_Cast_Conversions &)
+          {
+          }
+        };
+
+
+      /**
+       * Used by Proxy_Function_Impl to determine if it is equivalent to another
+       * Proxy_Function_Impl object. This function is primarly used to prevent
+       * registration of two functions with the exact same signatures
+       */
+      template<typename Ret, typename ... Params>
+        bool compare_types_cast(Ret (*)(Params...),
+             const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+       {
+          try {
+            Try_Cast<Params...>::do_try(params, 0, t_conversions);
+          } catch (const exception::bad_boxed_cast &) {
+            return false;
+          }
+
+          return true;
+        }
+
+      template<typename Ret, int count, typename ... Params>
+        struct Call_Func
+        {
+
+          template<typename ... InnerParams>
+          static Ret do_call(const std::function<Ret (Params...)> &f,
+              const std::vector<Boxed_Value> &params, const 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 BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+      template<typename Ret, typename ... Params>
-        Ret call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
+        Ret call_func(const std::function<Ret (Params...)> &f,
-            const std::vector<Boxed_Value> &params)
+            const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
         {
-          if (params.size() != n)
+          if (params.size() == sizeof...(Params))
           {
-            throw exception::arity_error(static_cast<int>(params.size()), n);
+            return Call_Func<Ret, sizeof...(Params), Params...>::do_call(f, params, t_conversions);
-          } else {
-            return f(BOOST_PP_REPEAT(n, casthelper, ~));
-          }
-        }
-
-      /**
-       * Used by Proxy_Function_Impl to determine if it is equivalent to another
-       * Proxy_Function_Impl object. This function is primarly used to prevent
-       * registration of two functions with the exact same signatures
-       */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-        bool compare_types_cast(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)),
-            const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, ))
-        {
-          try {
-            BOOST_PP_REPEAT(n, trycast, ~);
-          } catch (const exception::bad_boxed_cast &) {
-            return false;
           }
 
-          return true;
+          throw exception::arity_error(static_cast<int>(params.size()), sizeof...(Params));
         }
+
     }
   }
+
 }
 
-#undef n
-
-#endif
-
-
-#ifndef BOOST_PP_IS_ITERATING
 
 namespace chaiscript
 {
@@ -137,9 +198,9 @@ namespace chaiscript
       struct Do_Call
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          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));
+            return Handle_Return<Ret>::handle(call_func(fun, params, t_conversions));
           }
       };
 
@@ -147,9 +208,9 @@ namespace chaiscript
       struct Do_Call<void>
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          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);
+            call_func(fun, params, t_conversions);
             return Handle_Return<void>::handle();
           }
       };

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,20 +1,18 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #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 "dispatchkit.hpp"
-#include <boost/bind.hpp>
+#include "proxy_functions.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>
 
 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<
+                  new Proxy_Function_Impl<typename FunctionSignature<decltype(to_function(t)) >::Signature>(to_function(t)));
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(t)));
             }      
         };
 
       template<>
-        struct Fun_Helper<false, true>
+        struct Fun_Helper<true>
-        {
-          template<typename T>
-            static Proxy_Function go(T t)
-            {
-              return Proxy_Function(
-                  new Proxy_Function_Impl<
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(boost::mem_fn(t))));
-            }      
-        };
-
-
-      template<>
-        struct Fun_Helper<true, false>
         {
           template<typename T, typename Class>
             static Proxy_Function go(T Class::* m)
@@ -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

@@ -1,23 +1,17 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #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/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/ref.hpp>
 
 namespace chaiscript
 {
@@ -27,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;
       };
   }
 
@@ -35,39 +29,42 @@ 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, 
-          const std::type_info *t_ti, const std::type_info *t_bareti)
+          bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
-        : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
+        : m_type_info(t_ti), m_bare_type_info(t_bareti),
-        m_is_void(t_is_void),
+        m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
-        m_type_info(t_ti), m_bare_type_info(t_bareti),
+        m_is_void(t_is_void), m_is_arithmetic(t_is_arithmetic),
         m_is_undef(false)
       {
       }
 
       Type_Info()
-        : m_is_const(false), m_is_reference(false), m_is_pointer(false),
+        : m_type_info(nullptr), m_bare_type_info(nullptr),
-        m_is_void(false), m_type_info(0), m_bare_type_info(0),
+        m_is_const(false), m_is_reference(false), m_is_pointer(false),
+        m_is_void(false), m_is_arithmetic(false), 
         m_is_undef(true)
       {
       }
 
       Type_Info(const Type_Info &ti)
-        : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
+        : m_type_info(ti.m_type_info), 
-        m_is_pointer(ti.m_is_pointer),
-        m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
         m_bare_type_info(ti.m_bare_type_info),
+        m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
+        m_is_pointer(ti.m_is_pointer),
+        m_is_void(ti.m_is_void), m_is_arithmetic(ti.m_is_arithmetic),
         m_is_undef(ti.m_is_undef)
       {
       }
 
       Type_Info &operator=(const Type_Info &ti)
       {
+        m_type_info = ti.m_type_info;
+        m_bare_type_info = ti.m_bare_type_info;
         m_is_const = ti.m_is_const;
         m_is_reference = ti.m_is_reference;
         m_is_pointer = ti.m_is_pointer;
         m_is_void = ti.m_is_void;
-        m_type_info = ti.m_type_info;
+        m_is_arithmetic = ti.m_is_arithmetic;
-        m_bare_type_info = ti.m_bare_type_info;
         m_is_undef = ti.m_is_undef;
         return *this;
       }
@@ -85,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
@@ -94,10 +91,17 @@ namespace chaiscript
           || (ti.m_bare_type_info && m_bare_type_info && *ti.m_bare_type_info == *m_bare_type_info);
       }
 
+      bool bare_equal_type_info(const std::type_info &ti) const
+      {
+        return m_bare_type_info != nullptr 
+          && (*m_bare_type_info) == ti;
+      }
+
       bool is_const() const { return m_is_const; }
       bool is_reference() const { return m_is_reference; }
       bool is_void() const { return m_is_void; }
-      bool is_undef() const { return m_is_undef || m_bare_type_info == 0; }
+      bool is_arithmetic() const { return m_is_arithmetic; }
+      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
@@ -121,12 +125,13 @@ namespace chaiscript
       }
 
     private:
+      const std::type_info *m_type_info;
+      const std::type_info *m_bare_type_info;
       bool m_is_const;
       bool m_is_reference;
       bool m_is_pointer;
       bool m_is_void;
-      const std::type_info *m_type_info;
+      bool m_is_arithmetic;
-      const std::type_info *m_bare_type_info;
       bool m_is_undef;
   };
 
@@ -140,67 +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, 
+          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, 
-              boost::is_void<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, 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              boost::is_void<T>::value,
+              std::is_void<T>::value,
-              &typeid(boost::shared_ptr<T> ), 
+              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, 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              boost::is_void<T>::value,
+              std::is_void<T>::value,
-              &typeid(const boost::shared_ptr<T> &), 
+              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, 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              boost::is_void<T>::value,
+              std::is_void<T>::value,
-              &typeid(boost::reference_wrapper<T> ), 
+              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, 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
-              boost::is_void<T>::value,
+              std::is_void<T>::value,
-              &typeid(const boost::reference_wrapper<T> &), 
+              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));
         }
       };
@@ -222,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();
   }
@@ -237,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

@@ -0,0 +1,132 @@
+// 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_ALGEBRAIC_HPP_
+#define CHAISCRIPT_ALGEBRAIC_HPP_
+
+#include <string>
+
+#include "../dispatchkit/dispatchkit.hpp"
+
+namespace chaiscript
+{
+
+  struct Operators {
+    enum Opers
+    {
+      boolean_flag,
+      equals, less_than, greater_than, less_than_equal, greater_than_equal, not_equal, 
+      non_const_flag, 
+      assign, pre_increment, pre_decrement, assign_product, assign_sum,
+      assign_quotient, assign_difference,
+      non_const_int_flag,
+      assign_bitwise_and, assign_bitwise_or, assign_shift_left, assign_shift_right,
+      assign_remainder, assign_bitwise_xor,
+      const_int_flag,
+      shift_left, shift_right, remainder, bitwise_and, bitwise_or, bitwise_xor, bitwise_complement,
+      const_flag,
+      sum, quotient, product, difference, unary_plus, unary_minus, 
+      invalid
+    };
+
+    static const char *to_string(Opers t_oper) {
+      const char *opers[] = { 
+        "",
+        "==", "<", ">", "<=", ">=", "!=",
+        "",
+        "=", "++", "--", "*=", "+=",
+        "/=", "-=",
+        "",
+        "&=", "|=", "<<=", ">>=",
+        "%=", "^=",
+        "", 
+        "<<", ">>", "%", "&", "|", "^", "~",
+        "",
+        "+", "/", "*", "-", "+", "-",
+        ""
+      };
+      return opers[t_oper];
+    }
+
+    static Opers to_operator(const std::string &t_str, bool t_is_unary = false)
+    {
+      if (t_str == "==")
+      {
+        return equals;
+      } else if (t_str == "<") {
+        return less_than;
+      } else if (t_str == ">") {
+        return greater_than;
+      } else if (t_str == "<=") {
+        return less_than_equal; 
+      } else if (t_str == ">=") {
+        return greater_than_equal;
+      } else if (t_str == "!=") {
+        return not_equal;
+      } else if (t_str == "=") {
+        return assign;
+      } else if (t_str == "++") {
+        return pre_increment;
+      } else if (t_str == "--") {
+        return pre_decrement;
+      } else if (t_str == "*=") {
+        return assign_product;
+      } else if (t_str == "+=") {
+        return assign_sum;
+      } else if (t_str == "-=") {
+        return assign_difference;
+      } else if (t_str == "&=") {
+        return assign_bitwise_and;
+      } else if (t_str == "|=") {
+        return assign_bitwise_or;
+      } else if (t_str == "<<=") {
+        return assign_shift_left;
+      } else if (t_str == ">>=") {
+        return assign_shift_right;
+      } else if (t_str == "%=") {
+        return assign_remainder;
+      } else if (t_str == "^=") {
+        return assign_bitwise_xor;
+      } else if (t_str == "<<") {
+        return shift_left;
+      } else if (t_str == ">>") {
+        return shift_right;
+      } else if (t_str == "%") {
+        return remainder;
+      } else if (t_str == "&") { 
+        return bitwise_and;
+      } else if (t_str == "|") {
+        return bitwise_or;
+      } else if (t_str == "^") {
+        return bitwise_xor;
+      } else if (t_str == "~") {
+        return bitwise_complement;
+      } else if (t_str == "+") {
+        if (t_is_unary) {
+          return unary_plus;
+        } else {
+          return sum;
+        }
+      } else if (t_str == "-") {
+        if (t_is_unary) {
+          return unary_minus;
+        } else {
+          return difference;
+        }
+      } else if (t_str == "/") {
+        return quotient;
+      } else if (t_str == "*") {
+        return product;
+      } else {
+        return invalid;
+      } 
+    }
+
+  };
+}
+
+#endif /* _CHAISCRIPT_ALGEBRAIC_HPP */
+

include/chaiscript/language/chaiscript_common.hpp

@@ -1,42 +1,56 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
-#define	CHAISCRIPT_COMMON_HPP_
+#define CHAISCRIPT_COMMON_HPP_
 
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
+#include <algorithm>
-#include <boost/enable_shared_from_this.hpp>
+#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
 {
   /// Signature of module entry point that all binary loadable modules must implement.
   typedef ModulePtr (*Create_Module_Func)();
 
+
   /// Types of AST nodes available to the parser and eval
   class AST_Node_Type {
   public:
     enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
-                Comparison, Additive, Multiplicative, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
+                Comparison, Addition, Subtraction, Multiplication, Division, Modulus, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
-                Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
+                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
+                Logical_And, Logical_Or, Reference, Switch, Case, Default, Ternary_Cond, Noop, Class
     };
   };
 
   namespace
   {
-    /**
+
-     * Helper lookup to get the name of each node type
+    /// Helper lookup to get the name of each node type
-     */
     const char *ast_node_type_to_string(int ast_node_type) {
       const char *ast_node_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Inplace_Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
-                                    "Comparison", "Additive", "Multiplicative", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
+                                    "Comparison", "Addition", "Subtraction", "Multiplication", "Division", "Modulus", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
-                                    "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
+                                    "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"};
+                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
 
       return ast_node_types[ast_node_type];
     }
@@ -54,88 +68,382 @@ 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.
   namespace exception
   {
-    /**
+
-     * Errors generated during parsing or evaluation
+    /// Errors generated during parsing or evaluation
-     */
     struct eval_error : public std::runtime_error {
       std::string reason;
       File_Position start_position;
       File_Position end_position;
       std::string filename;
+      std::string detail;
       std::vector<AST_NodePtr> call_stack;
 
-      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) throw() :
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
-        std::runtime_error("Error: \"" + t_why + "\" " +
+          const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
-            (t_fname != "__EVAL__" ? ("in '" + t_fname + "' ") : "during evaluation ") +
+          bool t_dot_notation,
-            + "at (" + boost::lexical_cast<std::string>(t_where.line) + ", " +
+          const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_NOEXCEPT :
-            boost::lexical_cast<std::string>(t_where.column) + ")"),
+        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)
+        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) throw()
+      eval_error(const std::string &t_why, 
+           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+           bool t_dot_notation,
+           const chaiscript::detail::Dispatch_Engine &t_ss) 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) 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) CHAISCRIPT_NOEXCEPT
         : std::runtime_error("Error: \"" + t_why + "\" "),
         reason(t_why) 
       {}
 
-      virtual ~eval_error() throw() {}
+      std::string pretty_print() const
+      {
+        std::ostringstream ss;
+
+        ss << what();
+        if (call_stack.size() > 0) {
+          ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")" << std::endl;
+          ss << std::endl << detail << std::endl;
+          ss << "  " << fname(call_stack[0]) << " (" << startpos(call_stack[0]) << ") '" << pretty(call_stack[0]) << "'";
+          for (size_t j = 1; j < call_stack.size(); ++j) {
+            if (id(call_stack[j]) != chaiscript::AST_Node_Type::Block
+                && id(call_stack[j]) != chaiscript::AST_Node_Type::File)
+            {
+              ss << std::endl;
+              ss << "  from " << fname(call_stack[j]) << " (" << startpos(call_stack[j]) << ") '" << pretty(call_stack[j]) << "'";
+            }
+          }
+        }
+        ss << std::endl;
+        return ss.str();
+      }
+
+      virtual ~eval_error() CHAISCRIPT_NOEXCEPT {}
+
+    private:
+
+      template<typename T>
+        static int id(const T& t)
+        {
+          return t->identifier;
+        }
+
+      template<typename T>
+        static std::string pretty(const T& t)
+        {
+          return t->pretty_print();
+        }
+
+      template<typename T>
+        static std::string fname(const T& t)
+        {
+          return *t->filename;
+        }
+
+      template<typename T>
+        static std::string startpos(const T& t)
+        {
+          std::ostringstream oss;
+          oss << t->start.line << ", " << t->start.column;
+          return oss.str();
+        }
+
+      static std::string format_why(const std::string &t_why)
+      {
+        return "Error: \"" + t_why + "\"";
+      }
+
+      static std::string format_types(const Const_Proxy_Function &t_func,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        int arity = t_func->get_arity();
+        std::vector<Type_Info> types = t_func->get_param_types();
+
+        std::string retval;
+        if (arity == -1)
+        {
+          retval = "(...)";
+          if (t_dot_notation)
+          {
+            retval = "(Object)." + retval;
+          }
+        } else if (types.size() <= 1) {
+          retval = "()";
+        } else {
+          std::stringstream ss;
+          ss << "(";
+
+          std::string paramstr;
+
+          for (size_t index = 1;
+               index != types.size();
+               ++index)
+          {
+            paramstr += (types[index].is_const()?"const ":"");
+            paramstr += t_ss.get_type_name(types[index]);
+
+            if (index == 1 && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (types.size() == 2)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+
+          ss << ")";
+          retval = ss.str();
+        }
+
+
+        std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfun 
+          = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_func);
+
+        if (dynfun)
+        {
+          Proxy_Function f = dynfun->get_guard();
+
+          if (f)
+          {
+            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());
+            }
+          }
+
+          retval += "\n          Defined at " + format_location(dynfun->get_parse_tree());        
+        }
+
+        return retval;
+      }
+
+      template<typename T>
+        static std::string format_guard(const T &t)
+        {
+          return t->pretty_print();
+        }
+
+      template<typename T>
+        static std::string format_location(const T &t)
+        {
+          std::ostringstream oss;
+          oss << "(" << *t->filename << " " << t->start.line << ", " << t->start.column << ")"; 
+
+          return oss.str();
+
+        }
+
+      static std::string format_detail(const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        if (t_functions.size() == 1)
+        {
+          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << std::endl;
+        } else {
+          ss << "  " << t_functions.size() << " overloads available:" << std::endl;
+
+          for (const auto & t_function : t_functions)
+          {
+            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << std::endl;
+          }
+
+        }
+
+        return ss.str();
+
+      }
+
+      static std::string format_parameters(const std::vector<Boxed_Value> &t_parameters,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        ss << "(";
+
+        if (!t_parameters.empty())
+        {
+          std::string paramstr;
+
+          for (auto itr = t_parameters.begin();
+               itr != t_parameters.end();
+               ++itr)
+          {
+            paramstr += (itr->is_const()?"const ":"");
+            paramstr += t_ss.type_name(*itr);
+
+            if (itr == t_parameters.begin() && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (t_parameters.size() == 1)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+        }
+        ss << ")";
+
+        return ss.str();
+      }
+
+      static std::string format_filename(const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        if (t_fname != "__EVAL__")
+        {
+          ss << "in '" << t_fname << "' ";
+        } else {
+          ss << "during evaluation ";
+        }
+
+        return ss.str();
+      }
+
+      static std::string format_location(const File_Position &t_where)
+      {
+        std::stringstream ss;
+        ss << "at (" << t_where.line << ", " << t_where.column << ")";
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
+          const std::vector<Boxed_Value> &t_parameters, bool t_dot_notation, const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, 
+          const std::vector<Boxed_Value> &t_parameters, 
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
     };
 
-    /**
+
-     * Errors generated when loading a file
+    /// 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;
+      const int identifier; //< \todo shouldn't this be a strongly typed enum value?
-      boost::shared_ptr<const std::string> filename;
+      std::shared_ptr<const std::string> filename;
       File_Position start, end;
       std::vector<AST_NodePtr> children;
       AST_NodePtr annotation;
 
-      /**
+      virtual std::string pretty_print() const
-       * Prints the contents of an AST node, including its children, recursively
+      {
-       */
+        std::ostringstream oss;
-      std::string to_string(std::string t_prepend = "") {
+
+        oss << text;
+
+        for (auto & elem : this->children) {
+          oss << elem->pretty_print();
+        }
+
+        return oss.str();
+      }
+
+
+      /// Prints the contents of an AST node, including its children, recursively
+      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();
       }
 
-      std::string internal_to_string() {
-        return to_string();
-      }
-
       Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) 
       {
         try {
           return eval_internal(t_e);
         } catch (exception::eval_error &ee) {
           ee.call_stack.push_back(shared_from_this());
-          throw ee;
+          throw;
         }
       }
 
@@ -146,15 +454,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) :
+      AST_Node(std::string t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname) :
-        text(t_ast_node_text), identifier(t_id), filename(t_fname) {}
+        text(std::move(t_ast_node_text)), identifier(t_id), filename(t_fname) {}
 
       virtual ~AST_Node() {}
 
@@ -174,25 +482,33 @@ namespace chaiscript
   {
     namespace detail
     {
-      /**
+
-       * Special type for returned values
+      /// Special type for returned values
-       */
       struct Return_Value {
         Boxed_Value retval;
 
         Return_Value(const Boxed_Value &t_return_value) : retval(t_return_value) { }
       };
 
-      /**
+
-       * Special type indicating a call to 'break'
+      /// Special type indicating a call to 'break'
-       */
       struct Break_Loop {
         Break_Loop() { }
       };
 
+
+      /// Special type indicating a call to 'continue'
+      struct Continue_Loop {
+        Continue_Loop() { }
+      };
+
+
       /// Creates a new scope then pops it on destruction
       struct Scope_Push_Pop
       {
+        Scope_Push_Pop(const Scope_Push_Pop &) = delete;
+        Scope_Push_Pop& operator=(const Scope_Push_Pop &) = delete;
+
         Scope_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
           : m_de(t_de)
         {
@@ -206,9 +522,57 @@ namespace chaiscript
 
 
         private:
-        // explicitly unimplemented copy and assignment
+
-        Scope_Push_Pop(const Scope_Push_Pop &);
+        chaiscript::detail::Dispatch_Engine &m_de;
-        Scope_Push_Pop& operator=(const Scope_Push_Pop &);
+      };
+
+      /// Creates a new function call and pops it on destruction
+      struct Function_Push_Pop
+      {
+        Function_Push_Pop(const Function_Push_Pop &) = delete;
+        Function_Push_Pop& operator=(const Function_Push_Pop &) = delete;
+
+        Function_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_function_call();
+        }
+
+        ~Function_Push_Pop()
+        {
+          m_de.pop_function_call();
+        }
+
+        void save_params(const std::vector<Boxed_Value> &t_params)
+        {
+          m_de.save_function_params(t_params);
+        }
+
+
+        private:
+
+        chaiscript::detail::Dispatch_Engine &m_de;
+      };
+
+      /// Creates a new scope then pops it on destruction
+      struct Stack_Push_Pop
+      {
+        Stack_Push_Pop(const Stack_Push_Pop &) = delete;
+        Stack_Push_Pop& operator=(const Stack_Push_Pop &) = delete;
+
+        Stack_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_stack();
+        }
+
+        ~Stack_Push_Pop()
+        {
+          m_de.pop_stack();
+        }
+
+
+        private:
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
@@ -216,5 +580,5 @@ namespace chaiscript
   }
 }
 
-#endif	/* _CHAISCRIPT_COMMON_HPP */
+#endif /* _CHAISCRIPT_COMMON_HPP */
 

include/chaiscript/language/chaiscript_engine.hpp

@@ -1,21 +1,43 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #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/language/chaiscript_common.hpp>
+#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,8 +45,9 @@
 #endif
 
 
-#include <chaiscript/language/chaiscript_prelude.hpp>
+#include "../dispatchkit/exception_specification.hpp"
-#include <chaiscript/language/chaiscript_parser.hpp>
+#include "chaiscript_parser.hpp"
+#include "chaiscript_prelude.chai"
 
 namespace chaiscript
 {
@@ -33,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
       {
       }
     };
@@ -46,7 +69,7 @@ namespace chaiscript
 
   namespace detail
   {
-#ifdef _POSIX_VERSION
+#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
     struct Loadable_Module
     {
       struct DLModule
@@ -56,7 +79,7 @@ namespace chaiscript
         {
           if (!m_data)
           {
-            throw exception::load_module_error(dlerror());
+            throw chaiscript::exception::load_module_error(dlerror());
           }
         }
 
@@ -75,14 +98,27 @@ namespace chaiscript
         struct DLSym
         {
           DLSym(DLModule &t_mod, const std::string &t_symbol)
-            : m_symbol(reinterpret_cast<T>(dlsym(t_mod.m_data, t_symbol.c_str())))
+            : m_symbol(cast_symbol(dlsym(t_mod.m_data, t_symbol.c_str())))
           {
             if (!m_symbol)
             {
-              throw exception::load_module_error(dlerror());
+              throw chaiscript::exception::load_module_error(dlerror());
             }
           }
 
+          static T cast_symbol(void *p)
+          {
+            union cast_union
+            {
+              T func_ptr;
+              void *in_ptr;
+            };
+
+            cast_union c;
+            c.in_ptr = p;
+            return c.func_ptr;
+          }
+
           T m_symbol;
         };
 
@@ -104,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;
@@ -138,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,
@@ -148,25 +184,23 @@ namespace chaiscript
             t_err,
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
             (StringType)&lpMsgBuf,
-            0, NULL );        
+            0, NULL ) != 0 && lpMsgBuf)
-
-        if (lpMsgBuf)
         {
           retval = lpMsgBuf;
+          LocalFree(lpMsgBuf);
         }
 
-        LocalFree(lpMsgBuf);
+        return to_string(retval);
-        return tostring(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()));
           }
         }
 
@@ -186,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()));
             }
           }
 
@@ -209,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;
@@ -217,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;
   }
 
 
@@ -236,10 +270,7 @@ namespace chaiscript
 
     chaiscript::detail::Dispatch_Engine m_engine;
 
-
+    /// Evaluates the given string in by parsing it and running the results through the evaluator
-    /**
-     * Evaluates the given string in by parsing it and running the results through the evaluator
-     */
     Boxed_Value do_eval(const std::string &t_input, const std::string &t_filename = "__EVAL__", bool /* t_internal*/  = false) 
     {
       try {
@@ -260,57 +291,31 @@ namespace chaiscript
 
     const Boxed_Value internal_eval_ast(const AST_NodePtr &t_ast)
     {
-      return t_ast->eval(m_engine);
+      try {
-    }
+        return t_ast->eval(m_engine);
-
+      } catch (const exception::eval_error &t_ee) {
-
+        throw Boxed_Value(t_ee);
-    /**
-     * Evaluates the given string, used during eval() inside of a script
-     */
-    const Boxed_Value internal_eval(const std::string &t_e) {
-      return do_eval(t_e, "__EVAL__", true);
-    }
-
-    void use(const std::string &t_filename)
-    {
-      for (size_t i = 0; i < m_usepaths.size(); ++i)
-      {
-
-        try {
-          const std::string appendedpath = m_usepaths[i] + t_filename;
-
-          chaiscript::detail::threading::lock_guard<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
-
-          if (m_used_files.count(appendedpath) == 0)
-          {
-            m_used_files.insert(appendedpath);
-            l2.unlock();
-            eval_file(appendedpath);
-          }
-        } catch (const exception::file_not_found_error &) {
-          if (i == m_usepaths.size() - 1)
-          {
-            throw exception::file_not_found_error(t_filename);
-          }
-
-          // failed to load, try the next path
-        }
       }
     }
 
-    /**
+
-     * Returns the current evaluation m_engine
+
-     */
+    /// Evaluates the given string, used during eval() inside of a script
+    const Boxed_Value internal_eval(const std::string &t_e) {
+      try {
+        return do_eval(t_e, "__EVAL__", true);
+      } catch (const exception::eval_error &t_ee) {
+        throw Boxed_Value(t_ee);
+      }
+    }
+
+    /// 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.
-     * Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
+    void build_eval_system(const ModulePtr &t_lib) {
-     */
-    void build_eval_system() {
-      using namespace bootstrap;
       m_engine.add_reserved_word("def");
       m_engine.add_reserved_word("fun");
       m_engine.add_reserved_word("while");
@@ -320,51 +325,61 @@ 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("auto");
-      m_engine.add_reserved_word("var");
       m_engine.add_reserved_word("return");
       m_engine.add_reserved_word("break");
       m_engine.add_reserved_word("true");
       m_engine.add_reserved_word("false");
+      m_engine.add_reserved_word("class");
       m_engine.add_reserved_word("_");
 
-      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_system, std::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::dump_object, std::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::is_type, std::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::type_name, std::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::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> &)>(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, boost::ref(m_engine)), "name");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::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
+    /// Helper function for loading a file
-     */
+    static std::string load_file(const std::string &t_filename) {
-    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 +399,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>(),
+    ChaiScript(const ModulePtr &t_lib,
-                      const std::vector<std::string> &t_usepaths = std::vector<std::string>())
+               std::vector<std::string> t_modulepaths = std::vector<std::string>(),
-      : m_modulepaths(t_modulepaths), m_usepaths(t_usepaths) 
+                      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,13 +417,144 @@ 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();
+    }
+
+    std::string get_type_name(const Type_Info &ti) const
+    {
+      return m_engine.get_type_name(ti);
+    }
+
+    template<typename T>
+    std::string get_type_name() const
+    {
+      return get_type_name(user_type<T>());
+    }
+
+
+    /// \brief Loads and parses a file. If the file is already, it is not reloaded
+    /// The use paths specified at ChaiScript construction time are searched for the 
+    /// requested file.
+    ///
+    /// \param[in] t_filename Filename to load and evaluate
+    void use(const std::string &t_filename)
+    {
+      for (size_t i = 0; i < m_usepaths.size(); ++i)
+      {
+        try {
+          const std::string appendedpath = m_usepaths[i] + t_filename;
+
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
+
+          if (m_used_files.count(appendedpath) == 0)
+          {
+            l2.unlock();
+            eval_file(appendedpath);
+            l2.lock();
+            m_used_files.insert(appendedpath);
+           }
+
+          return; // return, we loaded it, or it was already loaded
+        } catch (const exception::file_not_found_error &) {
+           if (i == m_usepaths.size() - 1)
+          {
+            throw exception::file_not_found_error(t_filename);
+          }
+
+          // failed to load, try the next path
+        }
+      }
     }
 
     /// \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)
     {
@@ -414,6 +562,17 @@ namespace chaiscript
       return *this;
     }
 
+    /// \brief Adds a mutable 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
+    /// \warning The user is responsible for making sure the object is thread-safe if necessary
+    ///          ChaiScript is thread-safe but provides no threading locking mechanism to the script
+    ChaiScript &add_global(const Boxed_Value &t_bv, const std::string &t_name)
+    {
+      m_engine.add_global(t_bv, t_name);
+      return *this;
+    }
+
     /// \brief Represents the current state of the ChaiScript system. State and be saved and restored
     /// \sa ChaiScript::get_state
     /// \sa ChaiScript::set_state
@@ -424,8 +583,12 @@ namespace chaiscript
       std::set<std::string> active_loaded_modules;
     };
 
-    /// \brief Returns a state object that represents the current state of the system
+    /// \brief Returns a state object that represents the current state of the global system
-    /// \return Current state of the system
+    ///
+    /// The global system includes the reserved words, global const objects, functions and types.
+    /// local variables are thread specific and not included.
+    ///
+    /// \return Current state of the global system
     ///
     /// \b Example:
     ///
@@ -446,6 +609,10 @@ namespace chaiscript
     }
 
     /// \brief Sets the state of the system
+    ///
+    /// The global system includes the reserved words, global objects, functions and types.
+    /// local variables are thread specific and not included.
+    ///
     /// \param[in] t_state New state to set
     ///
     /// \b Example:
@@ -465,7 +632,23 @@ namespace chaiscript
       m_engine.set_state(t_state.engine_state);
     }
 
-    /// \brief Adds a type, function or object to ChaiScript
+    /// \returns All values in the local thread state, added through the add() function
+    std::map<std::string, Boxed_Value> get_locals() const
+    {
+      return m_engine.get_locals();
+    }
+
+    /// \brief Sets all of the locals for the current thread state.
+    ///
+    /// \param[in] t_locals The map<name, value> set of variables to replace the current state with
+    ///
+    /// Any existing locals are removed and the given set of variables is added
+    void set_locals(const std::map<std::string, Boxed_Value> &t_locals)
+    {
+      m_engine.set_locals(t_locals);
+    }
+
+    /// \brief Adds a type, function or object to ChaiScript. Objects are added to the local thread state.
     /// \param[in] t_t Item to add
     /// \param[in] t_name Name of item to add
     /// \returns Reference to current ChaiScript object
@@ -479,7 +662,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)
     {
@@ -522,13 +705,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.
+    /// \throw chaiscript::exception::load_module_error In the event that no matching module can be found.
-    void load_module(const std::string &t_module_name)
+    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;
@@ -536,23 +726,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 (auto & postfix : postfixes)
-            {
+          {
-              for (size_t k = 0; k < postfixes.size(); ++k)
+            try {
-                {
+              std::string name = elem + prefix + t_module_name + postfix;
-                  try {
+              // std::cerr << "trying location: " << name << std::endl;
-                    std::string name = m_modulepaths[i] + prefixes[j] + t_module_name + postfixes[k];
+              load_module(version_stripped_name, name);
-                    load_module(t_module_name, name);
+              return name;
-                    return;
+            } catch (const chaiscript::exception::load_module_error &e) {
-                  } catch (const exception::load_module_error &e) {
+              // std::cerr << "error: " << e.what() << std::endl;
-                    errors.push_back(e);
+              errors.push_back(e);
-                    // Try next set
+              // Try next set
-                  }
-                }
             }
+          }
         }
+      }
 
       std::string errstring;
 
@@ -568,7 +760,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
@@ -598,61 +790,113 @@ namespace chaiscript
     /// \brief Evaluates a string. Equivalent to ChaiScript::eval.
     ///
     /// \param[in] t_script Script to execute
+    /// \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 operator()(const std::string &t_script)
+    Boxed_Value operator()(const std::string &t_script, const Exception_Handler &t_handler = Exception_Handler())
     {
-      return do_eval(t_script);
+      try {
+        return do_eval(t_script);
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
     /// \brief Evaluates a string and returns a typesafe result.
     ///
     /// \tparam T Type to extract from the result value of the script execution
     /// \param[in] t_input Script to execute
+    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
+    /// \param[in] t_filename Optional filename to report to the user for where the error occured. Useful
+    ///                       in special cases where you are loading a file internally instead of using eval_file
     ///
     /// \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.
-    /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
+    /// \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)
+    T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
     {
-      return boxed_cast<T>(do_eval(t_input));
+      try {
+        return m_engine.boxed_cast<T>(do_eval(t_input, t_filename));
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
+    /// \brief casts an object while applying any Dynamic_Conversion available
+    template<typename Type>
+      typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv) const
+      {
+        return m_engine.boxed_cast<Type>(bv);
+      }
+ 
+
     /// \brief Evaluates a string.
     ///
     /// \param[in] t_input Script to execute
+    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
+    /// \param[in] t_filename Optional filename to report to the user for where the error occured. Useful
+    ///                       in special cases where you are loading a file internally instead of using eval_file
     ///
     /// \return result of the script execution
     /// 
     /// \throw exception::eval_error In the case that evaluation fails.
-    Boxed_Value eval(const std::string &t_input)
+    Boxed_Value eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
     {
-      return do_eval(t_input);
+      try {
+        return do_eval(t_input, t_filename);
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
     /// \brief Loads the file specified by filename, evaluates it, and returns the result.
     /// \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) {
+    Boxed_Value eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
-      return do_eval(load_file(t_filename), t_filename);
+      try {
+        return do_eval(load_file(t_filename), t_filename);
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
     /// \brief Loads the file specified by filename, evaluates it, and returns the typesafe result.
     /// \tparam T Type to extract from the result value of the script execution
     /// \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.
-    /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
+    /// \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) {
+    T eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
-      return boxed_cast<T>(do_eval(load_file(t_filename), t_filename));
+      try {
+        return m_engine.boxed_cast<T>(do_eval(load_file(t_filename), t_filename));
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
   };
 

include/chaiscript/language/chaiscript_prelude.chai

@@ -0,0 +1,532 @@
+// 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).copy_var_attrs(x);
+}
+
+
+# to_string for Pair()
+def to_string(x) : call_exists(first, x) && call_exists(second, x) { 
+  "<" + x.first.to_string() + ", " + x.second.to_string() + ">"; 
+}
+
+# to_string for containers
+def to_string(x) : call_exists(range, x) && !x.is_type("string"){ 
+  "[" + x.join(", ") + "]"; 
+}
+
+# Prints to console with no carriage return
+def puts(x) { 
+  print_string(x.to_string()); 
+}
+
+# Prints to console with carriage return
+def print(x) { 
+  println_string(x.to_string()); 
+}
+
+# Returns the maximum value of two numbers
+def max(a, b) {
+  if (a>b) { 
+    a 
+  } else { 
+    b 
+  } 
+} 
+
+# Returns the minimum value of two numbers
+def min(a, b) 
+{ 
+  if (a<b) 
+  { 
+    a 
+  } else { 
+    b 
+  } 
+}
+
+
+# Returns true if the value is odd
+def odd(x)  { 
+  if (x % 2 == 1) 
+  { 
+    true 
+  } else { 
+    false 
+  } 
+}
+
+
+# Returns true if the value is even
+def even(x) 
+{ 
+  if (x % 2 == 0) 
+  { 
+    true 
+  } else { 
+    false 
+  } 
+} 
+
+
+# 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) 
+{
+  clone(r);
+}
+
+def range(r) : call_exists(range_internal, r)
+{
+  var ri := range_internal(r);
+  ri.get_var_attr("internal_obj") := r;
+  ri;
+}
+
+# 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(); 
+  } 
+  false; 
+} 
+
+def contains(container, item) { 
+  contains(container, item, eq) 
+} 
+
+def map(container, func, inserter) : call_exists(range, container) { 
+  auto range := range(container); 
+  while (!range.empty()) { 
+    inserter(func(range.front())); 
+    range.pop_front(); 
+  } 
+} 
+
+# Performs the second value function over the container first value. Creates a new container with the results
+def map(container, func) { 
+  auto retval := new(container); 
+  map(container, func, back_inserter(retval));
+  retval;
+}
+
+# Performs the second value function over the container first value. Starts with initial and continues with each element.
+def foldl(container, func, initial) : call_exists(range, container){ 
+  auto retval = initial; 
+  auto range := range(container); 
+  while (!range.empty()) { 
+    retval = (func(range.front(), retval)); 
+    range.pop_front(); 
+  } 
+  retval; 
+}
+
+# Returns the sum of the elements of the given value
+def sum(container) { 
+  foldl(container, `+`, 0.0) 
+} 
+
+# Returns the product of the elements of the given value
+def product(container) { 
+  foldl(container, `*`, 1.0) 
+} 
+
+# Returns a new container with the elements of the first value concatenated with the elements of the second value
+def concat(x, y) : call_exists(clone, x) { 
+  auto retval = x; 
+  auto inserter := back_inserter(retval); 
+  auto range := range(y); 
+  while (!range.empty()) { 
+    inserter(range.front()); 
+    range.pop_front(); 
+  } 
+  retval; 
+}
+
+
+def take(container, num, inserter) : call_exists(range, container) { 
+  auto r := range(container); 
+  auto i = num; 
+  while ((i > 0) && (!r.empty())) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+    --i; 
+  } 
+}
+
+
+# Returns a new container with the given number of elements taken from the container
+def take(container, num) {
+  auto retval := new(container); 
+  take(container, num, back_inserter(retval)); 
+  retval; 
+}
+
+
+def take_while(container, f, inserter) : call_exists(range, container) { 
+  auto r := range(container); 
+  while ((!r.empty()) && f(r.front())) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+  } 
+} 
+
+
+# Returns a new container with the given elements match the second value function
+def take_while(container, f) {
+  auto retval := new(container); 
+  take_while(container, f, back_inserter(retval)); 
+  retval;
+}
+
+
+def drop(container, num, inserter) : call_exists(range, container) { 
+  auto r := range(container); 
+  auto i = num; 
+  while ((i > 0) && (!r.empty())) { 
+    r.pop_front(); 
+    --i; 
+  } 
+  while (!r.empty()) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+  } 
+}
+
+
+# Returns a new container with the given number of elements dropped from the given container 
+def drop(container, num) {
+  auto retval := new(container); 
+  drop(container, num, back_inserter(retval)); 
+  retval; 
+}
+
+
+def drop_while(container, f, inserter) : call_exists(range, container) { 
+  auto r := range(container); 
+  while ((!r.empty())&& f(r.front())) { 
+    r.pop_front(); 
+  } 
+  while (!r.empty()) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+  } 
+}
+
+
+# Returns a new container with the given elements dropped that match the second value function
+def drop_while(container, f) {
+  auto retval := new(container); 
+  drop_while(container, f, back_inserter(retval)); 
+  retval; 
+}
+
+
+# Applies the second value function to the container. Starts with the first two elements. Expects at least 2 elements.
+def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { 
+  auto r := range(container); 
+  auto retval = r.front(); 
+  r.pop_front(); 
+  retval = func(retval, r.front()); 
+  r.pop_front(); 
+  while (!r.empty()) { 
+    retval = func(retval, r.front()); 
+    r.pop_front(); 
+  } 
+  retval; 
+}
+
+
+# Returns a string of the elements in container delimited by the second value string
+def join(container, delim) { 
+  auto retval = ""; 
+  auto range := range(container); 
+  if (!range.empty()) { 
+    retval += to_string(range.front()); 
+    range.pop_front(); 
+    while (!range.empty()) { 
+      retval += delim; 
+      retval += to_string(range.front()); 
+      range.pop_front(); 
+    } 
+  } 
+  retval; 
+}
+
+
+def filter(container, f, inserter) : call_exists(range, container) { 
+  auto r := range(container); 
+  while (!r.empty()) { 
+    if (f(r.front())) { 
+      inserter(r.front()); 
+    } 
+    r.pop_front(); 
+  } 
+} 
+
+
+# Returns a new Vector which match the second value function
+def filter(container, f) { 
+  auto retval := new(container); 
+  filter(container, f, back_inserter(retval));
+  retval;
+}
+
+
+def generate_range(x, y, inserter) { 
+  auto i = x; 
+  while (i <= y) { 
+    inserter(i); 
+    ++i; 
+  } 
+}
+
+
+# Returns a new Vector which represents the range from the first value to the second value
+def generate_range(x, y) { 
+  auto retval := Vector(); 
+  generate_range(x,y,back_inserter(retval)); 
+  retval; 
+}
+
+
+# Returns a new Vector with the first value to the second value as its elements
+def collate(x, y) { 
+  return [x, y]; 
+}
+
+
+def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { 
+  auto r_x := range(x); 
+  auto r_y := range(y); 
+  while (!r_x.empty() && !r_y.empty()) { 
+    inserter(f(r_x.front(), r_y.front())); 
+    r_x.pop_front(); 
+    r_y.pop_front(); 
+  } 
+}
+
+
+# Returns a new Vector which joins matching elements of the second and third value with the first value function
+def zip_with(f, x, y) { 
+  auto retval := Vector(); 
+  zip_with(f,x,y,back_inserter(retval)); 
+  retval;
+}
+
+
+# Returns a new Vector which joins matching elements of the first and second
+def zip(x, y) { 
+  zip_with(collate, x, y); 
+}
+
+
+# Returns the position of the second value string in the first value string
+def string::find(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(); 
+    } 
+  } 
+  range; 
+} 
+
+
+def find(container, value) { 
+  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-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and 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

@@ -1,87 +1,48 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_UTILITY_UTILITY_HPP_
 #define CHAISCRIPT_UTILITY_UTILITY_HPP_
 
-#include "../chaiscript.hpp"
-#include <boost/preprocessor.hpp>
 #include <string>
+#include <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(_module, _class_name, _constructors, _methods) \
-  CHAISCRIPT_CLASS_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
-      chaiscript::utility::method_name_translator, _constructors, _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)
+
-    {
+    /// \todo Use of this utility, and uniform initializer lists, is causing memory errors in MSVC
-      size_t colon = t_name.rfind("::");
+    
-      if (colon != std::string::npos)
+    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);
+        t_module.add(chaiscript::user_type<Class>(), t_class_name); 
-      } else {
+
-        return t_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);
-    }
   }
 }
 

license.txt

@@ -1,4 +1,7 @@
-Copyright 2009-2010 Jason Turner and Jonathan Turner. All Rights Reserved.
+Copyright 2009-2014 Jason Turner
+Copyright 2009-2012 Jonathan Turner. 
+
+All Rights Reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:

readme.md

@@ -0,0 +1,119 @@
+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
+
+(c) 2009-2012 Jonathan Turner
+(c) 2009-2014 Jason Turner
+
+Release under the BSD license, see "license.txt" for details.
+
+
+Introduction
+============
+
+ChaiScript is one of the only embedded scripting language designed from the 
+ground up to directly target C++ and take advantage of modern C++ development 
+techniques, working with the developer like he expects it to work.  Being a 
+native C++ application, it has some advantages over existing embedded scripting 
+languages:
+
+1. It uses a header-only approach, which makes it easy to integrate with 
+   existing projects.
+2. It maintains type safety between your C++ application and the user scripts.
+3. It supports a variety of C++ techniques including callbacks, overloaded 
+   functions, class methods, and stl containers.
+
+
+Requirements
+============
+
+ChaiScript requires a 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`
+* The default behavior is to load the ChaiScript standard library from a 
+  loadable module. A second option is to compile the library into your code,
+  see below for an example.
+
+Once instantiated, the engine is ready to start running ChaiScript source.  You
+have two main options for processing ChaiScript source: a line at a time using 
+`chai.eval(string)` and a file at a time using `chai.eval_file(fname)`
+
+To make functions in your C++ code visible to scripts, they must be registered 
+with the scripting engine.  To do so, call add:
+
+    chai.add(chaiscript::fun(&my_function), "my_function_name");
+
+Once registered the function will be visible to scripts as "my_function_name"
+
+Examples
+========
+
+ChaiScript is similar to ECMAScript (aka JavaScript(tm)), but with some 
+modifications to make it easier to use.  For usage examples see the "samples" 
+directory, and for more in-depth look at the language, the unit tests in the 
+"unittests" directory cover the most ground.
+
+For examples of how to register parts of your C++ application, see 
+"example.cpp" in the "src" directory. Example.cpp is verbose and shows every 
+possible way of working with the library. For further documentation generate 
+the doxygen documentation in the build folder or see the website 
+http://www.chaiscript.com.
+
+
+The shortest complete example possible follows:
+
+    /// main.cpp
+
+    #include <chaiscript/chaiscript.hpp>
+
+    double function(int i, double j)
+    {
+      return i * j;
+    }
+
+    int main()
+    {
+      chaiscript::ChaiScript chai;
+      chai.add(chaiscript::fun(&function), "function");
+
+      double d = chai.eval<double>("function(3, 4.75);");
+    }
+
+
+
+Or, if you want to compile the std lib into your code, which reduces
+runtime requirements.
+
+    /// main.cpp
+
+    #include <chaiscript/chaiscript.hpp>
+    #include <chaiscript/chaiscript_stdlib.hpp>
+
+    double function(int i, double j)
+    {
+      return i * j;
+    }
+
+    int main()
+    {
+      chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
+      chai.add(chaiscript::fun(&function), "function");
+
+      double d = chai.eval<double>("function(3, 4.75);");
+    }
+
+

readme.txt

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

releasenotes.md

@@ -0,0 +1,117 @@
+Notes:
+=======
+Current Version: 5.4.0
+
+### Changes since 5.3.1
+* Decreased compile time and build size
+* Make "reflection" module built in (losing some of the time / build size gains)
+* Add new "class" syntax for ChaiScript defined methods and attributes see: [unittests/class.chai](unittests/class.chai) for examples
+* Minor performance enhancements
+* major to_string performance enhancements
+* Provide API for retrieving registered type name #124
+* Added strong reference to container to range object #132
+
+
+### Changes since 5.3.0
+* Add automatic conversion of arithmetic return types, following the same
+  rules as conversion of arithmetic types when passing parameters
+* Add automatic casting up the inheritence hierarchy when possible.
+* Enable travis.ci testing
+* Allow users to add globals from within script
+* Various static analysis fixes
+* Code modernization to C++11
+* Unofficial support for Haiku added
+* Fix #121 - Inability to compile on cygwin
+* Formatting fixes and spelling corrections
+* Apply "include what you use" https://code.google.com/p/include-what-you-use/
+* Apply clang-modernize
+* Various threading fixes
+* Performance improvements
+
+### Changes since 5.2.0
+* Official support for MSVC with C++11. All major platforms and compilers are now support for C++11 release
+
+### Changes since 4.2.0
+* Enhanced unit tests
+* Add `continue` statement, fix various use cases for `for`  loops
+* Fix use of suffixed numbers in vector initialization
+* Code cleanups
+* Eliminate global data, which makes code more portable and thread safe
+* Fix issue #79
+* Merge pretty_print fixes from @mgee #82
+* Compiler warning fixes for latest compiler releases
+* Fix threading problems
+* Fix linking error on MacOS Mavericks #88
+* Allow non-const globals
+* Make sure user cannot name a variable with `::` in it #91
+* Fix various string / map / vector `size` and `count` calls for compilers which have weird overloads for them. #90 #93 #95
+* Make module search path relative to the currently running executable
+* Build and work with wstring windows builds
+* fix for some new line cases in the middle of a vector initialization from jespada
+
+### Changes since 5.1.0
+* Add support for automatic conversion of arithmetic types when possible
+  and when no ambiguous method dispatch exists.
+
+### Changes since 5.0.0
+* Fix sizing of numeric constants to match that of the C++ standard
+* Add support for u,ll,l,f suffixes for numeric constants
+* Siginificant improvement in error reporting
+
+### Changes since 4.0.0
+* Dropped boost in favor of C++11
+* Separated out stdlib to make more options for compile time improvements
+
+### Changes since 3.1.0
+* svenstaro: Unused variables and CMake consistency fixes
+* Added support for returning pointers from functions (#13)
+* Compile with -pedantic (#9)
+* Fix issues with multiple ChaiScript object types having the same attribute name (#15)
+* Prevent variable redeclaration in same scope (#22)
+* mgee: Boxed_Number improvements (#27)
+* Support switch statements (#34)
+* Fix uint16 comparions (#26)
+* Add ability to add const_var globals in Module objects (#14)
+* Add support for ternary operators ?:
+* Add headers to CMakeLists so they show up in IDEs
+* Add ability to get vector of defined objects and vector of defined functions
+* Fix memory leak in cyclical references
+* Clean up static analysis issues discovered
+* Fix vector construction to be consistent with map construction
+* Increased unit tests to 161
+* Performance enhancements
+
+### Changes since 3.0.0
+* Numeric operations performance increased approximately 10x
+* Looping operations performance increased up to 2x
+* Engine start up time decreased
+* Several parsing bugs related to index operators fixed
+* Added full support for all C algebraic types: double, long double, float, int, long, char,
+  uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t
+* Enhanced support for capturing of exceptions thrown from ChaiScript in C++
+
+### Changes since 2.3.3
+* Code simplifications
+* Fully integrate documentation with source code in doxygen style comments
+* Unit tests increased from 114 to 137
+* Automatic conversion between boost::function objects and ChaiScript functions 
+* Many bug fixes
+* Minor performance improvements
+* Namespace reorganization to make end user code more accessible
+* clang support
+* VisualStudio 2010 Support
+* Support for C++ base classes and automatic upcasting 
+* Remove __ reserved identifiers
+* Better code organization to reduce #ifdefs 
+* clanmills: command line options for chai eval
+* clanmills: parser cleanups and code reduction
+* Function introspection and reflection 
+* Correct function dispatch order to account for base classes and provide a defined order of dispatch 
+* Predictable object lifetime that emulates C++ stack lifetime
+* emarcotte: pkgconfig support
+* standardize on method/member naming and indentation
+* 64bit Visual Studio support
+* Better support for const objects
+* Drastic reduction of runtime exceptions - making debug builds orders of magnitude faster
+* Support for platforms with no loadable module support
+* Add helper macro for registering class 

releasenotes.txt

@@ -1,26 +0,0 @@
-Changes since 2.3.3
-
-* Code simplifications
-* Fully integrate documentation with source code in doxygen style comments
-* Unit tests increased from 114 to 137
-* Automatic conversion between boost::function objects and ChaiScript functions 
-* Many bug fixes
-* Minor performance improvements
-* Namespace reorganization to make end user code more accessible
-* clang support
-* VisualStudio 2010 Support
-* Support for C++ base classes and automatic upcasting 
-* Remove __ reserved identifiers
-* Better code organization to reduce #ifdefs 
-* clanmills: command line options for chai eval
-* clanmills: parser cleanups and code reduction
-* Function introspection and reflection 
-* Correct function dispatch order to account for base classes and provide a defined order of dispatch 
-* Predictable object lifetime that emulates C++ stack lifetime
-* emarcotte: pkgconfig support
-* standardize on method/member naming and indentation
-* 64bit Visual Studio support
-* Better support for const objects
-* Drastic reduction of runtime exceptions - making debug builds orders of magnitude faster
-* Support for platforms with no loadable module support
-* Add helper macro for registering class 

samples/example.cpp

@@ -5,21 +5,20 @@
 // http://www.chaiscript.com
 
 #include <iostream>
+#include <ctime>
 
 #include <chaiscript/chaiscript.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
 #include <chaiscript/dispatchkit/function_call.hpp>
-#include <boost/function.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/regex.hpp>
 
 void log(const std::string &msg)
 {
-  std::cout << "[" << boost::posix_time::microsec_clock::local_time() << "] " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] " << msg << 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)
@@ -40,19 +39,19 @@ 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 chaiscript::Proxy_Function &t_func)
+      const std::function<std::string (const std::string &)> &t_func)
   {
-    m_callbacks[t_name] = chaiscript::dispatch::functor<std::string (const std::string &)>(t_func);
+    m_callbacks[t_name] = t_func;
   }
 
 
   void do_callbacks(const std::string &inp)
   {
     log("Running Callbacks: " + inp);
-    for (std::map<std::string, boost::function<std::string (const std::string &)> >::iterator itr = m_callbacks.begin();
+    for (std::map<std::string, std::function<std::string (const std::string &)> >::iterator itr = m_callbacks.begin();
          itr != m_callbacks.end();
          ++itr)
     {
@@ -61,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;
 }
@@ -87,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
@@ -108,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();
 
 
@@ -138,12 +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 
+  //Creating a functor on the stack and using it immediately 
-  int x = chai.eval<boost::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
+  int x = chai.eval<std::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
 
-  log("Functor test output", boost::lexical_cast<std::string>(x));
+  std::stringstream ss;
+  ss << x;
+  log("Functor test output", ss.str());
 
-  chai.add(var(boost::shared_ptr<int>()), "nullvar");
+  chai.add(var(std::shared_ptr<int>()), "nullvar");
   chai("print(\"This should be true.\"); print(nullvar.is_var_null())");
 
   // test the global const action
@@ -165,7 +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())
+  print("i: " + i.to_string())
-	if (i == 5) {
+  if (i == 5) {
-		break
+    break
-	}
+  }
 }
 
 var j = 0
 
 while (true) {
-	while (true) {
+  while (true) {
-		++j;
+    ++j;
-		if (j == 5) {
+    if (j == 5) {
-			break
+      break
-		}
+    }
-	}
+  }
-	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::ChaiScript chai;
-  ChaiScript::State backupState;
+  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/range.chai

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

samples/scope.chai

@@ -6,10 +6,10 @@
 */
 var x = 4
 def do_it() {
-	var x = 1
+  var x = 1
-	print(x)
+  print(x)
-	var y = fun(x) { x + 1 }
+  var y = fun(x) { x + 1 }
-	print(y(9))
+  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]))
+  print(i.to_string() + ": " + to_string(vec[i]))
-	i = i + 1
+  i = i + 1
 }

samples/while.chai

@@ -1,5 +1,5 @@
 var i = 0
 while (i < 10) {
-	print("i: " + i.to_string())
+  print("i: " + i.to_string())
-	i = i + 1
+  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

@@ -1,12 +1,12 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <iostream>
 #include <list>
-#include <boost/algorithm/string/trim.hpp>
+#include <regex>
 
 #define _CRT_SECURE_NO_WARNINGS
 #include <chaiscript/chaiscript.hpp>
@@ -15,21 +15,125 @@
 #include <readline/readline.h>
 #include <readline/history.h>
 #else
+
+char *mystrdup (const char *s) {
+  size_t len = strlen(s); // Space for length plus nul
+  char *d = static_cast<char*>(malloc (len+1));   
+  if (d == nullptr) return nullptr;          // No memory
+#ifdef CHAISCRIPT_MSVC
+  strcpy_s(d, len, s);                        // Copy the characters
+#else
+  strncpy(d,s,len);                        // Copy the characters
+#endif
+  d[len] = '\0';
+  return d;                            // Return the new string
+}
+
 char* readline(const char* p)
 {
   std::string retval;
   std::cout << p ;
   std::getline(std::cin, retval);
-#ifdef BOOST_MSVC
+  return std::cin.eof() ? nullptr : mystrdup(retval.c_str());
-  return std::cin.eof() ? NULL : _strdup(retval.c_str());
-#else
-  return std::cin.eof() ? NULL : strdup(retval.c_str());
-#endif
 }
+
+
 void add_history(const char*){}
 void using_history(){}
 #endif
 
+
+
+void *cast_module_symbol(std::vector<std::string> (*t_path)())
+{
+  union cast_union
+  {
+    std::vector<std::string> (*in_ptr)();
+    void *out_ptr;
+  };
+
+  cast_union c;
+  c.in_ptr = t_path;
+  return c.out_ptr;
+}
+
+std::vector<std::string> default_search_paths()
+{
+  std::vector<std::string> paths;
+
+#ifdef CHAISCRIPT_WINDOWS  // force no unicode
+  CHAR path[4096];
+  int size = GetModuleFileNameA(0, path, sizeof(path)-1);
+
+  std::string exepath(path, size);
+
+  size_t lastslash = exepath.rfind('\\');
+  size_t secondtolastslash = exepath.rfind('\\', lastslash - 1);
+  if (lastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, lastslash));
+  }
+
+  if (secondtolastslash != std::string::npos)
+  {
+    return {exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\"};
+  }
+#else
+
+  std::string exepath;
+
+  std::vector<char> buf(2048);
+  ssize_t size = -1;
+
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  {
+    exepath = std::string(&buf.front(), size);
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    Dl_info rInfo;
+    memset( &rInfo, 0, sizeof(rInfo) ); 
+    if ( !dladdr(cast_module_symbol(&default_search_paths), &rInfo)  || !rInfo.dli_fname ) { 
+      return paths;
+    }
+
+    exepath = std::string(rInfo.dli_fname);
+  }
+
+  size_t lastslash = exepath.rfind('/');
+
+  size_t secondtolastslash = exepath.rfind('/', lastslash - 1);
+  if (lastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, lastslash));
+  }
+
+  if (secondtolastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, secondtolastslash) + "/lib/chaiscript/");
+  }
+#endif
+
+  return paths;
+}
+
 void help(int n) {
   if ( n >= 0 ) {
     std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>." << std::endl;
@@ -52,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();
@@ -63,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();
@@ -80,7 +184,21 @@ std::string get_next_command() {
     char *input_raw = readline("eval> ");
     if ( input_raw ) {
       add_history(input_raw);
-      retval = boost::trim_copy_if(std::string(input_raw),boost::is_any_of(" \t"));
+
+      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);
     }
   }
@@ -113,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
       }
@@ -134,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
@@ -146,16 +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::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)
   {
@@ -215,21 +335,11 @@ int main(int argc, char *argv[])
         case eInteractive : interactive(chai); break;
         case eCommand     : val = chai.eval(arg); break;
         case eFile        : val = chai.eval_file(arg); break;
+        default           : std::cout << "Unrecognized execution mode" << std::endl; return EXIT_FAILURE;
       }
     }
     catch (const chaiscript::exception::eval_error &ee) {
-      std::cout << ee.what();
+      std::cout << ee.pretty_print();
-      if (ee.call_stack.size() > 0) {
-        std::cout << "during evaluation at (" << *(ee.call_stack[0]->filename) << " " << ee.call_stack[0]->start.line << ", " << ee.call_stack[0]->start.column << ")";
-        for (size_t j = 1; j < ee.call_stack.size(); ++j) {
-          if (ee.call_stack[j]->identifier != chaiscript::AST_Node_Type::Block
-              && ee.call_stack[j]->identifier != chaiscript::AST_Node_Type::File)
-          {
-            std::cout << std::endl;
-            std::cout << "  from " << *(ee.call_stack[j]->filename) << " (" << ee.call_stack[j]->start.line << ", " << ee.call_stack[j]->start.column << ")";
-          }
-        }
-      }
       std::cout << std::endl;
       return EXIT_FAILURE;
     }

src/multithreaded.cpp

@@ -1,40 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#include <iostream>
-
-#include <list>
-
-#include <chaiscript/chaiscript.hpp>
-#include <boost/thread.hpp>
-
-void do_work(chaiscript::ChaiScript &c)
-{
-//  c("use(\"work.chai\"); do_chai_work(num_iterations);"); 
-  std::string name = "MyVar" + boost::lexical_cast<std::string>(rand());
-  c.add(chaiscript::var(5), name);
-  c("use(\"work.chai\"); do_chai_work(10000);");
-}
-
-int main(int argc, char *argv[]) {
-    std::string input;
-    chaiscript::ChaiScript chai;
-
-    //chai.add_shared_object(chaiscript::Boxed_Value(10000), "num_iterations");
-
-    std::vector<boost::shared_ptr<boost::thread> > threads;
-
-    for (int i = 0; i < argc - 1; ++i)
-    {
-      threads.push_back(boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(do_work, boost::ref(chai)))));
-    }
-
-    for (int i = 0; i < argc - 1; ++i)
-    {
-      threads[i]->join();
-    }
-}
-

src/reflection.cpp

@@ -1,97 +0,0 @@
-
-#include <chaiscript/chaiscript.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
-#pragma warning(push)
-#pragma warning(disable : 4190)
-#endif
-
-
-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);
-  if (pf)
-  {
-    return pf->get_parse_tree();
-  } else {
-    return false;
-  }
-}
-
-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);
-  if (pf)
-  {
-    if (pf->get_parse_tree())
-    {
-      return pf->get_parse_tree();
-    } else {
-      throw std::runtime_error("Function does not have a parse tree");
-    }
-  } else {
-    throw std::runtime_error("Function does not have a parse tree");
-  }
-}
-
-
-CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflection()
-{
-  chaiscript::ModulePtr m(new chaiscript::Module());
-
-  m->add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
-  m->add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
-
-
-  chaiscript::bootstrap::standard_library::vector_type<std::vector<boost::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
-
-  CHAISCRIPT_CLASS( 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( 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))
-    );
-
-
-  return m;
-}
-
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif

src/stl_extra.cpp

@@ -1,21 +1,35 @@
+// 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
 
 #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
 
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
+
 CHAISCRIPT_MODULE_EXPORT chaiscript::ModulePtr create_chaiscript_module_stl_extra()
 {
   return chaiscript::bootstrap::standard_library::list_type<std::list<chaiscript::Boxed_Value> >("List");
 }
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

src/test_module.cpp

@@ -5,32 +5,81 @@
 class TestBaseType
 {
   public:
-    TestBaseType() {}
+    TestBaseType() : val(10), const_val(15) { }
-    TestBaseType(int) {}
+    TestBaseType(int) : val(10), const_val(15) {}
+    TestBaseType(int *) : val(10), const_val(15) {}
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
 
+    int base_only_func() { return -9; }
+
+    const TestBaseType &constMe() const { return *this; }
+
+    int val;
+    const int const_val;
+
+  private:
+    TestBaseType &operator=(const TestBaseType &);
 };
 
+enum TestEnum
+{
+  TestValue1 = 1
+};
+
+int to_int(TestEnum t)
+{
+  return t;
+}
+
 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";
 }
 
+int *get_new_int()
+{
+  return new int(1);
+}
+
 // 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
 
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
 
 CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_module()
 {
@@ -40,22 +89,55 @@ 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");
   m->add(chaiscript::constructor<TestBaseType (const TestBaseType &)>(), "TestBaseType");
+  m->add(chaiscript::constructor<TestBaseType (int *)>(), "TestBaseType");
 
   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");
+
+  m->add(chaiscript::fun(&to_int), "to_int");
+  m->add(chaiscript::fun(&TestBaseType::constMe), "constMe");
+
 
   return m;
 }
 
 
-#ifdef BOOST_MSVC
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

src/work.chai

@@ -1,10 +0,0 @@
-def do_chai_work(num_iters)
-{
-  var i = 0;
-  for (var k = 0; k<num_iters * 10; ++k)
-  {
-    i += k;
-  }
-
-  print(i);
-}

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)