Implement valuetypes with small size optimizations

Reduces trivial types such as int down to 1 dynamic allocation instead
of 3.

.decent_ci-Linux.yaml

@@ -0,0 +1,13 @@
+compilers:
+  - name: "clang"
+    version: "3.5"
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=OFF -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: "gcc"
+    version: "4.8"
+    cmake_extra_flags: -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: "gcc"
+    version: "4.6"
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: cppcheck
+    compiler_extra_flags: --enable=all -I include --inline-suppr
+

.decent_ci-MacOS.yaml

@@ -0,0 +1,7 @@
+compilers:
+  - name: clang
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=$COMMIT_SHA
+  - name: clang
+    build_type: Debug
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=$COMMIT_SHA
+

.decent_ci-Windows.yaml

@@ -0,0 +1,20 @@
+compilers:
+  - name: Visual Studio
+    version: 14
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /ANALYZE
+  - name: Visual Studio
+    version: 14
+    architecture: Win64
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /ANALYZE
+  - name: Visual Studio
+    version: 12
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /ANALYZE
+  - name: Visual Studio
+    version: 12
+    architecture: Win64
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /ANALYZE
+

.decent_ci.yaml

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

.travis.yml

@@ -1,17 +1,31 @@
 language: cpp
 compiler:
   - gcc
+env:
+  - GCC_VER=4.6
+  - GCC_VER=4.8
 before_install:
-    - sudo pip install cpp-coveralls --use-mirrors
+  - 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 -D USE_LIBCXX:BOOL=FALSE .
-  - make
+  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug .
+  - make -j2
   - make test
-  - coveralls -x hpp
+  - 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:
-  recipients:
-    - jason@emptycrate.com
   email:
+    recipients:
+      - jason@emptycrate.com
     on_success: always
     on_failure: always
-
+env:
+  global:
+    secure: eiaR6pXiiEpyB8+LLQ1NvZdl0Yylru1BLy9lMoHl+IpUNGGQGywmW/2WAn77rFfmR1OPA2qWQLfgPwgK0HxUA9HHlot9tre5QhiN2Lw8NOT8tCZ6tTm2+QntDBjBGJyal/knRvQkn/6qs6GxlXRerz4ArnnuPL1vESt3zwB0YtU=

CMakeLists.txt

@@ -3,20 +3,45 @@ cmake_minimum_required(VERSION 2.8)
 project(chaiscript)
 
 # MINGW does not yet support C++11's concurrency features
-if (MINGW)
+if(MINGW)
   option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" FALSE)
 else()
   option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
 endif()
 
-if (CMAKE_COMPILER_IS_GNUCC)
+
+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(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
-option(BUILD_SAMPLES "Build Samples Folder" FALSE)
+  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")
@@ -29,7 +54,7 @@ set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
 
 set(CPACK_PACKAGE_VERSION_MAJOR 5)
-set(CPACK_PACKAGE_VERSION_MINOR 3)
+set(CPACK_PACKAGE_VERSION_MINOR 4)
 set(CPACK_PACKAGE_VERSION_PATCH 0)
 
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
@@ -66,40 +91,30 @@ enable_testing()
 
 
 message(STATUS "Detecting readline support")
-if (READLINE_LIBRARY)
-    message(STATUS "Found: ${READLINE_LIBRARY}")
-    set (READLINE_LIB readline)
-    add_definitions(/DREADLINE_AVAILABLE)
-else(READLINE_LIBRARY)
-    message(STATUS "Not Found")
-    set (READLINE_LIB )
-    set (READLINE_FLAG )
-endif(READLINE_LIBRARY)
+if(READLINE_LIBRARY)
+  message(STATUS "Found: ${READLINE_LIBRARY}")
+  set(READLINE_LIB readline)
+  add_definitions(/DREADLINE_AVAILABLE)
+else()
+  message(STATUS "Not Found")
+  set(READLINE_LIB)
+  set(READLINE_FLAG)
+endif()
 
-SET(EXTRA_LINKER_FLAGS "")
-
-if (CMAKE_COMPILER_IS_GNUCC)
+if(CMAKE_COMPILER_IS_GNUCC)
   execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
 
-  if (GCC_VERSION VERSION_LESS 4.8)
-    SET(CPP11_FLAG "-std=c++0x")
+  if(GCC_VERSION VERSION_LESS 4.8)
+    set(CPP11_FLAG "-std=c++0x")
   else()
-    SET(CPP11_FLAG "-std=c++11")
+    set(CPP11_FLAG "-std=c++11")
   endif()
-
-  if (ENABLE_COVERAGE)
-    add_definitions(-fprofile-arcs -ftest-coverage)
-    SET(EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} "-fprofile-arcs -ftest-coverage")
-    #    SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "-fprofile-arcs -ftest-coverage")
-  endif()
-   
-
 else()
-  SET(CPP11_FLAG "-std=c++11")
+  set(CPP11_FLAG "-std=c++11")
 endif()
 
 if(MSVC)
-  add_definitions(/W4)
+  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
@@ -108,94 +123,96 @@ if(MSVC)
   # 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)
+  add_definitions(/wd4503)
 else()
   add_definitions(-Wall -Wextra -Wshadow -Wnon-virtual-dtor -pedantic ${CPP11_FLAG})
-  
-  if (APPLE)
+
+  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("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  option(USE_LIBCXX "Use clang's libcxx" FALSE)
 
-  if (USE_LIBCXX)
+  if(USE_LIBCXX)
     add_definitions(-stdlib=libc++)
-    set (EXTRA_LINKER_FLAGS  ${EXTRA_LINKER_FLAGS} ${CPP11_FLAG} -stdlib=libc++)
-  else ()
-    set (EXTRA_LINKER_FLAGS  ${EXTRA_LINKER_FLAGS} ${CPP11_FLAG})
+    set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG} -stdlib=libc++")
+  else()
+    set(LINKER_FLAGS "${LINKER_FLAGS} ${CPP11_FLAG}")
   endif()
 elseif(CMAKE_COMPILER_IS_GNUCC)
-  set (EXTRA_LINKER_FLAGS  ${EXTRA_LINKER_FLAGS} ${CPP11_FLAG})
+  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)
+if(MINGW OR CYGWIN)
   add_definitions(-O3)
 endif()
 
 include_directories(include)
 
 
-set (Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.chai include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
+set(Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.chai include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
 
 set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
 
-if (MULTITHREAD_SUPPORT_ENABLED)
-else()
+if(NOT MULTITHREAD_SUPPORT_ENABLED)
   add_definitions(-DCHAISCRIPT_NO_THREADS)
 endif()
 
-if (CMAKE_HOST_UNIX)
-  if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+if(CMAKE_HOST_UNIX)
+  if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
     list(APPEND LIBS "dl")
-  endif(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+  endif()
 
-  if (MULTITHREAD_SUPPORT_ENABLED)
-    if (CMAKE_COMPILER_IS_GNUCC)
+  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 (EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} -Wl,--no-as-needed -pthread )
+      if(GCC_FULL_VERSION MATCHES "4.8.1.*ubuntu")
+        set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--no-as-needed -pthread")
       else()
-        set (EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} -pthread )
+        set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
       endif()
     else()
-      set (EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} -pthread )
+      set(LINKER_FLAGS "${LINKER_FLAGS} -pthread")
     endif()
 
     add_definitions(-pthread)
   endif()
 
-endif(CMAKE_HOST_UNIX)
-  
+endif()
+
 list(APPEND LIBS ${READLINE_LIB})
 
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
+set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
 
 
-add_library(chaiscript_stdlib MODULE src/chaiscript_stdlib.cpp)
-target_link_libraries(chaiscript_stdlib ${LIBS} ${EXTRA_LINKER_FLAGS} ${CMAKE_THREAD_LIBS_INIT})
+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} ${EXTRA_LINKER_FLAGS})
-add_dependencies(chai chaiscript_stdlib)
+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} ${EXTRA_LINKER_FLAGS})
+  target_link_libraries(example ${LIBS})
   add_executable(memory_leak_test samples/memory_leak_test.cpp)
-  target_link_libraries(memory_leak_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+  target_link_libraries(memory_leak_test ${LIBS})
+  add_executable(inheritance samples/inheritance.cpp)
+  target_link_libraries(inheritance ${LIBS})
 endif()
 
 
-if (BUILD_MODULES)
+if(BUILD_MODULES)
   add_library(stl_extra MODULE src/stl_extra.cpp)
-  target_link_libraries(stl_extra ${LIBS} ${EXTRA_LINKER_FLAGS})
+  target_link_libraries(stl_extra ${LIBS})
 
-  add_library(reflection MODULE src/reflection.cpp)
-  target_link_libraries(reflection ${LIBS} ${EXTRA_LINKER_FLAGS})
-  set(MODULES stl_extra reflection)
+  set(MODULES stl_extra)
 endif()
 
 file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/3.x/*.chai)
@@ -205,134 +222,149 @@ list(SORT UNIT_TESTS)
 if(BUILD_TESTING)
   option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
 
-  foreach(filename ${UNIT_TESTS})
-    message(STATUS "Adding test ${filename}")
-    add_test(${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
- endforeach(filename)
-
-  set_property(TEST ${UNIT_TESTS}
-   PROPERTY ENVIRONMENT
+  add_test(version_check chai -c  "if(\"\\\${ version() };\\\${version_major()};\\\${version_minor()};\\\${version_patch()}\" != \"${CHAI_VERSION};${CPACK_PACKAGE_VERSION_MAJOR};${CPACK_PACKAGE_VERSION_MINOR};${CPACK_PACKAGE_VERSION_PATCH}\") { exit(-1) }")
+  set_property(TEST version_check
+    PROPERTY ENVIRONMENT
     "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
     "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
   )
 
-  if (NOT UNIT_TEST_LIGHT)
+
+  foreach(filename ${UNIT_TESTS})
+    message(STATUS "Adding test ${filename}")
+    add_test(${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
+  endforeach()
+
+  set_property(TEST ${UNIT_TESTS}
+    PROPERTY ENVIRONMENT
+    "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+  )
+
+  if(NOT UNIT_TEST_LIGHT)
     # commented out because uniform initializer syntax is not working properly in MSVC 2013
     add_executable(utility_test unittests/utility_test.cpp)
-    target_link_libraries(utility_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(utility_test ${LIBS})
     add_test(NAME Utility_Test COMMAND utility_test)
 
     add_executable(dynamic_object_test unittests/dynamic_object_test.cpp)
-    target_link_libraries(dynamic_object_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(dynamic_object_test ${LIBS})
     add_test(NAME Dynamic_Object_Test COMMAND dynamic_object_test)
 
     add_executable(functor_creation_test unittests/functor_creation_test.cpp)
-    target_link_libraries(functor_creation_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(functor_creation_test ${LIBS})
     add_test(NAME Functor_Creation_Test COMMAND functor_creation_test)
 
     add_executable(functor_cast_test unittests/functor_cast_test.cpp)
-    target_link_libraries(functor_cast_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(boxed_cast_test ${LIBS})
     add_test(NAME Boxed_Cast_Test COMMAND boxed_cast_test)
 
     add_executable(object_lifetime_test unittests/object_lifetime_test.cpp)
-    target_link_libraries(object_lifetime_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(object_lifetime_test ${LIBS})
     add_test(NAME Object_Lifetime_Test COMMAND object_lifetime_test)
 
     add_executable(function_ordering_test unittests/function_ordering_test.cpp)
-    target_link_libraries(function_ordering_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(function_ordering_test ${LIBS})
     add_test(NAME Function_Ordering_Test COMMAND function_ordering_test)
 
     add_executable(type_info_test unittests/type_info_test.cpp)
-    target_link_libraries(type_info_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(eval_catch_exception_test ${LIBS})
     add_test(NAME Eval_Catch_Exception_Test COMMAND eval_catch_exception_test)
 
     add_executable(short_comparison_test unittests/short_comparison_test.cpp)
-    target_link_libraries(short_comparison_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
-    add_test(NAME Simultaneous_Chaiscript_Test COMMAND simultaneous_chaiscript_test)
+    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} ${EXTRA_LINKER_FLAGS})
-    add_test(NAME Heap_Allocated_Chaiscript_Test COMMAND heap_allocated_chaiscript_test)
+    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} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
+    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} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(arithmetic_conversions_test ${LIBS})
     add_test(NAME Arithmetic_Conversions_Test COMMAND arithmetic_conversions_test)
 
-    if (MULTITHREAD_SUPPORT_ENABLED)
+    if(MULTITHREAD_SUPPORT_ENABLED)
       add_executable(multithreaded_test unittests/multithreaded_test.cpp)
-      target_link_libraries(multithreaded_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+      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} ${EXTRA_LINKER_FLAGS})
+    add_executable(multifile_test
+      unittests/multifile_test_main.cpp
+      unittests/multifile_test_chai.cpp
+      unittests/multifile_test_module.cpp
+    )
+    target_link_libraries(multifile_test ${LIBS})
     add_test(NAME MultiFile_Test COMMAND multifile_test)
 
     add_library(test_module MODULE src/test_module.cpp)
-    target_link_libraries(test_module ${LIBS} ${EXTRA_LINKER_FLAGS})
+    target_link_libraries(test_module ${LIBS})
 
     install(TARGETS test_module RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
   endif()
-endif(BUILD_TESTING)
+endif()
 
-install(TARGETS chai chaiscript_stdlib ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript )
+install(TARGETS chai chaiscript_stdlib-${CHAI_VERSION} ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
 
 install(DIRECTORY include/chaiscript DESTINATION include
-   PATTERN "*.hpp"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.hpp"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 install(DIRECTORY unittests DESTINATION share/chaiscript
-   PATTERN "*.chai" 
-   PATTERN "*.inc"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.chai"
+  PATTERN "*.inc"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 install(DIRECTORY samples DESTINATION share/chaiscript
-   PATTERN "*.chai"
-   PATTERN "*/.svn*" EXCLUDE
-   PATTERN "*/.git*" EXCLUDE
-   PATTERN "*~" EXCLUDE)
+  PATTERN "*.chai"
+  PATTERN "*/.svn*" EXCLUDE
+  PATTERN "*/.git*" EXCLUDE
+  PATTERN "*~" EXCLUDE)
 
 configure_file(contrib/pkgconfig/chaiscript.pc.in lib/pkgconfig/chaiscript.pc @ONLY)
 install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc"

contrib/codeanalysis/is_prime.chai

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

contrib/codeanalysis/runcppcheck.sh

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

contrib/geshi/chaiscript.php

@@ -38,7 +38,7 @@
  ************************************************************************************/
 
 $language_data = array (
-    'LANG_NAME' => 'Chaiscript',
+    'LANG_NAME' => 'ChaiScript',
     'COMMENT_SINGLE' => array(1 => '//'),
     'COMMENT_MULTI' => array('/*' => '*/'),
     //Regular Expressions

include/chaiscript/chaiscript.hpp

@@ -9,8 +9,8 @@
 
 
 
-/// \mainpage
-/// <a href="http://www.chaiscript.com">ChaiScript</a> is a scripting language designed specifically for integration with C++. It provides
+/// @mainpage
+/// [ChaiScript](http://www.chaiscript.com") is a scripting language designed specifically for integration with C++. It provides
 /// seamless integration with C++ on all levels, including shared_ptr objects, functors and exceptions.
 /// 
 /// The parts of the ChaiScript API that the average user will be concerned with are contained in the 
@@ -18,42 +18,42 @@
 ///
 /// The end user parts of the API are extremely simple both in size and ease of use.
 ///
-/// Currently, all source control and project management aspects of ChaiScript occur on <a href="http://www.github.com/ChaiScript/ChaiScript">github</a>.
+/// Currently, all source control and project management aspects of ChaiScript occur on [github](http://www.github.com/ChaiScript/ChaiScript").
 ///
-/// <hr>
+/// ------------------------------------------------------------
 /// 
-/// \sa chaiscript
-/// \sa chaiscript::ChaiScript
-/// \sa ChaiScript_Language for Built in Functions
-/// \sa \ref LangGettingStarted
-/// \sa \ref LangKeywordRef
-/// \sa \ref LangInPlaceRef
-/// \sa \ref LangObjectSystemRef
-/// \sa http://www.chaiscript.com
-/// \sa http://www.github.com/ChaiScript/ChaiScript
+/// @sa chaiscript
+/// @sa chaiscript::ChaiScript
+/// @sa ChaiScript_Language for Built in Functions
+/// @sa @ref LangGettingStarted
+/// @sa @ref LangKeywordRef
+/// @sa @ref LangInPlaceRef
+/// @sa @ref LangObjectSystemRef
+/// @sa http://www.chaiscript.com
+/// @sa http://www.github.com/ChaiScript/ChaiScript
 ///
-/// <hr>
+/// -----------------------------------------------------------
 ///
-/// \section gettingstarted API Getting Started
+/// @section gettingstarted API Getting Started
 ///
-/// \li \ref basics
-/// \li \ref compiling
-/// \li \ref eval
-/// \li \ref addingitems
-/// \li \ref operatoroverloading
-/// \li \ref helpermacro
-/// \li \ref pointerconversions
-/// \li \ref baseclasses
-/// \li \ref functionobjects
-/// \li \ref threading
-/// \li \ref exceptions
+/// - @ref basics
+/// - @ref compiling
+/// - @ref eval
+/// - @ref adding_items
+/// - @ref operatoroverloading
+/// - @ref add_class
+/// - @ref pointer_conversions
+/// - @ref baseclasses
+/// - @ref functionobjects
+/// - @ref threading
+/// - @ref exceptions
 /// 
 /// 
-/// \subsection basics Basics
+/// @subsection basics Basics
 /// 
 /// Basic simple example:
 ///
-/// \code
+/// ~~~~~~~{.cpp}
 /// //main.cpp
 /// #include <chaiscript/chaiscript.hpp>
 /// 
@@ -69,111 +69,115 @@
 ///
 ///   double d = chai.eval<double>("function(3, 4.75);");
 /// } 
-/// \endcode
+/// ~~~~~~~
 ///
-/// <hr>
-/// \subsection compiling Compiling ChaiScript Applications
+/// ------------------------------------------------------
 ///
-/// ChaiScript is a header only library with only one dependecy: The
+/// @subsection compiling Compiling ChaiScript Applications
+///
+/// ChaiScript is a header only library with only one dependency: The
 /// operating system provided dynamic library loader, which has to be specified on some platforms.
 /// 
-/// \subsubsection compilinggcc Compiling with GCC
+/// @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:
 ///
-/// \code
+/// ~~~~~~~~
 /// gcc main.cpp -I/path/to/chaiscript/headers -ldl 
-/// \endcode
+/// ~~~~~~~~
 ///
 /// Alternatively, you may compile without threading support.
 ///
-/// \code
+/// ~~~~~~~~
 /// gcc main.cpp -I/path/to/chaiscript/headers -ldl -DCHAISCRIPT_NO_THREADS
-/// \endcode
-/// 
-/// <hr>
-/// \subsection eval Evaluating Scripts
+/// ~~~~~~~~
+///
+/// ------------------------------------------
+///
+/// @subsection eval Evaluating Scripts
 ///
 /// Scripts can be evaluated with the () operator, eval method or eval_file method.
 ///
-/// \subsubsection parenoperator () Operator
+/// @subsubsection parenoperator () Operator
 ///
 /// operator() can be used as a handy shortcut for evaluating ChaiScript snippets.
-/// \code
-/// chaiscript::ChaiScript chai;
-/// chai("print(\"hello world\")");
-/// \endcode
-/// 
-/// \sa chaiscript::ChaiScript::operator()(const std::string &)
 ///
-/// \subsubsection evalmethod Method 'eval'
+/// ~~~~~~~~{.cpp}
+/// chaiscript::ChaiScript chai;
+/// chai("print(@"hello world@")");
+/// ~~~~~~~~
 /// 
-/// The eval method is somewhat more verbose and can be used to get typesafely return values
+/// @sa chaiscript::ChaiScript::operator()(const std::string &)
+///
+/// @subsubsection evalmethod Method 'eval'
+/// 
+/// The eval method is somewhat more verbose and can be used to get type safely return values
 /// from the script.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// chaiscript::ChaiScript chai;
 /// chai.eval("callsomefunc()");
 /// int result = chai.eval<int>("1 + 3");
 /// // result now equals 4
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa chaiscript::ChaiScript::eval
+/// @sa chaiscript::ChaiScript::eval
 ///
-/// \subsubsection evalfilemethod Method 'eval_file'
+/// @subsubsection evalfilemethod Method 'eval_file'
 /// 
 /// The 'eval_file' method loads a file from disk and executes the script in it
 /// 
-/// \code
+/// ~~~~~~~~{.cpp}
 /// chaiscript::ChaiScript chai;
 /// chai.eval_file("myfile.chai");
 /// std::string result = chai.eval_file<std::string>("myfile.chai") // extract the last value returned from the file
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa chaiscript::ChaiScript::eval_file
+/// @sa chaiscript::ChaiScript::eval_file
 ///
-/// <hr>
-/// \subsection addingitems Adding Items to ChaiScript
+/// --------------------------------------------------
+///
+/// @subsection adding_items Adding Items to ChaiScript
 ///
 /// ChaiScript supports 4 basic things that can be added: objects, functions, type infos and Modules
 ///
-/// \subsubsection addingobjects Adding Objects
+/// @subsubsection adding_objects Adding Objects
 ///
 /// Named objects can be created with the chaiscript::var function. Note: adding a object
 /// adds it to the current thread scope, not to a global scope. If you have multiple 
 /// threads that need to access the same variables you will need to add them
 /// separately for each thread, from the thread itself.
 /// 
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// using namespace chaiscript;
 /// ChaiScript chai;
 /// int i = 5;
 /// chai.add(var(i), "i");
 /// chai("print(i)");
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// Immutable objects can be created with the chaiscript::const_var function.
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// chai.add(const_var(i), "i");
 /// chai("i = 5"); // exception throw, cannot assign const var
-/// \endcode
+/// ~~~~~~~~~
 /// 
 /// Named variables can only be accessed from the context they are created in.
 /// If you want a global variable, it must be const, and created with the 
 /// chaiscript::ChaiScript::add_global_const function.
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// chai.add_global_const(const_var(i), "i");
 /// chai("def somefun() { print(i); }; sumfun();");
-/// \endcode
+/// ~~~~~~~~~
 /// 
-/// \subsubsection addingfunctions Adding Functions
+/// @subsubsection adding_functions Adding Functions
 /// 
 /// Functions, methods and members are all added using the same function: chaiscript::fun.
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// using namespace chaiscript;
 /// 
 /// class MyClass {
@@ -190,26 +194,26 @@
 /// chai.add(fun(&MyClass::memberdata), "memberdata");
 /// chai.add(fun(&MyClass::method), "method");
 /// chai.add(fun(&MyClass::staticmethod), "staticmethod");
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// Overloaded methods will need some help, to hint the compiler as to which overload you want:
 ///
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// chai.add(fun<void (MyClass::*)()>(&MyClass::overloadedmethod), "overloadedmethod");
 /// chai.add(fun<void (MyClass::*)(const std::string &)>(&MyClass::overloadedmethod), "overloadedmethod");
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// There are also shortcuts built into chaiscript::fun for binding up to the first two parameters of the function.
 /// 
-/// \code
+/// ~~~~~~~~~{.cpp}
 /// MyClass obj;
 /// chai.add(fun(&MyClass::method, &obj), "method");
 /// chai("method()"); // equiv to obj.method()
 /// chai.add(fun(&MyClass::method2, &obj, 3), "method2");
 /// chai("method2()"); // equiv to obj.method2(3)
-/// \endcode
+/// ~~~~~~~~~
 ///
-/// \subsubsection addingtypeinfo Adding Type Info
+/// @subsubsection addingtypeinfo Adding Type Info
 ///
 /// ChaiScript will automatically support any type implicitly provided to it in the form
 /// of objects and function parameters / return types. However, it can be nice to let ChaiScript 
@@ -219,27 +223,28 @@
 ///
 /// Continuing with the example "MyClass" from above:
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// chai.add(user_type<MyClass>(), "MyClass");
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \subsubsection addingmodules Adding Modules
+/// @subsubsection adding_modules Adding Modules
 /// 
 /// Modules are holders for collections of ChaiScript registrations.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// ModulePtr module = get_sum_module();
 /// chai.add(module);
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa chaiscript::Module
+/// @sa chaiscript::Module
 ///
-/// <hr>
-/// \subsection operatoroverloading Operator Overloading
+/// -----------------------------------------------------------------------
+///
+/// @subsection operatoroverloading Operator Overloading
 /// 
 /// Operators are just like any other function in ChaiScript, to overload an operator, simply register it.
 /// 
-/// \code 
+/// ~~~~~~~~{.cpp} 
 /// class MyClass {
 ///   MyClass operator+(const MyClass &) const;
 /// };
@@ -254,17 +259,18 @@
 /// }
 ///
 /// chai.add(fun(append_string_int), "+");
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref addingfunctions
+/// @sa @ref adding_functions
 ///
-/// <hr>
-/// \subsection helpermacro Class Helper Macro
+/// -----------------------------------------------------------------------
+///
+/// @subsection add_class Class Helper Utility
 /// 
 /// Much of the work of adding new classes to ChaiScript can be reduced with the help
-/// of the CHAISCRIPT_CLASS helper macro.
+/// of the add_class helper utility.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// class Test
 /// {
 ///   public:
@@ -277,40 +283,40 @@
 ///
 /// int main()
 /// {
-///
 ///   chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
 ///
-///   CHAISCRIPT_CLASS( m, 
-///       Test,
-///       (Test ())
-///       (Test (const Test &)),
-///       ((function))
-///       ((function2))
-///       ((function3))
-///       ((functionOverload)(std::string (Test::*)(double)))
-///       ((functionOverload)(std::string (Test::*)(int)))
-///       ((operator=))
-///     );
-/// 
+///   chaiscript::utility::add_class<chaiscript::Test>(*m,
+///      "Test",
+///      { constructor<Test()>(),
+///        constructor<Test(const Test &)>() },
+///      { {fun(&Test::function), "function"},
+///        {fun(&Test::function2), "function2"},
+///        {fun(&Test::function2), "function3"} 
+///        {fun(static_cast<std::string Test::*(double)>(&Test::functionOverload)), "functionOverload"} 
+///        {fun(static_cast<std::string Test::*(int)>(&Test::functionOverload)), "functionOverload"} }
+///      );
+///
+///
 ///   chaiscript::ChaiScript chai;
 ///   chai.add(m);
 /// }
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa \ref addingmodules
+/// @sa @ref adding_modules
 ///
-/// <hr>
-/// \subsection pointerconversions Pointer / Object Conversions
+/// -----------------------------------------------------------------------
+///
+/// @subsection pointer_conversions Pointer / Object Conversions
 ///
 /// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, std::shared_ptr<T>,
 /// std::shared_ptr<const T>, std::reference_wrapper<T>, std::reference_wrapper<const T> and value types automatically.
 ///
-/// If a chaiscript::var object was created in C++ from a pointer, it cannot be convered to a shared_ptr (this would add invalid reference counting).
+/// If a chaiscript::var object was created in C++ from a pointer, it cannot be converted to a shared_ptr (this would add invalid reference counting).
 /// Const may be added, but never removed. 
 ///
 /// The take away is that you can pretty much expect function calls to Just Work when you need them to.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// void fun1(const int *);
 /// void fun2(int *);
 /// void fun3(int);
@@ -350,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);
@@ -375,16 +382,17 @@
 ///   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
+///
+/// Functions are first class objects in ChaiScript and ChaiScript supports automatic conversion
 /// between ChaiScript functions and std::function objects.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// void callafunc(const std::function<void (const std::string &)> &t_func)
 /// {
 ///   t_func("bob");
@@ -400,11 +408,12 @@
 ///   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
@@ -414,16 +423,17 @@
 ///
 /// Disabling thread safety increases performance in many cases.
 ///
-/// <hr>
+/// -----------------------------------------------------------------------
 ///
-/// \subsection exceptions Exception Handling
+///
+/// @subsection exceptions Exception Handling
 /// 
-/// \subsubsection exceptionsbasics Exception Handling Basics
+/// @subsubsection exceptionsbasics Exception Handling Basics
 ///
 /// Exceptions can be thrown in ChaiScript and caught in C++ or thrown in C++ and caught in 
 /// ChaiScript.
 ///
-/// \code
+/// ~~~~~~~~{.cpp}
 /// void throwexception()
 /// {
 ///   throw std::runtime_error("err");
@@ -444,19 +454,19 @@
 ///     // i == 1
 ///   }
 /// }
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \subsubsection exceptionsautomatic Exception Handling Automatic Unboxing
+/// @subsubsection exceptionsautomatic Exception Handling Automatic Unboxing
 ///
 /// As an alternative to the manual unboxing of exceptions shown above, exception specifications allow the user to tell 
 /// ChaiScript what possible exceptions are expected from the script being executed. 
 ///
 /// Example:
-/// \code
+/// ~~~~~~~~{.cpp}
 /// chaiscript::ChaiScript chai;
 ///
 /// try {
-///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+///   chai.eval("throw(runtime_error(@"error@"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
 /// } catch (const double e) {
 /// } catch (int) {
 /// } catch (float) {
@@ -464,19 +474,19 @@
 /// } catch (const std::exception &e) {
 ///   // This is the one what will be called in the specific throw() above
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa chaiscript::Exception_Handler for details on automatic exception unboxing 
-/// \sa chaiscript::exception_specification
+/// @sa chaiscript::Exception_Handler for details on automatic exception unboxing 
+/// @sa chaiscript::exception_specification
 
 
 
-/// \page LangObjectSystemRef ChaiScript Language Object Model Reference
+/// @page LangObjectSystemRef ChaiScript Language Object Model Reference
 ///
 ///
 /// ChaiScript has an object system built in, for types defined within the ChaiScript system.
 ///
-/// \code
+/// ~~~~~~~~~
 /// attr Rectangle::height
 /// attr Rectangle::width
 /// def Rectangle::Rectangle() { this.height = 10; this.width = 20 }
@@ -485,67 +495,84 @@
 /// var rect = Rectangle()
 /// rect.height = 30
 /// print(rect.area())
-/// \endcode
+/// ~~~~~~~~~
 ///
-/// \sa \ref keywordattr
-/// \sa \ref keyworddef
+/// Since ChaiScript 5.4.0 it has been possible to use the "class" keyword to simplify this code.
+///
+/// ~~~~~~~~~
+/// class Rectangle {
+///   attr height
+///   attr width
+///   def Rectangle() { this.height = 10; this.width = 20 }
+///   def area() { this.height * this.width }
+/// }
+///
+/// var rect = Rectangle()
+/// rect.height = 30
+/// print(rect.area())
+/// ~~~~~~~~~
+///
+/// @sa @ref keywordattr
+/// @sa @ref keyworddef
 
-/// \page LangInPlaceRef ChaiScript Language In-Place Creation Reference
-/// \section inplacevector Vector
+/// @page LangInPlaceRef ChaiScript Language In-Place Creation Reference
+/// @section inplacevector Vector
 /// 
-/// \code
+/// ~~~~~~~~~
 /// In-place Vector ::= "[" [expression ("," expression)*]  "]"
-/// \endcode
+/// ~~~~~~~~~
 ///
-/// \section inplacerangedvector Ranged Vector
+/// @section inplacerangedvector Ranged Vector
 ///
-/// \code
+/// ~~~~~~~~~
 /// In-place Ranged Vector ::= "[" value ".." value "]"
-/// \endcode
+/// ~~~~~~~~~
 ///
 /// Creates a vector over a range (eg. 1..10)
 ///
-/// \section inplacemap Map
+/// @section inplacemap Map
 ///
-/// \code
+/// ~~~~~~~~
 /// In-place Map ::= "[" (string ":" expression)+ "]"
-/// \endcode
+/// ~~~~~~~~
 
-/// \page LangGettingStarted ChaiScript Language Getting Started
+/// @page LangGettingStarted ChaiScript Language Getting Started
 /// 
 /// ChaiScript is a simple language that should feel familiar to anyone who knows
 /// C++ or ECMAScript (JavaScript). 
 ///
-/// <hr>
-/// \section chaiscriptloops Loops
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptloops Loops
 ///
 /// Common looping constructs exist in ChaiScript
 ///
-/// \code
+/// ~~~~~~~~
 /// var i = 0;
 /// while (i < 10)
 /// {
 ///   // do something
 ///   ++i;
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \code
+/// ~~~~~~~~
 /// for (var i = 0; i < 10; ++i)
 /// {
 ///   // do something
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref keywordfor
-/// \sa \ref keywordwhile
+/// @sa @ref keywordfor
+/// @sa @ref keywordwhile
 ///
-/// <hr>
-/// \section chaiscriptifs Conditionals
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptifs Conditionals
 ///
 /// If statements work as expected
 /// 
-/// \code
+/// ~~~~~~~~
 /// var b = true;
 /// 
 /// if (b) {
@@ -555,103 +582,109 @@
 /// } else {
 ///   // or do this
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref keywordif
+/// @sa @ref keywordif
 ///
-/// <hr>
-/// \section chaiscriptfunctions Functions
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptfunctions Functions
 /// 
 /// Functions are defined with the def keyword
 /// 
-/// \code
+/// ~~~~~~~~
 /// def myfun(x) { print(x); }
 ///
 /// myfun(10);
-/// \endcode
+/// ~~~~~~~~
 ///
 /// Functions may have "guards" which determine if which is called.
 ///
-/// \code
+/// ~~~~~~~~
 /// eval> def myfun2(x) : x < 10 { print("less than 10"); }
 /// eval> def myfun2(x) : x >= 10 { print("10 or greater"); }
 /// eval> myfun2(5)
 /// less than 10
 /// eval> myfun2(12)
 /// 10 or greater
-/// \endcode
+/// ~~~~~~~~
 /// 
-/// \sa \ref keyworddef
-/// \sa \ref keywordattr
-/// \sa \ref LangObjectSystemRef
+/// @sa @ref keyworddef
+/// @sa @ref keywordattr
+/// @sa @ref LangObjectSystemRef
 ///
-/// <hr>
-/// \section chaiscriptfunctionobjects Function Objects
+/// -----------------------------------------------------------------------
+///
+/// @section chaiscriptfunctionobjects Function Objects
 /// 
 /// Functions are first class types in ChaiScript and can be used as variables.
 ///
-/// \code
+/// ~~~~~~~~
 /// eval> var p = print;
 /// eval> p(1);
 /// 1
-/// \endcode
+/// ~~~~~~~~
 /// 
 /// They can also be passed to functions. 
 ///
-/// \code
+/// ~~~~~~~~
 /// eval> def callfunc(f, lhs, rhs) { return f(lhs, rhs); }
-/// eval> def dosomething(lhs, rhs) { print("lhs: ${lhs}, rhs: ${rhs}"); }
-/// eval> callfunc(dosomething, 1, 2);
+/// eval> def do_something(lhs, rhs) { print("lhs: ${lhs}, rhs: ${rhs}"); }
+/// eval> callfunc(do_something, 1, 2);
 /// lhs: 1, rhs: 2
-/// \endcode
+/// ~~~~~~~~
 ///
 /// Operators can also be treated as functions by using the back tick operator. Building on the above example:
 /// 
-/// \code
+/// ~~~~~~~~
 /// eval> callfunc(`+`, 1, 4);
 /// 5
 /// eval> callfunc(`*`, 3, 2);
 /// 6
-/// \endcode
+/// ~~~~~~~~
 ///
-/// <hr>
-/// \sa \ref LangKeywordRef
-/// \sa ChaiScript_Language for Built in Functions
+/// -----------------------------------------------------------------------
+///
+/// @sa @ref LangKeywordRef
+/// @sa ChaiScript_Language for Built in Functions
 
 
-/// \page LangKeywordRef ChaiScript Language Keyword Reference
+/// @page LangKeywordRef ChaiScript Language Keyword Reference
 ///
 ///
-/// <hr>
-/// \section keywordattr attr
+/// -----------------------------------------------------------------------
+///
+/// @section keywordattr attr
 /// Defines a ChaiScript object attribute
 /// 
-/// \code 
+/// ~~~~~~~~ 
 /// Attribute Definition ::= "attr" class_name "::" attribute_name
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref LangObjectSystemRef
+/// @sa @ref LangObjectSystemRef
 ///
-/// <hr>
-/// \section keywordbreak break
+/// -----------------------------------------------------------------------
+///
+/// @section keywordbreak break
 /// Stops execution of a looping block.
 ///
-/// \code
+/// ~~~~~~~~
 /// Break Statement ::= "break"
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa \ref keywordfor
-/// \sa \ref keywordwhile 
+/// @sa @ref keywordfor
+/// @sa @ref keywordwhile 
 ///
 ///
-/// <hr>
-/// \section keyworddef def
+/// -----------------------------------------------------------------------
+///
+/// @section keyworddef def
 /// Begins a function or method definition
 ///
-/// \code
+/// ~~~~~~~~
 /// Function Definition ::= [annotation + CR/LF] "def" identifier "(" [arg ("," arg)*] ")" [":" guard] block
 /// Method Definition ::= [annotation + CR/LF] "def" class_name "::" method_name "(" [arg ("," arg)*] ")" [":" guard] block
-/// \endcode
+/// ~~~~~~~~
 /// 
 /// annotation: meta-annotation on function, currently used as documentation. Optional.
 /// identifier: name of function. Required.
@@ -667,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) {
@@ -718,35 +757,38 @@
 /// } else {
 ///   // otherwise do this
 /// }
-/// \endcode
+/// ~~~~~~~~
 ///
 ///
-/// <hr>
-/// \section keywordtry try
-/// \code
+/// -----------------------------------------------------------------------
+///
+/// @section keywordtry try
+/// ~~~~~~~~
 /// Try Block ::= "try" block 
 ///  ("catch" ["(" variable ")"] [":" guards] block)+ 
 ///    ["finally" block]
-/// \endcode
+/// ~~~~~~~~
 ///
-/// \sa ChaiScript_Language::throw
+/// @sa ChaiScript_Language::throw
 ///
-/// <hr>
-/// \section keywordwhile while
+/// -----------------------------------------------------------------------
+///
+/// @section keywordwhile while
 /// 
 /// Begins a conditional block of code that loops 0 or more times, as long as the condition is true
 ///
-/// \code
+/// ~~~~~~~~
 /// While Block ::= "while" "(" condition ")" block
-/// \endcode
-/// This loop can be broken using the \ref keywordbreak command.
+/// ~~~~~~~~
+///
+/// This loop can be broken using the @ref keywordbreak command.
 
 
-/// \namespace chaiscript
-/// \brief Namespace chaiscript contains every API call that the average user will be concerned with.
+/// @namespace chaiscript
+/// @brief Namespace chaiscript contains every API call that the average user will be concerned with.
 
-/// \namespace chaiscript::detail
-/// \brief Classes and functions reserved for internal use. Items in this namespace are not supported.
+/// @namespace chaiscript::detail
+/// @brief Classes and functions reserved for internal use. Items in this namespace are not supported.
 
 #include "chaiscript_defines.hpp"
 

include/chaiscript/chaiscript_defines.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DEFINES_HPP_
@@ -12,10 +12,22 @@
 #define CHAISCRIPT_HAS_DECLSPEC
 #endif
 
-#ifdef _WIN32
+#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)
@@ -31,7 +43,11 @@
 #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

@@ -7,11 +7,19 @@
 #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
+/// @file
 ///
 /// This file generates the standard library that normal ChaiScript usage requires.
 

include/chaiscript/chaiscript_threading.hpp

@@ -64,16 +64,59 @@ namespace chaiscript
 
       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.
-      /// 
-      /// \todo move to thread_local when it exists 
       template<typename T>
         class Thread_Storage
         {
           public:
+
+            Thread_Storage(void *t_key)
+              : m_key(t_key)
+            {
+            }
+
+            ~Thread_Storage()
+            {
+              t().erase(m_key);
+            }
+
+            inline T *operator->() const
+            {
+              return &(t()[m_key]);
+            }
+
+            inline T &operator*() const
+            {
+              return t()[m_key];
+            }
+
+            void *m_key;
+
+          private:
+            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();
@@ -88,35 +131,26 @@ namespace chaiscript
           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;
-              
-
-              /*
-              static __thread std::shared_ptr<T> *m_data = 0;
-              
-              if (!m_data) { m_data = new std::shared_ptr<T>(new T()); }
-
-              return *m_data;
-              */
             }
 
 
             mutable mutex m_mutex;
             mutable std::unordered_map<std::thread::id, std::shared_ptr<T> > m_instances;
         };
+#endif // threading enabled but no tls
 
-#else
+#else // threading disabled
       template<typename T>
       class unique_lock 
       {
@@ -151,6 +185,10 @@ namespace chaiscript
         class Thread_Storage
         {
           public:
+            Thread_Storage(void *)
+            {
+            }
+
             inline T *operator->() const
             {
               return &obj;

include/chaiscript/dispatchkit/any.hpp

@@ -7,6 +7,8 @@
 #ifndef CHAISCRIPT_ANY_HPP_
 #define CHAISCRIPT_ANY_HPP_
 
+#include <utility>
+
 namespace chaiscript {
   namespace detail {
     namespace exception
@@ -26,8 +28,8 @@ namespace chaiscript {
 
           virtual ~bad_any_cast() CHAISCRIPT_NOEXCEPT {}
 
-          /// \brief Description of what error occured
-          virtual const char * what() const CHAISCRIPT_NOEXCEPT
+          /// \brief Description of what error occurred
+          virtual const char * what() const CHAISCRIPT_NOEXCEPT CHAISCRIPT_OVERRIDE
           {
             return m_what.c_str();
           }
@@ -42,66 +44,89 @@ namespace chaiscript {
       private:
         struct Data
         {
+
+          Data &operator=(const Data &) = delete;
+
           virtual ~Data() {}
+
           virtual void *data() = 0;
-          virtual const std::type_info &type() const = 0;
-          virtual std::shared_ptr<Data> clone() const = 0;
+          virtual std::unique_ptr<Data> clone() const = 0;
         };
 
         template<typename T>
           struct Data_Impl : Data
           {
-            Data_Impl(const T &t_type)
-              : m_type(typeid(T)),
-                m_data(t_type)
+            explicit Data_Impl(T t_type)
+              : m_data(std::move(t_type))
             {
             }
 
             virtual ~Data_Impl() {}
 
-            virtual void *data()
+            virtual void *data() CHAISCRIPT_OVERRIDE
             {
               return &m_data;
             }
 
-            const std::type_info &type() const
+            std::unique_ptr<Data> clone() const CHAISCRIPT_OVERRIDE
             {
-              return m_type;
-            }
-
-            std::shared_ptr<Data> clone() const
-            {
-              return std::shared_ptr<Data>(new Data_Impl<T>(m_data));
+              return std::unique_ptr<Data>(new Data_Impl<T>(m_data));
             }
 
             Data_Impl &operator=(const Data_Impl&) = delete;
-              
-            const std::type_info &m_type;
+
             T m_data;
           };
 
-        std::shared_ptr<Data> m_data;
+        std::unique_ptr<Data> m_data;
+        mutable std::array<uint8_t, 15> m_smallSize;
+        bool m_isSmall = false;
+        const std::type_info *m_type = &typeid(void);
 
       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();
-          }
+          : m_data(t_any.m_data?t_any.m_data->clone():nullptr),
+            m_smallSize(t_any.m_smallSize),
+            m_isSmall(t_any.m_isSmall),
+            m_type(t_any.m_type)
+        {
+
         }
 
-        template<typename ValueType> 
-        Any(const ValueType &t_value)
-          : m_data(std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value)))
+#if _MSC_VER  != 1800
+        Any(Any &&) = default;
+        Any &operator=(Any &&t_any) = default;
+#endif
+
+        template<typename ValueType,
+          typename = typename std::enable_if<!std::is_same<Any, typename std::decay<ValueType>::type>::value>::type,
+          typename = typename std::enable_if< std::is_trivial<typename std::decay<ValueType>::type>::value>::type,
+          typename = typename std::enable_if<sizeof(typename std::decay<ValueType>::type) <= sizeof(decltype(m_smallSize)) >::type>
+        explicit Any(ValueType &&t_value)
+          : m_isSmall(true), m_type(&typeid(typename std::decay<ValueType>::type))
+        {
+          m_smallSize.fill(0);
+          *(static_cast<typename std::decay<ValueType>::type *>(static_cast<void *>(m_smallSize.data()))) = t_value;
+          // std::cout << "Setting type: " << typeid(typename std::decay<ValueType>::type).name() << " "  << t_value << " actual val: " << *(static_cast<typename std::decay<ValueType>::type *>(static_cast<void *>(m_smallSize.data()))) << " cast: " << cast<typename std::decay<ValueType>::type>() << "\n";
+        }
+
+        template<typename ValueType,
+          typename = typename std::enable_if<!std::is_same<Any, typename std::decay<ValueType>::type>::value>::type,
+          typename = typename std::enable_if< 
+            !std::is_trivial<typename std::decay<ValueType>::type>::value
+            || !(sizeof(typename std::decay<ValueType>::type) <= sizeof(decltype(m_smallSize))) >::type>
+        explicit Any(ValueType &&t_value)
+          : m_data(std::unique_ptr<Data>(new Data_Impl<typename std::decay<ValueType>::type>(std::forward<ValueType>(t_value)))),
+            m_isSmall(false),
+            m_type(&typeid(typename std::decay<ValueType>::type))
         {
         }
 
+
+
         Any & operator=(const Any &t_any)
         {
           Any copy(t_any);
@@ -109,25 +134,23 @@ namespace chaiscript {
           return *this; 
         }
 
-        template<typename ValueType> 
-          Any & operator=(const ValueType &t_value)
-        {
-          m_data = std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value));
-          return *this;
-        }
-
         template<typename ToType>
           ToType &cast() const
           {
-            if (m_data && typeid(ToType) == m_data->type())
+            if (m_isSmall && typeid(ToType) == *m_type)
             {
+              return *static_cast<ToType *>(static_cast<void *>(m_smallSize.data()));
+            } else if (!m_isSmall && m_data && typeid(ToType) == *m_type) {
               return *static_cast<ToType *>(m_data->data());
             } else {
               throw chaiscript::detail::exception::bad_any_cast();
             }
- 
           }
 
+        const std::type_info &type() const
+        {
+          return *m_type;
+        }
 
         ~Any()
         {
@@ -136,27 +159,31 @@ namespace chaiscript {
         // modifiers
         Any & swap(Any &t_other)
         {
-          std::shared_ptr<Data> data = t_other.m_data;
-          t_other.m_data = m_data;
-          m_data = data;
+          std::swap(t_other.m_smallSize, m_smallSize);
+          std::swap(t_other.m_isSmall, m_isSmall);
+          std::swap(t_other.m_data, m_data);
+          std::swap(t_other.m_type, m_type);
           return *this;
         }
 
         // queries
         bool empty() const
         {
-          return !bool(m_data);
+          return !bool(m_data) && !m_isSmall;
         }
 
-        const std::type_info & type() const
+        void *data() const
         {
-          if (m_data)
+          if (m_isSmall)
           {
-            return m_data->type();
+            return static_cast<void *>(m_smallSize.data());
+          } else if (m_data) {
+            return m_data->data();
           } else {
-            return typeid(void);
+            return nullptr;
           }
         }
+
     };
 
   }

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

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

include/chaiscript/dispatchkit/bind_first.hpp

@@ -14,71 +14,12 @@ namespace chaiscript
   namespace detail
   {
 
-    template<int>
-      struct Placeholder
-      {
+    struct Placeholder
+    {
+      static std::tuple<decltype(std::placeholders::_1),decltype(std::placeholders::_2),decltype(std::placeholders::_3),decltype(std::placeholders::_4),decltype(std::placeholders::_5),decltype(std::placeholders::_6),decltype(std::placeholders::_7),decltype(std::placeholders::_8),decltype(std::placeholders::_9),decltype(std::placeholders::_10)> placeholder() {
+        return std::tuple<decltype(std::placeholders::_1),decltype(std::placeholders::_2),decltype(std::placeholders::_3),decltype(std::placeholders::_4),decltype(std::placeholders::_5),decltype(std::placeholders::_6),decltype(std::placeholders::_7),decltype(std::placeholders::_8),decltype(std::placeholders::_9),decltype(std::placeholders::_10)>(std::placeholders::_1,std::placeholders::_2,std::placeholders::_3,std::placeholders::_4,std::placeholders::_5,std::placeholders::_6,std::placeholders::_7,std::placeholders::_8,std::placeholders::_9,std::placeholders::_10);
       };
-
-    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
@@ -86,7 +27,7 @@ namespace chaiscript
         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());
+            return Bind_First<count - 1, maxcount, Sig>::bind(f, innerparams..., std::get<maxcount - count>(Placeholder::placeholder()));
           } 
       };
 

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -7,13 +7,33 @@
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
 #define CHAISCRIPT_BOOTSTRAP_HPP_
 
-#include "dispatchkit.hpp"
-#include "dynamic_object.hpp"
-#include "register_function.hpp"
-#include "operators.hpp"
-#include "boxed_number.hpp"
+#include <cstdint>
+#include <exception>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
 #include <sstream>
+#include <stdexcept>
+#include <string>
 #include <type_traits>
+#include <vector>
+
+#include "bad_boxed_cast.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+#include "dispatchkit.hpp"
+#include "dynamic_cast_conversion.hpp"
+#include "dynamic_object.hpp"
+#include "operators.hpp"
+#include "proxy_constructors.hpp"
+#include "proxy_functions.hpp"
+#include "proxy_functions_detail.hpp"
+#include "register_function.hpp"
+#include "type_info.hpp"
+#include "../utility/utility.hpp"
+#include "../language/chaiscript_common.hpp"
 
 namespace chaiscript 
 {
@@ -26,13 +46,9 @@ namespace chaiscript
       /// \param[in] v Boxed_Number to copy into the new object
       /// \returns The newly created object.
       template<typename P1>
-      std::shared_ptr<P1> construct_pod(Boxed_Number v)
+      std::shared_ptr<P1> construct_pod(const Boxed_Number &v)
       {
-        std::shared_ptr<P1> p(new P1());
-        Boxed_Value bv(p);
-        Boxed_Number nb(bv);
-        nb = v;
-        return p;
+        return std::make_shared<P1>(v.get_as<P1>());
       }
     }
 
@@ -93,9 +109,7 @@ 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)
     {
@@ -104,10 +118,8 @@ namespace chaiscript
       return ss.str();
     }
 
-    /**
-     * Internal function for converting from a string to a value
-     * uses ostream operator >> to perform the conversion
-     */
+    /// Internal function for converting from a string to a value
+    /// uses ostream operator >> to perform the conversion
     template<typename Input>
     Input parse_string(const std::string &i)
     {
@@ -116,12 +128,10 @@ namespace chaiscript
       ss >> t;
       return t;
     }
-      
-            
-    /**
-    * Add all common functions for a POD type. All operators, and
-    * common conversions
-    */
+
+
+    /// Add all common functions for a POD type. All operators, and
+    /// common conversions
     template<typename T>
     ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
     {
@@ -135,13 +145,11 @@ namespace chaiscript
     }
 
 
-    /**
-    * "clone" function for a shared_ptr type. This is used in the case
-    * where you do not want to make a deep copy of an object during cloning
-    * but want to instead maintain the shared_ptr. It is needed internally
-    * for handling of Proxy_Function object (that is,
-    * function variables.
-    */
+    /// "clone" function for a shared_ptr type. This is used in the case
+    /// where you do not want to make a deep copy of an object during cloning
+    /// but want to instead maintain the shared_ptr. It is needed internally
+    /// for handling of Proxy_Function object (that is,
+    /// function variables.
     template<typename Type>
     std::shared_ptr<Type> shared_ptr_clone(const std::shared_ptr<Type> &p)
     {
@@ -304,14 +312,6 @@ namespace chaiscript
       static void throw_exception(const Boxed_Value &bv) {
         throw bv;
       }
-      
-      static std::shared_ptr<chaiscript::detail::Dispatch_Engine> bootstrap2(
-          std::shared_ptr<chaiscript::detail::Dispatch_Engine> e 
-             = std::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)
       {
@@ -347,12 +347,48 @@ namespace chaiscript
           return vbv;
         }
 
+
+      static bool has_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 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
@@ -370,7 +406,7 @@ namespace chaiscript
         m->add(fun(&dispatch::Proxy_Function_Base::annotation), "get_annotation");
         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");
 
@@ -399,9 +435,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);
@@ -421,8 +460,8 @@ namespace chaiscript
         operators::assign<bool>(m);
         operators::equal<bool>(m);
 
-        m->add(fun(&to_string<const std::string &>), "internal_to_string");
-        m->add(fun(&Bootstrap::bool_to_string), "internal_to_string");
+        m->add(fun(&to_string<const std::string &>), "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");
@@ -453,8 +492,7 @@ namespace chaiscript
         m->add(fun(&print), "print_string");
         m->add(fun(&println), "println_string");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&bind_function, std::placeholders::_1))), 
-          "bind");
+        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(&bind_function)), "bind");
 
         m->add(fun(&shared_ptr_unconst_clone<dispatch::Proxy_Function_Base>), "clone");
         m->add(fun(&ptr_assign<std::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
@@ -462,6 +500,68 @@ namespace chaiscript
 
         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> { 
+                std::vector<Boxed_Value> retval;
+                std::transform(t_eval_error.call_stack.begin(), t_eval_error.call_stack.end(),
+                               std::back_inserter(retval),
+                               &chaiscript::var<std::shared_ptr<const chaiscript::AST_Node>>);
+                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> { 
+                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"} }
+            );
+
+
+
         return m;
       }
     };

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -13,9 +13,21 @@
 #ifndef CHAISCRIPT_BOOTSTRAP_STL_HPP_
 #define CHAISCRIPT_BOOTSTRAP_STL_HPP_
 
-#include "dispatchkit.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 
 {
@@ -173,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");
@@ -189,8 +201,8 @@ namespace chaiscript
         template<typename Type>
           void insert_at(Type &container, int pos, const typename Type::value_type &v)
           {
-            typename Type::iterator itr = container.begin();
-            typename Type::iterator end = container.end();
+            auto itr = container.begin();
+            auto end = container.end();
 
             if (pos < 0 || std::distance(itr, end) < pos)
             {
@@ -206,8 +218,8 @@ namespace chaiscript
         template<typename Type>
           void erase_at(Type &container, int pos)
           {
-            typename Type::iterator itr = container.begin();
-            typename Type::iterator end = container.end();
+            auto itr = container.begin();
+            auto end = container.end();
 
             if (pos < 0 || std::distance(itr, end) < (pos-1))
             {
@@ -217,7 +229,7 @@ namespace chaiscript
             std::advance(itr, pos);
             container.erase(itr);
           }      
-        
+
       }
 
       template<typename ContainerType>
@@ -322,8 +334,8 @@ namespace chaiscript
             push_back_name = "push_back";
           }
 
-          typedef void (ContainerType::*pushback)(const typename ContainerType::value_type &);
-          m->add(fun(static_cast<pushback>(&ContainerType::push_back)), push_back_name);
+          typedef void (ContainerType::*push_back)(const typename ContainerType::value_type &);
+          m->add(fun(static_cast<push_back>(&ContainerType::push_back)), push_back_name);
           m->add(fun(&ContainerType::pop_back), "pop_back");
           return m;
         }
@@ -336,10 +348,12 @@ namespace chaiscript
         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))
@@ -463,7 +477,10 @@ namespace chaiscript
           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);
@@ -535,13 +552,13 @@ namespace chaiscript
           m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_last_not_of(f, pos); } ) ), "find_last_not_of");
           m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_first_not_of(f, pos); } ) ), "find_first_not_of");
 
-	        m->add(fun( std::function<void (String *)>( [](String *s) { return s->clear(); } ) ), "clear");
-	        m->add(fun( std::function<bool (const String *)>( [](const String *s) { return s->empty(); } ) ), "empty");
-	        m->add(fun( std::function<size_t (const String *)>( [](const String *s) { return s->size(); } ) ), "size");
+          m->add(fun( std::function<void (String *)>( [](String *s) { return s->clear(); } ) ), "clear");
+          m->add(fun( std::function<bool (const String *)>( [](const String *s) { return s->empty(); } ) ), "empty");
+          m->add(fun( std::function<size_t (const String *)>( [](const String *s) { return s->size(); } ) ), "size");
 
           m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->c_str(); } ) ), "c_str");
           m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->data(); } ) ), "data");
-          m->add(fun( std::function<String (const String *, int, int)>( [](const String *s, int pos, int len) { return s->substr(pos, len); } ) ), "substr");          
+          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;
         }

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -7,14 +7,24 @@
 #ifndef CHAISCRIPT_BOXED_CAST_HPP_
 #define CHAISCRIPT_BOXED_CAST_HPP_
 
+#include <type_traits>
+
 #include "../chaiscript_defines.hpp"
-
-#include "type_info.hpp"
-#include "boxed_value.hpp"
-#include "boxed_cast_helper.hpp"
-#include "dynamic_cast_conversion.hpp"
-
 #include "../chaiscript_threading.hpp"
+#include "bad_boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "dynamic_cast_conversion.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+namespace detail {
+namespace exception {
+class bad_any_cast;
+}  // namespace exception
+}  // namespace detail
+}  // namespace chaiscript
 
 namespace chaiscript 
 {
@@ -76,14 +86,21 @@ namespace chaiscript
 #pragma warning(disable : 4127)
 #endif
 
-      if (std::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value && t_conversions)
+      if (std::is_polymorphic<typename detail::Bare_Type<Type>::type>::value && t_conversions)
       {
         try {
+          // std::cout << "trying an up conversion " << typeid(Type).name() << std::endl;
           // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
           // either way, we are not responsible if it doesn't work
           return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_cast<Type>(bv), t_conversions);
-        } catch (const chaiscript::detail::exception::bad_any_cast &) {
-          throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+        } catch (...) {
+          try {
+          //  std::cout << "trying a down conversion " << typeid(Type).name() << std::endl;
+            // try going the other way - down the inheritance graph
+            return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_down_cast<Type>(bv), t_conversions);
+          } catch (const chaiscript::detail::exception::bad_any_cast &) {
+            throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+          }
         }
       } else {
         // If it's not polymorphic, just throw the error, don't waste the time on the 

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -7,8 +7,12 @@
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 #define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
 
-#include "type_info.hpp"
+#include <functional>
+#include <memory>
+#include <type_traits>
+
 #include "boxed_value.hpp"
+#include "type_info.hpp"
 
 
 namespace chaiscript 
@@ -19,9 +23,14 @@ namespace chaiscript
   {
     // Cast_Helper_Inner helper classes
 
-    /**
-     * Generic Cast_Helper_Inner, for casting to any type
-     */
+    template<typename T>
+      T* throw_if_null(T *t)
+      {
+        if (t) return t;
+        throw std::runtime_error("Attempted to dereference null Boxed_Value");
+      }
+
+    /// Generic Cast_Helper_Inner, for casting to any type
     template<typename Result>
       struct Cast_Helper_Inner
       {
@@ -29,46 +38,31 @@ namespace chaiscript
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
-          if (ob.is_ref())
+          if (ob.get_type_info().bare_equal_type_info(typeid(Result)))
           {
-            if (!ob.get_type_info().is_const())
-            {
-              return std::cref((ob.get().cast<std::reference_wrapper<Result> >()).get());
-            } else {
-              return ob.get().cast<std::reference_wrapper<const Result> >();
-            }
+            return *(static_cast<const Result *>(throw_if_null(ob.get_const_ptr())));
           } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return std::cref(*(ob.get().cast<std::shared_ptr<Result> >()));   
-            } else {
-              return std::cref(*(ob.get().cast<std::shared_ptr<const Result> >()));   
-            }
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
 
-	template<typename Result>
-	  struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
-	  {
-	  };
+    template<typename Result>
+      struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
+      {
+      };
 
-    /**
-     * Cast_Helper_Inner for casting to a const & type
-     */
+    /// Cast_Helper_Inner for casting to a const & type
     template<typename Result>
       struct Cast_Helper_Inner<const Result &> : Cast_Helper_Inner<Result>
       {
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const * type
-     */
+    /// Cast_Helper_Inner for casting to a const * type
     template<typename Result>
       struct Cast_Helper_Inner<const Result *>
       {
         typedef const Result * Result_Type;
-
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
@@ -90,14 +84,11 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a * type
-     */
+    /// Cast_Helper_Inner for casting to a * type
     template<typename Result>
       struct Cast_Helper_Inner<Result *>
       {
         typedef Result * Result_Type;
-
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
@@ -109,9 +100,8 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a & type
-     */
+
+    /// Cast_Helper_Inner for casting to a & type
     template<typename Result>
       struct Cast_Helper_Inner<Result &>
       {
@@ -119,19 +109,16 @@ namespace chaiscript
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
-          if (ob.is_ref())
+          if (!ob.get_type_info().is_const() && ob.get_type_info().bare_equal_type_info(typeid(Result)))
           {
-            return ob.get().cast<std::reference_wrapper<Result> >();
+            return *(static_cast<Result *>(throw_if_null(ob.get_ptr())));
           } else {
-            Result &r = *(ob.get().cast<std::shared_ptr<Result> >());
-            return r;
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a std::shared_ptr<> type
-     */
+    /// Cast_Helper_Inner for casting to a std::shared_ptr<> type
     template<typename Result>
       struct Cast_Helper_Inner<typename std::shared_ptr<Result> >
       {
@@ -143,9 +130,7 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a std::shared_ptr<const> type
-     */
+    /// Cast_Helper_Inner for casting to a std::shared_ptr<const> type
     template<typename Result>
       struct Cast_Helper_Inner<typename std::shared_ptr<const Result> >
       {
@@ -162,9 +147,7 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
-     */
+    /// Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
     template<typename Result>
       struct Cast_Helper_Inner<const std::shared_ptr<Result> > : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
@@ -176,9 +159,7 @@ namespace chaiscript
       };
 
 
-    /**
-     * Cast_Helper_Inner for casting to a const std::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 std::shared_ptr<const Result> > : Cast_Helper_Inner<std::shared_ptr<const Result> >
       {
@@ -191,9 +172,7 @@ namespace chaiscript
 
 
 
-    /**
-     * Cast_Helper_Inner for casting to a Boxed_Value type
-     */
+    /// Cast_Helper_Inner for casting to a Boxed_Value type
     template<>
       struct Cast_Helper_Inner<Boxed_Value>
       {
@@ -201,13 +180,24 @@ namespace chaiscript
 
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
-          return ob;    
+          return ob;
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const Boxed_Value & type
-     */
+    /// 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
     template<>
       struct Cast_Helper_Inner<const Boxed_Value> : Cast_Helper_Inner<Boxed_Value>
       {
@@ -217,11 +207,9 @@ namespace chaiscript
       struct Cast_Helper_Inner<const Boxed_Value &> : Cast_Helper_Inner<Boxed_Value>
       {
       };
-    
 
-	/**
-     * Cast_Helper_Inner for casting to a std::reference_wrapper type
-     */
+
+    /// Cast_Helper_Inner for casting to a std::reference_wrapper type
     template<typename Result>
       struct Cast_Helper_Inner<std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
@@ -252,14 +240,12 @@ namespace chaiscript
       {
       };
 
-    /**
-     * The exposed Cast_Helper object that by default just calls the Cast_Helper_Inner
-     */
+    /// The exposed Cast_Helper object that by default just calls the Cast_Helper_Inner
     template<typename T>
       struct Cast_Helper
       {
         typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
-        
+
         static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           return Cast_Helper_Inner<T>::cast(ob, t_conversions);

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -7,17 +7,30 @@
 #ifndef CHAISCRIPT_BOXED_NUMERIC_HPP_
 #define CHAISCRIPT_BOXED_NUMERIC_HPP_
 
-#include "boxed_value.hpp"
-#include "../language/chaiscript_algebraic.hpp"
-#include <sstream>
 #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)
+#pragma warning(disable : 4244 4018 4389 4146 4365)
 #endif
 
   /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values
@@ -220,7 +233,7 @@ namespace chaiscript
       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();
+          const auto &inp_ = t_rhs.get_type_info();
 
           if (inp_ == typeid(int)) {
             return Go<LHS, int, Float>::go(t_oper, t_lhs, t_rhs);
@@ -307,7 +320,7 @@ namespace chaiscript
         }
 
         template<typename Source>
-          std::string to_string_aux(const Boxed_Value &v) const
+         static std::string to_string_aux(const Boxed_Value &v)
         {
           std::ostringstream oss;
           oss << *static_cast<const Source *>(v.get_const_ptr());
@@ -321,10 +334,10 @@ namespace chaiscript
       {
       }
 
-      Boxed_Number(const Boxed_Value &v)
-        : bv(v)
+      Boxed_Number(Boxed_Value v)
+        : bv(std::move(v))
       {
-        validate_boxed_number(v);
+        validate_boxed_number(bv);
       }
 
       template<typename T> explicit Boxed_Number(T t)
@@ -520,7 +533,7 @@ namespace chaiscript
         return oper(Operators::assign_bitwise_and, this->bv, t_rhs.bv);
       }
 
-      void validate_boxed_number(const Boxed_Value &v)
+      static void validate_boxed_number(const Boxed_Value &v)
       {
         const Type_Info &inp_ = v.get_type_info();
         if (inp_ == typeid(bool))

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -7,12 +7,14 @@
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
 #define CHAISCRIPT_BOXED_VALUE_HPP_
 
-#include "type_info.hpp"
+#include <functional>
+#include <map>
+#include <memory>
+#include <type_traits>
 
 #include "../chaiscript_threading.hpp"
-
-#include <map>
 #include "any.hpp"
+#include "type_info.hpp"
 
 namespace chaiscript 
 {
@@ -22,24 +24,21 @@ namespace chaiscript
   class Boxed_Value
   {
     public:
-      /**
-       * used for explicitly creating a "void" object
-       */
+      /// used for explicitly creating a "void" object
       struct Void_Type
       {
       };
 
     private:
-      /**
-       * structure which holds the internal state of a Boxed_Value
-       */
+      /// structure which holds the internal state of a Boxed_Value
+      /// \todo Get rid of Any and merge it with this, reducing an allocation in the process
       struct Data
       {
         Data(const Type_Info &ti,
-            const chaiscript::detail::Any &to,
+            chaiscript::detail::Any to,
             bool tr,
             const void *t_void_ptr)
-          : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?0:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
+          : m_type_info(ti), m_obj(std::move(to)), m_data_ptr(ti.is_const()?nullptr:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
             m_is_ref(tr)
         {
         }
@@ -52,23 +51,32 @@ namespace chaiscript
           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()
-        {
-        }
+        Data(const Data &) = delete;
+
+#if !defined(__APPLE__) && (!defined(_MSC_VER) || _MSC_VER != 1800)
+        Data(Data &&) = default;
+        Data &operator=(Data &&rhs) = default;
+#endif
 
         Type_Info m_type_info;
         chaiscript::detail::Any m_obj;
         void *m_data_ptr;
         const void *m_const_data_ptr;
         bool m_is_ref;
+        std::unique_ptr<std::map<std::string, Boxed_Value>> m_attrs;
       };
 
       struct Object_Data
       {
-        static std::shared_ptr<Data> get(Boxed_Value::Void_Type)
+        static std::shared_ptr<Data> get(Boxed_Value::Void_Type, bool, bool)
         {
           return std::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
@@ -79,13 +87,13 @@ namespace chaiscript
         }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const std::shared_ptr<T> *obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> *obj, bool, bool)
           {
             return get(*obj);
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const std::shared_ptr<T> &obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> &obj, bool, bool)
           {
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
@@ -95,6 +103,18 @@ namespace chaiscript
                 );
           }
 
+        template<typename T>
+          static std::shared_ptr<Data> get(std::shared_ptr<T> &&obj, bool, bool)
+          {
+            auto ptr = obj.get();
+            return std::make_shared<Data>(
+                  detail::Get_Type_Info<T>::get(), 
+                  chaiscript::detail::Any(std::move(obj)), 
+                  false,
+                  ptr
+                );
+          }
+
         template<typename T>
           static std::shared_ptr<Data> get(T *t)
           {
@@ -102,32 +122,69 @@ namespace chaiscript
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(std::reference_wrapper<T> obj)
+          static std::shared_ptr<Data> get(std::reference_wrapper<T> obj, bool, bool)
           {
+            auto p = &obj.get();
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
-                  chaiscript::detail::Any(obj),
+                  chaiscript::detail::Any(std::move(obj)),
                   true,
-                  &obj.get()
+                  p
                 );
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const T& t)
+          static std::shared_ptr<Data> get(T t, bool t_value_type, bool t_make_const)
           {
-            auto p = std::make_shared<T>(t);
-            return std::make_shared<Data>(
-                  detail::Get_Type_Info<T>::get(), 
-                  chaiscript::detail::Any(p), 
-                  false,
-                  p.get()
-                );
+            typedef typename std::add_const<T>::type const_type;
+            if (t_make_const)
+            {
+              if (t_value_type)
+              {
+                chaiscript::detail::Any a(std::move(t));
+                return std::make_shared<Data>(
+                    detail::Get_Type_Info<const_type>::get(), 
+                    std::move(a),
+                    false,
+                    nullptr
+                    );
+              } else {
+                auto p = std::make_shared<const_type>(std::move(t));
+                auto ptr = p.get();
+                return std::make_shared<Data>(
+                    detail::Get_Type_Info<const_type>::get(), 
+                    chaiscript::detail::Any(std::move(p)),
+                    false,
+                    ptr
+                    );
+              }
+            } else {
+              if (t_value_type)
+              {
+                chaiscript::detail::Any a(std::move(t));
+                return std::make_shared<Data>(
+                    detail::Get_Type_Info<T>::get(), 
+                    std::move(a),
+                    false,
+                    nullptr
+                    );
+              } else {
+                auto p = std::make_shared<T>(std::move(t));
+                auto ptr = p.get();
+                return std::make_shared<Data>(
+                    detail::Get_Type_Info<T>::get(), 
+                    chaiscript::detail::Any(std::move(p)),
+                    false,
+                    ptr
+                    );
+              }
+            }
           }
 
         static std::shared_ptr<Data> get()
         {
           return std::make_shared<Data>(
-                Type_Info(),
+              Type_Info(),
                 chaiscript::detail::Any(),
                 false,
                 nullptr 
@@ -137,115 +194,125 @@ namespace chaiscript
       };
 
     public:
-      /**
-       * Basic Boxed_Value constructor
-       */
-      template<typename T>
-        explicit Boxed_Value(T t)
-        : m_data(Object_Data::get(t))
+      /// Basic Boxed_Value constructor
+        template<typename T,
+          typename = typename std::enable_if<!std::is_same<Boxed_Value, typename std::decay<T>::type>::value>::type>
+        explicit Boxed_Value(T &&t, bool t_make_const=false, bool t_value_type = std::is_trivial<typename std::decay<T>::type>::value)
+          : m_data(Object_Data::get(std::forward<T>(t), t_make_const, t_value_type))
         {
+          //std::cout << "typeid: " << typeid(T).name() << " is trivial " << std::is_trivial<typename std::decay<T>::type>::value << "\n";
         }
 
-      /**
-       * 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())
       {
       }
 
-      ~Boxed_Value()
-      {
-      }
+#if !defined(_MSC_VER) || _MSC_VER != 1800
+      Boxed_Value(Boxed_Value&&) = default;
+      Boxed_Value& operator=(Boxed_Value&&) = default;
+#endif
+
+      Boxed_Value(const Boxed_Value&) = default;
+      Boxed_Value& operator=(const Boxed_Value&) = default;
 
       void swap(Boxed_Value &rhs)
       {
         std::swap(m_data, rhs.m_data);
       }
 
-      /**
-       * copy the values stored in rhs.m_data to m_data
-       * m_data pointers are not shared in this case
-       */
+      /// Copy the values stored in rhs.m_data to m_data.
+      /// m_data pointers are not shared in this case
       Boxed_Value assign(const Boxed_Value &rhs)
       {
         (*m_data) = (*rhs.m_data);
         return *this;
       }
 
-      /**
-       * shared data assignment, same as copy construction
-       */
-      Boxed_Value &operator=(const Boxed_Value &rhs)
-      {
-        Boxed_Value temp(rhs);
-        swap(temp);
-        return *this;
-      }
-
-      const Type_Info &get_type_info() const
+      const Type_Info &get_type_info() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info;
       }
 
-      /**
-       * return true if the object is uninitialized
-       */
-      bool is_undef() const
+      /// return true if the object is uninitialized
+      bool is_undef() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info.is_undef();
       }
 
-      bool is_const() const
+      bool is_const() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info.is_const();
       }
 
-      bool is_type(const Type_Info &ti) const
+      bool is_type(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info.bare_equal(ti);
       }
 
-      bool is_null() const
+      bool is_null() const CHAISCRIPT_NOEXCEPT
       {
-        return (m_data->m_data_ptr == 0 && m_data->m_const_data_ptr == 0);
+        return (m_data->m_data_ptr == nullptr && m_data->m_const_data_ptr == nullptr);
       }
 
-      const chaiscript::detail::Any & get() const
+      const chaiscript::detail::Any & get() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_obj;
       }
 
-      bool is_ref() const
+      bool is_ref() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_is_ref;
       }
 
-      bool is_pointer() const
+      bool is_pointer() const CHAISCRIPT_NOEXCEPT
       {
         return !is_ref();
       }
 
-      void *get_ptr() const
+      void *get_ptr() const CHAISCRIPT_NOEXCEPT
       {
-        return m_data->m_data_ptr;
+        if (m_data->m_data_ptr)
+        {
+          return m_data->m_data_ptr;
+        } else {
+          return m_data->m_obj.data();
+        }
       }
 
-      const void *get_const_ptr() const
+      const void *get_const_ptr() const CHAISCRIPT_NOEXCEPT
       {
-        return m_data->m_const_data_ptr;
+        if (m_data->m_const_data_ptr)
+        {
+          return m_data->m_const_data_ptr;
+        } else {
+          return m_data->m_obj.data();
+        }
       }
 
+      Boxed_Value get_attr(const std::string &t_name)
+      {
+        if (!m_data->m_attrs)
+        {
+          m_data->m_attrs = std::unique_ptr<std::map<std::string, Boxed_Value>>(new std::map<std::string, Boxed_Value>());
+        }
+
+        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)
+      static bool type_match(const Boxed_Value &l, const Boxed_Value &r) CHAISCRIPT_NOEXCEPT
       {
         return l.get_type_info() == r.get_type_info();
       }
@@ -254,19 +321,20 @@ namespace chaiscript
       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, std::shared_ptr, or std::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)
     {
@@ -281,7 +349,7 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(const T &t)
       {
-        return Boxed_Value(std::shared_ptr<typename std::add_const<T>::type >(new T(t)));
+        return Boxed_Value(std::make_shared<typename std::add_const<T>::type >(t), true);
       }
 
     /// \brief Takes a pointer to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
@@ -339,7 +407,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)
     {

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

@@ -9,11 +9,16 @@
 
 #include <memory>
 #include <set>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
 
-#include "type_info.hpp"
-#include "boxed_value.hpp"
-#include "boxed_cast_helper.hpp"
+#include "../chaiscript_threading.hpp"
 #include "bad_boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "type_info.hpp"
 
 namespace chaiscript
 {
@@ -48,12 +53,13 @@ namespace chaiscript
     {
       public:
         virtual Boxed_Value convert(const Boxed_Value &derived) const = 0;
+        virtual Boxed_Value convert_down(const Boxed_Value &base) const = 0;
 
-        const Type_Info &base()
+        const Type_Info &base() const
         {
           return m_base;
         }
-        const Type_Info &derived()
+        const Type_Info &derived() const
         {
           return m_derived;
         }
@@ -72,6 +78,57 @@ namespace chaiscript
 
     };
 
+    template<typename From, typename To> 
+      class Dynamic_Caster
+      {
+        public: 
+          static Boxed_Value cast(const Boxed_Value &t_from)
+          {
+            if (t_from.get_type_info().bare_equal(user_type<From>()))
+            {
+              if (t_from.is_pointer())
+              {
+                // Dynamic cast out the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  std::shared_ptr<const To> data
+                    = std::dynamic_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr));
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                } else {
+                  std::shared_ptr<To> data
+                    = std::dynamic_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr));
+
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                }
+              } else {
+                // Pull the reference out of the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  const From &d = detail::Cast_Helper<const From &>::cast(t_from, nullptr);
+                  const To &data = dynamic_cast<const To &>(d);
+                  return Boxed_Value(std::cref(data));
+                } else {
+                  From &d = detail::Cast_Helper<From &>::cast(t_from, nullptr);
+                  To &data = dynamic_cast<To &>(d);
+                  return Boxed_Value(std::ref(data));
+                }
+              }
+            } else {
+              throw chaiscript::exception::bad_boxed_dynamic_cast(t_from.get_type_info(), typeid(To), "Unknown dynamic_cast_conversion");
+            }
+          }
+      };
+
     template<typename Base, typename Derived>
       class Dynamic_Conversion_Impl : public Dynamic_Conversion
     {
@@ -81,50 +138,14 @@ namespace chaiscript
         {
         }
 
-        virtual Boxed_Value convert(const Boxed_Value &t_derived) const
+        virtual Boxed_Value convert_down(const Boxed_Value &t_base) const CHAISCRIPT_OVERRIDE
         {
-          if (t_derived.get_type_info().bare_equal(user_type<Derived>()))
-          {
-            if (t_derived.is_pointer())
-            {
-              // Dynamic cast out the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                std::shared_ptr<const Base> data 
-                  = std::dynamic_pointer_cast<const Base>(detail::Cast_Helper<std::shared_ptr<const Derived> >::cast(t_derived, nullptr));
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
+          return Dynamic_Caster<Base, Derived>::cast(t_base);
+        }
 
-                return Boxed_Value(data);
-              } else {
-                std::shared_ptr<Base> data 
-                  = std::dynamic_pointer_cast<Base>(detail::Cast_Helper<std::shared_ptr<Derived> >::cast(t_derived, 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_derived.is_const())
-              {
-                const Derived &d = detail::Cast_Helper<const Derived &>::cast(t_derived, 0);
-                const Base &data = dynamic_cast<const Base &>(d);
-                return Boxed_Value(std::cref(data));
-              } else {
-                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived, 0);
-                Base &data = dynamic_cast<Base &>(d);
-                return Boxed_Value(std::ref(data));
-              }
-            }
-          } else {
-            throw chaiscript::exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
-          }
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
+        {
+          return Dynamic_Caster<Derived, Base>::cast(t_derived);
         }
     };
   }
@@ -155,7 +176,7 @@ namespace chaiscript
 
       bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived) const
       {
-        return has_conversion(base, derived);
+        return has_conversion(base, derived) || has_conversion(derived, base);
       }
 
       template<typename Base>
@@ -170,6 +191,19 @@ namespace chaiscript
           }
         }
 
+      template<typename Derived>
+        Boxed_Value boxed_dynamic_down_cast(const Boxed_Value &base) const
+        {
+          try {
+            return get_conversion(base.get_type_info(), user_type<Derived>())->convert_down(base);
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "Unable to perform dynamic_cast operation");
+          }
+        }
+
+
       bool has_conversion(const Type_Info &base, const Type_Info &derived) const
       {
         chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
@@ -180,7 +214,7 @@ namespace chaiscript
       {
         chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
-        std::set<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr =
+        auto itr =
           find(base, derived);
 
         if (itr != m_conversions.end())
@@ -195,7 +229,7 @@ namespace chaiscript
       std::set<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
           const Type_Info &base, const Type_Info &derived) const
       {
-        for (std::set<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr = m_conversions.begin();
+        for (auto itr = m_conversions.begin();
             itr != m_conversions.end();
             ++itr)
         {
@@ -224,7 +258,7 @@ namespace chaiscript
   /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
   ///        want automatic conversions up your inheritance hierarchy.
   ///
-  /// Create a new base class registration for applying to a module or to the chaiscript engine
+  /// Create a new base class registration for applying to a module or to the ChaiScript engine
   /// Currently, due to limitations in module loading on Windows, and for the sake of portability,
   /// if you have a type that is introduced in a loadable module and is used by multiple modules
   /// (through a tertiary dll that is shared between the modules, static linking the new type
@@ -242,8 +276,6 @@ 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()
   {

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -7,6 +7,27 @@
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 #define CHAISCRIPT_DYNAMIC_OBJECT_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
 {
@@ -15,8 +36,8 @@ namespace chaiscript
     class Dynamic_Object
     {
       public:
-        Dynamic_Object(const std::string &t_type_name)
-          : m_type_name(t_type_name)
+        Dynamic_Object(std::string t_type_name)
+          : m_type_name(std::move(t_type_name))
         {
         }
 
@@ -30,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;
         }
@@ -52,21 +73,21 @@ namespace chaiscript
       {
         public:
           Dynamic_Object_Function(
-              const std::string &t_type_name,
+              std::string t_type_name,
               const Proxy_Function &t_func)
             : Proxy_Function_Base(t_func->get_param_types()),
-            m_type_name(t_type_name), m_func(t_func)
+            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(
-              const std::string &t_type_name,
+              std::string t_type_name,
               const Proxy_Function &t_func,
               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(new Type_Info(t_ti))
+              m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>())
           {
             assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
                 && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
@@ -74,7 +95,9 @@ namespace chaiscript
 
           virtual ~Dynamic_Object_Function() {}
 
-          virtual bool operator==(const Proxy_Function_Base &f) const
+          Dynamic_Object_Function &operator=(const Dynamic_Object_Function) = delete;
+
+          virtual bool operator==(const Proxy_Function_Base &f) const CHAISCRIPT_OVERRIDE
           {
             const Dynamic_Object_Function *df = dynamic_cast<const Dynamic_Object_Function *>(&f);
             if (df)
@@ -85,7 +108,7 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
             {
@@ -95,25 +118,25 @@ namespace chaiscript
             }
           }    
 
-          virtual std::vector<Const_Proxy_Function> get_contained_functions() const
+          virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
           {
             return {m_func};
           }
 
 
-          virtual int get_arity() const
+          virtual int get_arity() const CHAISCRIPT_OVERRIDE
           {
             return m_func->get_arity();
           }
 
-          virtual std::string annotation() const
+          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
           {
             return m_func->annotation();
           }
 
 
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
             {
@@ -123,7 +146,7 @@ namespace chaiscript
             } 
           }
 
-          virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             return dynamic_object_typename_match(bv, m_type_name, m_ti, t_conversions);
           }
@@ -140,11 +163,10 @@ namespace chaiscript
             return types;
           }
 
-          static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions)
+          bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
+              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) const
           {
-            static Type_Info doti = user_type<Dynamic_Object>();
-            if (bv.get_type_info().bare_equal(doti))
+            if (bv.get_type_info().bare_equal(m_doti))
             {
               try {
                 const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
@@ -163,8 +185,8 @@ namespace chaiscript
 
           }
 
-          static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) 
+          bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) const
           {
             if (bvs.size() > 0)
             {
@@ -177,6 +199,8 @@ namespace chaiscript
           std::string m_type_name;
           Proxy_Function m_func;
           std::shared_ptr<Type_Info> m_ti;
+          const Type_Info m_doti;
+
 
       };
 
@@ -191,10 +215,10 @@ namespace chaiscript
       {
         public:
           Dynamic_Object_Constructor(
-              const std::string &t_type_name,
+              std::string t_type_name,
               const Proxy_Function &t_func)
             : Proxy_Function_Base(build_type_list(t_func->get_param_types())),
-              m_type_name(t_type_name), m_func(t_func)
+              m_type_name(std::move(t_type_name)), m_func(t_func)
           {
             assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
                 && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
@@ -202,8 +226,8 @@ namespace chaiscript
 
           static std::vector<Type_Info> build_type_list(const std::vector<Type_Info> &tl)
           {
-            std::vector<Type_Info>::const_iterator begin = tl.begin();
-            std::vector<Type_Info>::const_iterator end = tl.end();
+            auto begin = tl.begin();
+            auto end = tl.end();
 
             if (begin != end)
             {
@@ -215,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)
@@ -226,7 +250,7 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             std::vector<Boxed_Value> new_vals;
             new_vals.push_back(Boxed_Value(Dynamic_Object(m_type_name)));
@@ -236,19 +260,19 @@ namespace chaiscript
           }    
 
 
-          virtual int get_arity() const
+          virtual int get_arity() const CHAISCRIPT_OVERRIDE
           {
             // "this" is not considered part of the arity
             return m_func->get_arity() - 1; 
           }
 
-          virtual std::string annotation() const
+          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
           {
             return m_func->annotation();
           }
 
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
           {
             std::vector<Boxed_Value> new_params;
             chaiscript::Boxed_Value bv = var(Dynamic_Object(m_type_name));

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -7,12 +7,23 @@
 #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
   {
+    /// \todo make this a variadic template
     struct Exception_Handler_Base
     {
       virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) = 0;
@@ -32,7 +43,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl1() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
         }
@@ -42,7 +53,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl2() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);
@@ -54,7 +65,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl3() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);
@@ -66,7 +77,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl4() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);
@@ -79,7 +90,7 @@ namespace chaiscript
       {
         virtual ~Exception_Handler_Impl5() {}
 
-        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) CHAISCRIPT_OVERRIDE
         {
           throw_type<T1>(bv, t_engine);
           throw_type<T2>(bv, t_engine);

include/chaiscript/dispatchkit/function_call.hpp

@@ -7,13 +7,22 @@
 #ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_HPP_
 
+#include <functional>
+#include <iostream>
 #include <string>
 #include <vector>
-#include "proxy_functions.hpp"
+
+#include "boxed_cast.hpp"
 #include "function_call_detail.hpp"
+#include "proxy_functions.hpp"
 
-
-#include <iostream>
+namespace chaiscript {
+class Boxed_Value;
+class Dynamic_Cast_Conversions;
+namespace detail {
+template <typename T> struct Cast_Helper;
+}  // namespace detail
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -31,7 +40,7 @@ namespace chaiscript
       std::function<FunctionType>
       functor(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
       {
-        FunctionType *p=0;
+        FunctionType *p=nullptr;
         return detail::build_function_caller_helper(p, funcs, t_conversions);
       }
 

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -7,8 +7,17 @@
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 
+#include <algorithm>
+#include <functional>
+#include <memory>
 #include <string>
+#include <type_traits>
 #include <vector>
+
+#include "boxed_cast.hpp"
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+#include "dynamic_cast_conversion.hpp"
 #include "proxy_functions.hpp"
 
 namespace chaiscript
@@ -17,12 +26,11 @@ namespace chaiscript
   {
     namespace detail
     {
-
       /**
        * Internal helper class for handling the return
        * value of a build_function_caller
        */
-      template<typename Ret>
+      template<typename Ret, bool is_arithmetic>
         struct Function_Caller_Ret
         {
           static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
@@ -32,11 +40,25 @@ namespace chaiscript
           }
         };
 
+      /**
+       * Specialization for arithmetic return types
+       */
+      template<typename Ret>
+        struct Function_Caller_Ret<Ret, true>
+        {
+          static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          {
+            return Boxed_Number(dispatch::dispatch(t_funcs, params, t_conversions)).get_as<Ret>();
+          }
+        };
+
+
       /**
        * Specialization for void return types
        */
       template<>
-        struct Function_Caller_Ret<void>
+        struct Function_Caller_Ret<void, false>
         {
           static void call(const std::vector<Const_Proxy_Function> &t_funcs, 
               const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
@@ -51,19 +73,19 @@ namespace chaiscript
       template<typename Ret, typename ... Param>
         struct Build_Function_Caller_Helper
         {
-          Build_Function_Caller_Helper(const std::vector<Const_Proxy_Function> &t_funcs, const Dynamic_Cast_Conversions &t_conversions)
-            : m_funcs(t_funcs),
+          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)
           {
           }
 
           Ret operator()(Param...param)
           {
-            return Function_Caller_Ret<Ret>::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, std::is_arithmetic<Ret>::value && !std::is_same<Ret, bool>::value>::call(m_funcs, { 
+                (std::is_reference<Param>::value&&!(std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<Param>::type>::type>::value))?Boxed_Value(std::ref(param)):Boxed_Value(param)... 
+                }, m_conversions
+
+                );
 
           }
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -7,14 +7,20 @@
 #ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
 #define CHAISCRIPT_HANDLE_RETURN_HPP_
 
-#include "boxed_value.hpp"
-#include "boxed_number.hpp"
-#include "type_info.hpp"
-#include <string>
-
+#include <functional>
+#include <memory>
 #include <stdexcept>
+#include <string>
 #include <vector>
 
+#include "boxed_number.hpp"
+#include "boxed_value.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Boxed_Number;
+}  // namespace chaiscript
+
 namespace chaiscript
 {
   namespace dispatch

include/chaiscript/dispatchkit/operators.hpp

@@ -8,6 +8,7 @@
 #define CHAISCRIPT_OPERATORS_HPP_
 
 #include "../chaiscript_defines.hpp"
+#include "register_function.hpp"
 
 namespace chaiscript 
 {
@@ -15,442 +16,446 @@ namespace chaiscript
   {
     namespace operators
     {
-      template<typename Ret, typename L, typename R>
-        Ret assign(L l, R r)
-        {
-          return (l = r);
-        }
+      namespace detail
+      {
+        /// \todo make this return a decltype once we drop gcc 4.6
+        template<typename L, typename R>
+          auto assign(L l, R r) -> L&
+          {
+            return (l = r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_bitwise_and(L l, R r)
-        {
-          return (l &= r);
-        }
+        template<typename L, typename R>
+          auto assign_bitwise_and(L l, R r) -> decltype((l &= r))
+          {
+            return (l &= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_xor(L l, R r)
-        {
-          return (l ^= r);
-        }
+        template<typename L, typename R>
+          auto assign_xor(L l, R r) -> decltype((l^=r))
+          {
+            return (l ^= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_bitwise_or(L l, R r)
-        {
-          return (l |= r);
-        }
+        template<typename L, typename R>
+          auto assign_bitwise_or(L l, R r) -> decltype((l |= r))
+          {
+            return (l |= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_difference(L l, R r)
-        {
-          return (l -= r);
-        }
+        template<typename L, typename R>
+          auto assign_difference(L l, R r) -> decltype(( l -= r))
+          {
+            return (l -= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_left_shift(L l, R r)
-        {
-          return (l <<= r);
-        }
+        template<typename L, typename R>
+          auto assign_left_shift(L l, R r) -> decltype(( l <<= r))
+          {
+            return (l <<= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_product(L l, R r)
-        {
-          return (l *= r);
-        }
+        template<typename L, typename R>
+          auto assign_product(L l, R r) -> decltype(( l *= r ))
+          {
+            return (l *= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_quotient(L l, R r)
-        {
-          return (l /= r);
-        }
+        template<typename L, typename R>
+          auto assign_quotient(L l, R r) -> decltype(( l /= r ))
+          {
+            return (l /= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_remainder(L l, R r)
-        {
-          return (l %= r);
-        }
+        template<typename L, typename R>
+          auto assign_remainder(L l, R r) -> decltype(( l %= r ))
+          {
+            return (l %= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_right_shift(L l, R r)
-        {
-          return (l >>= r);
-        }
+        template<typename L, typename R>
+          auto assign_right_shift(L l, R r) -> decltype(( l >>= r))
+          {
+            return (l >>= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_sum(L l, R r)
-        {
-          return (l += r);
-        }
+        /// \todo make this return a decltype once we drop gcc 4.6
+        template<typename L, typename R>
+          auto assign_sum(L l, R r) -> L&
+          {
+            return (l += r);
+          }
 
-      template<typename Ret, typename L>
-        Ret prefix_decrement(L l)
-        {
-          return (--l);
-        }
+        template<typename L>
+          auto prefix_decrement(L l) -> decltype(( --l ))
+          {
+            return (--l);
+          }
 
-      template<typename Ret, typename L>
-        Ret prefix_increment(L l)
-        {
-          return (++l);
-        }
+        template<typename L>
+          auto prefix_increment(L l) -> decltype(( ++l ))
+          {
+            return (++l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret equal(L l, R r)
-        {
-          return (l == r);
-        }
+        template<typename L, typename R>
+          auto equal(L l, R r) -> decltype(( l == r ))
+          {
+            return (l == r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret greater_than(L l, R r)
-        {
-          return (l > r);
-        }
+        template<typename L, typename R>
+          auto greater_than(L l, R r) -> decltype(( l > r ))
+          {
+            return (l > r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret greater_than_equal(L l, R r)
-        {
-          return (l >= r);
-        }
+        template<typename L, typename R>
+          auto greater_than_equal(L l, R r) -> decltype(( l >= r ))
+          {
+            return (l >= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret less_than(L l, R r)
-        {
-          return (l < r);
-        }
+        template<typename L, typename R>
+          auto less_than(L l, R r) -> decltype(( l < r ))
+          {
+            return (l < r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret less_than_equal(L l, R r)
-        {
-          return (l <= r);
-        }
+        template<typename L, typename R>
+          auto less_than_equal(L l, R r) -> decltype(( l <= r ))
+          {
+            return (l <= r);
+          }
 
-      template<typename Ret, typename L>
-        Ret logical_compliment(L l)
-        {
-          return (!l);
-        }
+        template<typename L>
+          auto logical_compliment(L l) -> decltype(( !l ))
+          {
+            return (!l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret not_equal(L l, R r)
-        {
-          return (l != r);
-        }
+        template<typename L, typename R>
+          auto not_equal(L l, R r) -> decltype(( l != r ))
+          {
+            return (l != r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret addition(L l, R r)
-        {
-          return (l + r);
-        }
+        template<typename L, typename R>
+          auto addition(L l, R r) -> decltype(( l + r ))
+          {
+            return (l + r);
+          }
 
-      template<typename Ret, typename L>
-        Ret unary_plus(L l)
-        {
-          return (+l);
-        }
+        template<typename L>
+          auto unary_plus(L l) -> decltype(( +l ))
+          {
+            return (+l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret subtraction(L l, R r)
-        {
-          return (l - r);
-        }
+        template<typename L, typename R>
+          auto subtraction(L l, R r) -> decltype(( l - r ))
+          {
+            return (l - r);
+          }
 
-      template<typename Ret, typename L>
-        Ret unary_minus(L l)
-        {
+        template<typename L>
+          auto unary_minus(L l) -> decltype(( -l ))
+          {
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4146)
-          return (-l);
+            return (-l);
 #pragma warning(pop)
 #else
-          return (-l);
+            return (-l);
 #endif
-        }
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_and(L l, R r)
-        {
-          return (l & r);
-        }
+        template<typename L, typename R>
+          auto bitwise_and(L l, R r) -> decltype(( l & r ))
+          {
+            return (l & r);
+          }
 
-      template<typename Ret, typename L>
-        Ret bitwise_compliment(L l)
-        {
-          return (~l);
-        }
+        template<typename L>
+          auto bitwise_compliment(L l) -> decltype(( ~l ))
+          {
+            return (~l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_xor(L l, R r)
-        {
-          return (l ^ r);
-        }
+        template<typename L, typename R>
+          auto bitwise_xor(L l, R r) -> decltype(( l ^ r ))
+          {
+            return (l ^ r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_or(L l, R r)
-        {
-          return (l | r);
-        }
+        template<typename L, typename R>
+          auto bitwise_or(L l, R r) -> decltype(( l | r ))
+          {
+            return (l | r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret division(L l, R r)
-        {
-          return (l / r);
-        }
+        template<typename L, typename R>
+          auto division(L l, R r) -> decltype(( l / r ))
+          {
+            return (l / r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret left_shift(L l, R r)
-        {
-          return l << r;
-        }
+        template<typename L, typename R>
+          auto left_shift(L l, R r) -> decltype(( l << r ))
+          {
+            return l << r;
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret multiplication(L l, R r)
-        {
-          return l * r;
-        }
+        template<typename L, typename R>
+          auto multiplication(L l, R r) -> decltype(( l * r ))
+          {
+            return l * r;
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret remainder(L l, R r)
-        {
-          return (l % r);
-        }
-
-      template<typename Ret, typename L, typename R>
-        Ret right_shift(L l, R r)
-        {
-          return (l >> r);
-        }
+        template<typename L, typename R>
+          auto remainder(L l, R r) -> decltype(( l % r ))
+          {
+            return (l % r);
+          }
 
+        template<typename L, typename R>
+          auto right_shift(L l, R r) -> decltype(( l >> r ))
+          {
+            return (l >> r);
+          }
+      }
 
 
 
       template<typename T>
         ModulePtr assign(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign<T &, T &, const T&>), "=");
+          m->add(chaiscript::fun(&detail::assign<T &, const T&>), "=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_bitwise_and(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_bitwise_and<T &, T &, const T&>), "&=");
+          m->add(chaiscript::fun(&detail::assign_bitwise_and<T &, const T&>), "&=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_xor(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_xor<T &, T &, const T&>), "^=");
+          m->add(chaiscript::fun(&detail::assign_xor<T &, const T&>), "^=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_bitwise_or(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_bitwise_or<T &, T &, const T&>), "|=");
+          m->add(chaiscript::fun(&detail::assign_bitwise_or<T &, const T&>), "|=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_difference(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_difference<T &, T &, const T&>), "-=");
+          m->add(chaiscript::fun(&detail::assign_difference<T &, const T&>), "-=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_left_shift(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_left_shift<T &, T &, const T&>), "<<=");
+          m->add(chaiscript::fun(&detail::assign_left_shift<T &, const T&>), "<<=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_product(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_product<T &, T &, const T&>), "*=");
+          m->add(chaiscript::fun(&detail::assign_product<T &, const T&>), "*=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_quotient(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_quotient<T &, T &, const T&>), "/=");
+          m->add(chaiscript::fun(&detail::assign_quotient<T &, const T&>), "/=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_remainder(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_remainder<T &, T &, const T&>), "%=");
+          m->add(chaiscript::fun(&detail::assign_remainder<T &, const T&>), "%=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_right_shift(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_right_shift<T &, T &, const T&>), ">>=");
+          m->add(chaiscript::fun(&detail::assign_right_shift<T &, const T&>), ">>=");
           return m;
         }
 
       template<typename T>
         ModulePtr assign_sum(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign_sum<T &, T &, const T&>), "+=");
+          m->add(chaiscript::fun(&detail::assign_sum<T &, const T&>), "+=");
           return m;
         }
 
       template<typename T>
         ModulePtr prefix_decrement(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&prefix_decrement<T &, T &>), "--");
+          m->add(chaiscript::fun(&detail::prefix_decrement<T &>), "--");
           return m;
         }
 
       template<typename T>
         ModulePtr prefix_increment(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&prefix_increment<T &, T &>), "++");
+          m->add(chaiscript::fun(&detail::prefix_increment<T &>), "++");
           return m;
         }
 
       template<typename T>
         ModulePtr equal(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&equal<bool, const T&, const T&>), "==");
+          m->add(chaiscript::fun(&detail::equal<const T&, const T&>), "==");
           return m;
         }
 
       template<typename T>
         ModulePtr greater_than(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&greater_than<bool, const T&, const T&>), ">");
+          m->add(chaiscript::fun(&detail::greater_than<const T&, const T&>), ">");
           return m;
         }
 
       template<typename T>
         ModulePtr greater_than_equal(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&greater_than_equal<bool, const T&, const T&>), ">=");
+          m->add(chaiscript::fun(&detail::greater_than_equal<const T&, const T&>), ">=");
           return m;
         }
 
       template<typename T>
         ModulePtr less_than(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&less_than<bool, const T&, const T&>), "<");
+          m->add(chaiscript::fun(&detail::less_than<const T&, const T&>), "<");
           return m;
         }
 
       template<typename T>
         ModulePtr less_than_equal(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&less_than_equal<bool, const T&, const T&>), "<=");
+          m->add(chaiscript::fun(&detail::less_than_equal<const T&, const T&>), "<=");
           return m;
         }
 
       template<typename T>
         ModulePtr logical_compliment(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&logical_compliment<bool, const T &>), "!");
+          m->add(chaiscript::fun(&detail::logical_compliment<const T &>), "!");
           return m;
         }
 
       template<typename T>
         ModulePtr not_equal(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&not_equal<bool, const T &, const T &>), "!=");
+          m->add(chaiscript::fun(&detail::not_equal<const T &, const T &>), "!=");
           return m;
         }
 
       template<typename T>
         ModulePtr addition(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&addition<T, const T &, const T &>), "+");
+          m->add(chaiscript::fun(&detail::addition<const T &, const T &>), "+");
           return m;
         }
 
       template<typename T>
         ModulePtr unary_plus(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&unary_plus<T, const T &>), "+");
+          m->add(chaiscript::fun(&detail::unary_plus<const T &>), "+");
           return m;
         }
 
       template<typename T>
         ModulePtr subtraction(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&subtraction<T, const T &, const T &>), "-");
+          m->add(chaiscript::fun(&detail::subtraction<const T &, const T &>), "-");
           return m;
         }
 
       template<typename T>
         ModulePtr unary_minus(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&unary_minus<T, const T &>), "-");
+          m->add(chaiscript::fun(&detail::unary_minus<const T &>), "-");
           return m;
         }
 
       template<typename T>
         ModulePtr bitwise_and(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&bitwise_and<T, const T &, const T &>), "&");
+          m->add(chaiscript::fun(&detail::bitwise_and<const T &, const T &>), "&");
           return m;
         }
 
       template<typename T>
         ModulePtr bitwise_compliment(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&bitwise_compliment<T, const T &>), "~");
+          m->add(chaiscript::fun(&detail::bitwise_compliment<const T &>), "~");
           return m;
         }
 
       template<typename T>
         ModulePtr bitwise_xor(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&bitwise_xor<T, const T &, const T &>), "^");
+          m->add(chaiscript::fun(&detail::bitwise_xor<const T &, const T &>), "^");
           return m;
         }
 
       template<typename T>
         ModulePtr bitwise_or(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&bitwise_or<T, const T &, const T &>), "|");
+          m->add(chaiscript::fun(&detail::bitwise_or<const T &, const T &>), "|");
           return m;
         }
 
       template<typename T>
         ModulePtr division(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&division<T, const T &, const T &>), "/");
+          m->add(chaiscript::fun(&detail::division<const T &, const T &>), "/");
           return m;
         }
 
       template<typename T>
         ModulePtr left_shift(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&left_shift<T, const T &, const T &>), "<<");
+          m->add(chaiscript::fun(&detail::left_shift<const T &, const T &>), "<<");
           return m;
         }
 
       template<typename T>
         ModulePtr multiplication(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&multiplication<T, const T &, const T &>), "*");
+          m->add(chaiscript::fun(&detail::multiplication<const T &, const T &>), "*");
           return m;
         }
 
       template<typename T>
         ModulePtr remainder(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&remainder<T, const T &, const T &>), "%");
+          m->add(chaiscript::fun(&detail::remainder<const T &, const T &>), "%");
           return m;
         }
 
       template<typename T>
         ModulePtr right_shift(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&right_shift<T, const T &, const T &>), ">>");
+          m->add(chaiscript::fun(&detail::right_shift<const T &, const T &>), ">>");
           return m;
         }
     }

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -21,7 +21,7 @@ namespace chaiscript
       template<typename Class, typename ... Params>
         std::shared_ptr<Class> constructor_(Params ... params)
         {
-          return std::shared_ptr<Class>(new Class(params...));
+          return std::make_shared<Class>(params...);
         }
 
       template<typename Class, typename ... Params  >
@@ -48,7 +48,7 @@ namespace chaiscript
   template<typename T>
     Proxy_Function constructor()
     {
-      T *f = 0;
+      T *f = nullptr;
       return (dispatch::detail::build_constructor_(f));
     }
 

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -9,21 +9,36 @@
 #define CHAISCRIPT_PROXY_FUNCTIONS_HPP_
 
 
-#include "boxed_value.hpp"
-#include "type_info.hpp"
+#include <algorithm>
+#include <cassert>
+#include <functional>
+#include <memory>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
-#include <stdexcept>
 #include <vector>
-#include <cassert>
+
+#include "../chaiscript_defines.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
 #include "proxy_functions_detail.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+namespace exception {
+class bad_boxed_cast;
+struct arity_error;
+}  // namespace exception
+}  // namespace chaiscript
 
 namespace chaiscript
 {
   class Boxed_Number;
   struct AST_Node;
 
-  typedef std::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<AST_Node> AST_NodePtr;
 
   namespace dispatch
   {
@@ -48,7 +63,7 @@ namespace chaiscript
 
         /// Returns a vector containing all of the types of the parameters the function returns/takes
         /// 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
+        /// value contains exactly 1 Type_Info object: the return type
         /// \returns the types of all parameters. 
         const std::vector<Type_Info> &get_param_types() const { return m_types; }
 
@@ -112,8 +127,8 @@ namespace chaiscript
       protected:
         virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
-        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
-          : m_types(t_types), m_has_arithmetic_param(false)
+        Proxy_Function_Base(std::vector<Type_Info> t_types)
+          : m_types(std::move(t_types)), m_has_arithmetic_param(false)
         {
           for (size_t i = 1; i < m_types.size(); ++i)
           {
@@ -167,7 +182,7 @@ namespace chaiscript
   /// \brief Common typedef used for passing of any registered function in ChaiScript
   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
+  /// \brief Const version of Proxy_Function. Points to a const Proxy_Function. This is how most registered functions
   ///        are handled internally.
   typedef std::shared_ptr<const dispatch::Proxy_Function_Base> Const_Proxy_Function;
 
@@ -196,19 +211,19 @@ namespace chaiscript
     {
       public:
         Dynamic_Proxy_Function(
-            const std::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, 
+            std::function<Boxed_Value (const std::vector<Boxed_Value> &)> t_f, 
             int t_arity=-1,
-            const AST_NodePtr &t_parsenode = AST_NodePtr(),
-            const std::string &t_description = "",
-            const Proxy_Function &t_guard = Proxy_Function())
+            AST_NodePtr t_parsenode = AST_NodePtr(),
+            std::string t_description = "",
+            Proxy_Function t_guard = Proxy_Function())
           : Proxy_Function_Base(build_param_type_list(t_arity)),
-            m_f(t_f), m_arity(t_arity), m_description(t_description), m_guard(t_guard), m_parsenode(t_parsenode)
+            m_f(std::move(t_f)), m_arity(t_arity), m_description(std::move(t_description)), m_guard(std::move(t_guard)), m_parsenode(std::move(t_parsenode))
         {
         }
 
         virtual ~Dynamic_Proxy_Function() {}
 
-        virtual bool operator==(const Proxy_Function_Base &rhs) const
+        virtual bool operator==(const Proxy_Function_Base &rhs) const CHAISCRIPT_OVERRIDE
         {
           const Dynamic_Proxy_Function *prhs = dynamic_cast<const Dynamic_Proxy_Function *>(&rhs);
 
@@ -218,13 +233,13 @@ namespace chaiscript
                 && !this->m_guard && !prhs->m_guard);
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return (m_arity < 0 || vals.size() == size_t(m_arity))
             && test_guard(vals, t_conversions);
         }    
 
-        virtual int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return m_arity;
         }
@@ -239,13 +254,13 @@ namespace chaiscript
           return m_parsenode;
         }
 
-        virtual std::string annotation() const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return m_description;
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (m_arity < 0 || params.size() == size_t(m_arity))
           {
@@ -329,19 +344,19 @@ namespace chaiscript
           assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
         }
 
-        virtual bool operator==(const Proxy_Function_Base &t_f) const
+        virtual bool operator==(const Proxy_Function_Base &t_f) const CHAISCRIPT_OVERRIDE
         {
           return &t_f == this;
         }
 
         virtual ~Bound_Function() {}
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return m_f->call_match(build_param_list(vals), t_conversions);
         }
 
-        virtual std::vector<Const_Proxy_Function> get_contained_functions() const
+        virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
         {
           std::vector<Const_Proxy_Function> fs;
           fs.push_back(m_f);
@@ -351,10 +366,8 @@ namespace chaiscript
 
         std::vector<Boxed_Value> build_param_list(const std::vector<Boxed_Value> &params) const
         {
-          typedef std::vector<Boxed_Value>::const_iterator pitr;
-
-          pitr parg = params.begin();
-          pitr barg = m_args.begin();
+          auto parg = params.begin();
+          auto barg = m_args.begin();
 
           std::vector<Boxed_Value> args;
 
@@ -382,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();
         }
@@ -416,7 +429,7 @@ namespace chaiscript
           return retval;
         }
 
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return (*m_f)(build_param_list(params), t_conversions);
         }
@@ -427,47 +440,64 @@ namespace chaiscript
         int m_arity;
     };
 
-    /**
-     * 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_Base
+    class Proxy_Function_Impl_Base : public Proxy_Function_Base
     {
       public:
-        Proxy_Function_Impl(const std::function<Func> &f)
-          : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(0))),
-          m_f(f), m_dummy_func(0)
+        Proxy_Function_Impl_Base(std::vector<Type_Info> t_types)
+          : Proxy_Function_Base(std::move(t_types))
         {
         }
 
-        virtual ~Proxy_Function_Impl() {}
+        virtual ~Proxy_Function_Impl_Base() {}
 
-        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 int get_arity() const
+        virtual int get_arity() const CHAISCRIPT_OVERRIDE
         {
           return static_cast<int>(m_types.size()) - 1;
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
+        {
+          return "";
+        }
+
+        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, t_conversions);
+          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 "";
+        }
+
+        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
@@ -501,7 +531,7 @@ namespace chaiscript
 
         virtual ~Attribute_Access() {}
 
-        virtual bool operator==(const Proxy_Function_Base &t_func) const
+        virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
         {
           const Attribute_Access<T, Class> * aa 
             = dynamic_cast<const Attribute_Access<T, Class> *>(&t_func);
@@ -514,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 Dynamic_Cast_Conversions &) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const CHAISCRIPT_OVERRIDE
         {
           if (vals.size() != 1)
           {
@@ -529,13 +559,13 @@ namespace chaiscript
           return vals[0].get_type_info().bare_equal(user_type<Class>());
         }
 
-        virtual std::string annotation() const
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return "";
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (params.size() == 1)
           {
@@ -573,9 +603,9 @@ namespace chaiscript
     class dispatch_error : public std::runtime_error
     {
       public:
-        dispatch_error(const std::vector<Boxed_Value> &t_parameters, 
-            const std::vector<Const_Proxy_Function> &t_functions)
-          : std::runtime_error("Error with function dispatch"), parameters(t_parameters), functions(t_functions)
+        dispatch_error(std::vector<Boxed_Value> t_parameters, 
+            std::vector<Const_Proxy_Function> t_functions)
+          : std::runtime_error("Error with function dispatch"), parameters(std::move(t_parameters)), functions(std::move(t_functions))
         {
         }
 

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -7,15 +7,25 @@
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
-#include "boxed_value.hpp"
-#include "boxed_cast.hpp"
-#include "type_info.hpp"
-#include "handle_return.hpp"
-#include <string>
-
+#include <algorithm>
+#include <functional>
 #include <stdexcept>
+#include <string>
 #include <vector>
 
+#include "../chaiscript_defines.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_value.hpp"
+#include "handle_return.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript {
+class Dynamic_Cast_Conversions;
+namespace exception {
+class bad_boxed_cast;
+}  // namespace exception
+}  // namespace chaiscript
+
 namespace chaiscript
 {
   namespace exception
@@ -43,29 +53,6 @@ namespace chaiscript
   {
     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.
@@ -73,12 +60,8 @@ namespace chaiscript
       template<typename Ret, typename ... Params>
         std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
         {
-          /// \todo this code was previously using { chaiscript::detail::Get_Type_Info<Ret>::get()... }
-          ///       but this seems to indicate another bug with MSVC's uniform initializer lists
-          std::vector<Type_Info> params;
-          params.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
-          Build_Param_Type_List<Params...>::build(params);
-          return params;
+          /// \note somehow this is responsible for a large part of the code generation
+          return { user_type<Ret>(), user_type<Params>()... };
         }
 
 
@@ -104,11 +87,11 @@ namespace chaiscript
           {
           }
         };
-      
+
 
       /**
        * Used by Proxy_Function_Impl to determine if it is equivalent to another
-       * Proxy_Function_Impl object. This function is primarly used to prevent
+       * Proxy_Function_Impl object. This function is primarily used to prevent
        * registration of two functions with the exact same signatures
        */
       template<typename Ret, typename ... Params>
@@ -145,7 +128,7 @@ namespace chaiscript
 #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)
+                const std::vector<Boxed_Value> &, const Dynamic_Cast_Conversions &t_conversions, InnerParams &&... innerparams)
             {
               return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams), &t_conversions)...);
             }
@@ -156,7 +139,7 @@ namespace chaiscript
 
       /**
        * Used by Proxy_Function_Impl to perform typesafe execution of a function.
-       * The function attempts to unbox each paramter to the expected type.
+       * The function attempts to unbox each parameter to the expected type.
        * if any unboxing fails the execution of the function fails and
        * the bad_boxed_cast is passed up to the caller.
        */
@@ -171,7 +154,7 @@ namespace chaiscript
 
           throw exception::arity_error(static_cast<int>(params.size()), sizeof...(Params));
         }
-          
+
     }
   }
 

include/chaiscript/dispatchkit/register_function.hpp

@@ -7,8 +7,12 @@
 #ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_
 #define CHAISCRIPT_REGISTER_FUNCTION_HPP_
 
-#include "dispatchkit.hpp"
+#include <functional>
+#include <type_traits>
+
 #include "bind_first.hpp"
+#include "dispatchkit.hpp"
+#include "proxy_functions.hpp"
 
 namespace chaiscript
 {
@@ -92,7 +96,7 @@ namespace chaiscript
   /// chai.add(fun(&MyClass::memberdata), "memberdata");
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T>
     Proxy_Function fun(T t)
     {
@@ -110,7 +114,7 @@ namespace chaiscript
   /// chai.add(fun(f), "some_function");
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T>
     Proxy_Function fun(const std::function<T> &f)
     {
@@ -135,7 +139,7 @@ namespace chaiscript
   /// 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)
     {
@@ -161,7 +165,7 @@ namespace chaiscript
   /// chai.add(fun(&MyClass::memberfunction, std::ref(obj), 1), "memberfunction"); 
   /// \endcode
   /// 
-  /// \sa \ref addingfunctions
+  /// \sa \ref adding_functions
   template<typename T, typename Q, typename R>
     Proxy_Function fun(T t, const Q &q, const R &r)
     {

include/chaiscript/dispatchkit/type_info.hpp

@@ -7,10 +7,11 @@
 #ifndef CHAISCRIPT_TYPE_INFO_HPP_
 #define CHAISCRIPT_TYPE_INFO_HPP_
 
-#include <string>
-#include <typeinfo>
+#include <functional>
 #include <memory>
+#include <string>
 #include <type_traits>
+#include <typeinfo>
 
 namespace chaiscript
 {
@@ -24,6 +25,7 @@ namespace chaiscript
       };
   }
 
+
   /// \brief Compile time deduced information about a type
   class Type_Info
   {
@@ -37,71 +39,57 @@ namespace chaiscript
       {
       }
 
-      Type_Info()
-        : m_type_info(0), m_bare_type_info(0),
+      CHAISCRIPT_CONSTEXPR Type_Info()
+        : m_type_info(nullptr), m_bare_type_info(nullptr),
         m_is_const(false), m_is_reference(false), m_is_pointer(false),
         m_is_void(false), m_is_arithmetic(false), 
         m_is_undef(true)
       {
       }
 
-      Type_Info(const Type_Info &ti)
-        : m_type_info(ti.m_type_info), 
-        m_bare_type_info(ti.m_bare_type_info),
-        m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
-        m_is_pointer(ti.m_is_pointer),
-        m_is_void(ti.m_is_void), m_is_arithmetic(ti.m_is_arithmetic),
-        m_is_undef(ti.m_is_undef)
-      {
-      }
+#if !defined(_MSC_VER) || _MSC_VER != 1800
+      Type_Info(Type_Info&&) = default;
+      Type_Info& operator=(Type_Info&&) = default;
+#endif
 
-      Type_Info &operator=(const Type_Info &ti)
-      {
-        m_type_info = ti.m_type_info;
-        m_bare_type_info = ti.m_bare_type_info;
-        m_is_const = ti.m_is_const;
-        m_is_reference = ti.m_is_reference;
-        m_is_pointer = ti.m_is_pointer;
-        m_is_void = ti.m_is_void;
-        m_is_arithmetic = ti.m_is_arithmetic;
-        m_is_undef = ti.m_is_undef;
-        return *this;
-      }
+      Type_Info(const Type_Info&) = default;
+      Type_Info& operator=(const Type_Info&) = default;
 
-      bool operator<(const Type_Info &ti) const
+
+      CHAISCRIPT_CONSTEXPR bool operator<(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return m_type_info < ti.m_type_info;
       }
 
-      bool operator==(const Type_Info &ti) const
+      CHAISCRIPT_CONSTEXPR bool operator==(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return ti.m_type_info == m_type_info 
           || (ti.m_type_info && m_type_info && *ti.m_type_info == *m_type_info);
       }
 
-      bool operator==(const std::type_info &ti) const
+      CHAISCRIPT_CONSTEXPR bool operator==(const std::type_info &ti) const CHAISCRIPT_NOEXCEPT
       {
-        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
+      CHAISCRIPT_CONSTEXPR bool bare_equal(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return ti.m_bare_type_info == m_bare_type_info 
           || (ti.m_bare_type_info && m_bare_type_info && *ti.m_bare_type_info == *m_bare_type_info);
       }
 
-      bool bare_equal_type_info(const std::type_info &ti) const
+      CHAISCRIPT_CONSTEXPR bool bare_equal_type_info(const std::type_info &ti) const CHAISCRIPT_NOEXCEPT
       {
-        return m_bare_type_info != 0 
+        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_arithmetic() const { return m_is_arithmetic; }
-      bool is_undef() const { return m_is_undef || m_bare_type_info == 0; }
-      bool is_pointer() const { return m_is_pointer; }
+      CHAISCRIPT_CONSTEXPR bool is_const() const CHAISCRIPT_NOEXCEPT { return m_is_const; }
+      CHAISCRIPT_CONSTEXPR bool is_reference() const CHAISCRIPT_NOEXCEPT { return m_is_reference; }
+      CHAISCRIPT_CONSTEXPR bool is_void() const CHAISCRIPT_NOEXCEPT { return m_is_void; }
+      CHAISCRIPT_CONSTEXPR bool is_arithmetic() const CHAISCRIPT_NOEXCEPT { return m_is_arithmetic; }
+      CHAISCRIPT_CONSTEXPR bool is_undef() const CHAISCRIPT_NOEXCEPT { return m_is_undef || m_bare_type_info == nullptr; }
+      CHAISCRIPT_CONSTEXPR bool is_pointer() const CHAISCRIPT_NOEXCEPT { return m_is_pointer; }
 
       std::string name() const
       {
@@ -113,7 +101,7 @@ namespace chaiscript
         }
       }
 
-      std::string bare_name() const
+      std::string bare_name() const 
       {
         if (m_bare_type_info)
         {
@@ -214,11 +202,6 @@ namespace chaiscript
         }
       };
 
-    template<typename T>
-      struct Stripped_Type
-      {
-        typedef typename Bare_Type<typename detail::Get_Type_Info<T>::type>::type type;
-      };
   }
 
   /// \brief Creates a Type_Info object representing the type passed in

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -5,7 +5,9 @@
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ALGEBRAIC_HPP_
-#define	CHAISCRIPT_ALGEBRAIC_HPP_
+#define CHAISCRIPT_ALGEBRAIC_HPP_
+
+#include <string>
 
 #include "../dispatchkit/dispatchkit.hpp"
 
@@ -126,5 +128,5 @@ namespace chaiscript
   };
 }
 
-#endif	/* _CHAISCRIPT_ALGEBRAIC_HPP */
+#endif /* _CHAISCRIPT_ALGEBRAIC_HPP */
 

include/chaiscript/language/chaiscript_common.hpp

@@ -5,10 +5,24 @@
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
-#define	CHAISCRIPT_COMMON_HPP_
+#define CHAISCRIPT_COMMON_HPP_
 
+#include <algorithm>
+#include <memory>
 #include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../chaiscript_defines.hpp"
+#include "../dispatchkit/boxed_value.hpp"
 #include "../dispatchkit/dispatchkit.hpp"
+#include "../dispatchkit/proxy_functions.hpp"
+#include "../dispatchkit/type_info.hpp"
+
+namespace chaiscript {
+struct AST_Node;
+}  // namespace chaiscript
 
 namespace chaiscript
 {
@@ -23,7 +37,7 @@ namespace chaiscript
                 Comparison, Addition, Subtraction, Multiplication, Division, Modulus, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
                 Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Continue, Map_Pair, Value_Range,
                 Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl, Shift, Equality, Bitwise_And, Bitwise_Xor, Bitwise_Or, 
-                Logical_And, Logical_Or, Reference, Switch, Case, Default, Ternary_Cond, Noop
+                Logical_And, Logical_Or, Reference, Switch, Case, Default, Ternary_Cond, Noop, Class
     };
   };
 
@@ -54,7 +68,8 @@ namespace chaiscript
   };
 
   /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
-  typedef std::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<const AST_Node> AST_NodePtr_Const;
 
 
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
@@ -68,7 +83,7 @@ namespace chaiscript
       File_Position end_position;
       std::string filename;
       std::string detail;
-      std::vector<AST_NodePtr> call_stack;
+      std::vector<AST_NodePtr_Const> call_stack;
 
       eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
@@ -253,11 +268,9 @@ namespace chaiscript
         } else {
           ss << "  " << t_functions.size() << " overloads available:" << std::endl;
 
-          for (std::vector<chaiscript::Const_Proxy_Function>::const_iterator itr = t_functions.begin();
-               itr != t_functions.end();
-               ++itr)
+          for (const auto & t_function : t_functions)
           {
-            ss << "      " << format_types((*itr), t_dot_notation, t_ss) << std::endl;
+            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << std::endl;
           }
 
         }
@@ -277,7 +290,7 @@ namespace chaiscript
         {
           std::string paramstr;
 
-          for (std::vector<Boxed_Value>::const_iterator itr = t_parameters.begin();
+          for (auto itr = t_parameters.begin();
                itr != t_parameters.end();
                ++itr)
           {
@@ -404,8 +417,8 @@ namespace chaiscript
 
         oss << text;
 
-        for (unsigned int j = 0; j < this->children.size(); ++j) {
-          oss << this->children[j]->pretty_print();
+        for (auto & elem : this->children) {
+          oss << elem->pretty_print();
         }
 
         return oss.str();
@@ -413,29 +426,25 @@ namespace chaiscript
 
 
       /// Prints the contents of an AST node, including its children, recursively
-      std::string to_string(std::string t_prepend = "") {
+      std::string to_string(const std::string &t_prepend = "") const {
         std::ostringstream oss;
 
         oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
             << this->text << " : " << this->start.line << ", " << this->start.column << std::endl;
-        
-        for (unsigned int j = 0; j < this->children.size(); ++j) {
+
+        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) 
+      Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) const
       {
         try {
           return eval_internal(t_e);
         } catch (exception::eval_error &ee) {
           ee.call_stack.push_back(shared_from_this());
-          throw ee;
+          throw;
         }
       }
 
@@ -446,19 +455,19 @@ namespace chaiscript
       }
 
     protected:
-      AST_Node(const std::string &t_ast_node_text, int t_id, const std::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 std::shared_ptr<std::string> &t_fname) :
-        text(t_ast_node_text), identifier(t_id), filename(t_fname) {}
+      AST_Node(std::string t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname) :
+        text(std::move(t_ast_node_text)), identifier(t_id), filename(t_fname) {}
 
       virtual ~AST_Node() {}
 
-      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &)
+      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &) const
       {
         throw std::runtime_error("Undispatched ast_node (internal error)");
       }
@@ -498,6 +507,9 @@ namespace chaiscript
       /// 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)
         {
@@ -511,16 +523,16 @@ namespace chaiscript
 
 
         private:
-        // explicitly unimplemented copy and assignment
-        Scope_Push_Pop(const Scope_Push_Pop &);
-        Scope_Push_Pop& operator=(const Scope_Push_Pop &);
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
 
-      /// Creates a new functon call and pops it on destruction
+      /// Creates a new function call and pops it on destruction
       struct Function_Push_Pop
       {
+        Function_Push_Pop(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)
         {
@@ -539,9 +551,6 @@ namespace chaiscript
 
 
         private:
-        // explicitly unimplemented copy and assignment
-        Function_Push_Pop(const Function_Push_Pop &);
-        Function_Push_Pop& operator=(const Function_Push_Pop &);
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
@@ -549,6 +558,9 @@ namespace chaiscript
       /// 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)
         {
@@ -562,9 +574,6 @@ namespace chaiscript
 
 
         private:
-        // explicitly unimplemented copy and assignment
-        Stack_Push_Pop(const Stack_Push_Pop &);
-        Stack_Push_Pop& operator=(const Stack_Push_Pop &);
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
@@ -572,5 +581,5 @@ namespace chaiscript
   }
 }
 
-#endif	/* _CHAISCRIPT_COMMON_HPP */
+#endif /* _CHAISCRIPT_COMMON_HPP */
 

include/chaiscript/language/chaiscript_engine.hpp

@@ -7,17 +7,34 @@
 #ifndef CHAISCRIPT_ENGINE_HPP_
 #define CHAISCRIPT_ENGINE_HPP_
 
+#include <cassert>
+#include <cstring>
+#include <algorithm>
 #include <exception>
 #include <fstream>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <vector>
 
 #include "../chaiscript_defines.hpp"
+#include "../chaiscript_threading.hpp"
+#include "../dispatchkit/boxed_cast_helper.hpp"
+#include "../dispatchkit/boxed_value.hpp"
+#include "../dispatchkit/dispatchkit.hpp"
+#include "../dispatchkit/dynamic_cast_conversion.hpp"
+#include "../dispatchkit/proxy_functions.hpp"
 #include "chaiscript_common.hpp"
 
-#if defined(__linux__) || defined(__unix__) || defined(__APPLE__)
+#if defined(__linux__) || defined(__unix__) || defined(__APPLE__) || defined(__HAIKU__)
 #include <unistd.h>
 #endif
 
-#ifdef _POSIX_VERSION
+#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
 #include <dlfcn.h>
 #else
 #ifdef CHAISCRIPT_WINDOWS
@@ -28,9 +45,9 @@
 #endif
 
 
-#include "chaiscript_prelude.chai"
-#include "chaiscript_parser.hpp"
 #include "../dispatchkit/exception_specification.hpp"
+#include "chaiscript_parser.hpp"
+#include "chaiscript_prelude.chai"
 
 namespace chaiscript
 {
@@ -52,7 +69,7 @@ namespace chaiscript
 
   namespace detail
   {
-#ifdef _POSIX_VERSION
+#if defined(_POSIX_VERSION) && !defined(__CYGWIN__) 
     struct Loadable_Module
     {
       struct DLModule
@@ -123,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;
@@ -173,17 +190,17 @@ namespace chaiscript
           LocalFree(lpMsgBuf);
         }
 
-        return tostring(retval);
+        return to_string(retval);
       }
 
       struct DLModule
       {
         DLModule(const std::string &t_filename)
-          : m_data(LoadLibrary(toproperstring(t_filename).c_str()))
+          : m_data(LoadLibrary(to_proper_string(t_filename).c_str()))
         {
           if (!m_data)
           {
-            throw chaiscript::exception::load_module_error(GetErrorMessage(GetLastError()));
+            throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
           }
         }
 
@@ -203,7 +220,7 @@ namespace chaiscript
           {
             if (!m_symbol)
             {
-              throw chaiscript::exception::load_module_error(GetErrorMessage(GetLastError()));
+              throw chaiscript::exception::load_module_error(get_error_message(GetLastError()));
             }
           }
 
@@ -253,8 +270,6 @@ namespace chaiscript
 
     chaiscript::detail::Dispatch_Engine m_engine;
 
-
-
     /// Evaluates the given string in by parsing it and running the results through the evaluator
     Boxed_Value do_eval(const std::string &t_input, const std::string &t_filename = "__EVAL__", bool /* t_internal*/  = false) 
     {
@@ -267,7 +282,7 @@ namespace chaiscript
           return Boxed_Value();
         }
       }
-      catch (const chaiscript::eval::detail::Return_Value &rv) {
+      catch (chaiscript::eval::detail::Return_Value &rv) {
         return rv.retval;
       }
     }
@@ -315,6 +330,7 @@ namespace chaiscript
       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("_");
 
       if (t_lib)
@@ -329,9 +345,10 @@ namespace chaiscript
       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(Proxy_Function(new dispatch::Dynamic_Proxy_Function(
+              [this](const std::vector<Boxed_Value> &t_params) {
+                return m_engine.call_exists(t_params);
+              })), "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, std::ref(m_engine)), "name");
@@ -347,19 +364,27 @@ namespace chaiscript
       m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
       m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
 
+      m_engine.add(fun(&ChaiScript::version_major, this), "version_major");
+      m_engine.add(fun(&ChaiScript::version_minor, this), "version_minor");
+      m_engine.add(fun(&ChaiScript::version_patch, this), "version_patch");
+      m_engine.add(fun(&ChaiScript::version, this), "version");
+
+      m_engine.add(fun(&ChaiScript::add_global_const, this), "add_global_const");
+      m_engine.add(fun(&ChaiScript::add_global, this), "add_global");
+
       do_eval(ChaiScript_Prelude::chaiscript_prelude(), "standard prelude");
     }
 
 
     /// Helper function for loading a file
-    std::string load_file(const std::string &t_filename) {
+    static std::string load_file(const std::string &t_filename) {
       std::ifstream infile(t_filename.c_str(), std::ios::in | std::ios::ate | std::ios::binary );
 
       if (!infile.is_open()) {
         throw chaiscript::exception::file_not_found_error(t_filename);
       }
 
-      std::streampos size = infile.tellg();
+      const auto size = infile.tellg();
       infile.seekg(0, std::ios::beg);
 
       assert(size >= 0);
@@ -368,7 +393,7 @@ namespace chaiscript
       {
         return std::string();
       } else {
-        std::vector<char> v(static_cast<unsigned int>(size));
+        std::vector<char> v(static_cast<size_t>(size));
         infile.read(&v[0], size);
         return std::string(v.begin(), v.end());
       }
@@ -380,9 +405,9 @@ namespace chaiscript
     /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
     /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
     ChaiScript(const ModulePtr &t_lib,
-               const std::vector<std::string> &t_modulepaths = std::vector<std::string>(),
-                      const std::vector<std::string> &t_usepaths = std::vector<std::string>())
-      : m_modulepaths(t_modulepaths), m_usepaths(t_usepaths) 
+               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())
       {
@@ -404,9 +429,9 @@ namespace chaiscript
     ///
     /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
     /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
-    ChaiScript( const std::vector<std::string> &t_modulepaths = std::vector<std::string>(),
-                      const std::vector<std::string> &t_usepaths = std::vector<std::string>())
-      : m_modulepaths(t_modulepaths), m_usepaths(t_usepaths) 
+    ChaiScript( 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())
       {
@@ -418,8 +443,7 @@ namespace chaiscript
         m_usepaths.push_back("");
       }
 
-
-#ifdef _POSIX_VERSION
+#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
 
@@ -435,7 +459,7 @@ namespace chaiscript
       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('/');
+        const size_t lastslash = dllpath.rfind('/');
         if (lastslash != std::string::npos)
         {
           dllpath.erase(lastslash);
@@ -443,23 +467,55 @@ namespace chaiscript
 
         // 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());
+        const 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    
+      }
+#endif
 
 
       // attempt to load the stdlib
-      load_module("chaiscript_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
@@ -469,10 +525,10 @@ namespace chaiscript
     /// \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)
+      for (const auto &path : m_usepaths)
       {
         try {
-          const std::string appendedpath = m_usepaths[i] + t_filename;
+          const auto appendedpath = path + 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);
@@ -487,14 +543,12 @@ namespace chaiscript
 
           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
         }
       }
+
+      // failed to load by any name
+      throw exception::file_not_found_error(t_filename);
     }
 
     /// \brief Adds a constant object that is available in all contexts and to all threads
@@ -608,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)
     {
@@ -655,26 +709,27 @@ namespace chaiscript
     std::string load_module(const std::string &t_module_name)
     {
       std::vector<exception::load_module_error> errors;
-
-      std::vector<std::string> prefixes;
-      prefixes.push_back("lib");
-      prefixes.push_back("");
-
-      std::vector<std::string> postfixes;
-      postfixes.push_back(".dll");
-      postfixes.push_back(".so");
-      postfixes.push_back("");
-
-      for (size_t i = 0; i < m_modulepaths.size(); ++i) 
+      std::string version_stripped_name = t_module_name;
+      size_t version_pos = version_stripped_name.find("-"+version());
+      if (version_pos != std::string::npos)
       {
-        for (size_t j = 0; j < prefixes.size(); ++j)
+        version_stripped_name.erase(version_pos);
+      }
+
+      std::vector<std::string> prefixes{"lib", "cyg", ""};
+
+      std::vector<std::string> postfixes{".dll", ".so", ""};
+
+      for (auto & elem : m_modulepaths) 
+      {
+        for (auto & prefix : prefixes)
         {
-          for (size_t k = 0; k < postfixes.size(); ++k)
+          for (auto & postfix : postfixes)
           {
             try {
-              std::string name = m_modulepaths[i] + prefixes[j] + t_module_name + postfixes[k];
+              const auto name = elem + prefix + t_module_name + postfix;
               // std::cerr << "trying location: " << name << std::endl;
-              load_module(t_module_name, name);
+              load_module(version_stripped_name, name);
               return name;
             } catch (const chaiscript::exception::load_module_error &e) {
               // std::cerr << "error: " << e.what() << std::endl;
@@ -742,7 +797,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -768,7 +823,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -784,7 +839,7 @@ namespace chaiscript
     ///
     /// \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
+    /// \param[in] t_filename Optional filename to report to the user for where the error occurred. Useful
     ///                       in special cases where you are loading a file internally instead of using eval_file
     ///
     /// \return result of the script execution
@@ -798,7 +853,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -814,11 +869,11 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
-    /// \brief Loads the file specified by filename, evaluates it, and returns the typesafe result.
+    /// \brief Loads the file specified by filename, evaluates it, and returns the type safe 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
@@ -834,7 +889,7 @@ namespace chaiscript
         if (t_handler) {
           t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
   };

include/chaiscript/language/chaiscript_prelude.chai

@@ -40,9 +40,9 @@ 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); 
+def clone(x) : function_exists(type_name(x)) && call_exists(eval(type_name(x)), x)
+{
+  eval(type_name(x))(x).copy_var_attrs(x);
 }
 
 
@@ -56,11 +56,6 @@ def to_string(x) : call_exists(range, x) && !x.is_type("string"){
   "[" + x.join(", ") + "]"; 
 }
 
-# Basic to_string function
-def to_string(x) { 
-  internal_to_string(x); 
-}
-
 # Prints to console with no carriage return
 def puts(x) { 
   print_string(x.to_string()); 
@@ -136,8 +131,8 @@ def insert_at(container, pos, x)
 
 # Returns the reverse of the given container
 def reverse(container) {
-  auto retval = new(container); 
-  auto r = range(container); 
+  auto retval := new(container); 
+  auto r := range(container); 
   while (!r.empty()) { 
     retval.push_back(r.back()); 
     r.pop_back(); 
@@ -147,10 +142,16 @@ def reverse(container) {
 
 # Return a range from a range 
 def range(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) 
-{ 
-  return clone(r); 
+{
+  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; 
@@ -200,19 +201,19 @@ def retro::empty()
 
 # Performs the second value function over the container first value
 def for_each(container, func) : call_exists(range, container) { 
-  var t_range = 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 back_inserter(container) {
+  bind(push_back, container, _);
 }
 
 def contains(container, item, compare_func) : call_exists(range, container) { 
-  auto t_range = range(container); 
+  auto t_range := range(container); 
   while (!t_range.empty()) { 
     if ( compare_func(t_range.front(), item) ) { 
       return true; 
@@ -220,15 +221,15 @@ def contains(container, item, compare_func) : call_exists(range, container) {
 
     t_range.pop_front(); 
   } 
-  return false; 
+  false; 
 } 
 
 def contains(container, item) { 
-  return contains(container, item, eq) 
+  contains(container, item, eq) 
 } 
 
 def map(container, func, inserter) : call_exists(range, container) { 
-  auto range = range(container); 
+  auto range := range(container); 
   while (!range.empty()) { 
     inserter(func(range.front())); 
     range.pop_front(); 
@@ -237,7 +238,7 @@ def map(container, func, inserter) : call_exists(range, container) {
 
 # 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); 
+  auto retval := new(container); 
   map(container, func, back_inserter(retval));
   retval;
 }
@@ -245,7 +246,7 @@ def map(container, func) {
 # 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); 
+  auto range := range(container); 
   while (!range.empty()) { 
     retval = (func(range.front(), retval)); 
     range.pop_front(); 
@@ -266,8 +267,8 @@ def product(container) {
 # 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); 
+  auto inserter := back_inserter(retval); 
+  auto range := range(y); 
   while (!range.empty()) { 
     inserter(range.front()); 
     range.pop_front(); 
@@ -277,7 +278,7 @@ def concat(x, y) : call_exists(clone, x) {
 
 
 def take(container, num, inserter) : call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   auto i = num; 
   while ((i > 0) && (!r.empty())) { 
     inserter(r.front()); 
@@ -289,14 +290,14 @@ def take(container, num, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given number of elements taken from the container
 def take(container, num) {
-  auto retval = new(container); 
+  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); 
+  auto r := range(container); 
   while ((!r.empty()) && f(r.front())) { 
     inserter(r.front()); 
     r.pop_front(); 
@@ -306,14 +307,14 @@ def take_while(container, f, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given elements match the second value function
 def take_while(container, f) {
-  auto retval = new(container); 
+  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 r := range(container); 
   auto i = num; 
   while ((i > 0) && (!r.empty())) { 
     r.pop_front(); 
@@ -328,14 +329,14 @@ def drop(container, num, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given number of elements dropped from the given container 
 def drop(container, num) {
-  auto retval = new(container); 
+  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); 
+  auto r := range(container); 
   while ((!r.empty())&& f(r.front())) { 
     r.pop_front(); 
   } 
@@ -348,7 +349,7 @@ def drop_while(container, f, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given elements dropped that match the second value function
 def drop_while(container, f) {
-  auto retval = new(container); 
+  auto retval := new(container); 
   drop_while(container, f, back_inserter(retval)); 
   retval; 
 }
@@ -356,7 +357,7 @@ def drop_while(container, f) {
 
 # 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 r := range(container); 
   auto retval = r.front(); 
   r.pop_front(); 
   retval = func(retval, r.front()); 
@@ -372,7 +373,7 @@ def reduce(container, func) : container.size() >= 2 && call_exists(range, contai
 # Returns a string of the elements in container delimited by the second value string
 def join(container, delim) { 
   auto retval = ""; 
-  auto range = range(container); 
+  auto range := range(container); 
   if (!range.empty()) { 
     retval += to_string(range.front()); 
     range.pop_front(); 
@@ -387,7 +388,7 @@ def join(container, delim) {
 
 
 def filter(container, f, inserter) : call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   while (!r.empty()) { 
     if (f(r.front())) { 
       inserter(r.front()); 
@@ -399,7 +400,7 @@ def filter(container, f, inserter) : call_exists(range, container) {
 
 # Returns a new Vector which match the second value function
 def filter(container, f) { 
-  auto retval = new(container); 
+  auto retval := new(container); 
   filter(container, f, back_inserter(retval));
   retval;
 }
@@ -416,7 +417,7 @@ def generate_range(x, y, inserter) {
 
 # Returns a new Vector which represents the range from the first value to the second value
 def generate_range(x, y) { 
-  auto retval = Vector(); 
+  auto retval := Vector(); 
   generate_range(x,y,back_inserter(retval)); 
   retval; 
 }
@@ -429,8 +430,8 @@ def collate(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); 
+  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(); 
@@ -441,7 +442,7 @@ def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y)
 
 # 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(); 
+  auto retval := Vector(); 
   zip_with(f,x,y,back_inserter(retval)); 
   retval;
 }
@@ -505,7 +506,7 @@ def string::trim() {
 
 
 def find(container, value, compare_func) : call_exists(range, container) && is_type(compare_func, "Function") { 
-  auto range = range(container); 
+  auto range := range(container); 
   while (!range.empty()) { 
     if (compare_func(range.front(), value)) { 
       return range; 
@@ -513,12 +514,12 @@ def find(container, value, compare_func) : call_exists(range, container) && is_t
       range.pop_front(); 
     } 
   } 
-  return range; 
+  range; 
 } 
 
 
 def find(container, value) { 
-  return find(container, value, eq) 
+  find(container, value, eq) 
 } 
 
 

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -5,7 +5,7 @@
 namespace ChaiScript_Language
 {
 
-/// \page LangStandardLibraryRef ChaiScript Language Standard Libary Reference
+/// \page LangStandardLibraryRef ChaiScript Language Standard Library Reference
 ///
 /// ChaiScript, at its core, has some very functional programming-inspired habits. Few places show this off as clearly 
 /// as the prelude, itself a name taken as a nod to the popular functional language Haskell. This prelude is available 
@@ -112,7 +112,7 @@ class Map
 };
 
 
-/// \brief A concept implemented by string, Vector and Map. It is convertable to Range, default constructable and back_insertable
+/// \brief A concept implemented by string, Vector and Map. It is convertible to Range, default constructable and back_insertable
 class Container
 {
   public:
@@ -153,10 +153,10 @@ void print(Object o);
 
 /// \brief ChaiScript representation of std::string. It is an std::string but only some member are exposed to ChaiScript.
 /// 
-/// Because the ChaiScript string object is an std::string, it is directly convertable to and from std::string
+/// Because the ChaiScript string object is an std::string, it is directly convertible to and from std::string
 /// using the chaiscript::boxed_cast and chaiscript::var functions.
 ///
-/// With the exception of string::trim, string::rtrim, string::ltrim, all members are direct passthroughs to the
+/// With the exception of string::trim, string::rtrim, string::ltrim, all members are direct pass-throughs to the
 /// std::string of the same name. 
 ///
 /// \note Object and function notations are equivalent in ChaiScript. This means that
@@ -519,7 +519,7 @@ class Function
     /// \brief Returns a vector of Type_Info objects that represent the param types for this function.
     ///        The first value in the list is the return type.
     /// 
-    /// If this function is a conglomeration of several functions (get_contained_values().size() > 0)
+    /// If this function is a conglomerate of several functions (get_contained_values().size() > 0)
     /// then the function returns as many Type_Info objects as it can. If the functions contained all have
     /// the same arity, then it represents the arity. If they have different arities, it returns only
     /// one value - the return type. 
@@ -534,7 +534,7 @@ class Function
     /// \endcode
     Vector get_param_types() const;
 
-    /// \brief Returns true if the function has a guard to it. Always returns falls for a conglomerate function
+    /// \brief Returns true if the function has a guard to it. Always returns false for a conglomerate function
     bool has_guard() const;
 
     /// \brief Calls the function with the given set of parameters and returns the value;

include/chaiscript/utility/utility.hpp

@@ -7,8 +7,13 @@
 #ifndef CHAISCRIPT_UTILITY_UTILITY_HPP_
 #define CHAISCRIPT_UTILITY_UTILITY_HPP_
 
-#include "../chaiscript.hpp"
 #include <string>
+#include <utility>
+#include <vector>
+
+#include "../chaiscript.hpp"
+#include "../dispatchkit/proxy_functions.hpp"
+#include "../dispatchkit/type_info.hpp"
 
 
 namespace chaiscript 
@@ -16,28 +21,47 @@ namespace chaiscript
   namespace utility
   {
 
-    /// \todo Use of this utility, and uniform initializer lists, is causing memory errors in MSVC
-    
+    /// Single step command for registering a class with ChaiScript
+    /// 
+    /// \param[in,out] t_module Model to add class to
+    /// \param[in] t_class_name Name of the class being registered
+    /// \param[in] t_constructors Vector of constructors to add
+    /// \param[in] t_funcs Vector of methods to add
+    ///
+    /// \example Adding a basic class to ChaiScript in one step
+    /// 
+    /// \code
+    /// chaiscript::utility::add_class<test>(*m,
+    ///      "test",
+    ///      { constructor<test ()>(),
+    ///        constructor<test (const test &)>() },
+    ///      { {fun(&test::function), "function"},
+    ///        {fun(&test::function2), "function2"},
+    ///        {fun(&test::function3), "function3"},
+    ///        {fun(static_cast<std::string(test::*)(double)>(&test::functionoverload)), "functionoverload" },
+    ///        {fun(static_cast<std::string(test::*)(int)>(&test::functionoverload)), "functionoverload" },
+    ///        {fun(static_cast<test & (test::*)(const test &)>(&test::operator=)), "=" }
+    ///        }
+    ///      );
+    /// 
     template<typename Class, typename ModuleType>
       void add_class(ModuleType &t_module,
-          const std::string &t_classname,
+          const std::string &t_class_name,
           const std::vector<chaiscript::Proxy_Function> &t_constructors,
           const std::vector<std::pair<chaiscript::Proxy_Function, std::string>> &t_funcs)
       {
-        t_module.add(chaiscript::user_type<Class>(), t_classname); 
+        t_module.add(chaiscript::user_type<Class>(), t_class_name); 
 
         for(const chaiscript::Proxy_Function &ctor: t_constructors)
         {
-          t_module.add(ctor, t_classname);
+          t_module.add(ctor, t_class_name);
         }
 
-        for(auto fun: t_funcs)
+        for(const auto &fun: t_funcs)
         {
           t_module.add(fun.first, fun.second);
         }
-        
       }
-      
   }
 }
 

readme.md

@@ -1,5 +1,7 @@
-[![Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=ChaiScript_5_0_CPP_11)](https://travis-ci.org/ChaiScript/ChaiScript)
-[![Coverage Status](https://coveralls.io/repos/ChaiScript/ChaiScript/badge.png?branch=ChaiScript_5_0_CPP_11)](https://coveralls.io/r/ChaiScript/ChaiScript?branch=ChaiScript_5_0_CPP_11)
+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
 

releasenotes.md

@@ -1,11 +1,37 @@
 Notes:
+=======
+Current Version: 5.4.0
 
- * There was overlap during the 5.x and 4.x development cycle, so some of the notes appear twice as the new features were developed for 4.x (which required boost) then ported to 5.x (which requires C++11).
- * This is the last release of 5.x, all future development will be on the final merged 6.x line.
+### 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

samples/example.cpp

@@ -137,7 +137,7 @@ 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<std::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
 
   std::stringstream ss;

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/inheritance.cpp

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

samples/loop_break.chai

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

samples/memory_leak_test.cpp

@@ -24,7 +24,7 @@ std::string get_next_command() {
 #endif
 }
 
-void fuction(void)
+void function(void)
 {
   // do nothing
 }
@@ -35,28 +35,28 @@ class test
   chaiscript::ChaiScript::State backupState;
 
   public:
-    test()
-      : chai(chaiscript::Std_Lib::library())
-    {		
-      backupState = chai.get_state();
-    }
-    ~test(){}
+  test()
+    : chai(chaiscript::Std_Lib::library())
+  {
+    backupState = chai.get_state();
+  }
+  ~test(){}
 
-    void ResetState()
-    {
-      chai.set_state(backupState);
-      chai.add(chaiscript::fun(&fuction),"Whatever()");
-    }
+  void ResetState()
+  {
+    chai.set_state(backupState);
+    chai.add(chaiscript::fun(&function),"Whatever()");
+  }
 
-    void RunFile(std::string sFile)
-    {
-      try {
-        chaiscript::Boxed_Value val = chai.eval_file(sFile);
-      }
-      catch (std::exception &e) {
-        std::cout << e.what() << std::endl;
-      }
+  void RunFile(std::string sFile)
+  {
+    try {
+      chaiscript::Boxed_Value val = chai.eval_file(sFile);
     }
+    catch (std::exception &e) {
+      std::cout << e.what() << std::endl;
+    }
+  }
 
 };
 
@@ -70,12 +70,12 @@ int main(int /*argc*/, char * /*argv*/[]) {
   std::string command = "";
 
   //
-  // this loop increases memoryusage, if RunFile is not called (just hittin enter)
+  // this loop increases memory usage, if RunFile is not called (just hitting enter)
   // as soon RunFile gets called, memory will be freed.
   //
-  // scenario1 - RunFile gets called every Loop: memoryusage does not change
-  // scenario2 - RunFile gets never called (just hitting enter): memoryusage increases every loop
-  // scenario3 - RunFile gets in changing intervals: memoryusage goes up and down, but never as 
+  // scenario1 - RunFile gets called every Loop: memory usage does not change
+  // scenario2 - RunFile gets never called (just hitting enter): memory usage increases every loop
+  // scenario3 - RunFile gets in changing intervals: memory usage goes up and down, but never as
   //            low as in case 1 scenario3 :
 
   while(command != "quit")

samples/oper.chai

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

samples/scope.chai

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

samples/vector.chai

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

samples/while.chai

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

src/main.cpp

@@ -17,14 +17,15 @@
 #else
 
 char *mystrdup (const char *s) {
-  size_t len = strlen(s) + 1; // Space for length plus nul
-  char *d = static_cast<char*>(malloc (len));   
+  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
-  strcpy(d,s);                        // Copy the characters
+  strncpy(d,s,len);                        // Copy the characters
 #endif
+  d[len] = '\0';
   return d;                            // Return the new string
 }
 
@@ -33,7 +34,7 @@ char* readline(const char* p)
   std::string retval;
   std::cout << p ;
   std::getline(std::cin, retval);
-  return std::cin.eof() ? NULL : mystrdup(retval.c_str());
+  return std::cin.eof() ? nullptr : mystrdup(retval.c_str());
 }
 
 

src/reflection.cpp

@@ -1,129 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-
-#include <chaiscript/chaiscript.hpp>
-#include <chaiscript/dispatchkit/bootstrap.hpp>
-#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
-#include <chaiscript/utility/utility.hpp>
-#include <string>
-
-
-// MSVC doesn't like that we are using C++ return types from our C declared module
-// but this is the best way to do it for cross platform compatibility
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4190)
-#endif
-
-
-bool has_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 true;
-    } else {
-      return false;
-    }
-  } else {
-    return false;
-  }
-}
-
-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");
-  }
-}
-
-
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
-#endif
-
-
-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");
-
-  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);
-
-  using namespace chaiscript;
-  
-  chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
-      "eval_error",
-      { },
-      { {fun(&chaiscript::exception::eval_error::reason), "reason"},
-        {fun(&chaiscript::exception::eval_error::call_stack), "call_stack"} }
-      );
-      
-  
-  chaiscript::utility::add_class<chaiscript::File_Position>(*m,
-      "File_Position",
-      { constructor<File_Position()>(),
-        constructor<File_Position(int, int)>() },
-      { {fun(&File_Position::line), "line"},
-        {fun(&File_Position::column), "column"} }
-      );
-      
-  
-  chaiscript::utility::add_class<AST_Node>(*m, 
-  "AST_Node",
-  {  },
-  { {fun(&AST_Node::text), "text"},
-    {fun(&AST_Node::identifier), "identifier"},
-    {fun(&AST_Node::filename), "filename"},
-    {fun(&AST_Node::start), "start"},
-    {fun(&AST_Node::end), "end"},
-    {fun(&AST_Node::internal_to_string), "internal_to_string"},
-    {fun(&AST_Node::children), "children"},
-    {fun(&AST_Node::replace_child), "replace_child"}
-  }
-  );
-  
-  
-  chaiscript::utility::add_class<parser::ChaiScript_Parser>(*m,
-      "ChaiScript_Parser",
-      { constructor<parser::ChaiScript_Parser ()>() },
-      { {fun(&parser::ChaiScript_Parser::parse), "parse"},
-        {fun(&parser::ChaiScript_Parser::ast), "ast"} }
-      );
-      
-
-
-  return m;
-}
-
-#ifdef __llvm__
-#pragma clang diagnostic pop
-#endif
-
-
-
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(pop)
-#endif

src/test_module.cpp

@@ -11,6 +11,8 @@ class TestBaseType
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
 
+    int base_only_func() { return -9; }
+
     const TestBaseType &constMe() const { return *this; }
 
     int val;
@@ -34,12 +36,34 @@ 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::make_shared<TestDerivedType>();
+}
+
+std::shared_ptr<TestBaseType> more_derived_type_factory()
+{
+  return std::make_shared<TestMoreDerivedType>();
+}
+
+std::shared_ptr<TestBaseType> null_factory()
+{
+  return std::shared_ptr<TestBaseType>();
+}
+
 std::string hello_world()
 {
   return "Hello World";
@@ -70,6 +94,7 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
 
   m->add(chaiscript::user_type<TestBaseType>(), "TestBaseType");
   m->add(chaiscript::user_type<TestDerivedType>(), "TestDerivedType");
+  m->add(chaiscript::user_type<TestMoreDerivedType>(), "TestMoreDerivedType");
 
   m->add(chaiscript::constructor<TestBaseType ()>(), "TestBaseType");
 //  m->add(chaiscript::constructor<TestBaseType (int)>(), "TestBaseType");
@@ -79,14 +104,30 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::constructor<TestDerivedType ()>(), "TestDerivedType");
   m->add(chaiscript::constructor<TestDerivedType (const TestDerivedType &)>(), "TestDerivedType");
 
+  m->add(chaiscript::constructor<TestMoreDerivedType ()>(), "TestMoreDerivedType");
+  m->add(chaiscript::constructor<TestMoreDerivedType (const TestMoreDerivedType &)>(), "TestMoreDerivedType");
+
+  /// \todo automatic chaining of base classes?
   m->add(chaiscript::base_class<TestBaseType, TestDerivedType>());
+  m->add(chaiscript::base_class<TestBaseType, TestMoreDerivedType>());
+  m->add(chaiscript::base_class<TestDerivedType, TestMoreDerivedType>());
+
+  m->add(chaiscript::fun(&TestDerivedType::derived_only_func), "derived_only_func");
+
+  m->add(chaiscript::fun(&derived_type_factory), "derived_type_factory");
+  m->add(chaiscript::fun(&more_derived_type_factory), "more_derived_type_factory");
+  m->add(chaiscript::fun(&null_factory), "null_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");

unittests/3.x/break_while.chai

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

unittests/3.x/eval_error.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 
 def deep()
 {

unittests/3.x/mmd1.chai

@@ -1,17 +1,17 @@
 def bob(x, y, z) {
-	x + y + z
+  x + y + z
 }
 
 def bob(x, y) {
-	x - y
+  x - y
 }
 
 def bob(x) {
-	-x
+  -x
 }
 
 def bob() {
-	10
+  10
 }
 
 assert_equal(10, bob())

unittests/3.x/reflection_test.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 var parser := ChaiScript_Parser()
 var parse_success = parser.parse("3 + 4", "INPUT")
 var a := parser.ast()

unittests/3.x/return.chai

@@ -1,5 +1,5 @@
 def sam() {
-	return 5
+  return 5
 }
 
 assert_equal(5, sam())

unittests/3.x/use.inc

@@ -1,4 +1,4 @@
 def greet {
-	return("hello")
+  return("hello")
 }
 

unittests/arithmetic_conversions_test.cpp

@@ -18,6 +18,11 @@ void f3(double)
 {
 }
 
+void f_func_return(const std::function<unsigned int (unsigned long)> &f)
+{
+  // test the ability to return an unsigned with auto conversion
+  f(4);
+}
 
 int main()
 {
@@ -29,6 +34,8 @@ int main()
   chai.add(chaiscript::fun(&f1), "f3");
   chai.add(chaiscript::fun(&f4), "f3");
 
+  chai.add(chaiscript::fun(&f_func_return), "func_return");
+
   // no overloads
   chai.eval("f1(0)");
   chai.eval("f1(0l)");
@@ -46,7 +53,12 @@ int main()
   // 1 non-arithmetic overload
   chai.eval("f2(1.0)");
 
-  // this is the one call we expect to fail
+  // various options for returning with conversions from chaiscript
+  chai.eval("func_return(fun(x) { return 5u; })");
+  chai.eval("func_return(fun(x) { return 5; })");
+  chai.eval("func_return(fun(x) { return 5.0f; })");
+
+  // this is the one call we expect to fail, ambiguous overloads
   try {
     chai.eval("f2(1.0l)");
   } catch (const std::exception &) {

unittests/boxed_cast_test.cpp

@@ -44,9 +44,9 @@ bool test_type_conversion(const Boxed_Value &bv, bool expectedpass)
   if (!ret)
   {
     std::cerr << "Error with type conversion test. From: " 
-		<< (bv.is_const()?(std::string("const ")):(std::string())) << bv.get_type_info().name() 
-		<< " To: "  
-		<< (std::is_const<To>::value?(std::string("const ")):(std::string())) << typeid(To).name() 
+      << (bv.is_const()?(std::string("const ")):(std::string())) << bv.get_type_info().name() 
+      << " To: "  
+      << (std::is_const<To>::value?(std::string("const ")):(std::string())) << typeid(To).name() 
       << " test was expected to " << ((expectedpass)?(std::string("succeed")):(std::string("fail"))) << " but did not" << std::endl;
   }
 

unittests/break_while.chai

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

unittests/c_linkage_test.cpp

@@ -3,7 +3,7 @@
 
 extern "C"
 {
-  int dosomething(int i)
+  int do_something(int i)
   {
     return i % 2;
   }
@@ -13,8 +13,8 @@ int main()
 {
 
   chaiscript::ChaiScript chai;
-  chai.add(chaiscript::fun(&dosomething), "dosomething");
+  chai.add(chaiscript::fun(&do_something), "do_something");
 
-  return chai.eval<int>("dosomething(101)") == 101 % 2?EXIT_SUCCESS:EXIT_FAILURE;
+  return chai.eval<int>("do_something(101)") == 101 % 2?EXIT_SUCCESS:EXIT_FAILURE;
 
 }

unittests/class.chai

@@ -0,0 +1,27 @@
+
+class Vector3
+{
+  // you can use attr, auto or var in this context
+  attr x
+  auto y
+  var z
+
+  def Vector3(x,y,z)
+  {
+    this.x = x
+    this.y = y
+    this.z = z
+  }
+
+  def doSomething(mult)
+  {
+    return this.x * this.y * this.z * mult
+  }
+
+}
+
+
+auto v = Vector3(1,2,3)
+assert_equal(1, v.x)
+assert_equal(v.doSomething(2), 12)
+

unittests/eval_error.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 
 def deep()
 {

unittests/expected_eval_errors_test.cpp

@@ -19,7 +19,7 @@ int main()
   // Dot notation
 
   try {
-    // non-existant function
+    // non-existent function
     chai.eval("\"test\".test_one()");
     eval_error = false;
   } catch (const chaiscript::exception::eval_error &) {
@@ -51,7 +51,7 @@ int main()
   // regular notation
 
   try {
-    // non-existant function
+    // non-existent function
     chai.eval("test_one(\"test\")");
     eval_error = false;
   } catch (const chaiscript::exception::eval_error &) {

unittests/global_in_script.chai

@@ -0,0 +1,10 @@
+
+var i = 5
+add_global(i, "j")
+
+def myFun()
+{
+  assert_equal(j, 5)
+}
+
+myFun();

unittests/inheritance.chai

@@ -15,3 +15,26 @@ assert_equal(15, t.const_val);
 t.val = 23;
 assert_equal(23, t.val)
 
+// test_derived_factory returns a TestDerivedType contained
+// in a shared_ptr<TestBaseType>. This is testing our ability
+// to detect that and do the down casting for the user automatically
+// at runtime
+
+assert_equal(t.derived_only_func(), 19);
+
+var d := derived_type_factory();
+assert_equal(d.derived_only_func(), 19);
+
+var t2 = TestMoreDerivedType();
+assert_equal(t2.derived_only_func(), 19);
+assert_equal(t2.base_only_func(), -9);
+
+var md := more_derived_type_factory();
+assert_equal(md.derived_only_func(), 19);
+assert_equal(md.base_only_func(), -9);
+
+assert_equal(md.func(), 1);
+assert_equal(t2.func(), 1);
+assert_equal(d.func(), 1);
+
+

unittests/mmd1.chai

@@ -1,17 +1,17 @@
 def bob(x, y, z) {
-	x + y + z
+  x + y + z
 }
 
 def bob(x, y) {
-	x - y
+  x - y
 }
 
 def bob(x) {
-	-x
+  -x
 }
 
 def bob() {
-	10
+  10
 }
 
 assert_equal(10, bob())

unittests/multithreaded_test.cpp

@@ -35,7 +35,7 @@ int main()
 {
   // Disable deprecation warning for getenv call.
 #ifdef CHAISCRIPT_MSVC
-#ifdef max // Why microsoft? why?
+#ifdef max // Why Microsoft? why?
 #undef max
 #endif
 #pragma warning(push)

unittests/null_object_access.chai

@@ -0,0 +1,13 @@
+load_module("test_module")
+
+auto o := null_factory();
+
+try {
+  o.func();
+} catch (e) {
+  exit(0);
+}
+
+assert_true(false);
+
+

unittests/operator_scoping.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 
 try {
   eval("def `+`(x, y) \n { \n print(i); \n } \n \n var i = 10; \n \"1\" + 1;\n")

unittests/range.chai

@@ -2,3 +2,9 @@ auto x = [1, 2, 3, 4]
 auto r = range(x)
 r.pop_front()
 assert_equal(2, r.front());
+
+// test with temporary vector for range
+auto q = range([1, 2, 3, 4])
+q.pop_front()
+assert_equal(2, q.front());
+

unittests/reflection_test.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 auto& parser = ChaiScript_Parser()
 auto parse_success = parser.parse("3 + 4", "INPUT")
 auto& a = parser.ast()

unittests/return.chai

@@ -1,5 +1,5 @@
 def sam() {
-	return 5
+  return 5
 }
 
 assert_equal(5, sam())

unittests/simultaneous_chaiscript_test.cpp

@@ -1,11 +1,11 @@
 #include <chaiscript/chaiscript.hpp>
 
-int dosomething(int i)
+int do_something(int i)
 {
   return i + 2;
 }
 
-int dosomethingelse(int i)
+int do_something_else(int i)
 {
   return i * 2;
 }
@@ -15,29 +15,29 @@ int dosomethingelse(int i)
 int main()
 {
   chaiscript::ChaiScript chai;
-  chai.add(chaiscript::fun(&dosomething), "dosomething");
+  chai.add(chaiscript::fun(&do_something), "do_something");
   chai.add(chaiscript::var(1), "i");
 
   for (int i = 0; i < 10; ++i)
   {
     chaiscript::ChaiScript chai2;
-    chai2.add(chaiscript::fun(&dosomethingelse), "dosomethingelse");
+    chai2.add(chaiscript::fun(&do_something_else), "do_something_else");
 
     std::stringstream ss;
     ss << i;
 
-    if (chai.eval<int>("dosomething(" + ss.str() + ")") != i + 2)
+    if (chai.eval<int>("do_something(" + ss.str() + ")") != i + 2)
     {
       return EXIT_FAILURE;
     }
 
-    if (chai2.eval<int>("dosomethingelse(" + ss.str() + ")") != i * 2)
+    if (chai2.eval<int>("do_something_else(" + ss.str() + ")") != i * 2)
     {
       return EXIT_FAILURE;
     }
 
     try {
-      chai2.eval("dosomething(1)");
+      chai2.eval("do_something(1)");
       return EXIT_FAILURE; // should not get here
     } catch (const chaiscript::exception::eval_error &) {
       // nothing to do, expected case
@@ -51,7 +51,7 @@ int main()
     }
 
     try {
-      chai.eval("dosomethingelse(1)");
+      chai.eval("do_something_else(1)");
       return EXIT_FAILURE; // should not get here
     } catch (const chaiscript::exception::eval_error &) {
       // nothing to do, expected case

unittests/type_info_test.cpp

@@ -2,6 +2,7 @@
 
 #include <chaiscript/chaiscript_defines.hpp>
 #include <chaiscript/dispatchkit/type_info.hpp>
+#include <iostream>
 #include <cstdlib>
 
 void test_type(const chaiscript::Type_Info &ti, bool t_is_const, bool t_is_pointer, bool t_is_reference, bool t_is_void,
@@ -30,5 +31,7 @@ int main()
   test_type(chaiscript::user_type<const int *>(), true, true, false, false, false);
   test_type(chaiscript::Type_Info(), false, false, false, false, true);
 
+  std::cout << "Size of Type_Info " << sizeof(chaiscript::Type_Info) << std::endl;
+
   return EXIT_SUCCESS;
 }

unittests/type_name_test.cpp

@@ -0,0 +1,22 @@
+// Tests to make sure that the order in which function dispatches occur is correct
+
+#include <chaiscript/chaiscript.hpp>
+#include <cstdlib>
+
+class MyClass
+{
+};
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+  auto type = chaiscript::user_type<MyClass>();
+  chai.add(type, "MyClass");
+
+  if (chai.get_type_name(type) == "MyClass" && chai.get_type_name<MyClass>() == "MyClass")
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+}

unittests/use.inc

@@ -1,4 +1,4 @@
 def greet {
-	return("hello")
+  return("hello")
 }