Update release notes for release 4.3.1

for returns from chaiscript function wrappers

.travis.yml

@@ -0,0 +1,25 @@
+language: cpp
+compiler:
+  - gcc
+before_install:
+  - sudo apt-get install libboost-dev libboost-all-dev
+  - sudo pip install cpp-coveralls
+script:
+  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug .
+  - make -j2
+  - make test
+  - mkdir gcov
+  - find CMakeFiles/ -name "*.gc*" -exec mv {} gcov/ \;
+  - gcov -d -o gcov gcov/*.gcda
+  - coveralls -n -E ".*\.cpp"
+after_script:
+  - contrib/codeanalysis/runcppcheck.sh
+notifications:
+  email:
+    recipients:
+      - jason@emptycrate.com
+    on_success: always
+    on_failure: always
+env:
+  global:
+    secure: LCUAKUCRtFp2ak81nVLR+jx0C9+Drwx1OR4VzuvH+HNGWFdUZmAIV3R84euDqFC5cUhYYipaeMbiSOJUHE4MNlL58eQZryED6KSL7k7SgxOLpFSspMvuMjIYZLlBWpBneCR/EMDilu+zXEnASfVUMPuLmtY1GAyfSoZboqFProc=

CMakeLists.txt

@@ -6,6 +6,18 @@ option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
 option(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
 option(BUILD_SAMPLES "Build Samples Folder" FALSE)
 
+set(EXTRA_LINKER_FLAGS "")
+
+if (CMAKE_COMPILER_IS_GNUCC)
+  option(ENABLE_COVERAGE "Enable Coverage Reporting in GCC" FALSE)
+
+  if (ENABLE_COVERAGE)
+    add_definitions(--coverage -O0)
+    SET(EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} "--coverage")
+  endif()
+
+endif()
+
 list(APPEND CPACK_SOURCE_IGNORE_FILES "${CMAKE_CURRENT_BINARY_DIR}")
 list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.svn")
 list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.git")
@@ -13,12 +25,12 @@ list(APPEND CPACK_SOURCE_IGNORE_FILES ".swp")
 list(APPEND CPACK_SOURCE_IGNORE_FILES ".*~")
 
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt")
-set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.txt")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
 
-set(CPACK_PACKAGE_VERSION_MAJOR 3)
-set(CPACK_PACKAGE_VERSION_MINOR 0)
-set(CPACK_PACKAGE_VERSION_PATCH 0)
+set(CPACK_PACKAGE_VERSION_MAJOR 4)
+set(CPACK_PACKAGE_VERSION_MINOR 3)
+set(CPACK_PACKAGE_VERSION_PATCH 1)
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
 set(CPACK_PACKAGE_CONTACT "contact@chaiscript.com")
@@ -39,58 +51,71 @@ configure_file(Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile)
 include(CTest)
 include(CPack)
 
-FIND_LIBRARY(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
 
 enable_testing()
 
 
-MESSAGE(STATUS "Detecting readline support")
+message(STATUS "Detecting readline support")
 if (READLINE_LIBRARY)
-    MESSAGE(STATUS "Found: ${READLINE_LIBRARY}")
-    SET (READLINE_LIB readline)
-    ADD_DEFINITIONS(/DREADLINE_AVAILABLE)
+    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 )
+    message(STATUS "Not Found")
+    set (READLINE_LIB )
+    set (READLINE_FLAG )
 endif(READLINE_LIBRARY)
 
-IF(MSVC)
-  ADD_DEFINITIONS(/W4)
-  IF(CMAKE_CL_64)
-    ADD_DEFINITIONS(/bigobj)
-   ENDIF()
-ELSE()
-  # -Wno-missing-field-initializers is for boost on macos
-  ADD_DEFINITIONS(-Wall -Wextra -Wno-missing-field-initializers -Wshadow) 
-ENDIF()
+if(MSVC)
+  add_definitions(/W4)
+  if(CMAKE_CL_64)
+    add_definitions(/bigobj)
+   endif()
+else()
+  add_definitions(-Wall -Wextra -Wshadow -pedantic)
+
+  if (APPLE)
+    # -Wno-missing-field-initializers is for boost on macos
+    add_definitions(-Wno-missing-field-initializers -Wno-sign-compare)
+  endif()
+endif()
 
 include_directories(include)
- 
-SET(Boost_ADDITIONAL_VERSIONS "1.44" "1.44.0" "1.43" "1.43.0" "1.42" "1.42.0" "1.41")
-SET(Boost_USE_MULTITHREADED ON)
+
+set(Boost_ADDITIONAL_VERSIONS "1.44" "1.44.0" "1.43" "1.43.0" "1.42" "1.42.0" "1.41")
+set(Boost_USE_MULTITHREADED ON)
+
+set (Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.hpp include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
+
+set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
 
 if (MULTITHREAD_SUPPORT_ENABLED)
-  find_package(Boost 1.36.0 COMPONENTS thread)
+  find_package(Boost 1.36.0 COMPONENTS thread system)
 
   if (Boost_FOUND)
     link_directories( ${Boost_LIBRARY_DIRS} )
   else()
     message(FATAL_ERROR "Can not find Boost")
   endif(Boost_FOUND)
+
+  if (CMAKE_HOST_UNIX)
+    add_definitions(-pthread)
+    list(APPEND LIBS "pthread")
+  endif()
 else()
-  ADD_DEFINITIONS(-DCHAISCRIPT_NO_THREADS)
+  add_definitions(-DCHAISCRIPT_NO_THREADS)
 endif()
 
-if (CMAKE_HOST_UNIX)
-  SET(DYNAMIC_LOADER "dl")
-endif(CMAKE_HOST_UNIX)
+if (CMAKE_HOST_UNIX AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+  list(APPEND LIBS "dl")
+endif()
+  
+list(APPEND LIBS ${READLINE_LIB})
 
-if (MSVC)
+if (NOT MSVC)
   # Boost on MSVC does automatic linking
-  SET(LIBS ${DYNAMIC_LOADER} ${READLINE_LIB})
-else()
-  SET(LIBS ${DYNAMIC_LOADER} ${Boost_LIBRARIES} ${READLINE_LIB})
+  list(APPEND LIBS ${Boost_LIBRARIES})
 endif()
 
 if (CMAKE_COMPILER_2005)
@@ -100,23 +125,23 @@ endif()
 
 include_directories(${Boost_INCLUDE_DIRS})
 include_directories(${Boost_INCLUDE_DIR})
-add_executable(chai src/main.cpp)
-target_link_libraries(chai ${LIBS})
+add_executable(chai src/main.cpp ${Chai_INCLUDES})
+target_link_libraries(chai ${LIBS} ${EXTRA_LINKER_FLAGS})
 
 if (BUILD_SAMPLES)
   add_executable(example samples/example.cpp)
-  target_link_libraries(example ${LIBS})
+  target_link_libraries(example ${LIBS} ${EXTRA_LINKER_FLAGS})
   add_executable(memory_leak_test samples/memory_leak_test.cpp)
-  target_link_libraries(memory_leak_test ${LIBS})
+  target_link_libraries(memory_leak_test ${LIBS} ${EXTRA_LINKER_FLAGS})
 endif()
 
 
 if (BUILD_MODULES)
   add_library(stl_extra MODULE src/stl_extra.cpp)
-  target_link_libraries(stl_extra ${LIBS})
+  target_link_libraries(stl_extra ${LIBS} ${EXTRA_LINKER_FLAGS})
 
   add_library(reflection MODULE src/reflection.cpp)
-  target_link_libraries(reflection ${LIBS})
+  target_link_libraries(reflection ${LIBS} ${EXTRA_LINKER_FLAGS})
   set(MODULES stl_extra reflection)
 endif()
 
@@ -124,7 +149,7 @@ file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CUR
 
 list(SORT UNIT_TESTS)
 
-IF(BUILD_TESTING)
+if(BUILD_TESTING)
   option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
 
   foreach(filename ${UNIT_TESTS})
@@ -132,81 +157,122 @@ IF(BUILD_TESTING)
     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}
+  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)
+  if (NOT UNIT_TEST_LIGHT)
     add_executable(utility_test unittests/utility_test.cpp)
-    target_link_libraries(utility_test ${LIBS})
+    target_link_libraries(utility_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    target_link_libraries(dynamic_object_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    target_link_libraries(functor_creation_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    target_link_libraries(functor_cast_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    target_link_libraries(boxed_cast_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    target_link_libraries(object_lifetime_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    target_link_libraries(function_ordering_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    target_link_libraries(type_info_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Type_Info_Test COMMAND type_info_test)
 
     add_executable(eval_catch_exception_test unittests/eval_catch_exception_test.cpp)
-    target_link_libraries(eval_catch_exception_test ${LIBS})
+    target_link_libraries(eval_catch_exception_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     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})
+    add_test(NAME Short_Comparison_Test COMMAND short_comparison_test)
+
+    add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
+    target_link_libraries(expected_eval_errors_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    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})
+    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)
+
+    add_executable(c_linkage_test unittests/c_linkage_test.cpp)
+    target_link_libraries(c_linkage_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    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})
+    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})
+    add_test(NAME Arithmetic_Conversions_Test COMMAND arithmetic_conversions_test)
+
+    if (MULTITHREAD_SUPPORT_ENABLED)
+      add_executable(multithreaded_test unittests/multithreaded_test.cpp)
+      target_link_libraries(multithreaded_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+      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})
+    target_link_libraries(multifile_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME MultiFile_Test COMMAND multifile_test)
 
     add_library(test_module MODULE src/test_module.cpp)
-    target_link_libraries(test_module ${LIBS})
+    target_link_libraries(test_module ${LIBS} ${EXTRA_LINKER_FLAGS})
 
     install(TARGETS test_module RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
-  ENDIF()
-ENDIF(BUILD_TESTING)
+  endif()
+endif(BUILD_TESTING)
 
 install(TARGETS chai ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript )
-install(DIRECTORY include/chaiscript DESTINATION include 
+
+install(DIRECTORY include/chaiscript DESTINATION include
    PATTERN "*.hpp"
    PATTERN "*/.svn*" EXCLUDE
    PATTERN "*/.git*" EXCLUDE
    PATTERN "*~" EXCLUDE)
-install(DIRECTORY unittests DESTINATION share/chaiscript 
+install(DIRECTORY unittests DESTINATION share/chaiscript
    PATTERN "*.chai" 
    PATTERN "*.inc"
    PATTERN "*/.svn*" EXCLUDE
    PATTERN "*/.git*" EXCLUDE
    PATTERN "*~" EXCLUDE)
-install(DIRECTORY samples DESTINATION share/chaiscript 
+install(DIRECTORY samples DESTINATION share/chaiscript
    PATTERN "*.chai"
    PATTERN "*/.svn*" EXCLUDE
    PATTERN "*/.git*" EXCLUDE
    PATTERN "*~" EXCLUDE)
-        
 
 configure_file(contrib/pkgconfig/chaiscript.pc.in lib/pkgconfig/chaiscript.pc @ONLY)
-install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc" 
-	DESTINATION lib/pkgconfig)
+install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc"
+        DESTINATION lib/pkgconfig)
 

contrib/codeanalysis/heterogenous_array_loop.chai

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

contrib/codeanalysis/is_prime.chai

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

contrib/codeanalysis/profile_math.chai

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

contrib/codeanalysis/runcppcheck.sh

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

contrib/geshi/chaiscript.php

@@ -48,7 +48,7 @@ $language_data = array (
     'ESCAPE_CHAR' => '\\',
     'KEYWORDS' => array(
         1 => array(
-            'break', 'else', 'else if', 'eval', 'for', 'if', 'return', 'while', 'try', 'catch', 'finally',
+            'break', 'else', 'else if', 'eval', 'for', 'if', 'return', 'while', 'try', 'catch', 'finally', 'case', 'switch', 'default',
             ),
         2 => array(
             'def', 'false', 'fun', 'true', 'var', 'attr',

contrib/vim/syntax/chaiscript.vim

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

include/chaiscript/chaiscript.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HPP_
@@ -24,6 +24,8 @@
 /// 
 /// \sa chaiscript
 /// \sa chaiscript::ChaiScript
+/// \sa ChaiScript_Language for Built in Functions
+/// \sa \ref LangGettingStarted
 /// \sa \ref LangKeywordRef
 /// \sa \ref LangInPlaceRef
 /// \sa \ref LangObjectSystemRef
@@ -32,11 +34,13 @@
 ///
 /// <hr>
 ///
-/// \section gettingstarted 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
@@ -50,6 +54,7 @@
 /// Basic simple example:
 ///
 /// \code
+/// //main.cpp
 /// #include <chaiscript/chaiscript.hpp>
 /// 
 /// double function(int i, double j)
@@ -67,6 +72,27 @@
 /// \endcode
 ///
 /// <hr>
+/// \subsection compiling Compiling ChaiScript Applications
+///
+/// ChaiScript is a header only library with only two dependecies. boost::threads (optional) and the
+/// operating system provided dynamic library loader, which has to be specified on some platforms.
+/// 
+/// \subsubsection compilinggcc Compiling with GCC
+/// 
+/// To compile the above application on a Unix like operating system (MacOS, Linux) with GCC you need to link
+/// both boost::threads and the dynamic loader. For example:
+///
+/// \code
+/// gcc main.cpp -I/path/to/chaiscript/headers -ldl -lboost_threads
+/// \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
 ///
 /// Scripts can be evaluated with the () operator, eval method or eval_file method.
@@ -114,7 +140,10 @@
 ///
 /// \subsubsection addingobjects Adding Objects
 ///
-/// Named objects can be created with the #var function.
+/// Named objects can be created with the chaiscript::var function. Note: adding a object
+/// adds it to the current thread scope, not to a global scope. If you have multiple 
+/// threads that need to access the same variables you will need to add them
+/// separately for each thread, from the thread itself.
 /// 
 /// \code
 /// using namespace chaiscript;
@@ -166,8 +195,8 @@
 /// Overloaded methods will need some help, to hint the compiler as to which overload you want:
 ///
 /// \code
-/// chai.add(fun<void (MyClass::*)()>(&MyClass::overloadedmethod), "overloadedmethod"));
-/// chai.add(fun<void (MyClass::*)(const std::string &)>(&MyClass::overloadedmethod, "overloadedmethod"));
+/// 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.
@@ -204,7 +233,29 @@
 /// \endcode
 /// 
 /// \sa chaiscript::Module
+///
+/// <hr>
+/// \subsection operatoroverloading Operator Overloading
 /// 
+/// Operators are just like any other function in ChaiScript, to overload an operator, simply register it.
+/// 
+/// \code 
+/// class MyClass {
+///   MyClass operator+(const MyClass &) const;
+/// };
+///
+/// chai.add(fun(&MyClass::operator+), "+");
+///
+/// std::string append_string_int(const std::string &t_lhs, int t_rhs)
+/// {
+///   return t_lhs + boost::lexical_cast<std::string>(t_rhs);
+/// }
+///
+/// chai.add(fun(append_string_int), "+");
+/// \endcode
+///
+/// \sa \ref addingfunctions
+///
 /// <hr>
 /// \subsection helpermacro Class Helper Macro
 /// 
@@ -252,7 +303,7 @@
 /// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, boost::shared_ptr<T>,
 /// boost::shared_ptr<const T>, boost::reference_wrapper<T>, boost::reference_wrapper<const T> and value types automatically.
 ///
-/// If a var object was created in C++ from a pointer, it cannot be convered to a shared_ptr (this would add invalid reference counting).
+/// If a chaiscript::var object was created in C++ from a pointer, it cannot be convered to a shared_ptr (this would add invalid reference counting).
 /// Const may be added, but never removed. 
 ///
 /// The take away is that you can pretty much expect function calls to Just Work when you need them to.
@@ -365,6 +416,8 @@
 ///
 /// \subsection exceptions Exception Handling
 /// 
+/// \subsubsection exceptionsbasics Exception Handling Basics
+///
 /// Exceptions can be thrown in ChaiScript and caught in C++ or thrown in C++ and caught in 
 /// ChaiScript.
 ///
@@ -376,10 +429,12 @@
 /// 
 /// int main()
 /// {
+///   // Throw in C++, catch in ChaiScript
 ///   chaiscript::ChaiScript chai;
 ///   chai.add(chaiscript::fun(&throwexception), "throwexception");
 ///   chai("try { throwexception(); } catch (e) { print(e.what()); }"); // prints "err"
 /// 
+///   // Throw in ChaiScript, catch in C++
 ///   try {
 ///     chai("throw(1)");
 ///   } catch (chaiscript::Boxed_Value bv) {
@@ -388,6 +443,31 @@
 ///   }
 /// }
 /// \endcode
+/// 
+/// \subsubsection exceptionsautomatic Exception Handling Automatic Unboxing
+///
+/// As an alternative to the manual unboxing of exceptions shown above, exception specifications allow the user to tell 
+/// ChaiScript what possible exceptions are expected from the script being executed. 
+///
+/// Example:
+/// \code
+/// chaiscript::ChaiScript chai;
+///
+/// try {
+///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+/// } catch (const double e) {
+/// } catch (int) {
+/// } catch (float) {
+/// } catch (const std::string &) {
+/// } catch (const std::exception &e) {
+///   // This is the one what will be called in the specific throw() above
+/// }
+/// \endcode
+///
+/// \sa chaiscript::Exception_Handler for details on automatic exception unboxing 
+/// \sa chaiscript::exception_specification
+
+
 
 /// \page LangObjectSystemRef ChaiScript Language Object Model Reference
 ///
@@ -429,6 +509,114 @@
 /// In-place Map ::= "[" (string ":" expression)+ "]"
 /// \endcode
 
+/// \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
+///
+/// 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
+///
+/// <hr>
+/// \section chaiscriptifs Conditionals
+///
+/// If statements work as expected
+/// 
+/// \code
+/// var b = true;
+/// 
+/// if (b) {
+///   // do something
+/// } else if (c < 10) {
+///   // do something else
+/// } else {
+///   // or do this
+/// }
+/// \endcode
+///
+/// \sa \ref keywordif
+///
+/// <hr>
+/// \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
+///
+/// <hr>
+/// \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);
+/// 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
+
+
 /// \page LangKeywordRef ChaiScript Language Keyword Reference
 ///
 ///
@@ -563,7 +751,7 @@
 #include "dispatchkit/bootstrap_stl.hpp"
 #include "dispatchkit/function_call.hpp"
 #include "dispatchkit/dynamic_object.hpp"
-#include "dispatchkit/boxed_pod_value.hpp"
+#include "dispatchkit/boxed_number.hpp"
 
 #ifdef  BOOST_HAS_DECLSPEC
 #define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)

include/chaiscript/chaiscript_threading.hpp

@@ -1,14 +1,23 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_THREADING_HPP_
 #define CHAISCRIPT_THREADING_HPP_
 
 #ifndef CHAISCRIPT_NO_THREADS
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif
 #include <boost/thread.hpp>
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
 #else
 #pragma message ("ChaiScript is compiling without thread safety.")
 #endif
@@ -75,6 +84,8 @@ namespace chaiscript
       {
         public:
           unique_lock(T &) {}
+          void lock() {}
+          void unlock() {}
       };
 
       template<typename T>
@@ -82,6 +93,7 @@ namespace chaiscript
       {
         public:
           shared_lock(T &) {}
+          void lock() {}
           void unlock() {}
       };
 

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
@@ -33,7 +33,7 @@ namespace chaiscript
         }
 
         bad_boxed_cast(const std::string &t_what) throw()
-          : m_what(t_what)
+          : to(0), m_what(t_what)
         {
         }
 

include/chaiscript/dispatchkit/bind_first.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <boost/preprocessor.hpp>
@@ -89,5 +89,6 @@ namespace chaiscript
 
 #undef n
 #undef m
+#undef param
 
 #endif

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
@@ -11,8 +11,9 @@
 #include "dynamic_object.hpp"
 #include "register_function.hpp"
 #include "operators.hpp"
-#include "boxed_pod_value.hpp"
+#include "boxed_number.hpp"
 #include <boost/function_types/result_type.hpp>
+#include <sstream>
 
 namespace chaiscript 
 {
@@ -21,189 +22,30 @@ namespace chaiscript
   {
     namespace detail
     {
-
-      /// \brief Assigns a POD value from a Boxed_POD_Value. Helps support operators between
-      ///        disparate POD types.
-      /// \param[in,out] p1 object to assign to
-      /// \param[in] v Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_pod(P1 &p1, const Boxed_POD_Value &v)
-      {
-        if (v.isfloat)
-        {
-          return (p1 = P1(v.d));
-        } else {
-          return (p1 = P1(v.i));
-        }
-      }
-
-      /// \brief Constructs a new POD value object from a Boxed_POD_Value
-      /// \param[in] v Boxed_POD_Value to copy into the new object
+      /// \brief Constructs a new POD value object from a Boxed_Number
+      /// \param[in] v Boxed_Number to copy into the new object
       /// \returns The newly created object.
       template<typename P1>
-      P1 construct_pod(Boxed_POD_Value v)
+      boost::shared_ptr<P1> construct_pod(Boxed_Number v)
       {
-        if (v.isfloat)
-        {
-          return P1(v.d);
-        } else {
-          return P1(v.i);
-        }    
-      }
-
-      /// \brief Performs a bitwise and assignment (&=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to bitwise and assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_bitwise_and_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 &= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("&= only valid for integer types");
-      }
-
-      /// \brief Performs a xor assignment (^=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to xor assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_xor_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 ^= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("^= only valid for integer types");
-      }
-
-      /// \brief Performs a bitwise or assignment (|=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to bitwise or assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_bitwise_or_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 |= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("&= only valid for integer types");
-      }
-
-      /// \brief Performs an assign difference (-=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to difference assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_difference_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 -= P1(r.d);
-        } else {
-          return p1 -= P1(r.i);
-        }
-      }
-
-      /// \brief Performs an assign shift left (<<=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign shift left to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_left_shift_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 <<= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("<<= only valid for integer types");
-      }
-
-
-      /// \brief Performs an assign product (*=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign product to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_product_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 *= P1(r.d);
-        } else {
-          return p1 *= P1(r.i);
-        }
-      }
-
-      /// \brief Performs an assign quotient (/=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign quotient to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_quotient_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 /= P1(r.d);
-        } else {
-          return p1 /= P1(r.i);
-        }
-      }
-
-      /// \brief Performs an assign remainder (%=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign remainder to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_remainder_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 %= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast("%= only valid for integer types");
-      }
-
-
-      /// \brief Performs an assign shift right (>>=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to assign shift right to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_right_shift_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (!r.isfloat)
-        {
-          return p1 >>= P1(r.i);
-        }
-
-        throw exception::bad_boxed_cast(">>= only valid for integer types");
-      }
-
-      /// \brief Performs an assign sum (+=) on the given object with the given Boxed_POD_Value
-      /// \param[in,out] p1 object to sum assign to
-      /// \param[in] r Boxed_POD_Value to assign from
-      /// \returns Reference to p1, to support normal C assignment semantics
-      template<typename P1>
-      P1 &assign_sum_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.isfloat)
-        {
-          return p1 += P1(r.d);
-        } else {
-          return p1 += P1(r.i);
-        }
+        boost::shared_ptr<P1> p(new P1());
+        Boxed_Value bv(p);
+        Boxed_Number nb(bv);
+        nb = v;
+        return p;
       }
+    }
 
+    /// \brief Adds a copy constructor for the given type to the given Model
+    /// \param[in] type The name of the type. The copy constructor will be named "type".
+    /// \param[in,out] m The Module to add the copy constructor to
+    /// \tparam T The type to add a copy constructor for
+    /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
+    template<typename T>
+    ModulePtr copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      m->add(constructor<T (const T &)>(), type);
+      return m;
     }
 
     /// \brief Add all comparison operators for the templated type. Used during bootstrap, also available to users.
@@ -223,76 +65,6 @@ namespace chaiscript
     }
 
 
-    /// \brief Add all arithmetic operators appropriate for integers for the templated type. 
-    ///        Used during bootstrap, also available to users.
-    /// \tparam T Type to create arithmetic operators for
-    /// \param[in,out] m module to add arithmetic operators to
-    /// \returns the passed in ModulePtr or the newly constructed one if the default params are used.
-    template<typename T>
-    ModulePtr opers_integer_arithmetic(ModulePtr m = ModulePtr(new Module()))
-    {
-      operators::assign_bitwise_and<T>(m);
-      operators::assign_xor<T>(m);
-      operators::assign_bitwise_or<T>(m);
-      operators::assign_difference<T>(m);
-      operators::assign_left_shift<T>(m);
-      operators::assign_product<T>(m);
-      operators::assign_quotient<T>(m);
-      operators::assign_remainder<T>(m);
-      operators::assign_right_shift<T>(m);
-      operators::assign_sum<T>(m);
-
-      operators::prefix_decrement<T>(m);
-      operators::prefix_increment<T>(m);
-      operators::addition<T>(m);
-      operators::unary_plus<T>(m);
-      operators::subtraction<T>(m);
-      operators::unary_minus<T>(m);
-      operators::bitwise_and<T>(m);
-      operators::bitwise_compliment<T>(m);
-      operators::bitwise_xor<T>(m);
-      operators::bitwise_or<T>(m);
-      operators::division<T>(m);
-      operators::left_shift<T>(m);
-      operators::multiplication<T>(m);
-      operators::remainder<T>(m);
-      operators::right_shift<T>(m);
-      return m;
-    }
-
-    /// \brief Add all arithmetic operators appropriate for floating point numbers for the templated type. 
-    ///        Used during bootstrap, also available to users.
-    /// \tparam T Type to create arithmetic operators for
-    /// \param[in,out] m module to add arithmetic operators to
-    /// \returns the passed in ModulePtr or the newly constructed one if the default params are used.
-    template<typename T>
-    ModulePtr opers_float_arithmetic(ModulePtr m = ModulePtr(new Module()))
-    {
-      operators::assign_difference<T>(m);
-      operators::assign_product<T>(m);
-      operators::assign_quotient<T>(m);
-      operators::assign_sum<T>(m);
-
-      operators::addition<T>(m);
-      operators::unary_plus<T>(m);
-      operators::subtraction<T>(m);
-      operators::unary_minus<T>(m);
-      operators::division<T>(m);
-      operators::multiplication<T>(m);
-      return m;
-    }
-
-    /// \brief Adds a copy constructor for the given type to the given Model
-    /// \param[in] type The name of the type. The copy constructor will be named "type".
-    /// \param[in,out] m The Module to add the copy constructor to
-    /// \tparam T The type to add a copy constructor for
-    /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
-    template<typename T>
-    ModulePtr copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(constructor<T (const T &)>(), type);
-      return m;
-    }
 
     /// \brief Adds default and copy constructors for the given type
     /// \param[in] type The name of the type to add the constructors for.
@@ -322,36 +94,34 @@ namespace chaiscript
 
 
     /**
-    * to_string function for internal use. Uses ostream operator<<
-    */
-    template<typename Input>
-    std::string to_string(Input i)
-    {
-      return boost::lexical_cast<std::string>(i);
-    }
-
-
-    /**
-    * 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)
-    {
-      return boost::lexical_cast<Input>(i);
-    }
-
-
-    /**
-     * Add assignment operator for T = POD.
+     * to_string function for internal use. Uses ostream operator<<
      */
-    template<typename T>
-      ModulePtr oper_assign_pod(ModulePtr m = ModulePtr(new Module()))
+    template<typename Input>
+      std::string to_string(Input i)
       {
-        m->add(fun(&detail::assign_pod<T>), "=");
-        return m;
+        std::stringstream ss;
+        ss << i;
+        return ss.str();
       }
 
+    /**
+     * Internal function for converting from a string to a value
+     * uses ostream operator >> to perform the conversion
+     */
+    template<typename Input>
+      Input parse_string(const std::string &i)
+      {
+        std::stringstream ss(i);
+        Input t;
+        ss >> t;
+        return t;
+      }
+
+
+
+     
+      
+            
     /**
     * Add all common functions for a POD type. All operators, and
     * common conversions
@@ -360,52 +130,14 @@ namespace chaiscript
     ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
     {
       m->add(user_type<T>(), name);
-      basic_constructors<T>(name, m);
-      operators::assign<T>(m);
-      oper_assign_pod<T>(m);
+      m->add(constructor<T ()>(), name);
       construct_pod<T>(name, m);
 
-      m->add(fun(&detail::assign_sum_pod<T>), "+=");
-      m->add(fun(&detail::assign_difference_pod<T>), "-=");
-      m->add(fun(&detail::assign_product_pod<T>), "*=");
-      m->add(fun(&detail::assign_quotient_pod<T>), "/=");
-
       m->add(fun(&to_string<T>), "to_string");
       m->add(fun(&parse_string<T>), "to_" + name);
       return m;
     }
 
-    /**
-    * Add all common functions for a POD type. All operators, and
-    * common conversions
-    */
-    template<typename T>
-    ModulePtr bootstrap_integer_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
-    {
-      bootstrap_pod_type<T>(name, m);
-
-      m->add(fun(&detail::assign_bitwise_and_pod<T>), "&=");
-      m->add(fun(&detail::assign_xor_pod<T>), "^=");
-      m->add(fun(&detail::assign_bitwise_or_pod<T>), "|=");
-      m->add(fun(&detail::assign_left_shift_pod<T>), "<<=");
-      m->add(fun(&detail::assign_remainder_pod<T>), "%=");
-      m->add(fun(&detail::assign_right_shift_pod<T>), ">>=");
-
-      opers_integer_arithmetic<T>(m);
-      return m;
-    }
-
-    /**
-    * Add all common functions for a POD type. All operators, and
-    * common conversions
-    */
-    template<typename T>
-    ModulePtr bootstrap_float_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
-    {
-      bootstrap_pod_type<T>(name, m);
-      opers_float_arithmetic<T>(m);
-      return m;
-    }
 
     /**
     * "clone" function for a shared_ptr type. This is used in the case
@@ -480,22 +212,48 @@ namespace chaiscript
         std::cout << s << std::endl;
       }
 
+
       /**
       * Add all arithmetic operators for PODs
       */
       static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
       {
-        m->add(fun(&operators::addition<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "+");
-        m->add(fun(&operators::subtraction<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "-");
-        m->add(fun(&operators::bitwise_and<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "&");
-        m->add(fun(&operators::bitwise_xor<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "^");
-        m->add(fun(&operators::bitwise_or<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "|");
-        m->add(fun(&operators::division<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "/");
-        m->add(fun(&operators::left_shift<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "<<");
-        m->add(fun(&operators::multiplication<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "*");
-        m->add(fun(&operators::remainder<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "%");
-        m->add(fun(&operators::right_shift<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), ">>");
-      }
+        m->add(fun(&Boxed_Number::equals), "==");
+        m->add(fun(&Boxed_Number::less_than), "<");
+        m->add(fun(&Boxed_Number::greater_than), ">");
+        m->add(fun(&Boxed_Number::greater_than_equal), ">=");
+        m->add(fun(&Boxed_Number::less_than_equal), "<=");
+        m->add(fun(&Boxed_Number::not_equal), "!=");
+
+        m->add(fun(&Boxed_Number::pre_decrement), "--");
+        m->add(fun(&Boxed_Number::pre_increment), "++");
+        m->add(fun(&Boxed_Number::sum), "+");
+        m->add(fun(&Boxed_Number::unary_plus), "+");
+        m->add(fun(&Boxed_Number::unary_minus), "-");
+        m->add(fun(&Boxed_Number::difference), "-");
+        m->add(fun(&Boxed_Number::assign_bitwise_and), "&=");
+        m->add(fun(&Boxed_Number::assign), "=");
+        m->add(fun(&Boxed_Number::assign_bitwise_or), "|=");
+        m->add(fun(&Boxed_Number::assign_bitwise_xor), "^=");
+        m->add(fun(&Boxed_Number::assign_remainder), "%=");
+        m->add(fun(&Boxed_Number::assign_shift_left), "<<=");
+        m->add(fun(&Boxed_Number::assign_shift_right), ">>=");
+        m->add(fun(&Boxed_Number::bitwise_and), "&");
+        m->add(fun(&Boxed_Number::bitwise_complement), "~");
+        m->add(fun(&Boxed_Number::bitwise_xor), "^");
+        m->add(fun(&Boxed_Number::bitwise_or), "|");
+        m->add(fun(&Boxed_Number::assign_product), "*=");
+        m->add(fun(&Boxed_Number::assign_quotient), "/=");
+        m->add(fun(&Boxed_Number::assign_sum), "+=");
+        m->add(fun(&Boxed_Number::assign_difference), "-=");
+        m->add(fun(&Boxed_Number::quotient), "/");
+        m->add(fun(&Boxed_Number::shift_left), "<<");
+        m->add(fun(&Boxed_Number::product), "*");
+        m->add(fun(&Boxed_Number::remainder), "%");
+        m->add(fun(&Boxed_Number::shift_right), ">>");
+
+
+     }
 
       /**
       * Create a bound function object. The first param is the function to bind
@@ -515,28 +273,17 @@ namespace chaiscript
           std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
       }
 
-      /**
-      * Returns true if a call can be made that consists of the first parameter
-      * (the function) with the remaining parameters as its arguments.
-      */
-      static Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
-      {
-        if (params.size() < 1)
-        {
-          throw exception::arity_error(static_cast<int>(params.size()), 1);
-        }
-
-        Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
-
-        return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end())));
-      }
 
       static bool has_guard(const Const_Proxy_Function &t_pf)
       {
         boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
-          return pf->get_guard();
+          if (pf->get_guard()) {
+            return true;
+          } else {
+            return false;
+          }
         } else {
           return false;
         }
@@ -561,12 +308,6 @@ namespace chaiscript
       static void throw_exception(const Boxed_Value &bv) {
         throw bv;
       }
-      
-      static boost::shared_ptr<chaiscript::detail::Dispatch_Engine> bootstrap2(boost::shared_ptr<chaiscript::detail::Dispatch_Engine> e = boost::shared_ptr<chaiscript::detail::Dispatch_Engine> (new chaiscript::detail::Dispatch_Engine()))
-      {
-        e->add(user_type<void>(), "void");
-        return e;
-      }
 
       static std::string what(const std::exception &e)
       {
@@ -619,13 +360,12 @@ namespace chaiscript
         m->add(user_type<void>(), "void");
         m->add(user_type<bool>(), "bool");
         m->add(user_type<Boxed_Value>(), "Object");
-        m->add(user_type<Boxed_POD_Value>(), "PODObject");
+        m->add(user_type<Boxed_Number>(), "Number");
         m->add(user_type<Proxy_Function>(), "Function");
         m->add(user_type<std::exception>(), "exception");
 
         m->add(fun(&dispatch::Proxy_Function_Base::get_arity), "get_arity");
         m->add(fun(&dispatch::Proxy_Function_Base::annotation), "get_annotation");
-        m->add(fun(&dispatch::Proxy_Function_Base::operator()), "call");
         m->add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
 
         
@@ -669,16 +409,15 @@ namespace chaiscript
         m->add(fun(&Type_Info::is_void), "is_type_void");
         m->add(fun(&Type_Info::is_undef), "is_type_undef");
         m->add(fun(&Type_Info::is_pointer), "is_type_pointer");
+        m->add(fun(&Type_Info::is_arithmetic), "is_type_arithmetic");
         m->add(fun(&Type_Info::name), "cpp_name");
         m->add(fun(&Type_Info::bare_name), "cpp_bare_name");
         m->add(fun(&Type_Info::bare_equal), "bare_equal");
-        typedef bool (Type_Info::*typeinfocompare)(const Type_Info &) const;
-        m->add(fun(typeinfocompare(&Type_Info::operator==)), "==");
-        m->add(fun(&Type_Info::bare_equal), "bare_equal");
 
 
         basic_constructors<bool>("bool", m);
         operators::assign<bool>(m);
+        operators::equal<bool>(m);
 
         m->add(fun(&to_string<const std::string &>), "internal_to_string");
         m->add(fun(&Bootstrap::bool_to_string), "internal_to_string");
@@ -686,15 +425,26 @@ namespace chaiscript
         m->add(fun(&throw_exception), "throw");
         m->add(fun(&what), "what");
 
-        bootstrap_float_type<double>("double", m);
-        bootstrap_integer_type<int>("int", m);
-        bootstrap_integer_type<size_t>("size_t", m);
-        bootstrap_integer_type<char>("char", m);
-        bootstrap_integer_type<boost::int64_t>("int64_t", m);
+        bootstrap_pod_type<double>("double", m);
+        bootstrap_pod_type<long double>("long_double", m);
+        bootstrap_pod_type<float>("float", m);
+        bootstrap_pod_type<int>("int", m);
+        bootstrap_pod_type<long>("long", m);
+        bootstrap_pod_type<unsigned int>("unsigned_int", m);
+        bootstrap_pod_type<unsigned long>("unsigned_long", m);
+        bootstrap_pod_type<size_t>("size_t", m);
+        bootstrap_pod_type<char>("char", m);
+        bootstrap_pod_type<boost::int8_t>("int8_t", m);
+        bootstrap_pod_type<boost::int16_t>("int16_t", m);
+        bootstrap_pod_type<boost::int32_t>("int32_t", m);
+        bootstrap_pod_type<boost::int64_t>("int64_t", m);
+        bootstrap_pod_type<boost::uint8_t>("uint8_t", m);
+        bootstrap_pod_type<boost::uint16_t>("uint16_t", m);
+        bootstrap_pod_type<boost::uint32_t>("uint32_t", m);
+        bootstrap_pod_type<boost::uint64_t>("uint64_t", m);
 
         operators::logical_compliment<bool>(m);
 
-        opers_comparison<Boxed_POD_Value>(m);
         opers_arithmetic_pod(m);
 
 
@@ -708,9 +458,6 @@ namespace chaiscript
         m->add(fun(&ptr_assign<boost::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
         m->add(fun(&ptr_assign<boost::add_const<dispatch::Proxy_Function_Base>::type>), "=");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), 
-          "call_exists");
-
         m->add(fun(&type_match), "type_match");
 
         return m;

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -1,16 +1,13 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-/**
- * \file
- * This file contains utility functions for registration of STL container
- * classes. The methodology used is based on the SGI STL concepts.
- * http://www.sgi.com/tech/stl/table_of_contents.html
- */
-
+/// \file
+/// This file contains utility functions for registration of STL container
+/// classes. The methodology used is based on the SGI STL concepts.
+/// http://www.sgi.com/tech/stl/table_of_contents.html
 
 
 #ifndef CHAISCRIPT_BOOTSTRAP_STL_HPP_
@@ -25,11 +22,10 @@ namespace chaiscript
   {
     namespace standard_library
     {
-      /**
-       * Bidir_Range, based on the D concept of ranges.
-       * \todo Update the Range code to base its capabilities on
-       *       the user_typetraits of the iterator passed in
-       */
+
+      /// Bidir_Range, based on the D concept of ranges.
+      /// \todo Update the Range code to base its capabilities on
+      ///       the user_typetraits of the iterator passed in
       template<typename Container>
         struct Bidir_Range
         {
@@ -147,9 +143,106 @@ namespace chaiscript
         };
 
       namespace detail {
-        /**
-         * Add Bidir_Range support for the given ContainerType
-         */
+        template<typename T>
+          int return_int_impl(const boost::function<typename T::size_type (const T *)> &t_func, const T *t_obj)
+          {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
+
+        template<typename T>
+        boost::function<int (const T *)> return_int(size_t (T::*t_func)() const)
+          {
+            return boost::bind(&return_int_impl<T>, boost::function<size_t (const T *)>(boost::mem_fn(t_func)), _1);
+          }
+
+        template<typename T, typename P1>
+          int return_int_impl(const boost::function<typename T::size_type (const T *, P1)> &t_func, const T *t_obj, P1 p1)
+          {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj, p1);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
+
+        template<typename T, typename P1>
+          int return_int_impl_non_const(const boost::function<typename T::size_type (T *, P1)> &t_func, T *t_obj, P1 p1)
+          {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj, p1);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
+
+        template<typename T, typename P1>
+        boost::function<int (const T *, P1)> return_int(size_t (T::*t_func)(P1) const)
+          {
+            return boost::bind(&return_int_impl<T, P1>, boost::function<size_t (const T *, P1)>(boost::mem_fn(t_func)), _1, _2);
+          }
+
+        template<typename T, typename P1>
+        boost::function<int (T *, P1)> return_int(size_t (T::*t_func)(P1) )
+          {
+            return boost::bind(&return_int_impl_non_const<T, P1>, boost::function<size_t (T*, P1)>(boost::mem_fn(t_func)), _1, _2);
+          }
+
+
+        template<typename T, typename P1, typename P2>
+          int return_int_impl(const boost::function<typename T::size_type (const T *, P1, P2)> &t_func, const T *t_obj, P1 p1, P2 p2)
+          {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj, p1, p2);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
+
+        template<typename StringType, StringType (StringType::*Func)(typename StringType::size_type, typename StringType::size_type) const >
+        StringType substr_helper(const StringType &str, int begin, int end)
+        {
+          return (str.*Func)(begin, end);
+        }
+
+        template<typename T, typename P1, typename P2>
+        boost::function<int (const T *, P1, P2)> return_int(size_t (T::*t_func)(P1, P2) const)
+          {
+            return boost::bind(&return_int_impl<T, P1, P2>, boost::function<size_t (const T *, P1, P2)>(boost::mem_fn(t_func)), _1, _2, _3);
+          }
+
+        template<typename T>
+          void insert(T &t_target, const T &t_other)
+          {
+            t_target.insert(t_other.begin(), t_other.end());
+          }
+
+        template<typename T>
+          void insert_ref(T &t_target, const typename T::value_type &t_val)
+          {
+            t_target.insert(t_val);
+          }
+
+
+
+
+
+        /// Add Bidir_Range support for the given ContainerType
         template<typename Bidir_Type>
           ModulePtr input_range_type_impl(const std::string &type, ModulePtr m = ModulePtr(new Module()))
           {
@@ -168,9 +261,8 @@ namespace chaiscript
             return m;
           } 
 
-        /**
-         * Algorithm for inserting at a specific position into a container
-         */
+
+        /// Algorithm for inserting at a specific position into a container
         template<typename Type>
           void insert_at(Type &container, int pos, const typename Type::value_type &v)
           {
@@ -186,9 +278,8 @@ namespace chaiscript
             container.insert(itr, v);
           }
 
-        /**
-         * Algorithm for erasing a specific position from a container
-         */
+
+        /// Algorithm for erasing a specific position from a container
         template<typename Type>
           void erase_at(Type &container, int pos)
           {
@@ -214,10 +305,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add random_access_container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/RandomAccessContainer.html
-       */
+
+      /// Add random_access_container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/RandomAccessContainer.html
       template<typename ContainerType>
         ModulePtr random_access_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -236,10 +326,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add assignable concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Assignable.html
-       */
+
+      /// Add assignable concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Assignable.html
       template<typename ContainerType>
         ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -248,24 +337,22 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Container.html
-       */
+
+      /// Add container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Container.html
       template<typename ContainerType>
         ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(boost::function<int (const ContainerType *)>(boost::mem_fn(&ContainerType::size))), "size");
+          boost::function<int (const ContainerType *)> f = detail::return_int(&ContainerType::size);
+          m->add(fun(f), "size");
           m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
           m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
-
           return m;
         }
 
-      /**
-       * Add default constructable concept to the given Type
-       * http://www.sgi.com/tech/stl/DefaultConstructible.html
-       */
+
+      /// Add default constructable concept to the given Type
+      /// http://www.sgi.com/tech/stl/DefaultConstructible.html
       template<typename Type>
         ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -275,10 +362,9 @@ namespace chaiscript
 
 
 
-      /**
-       * Add sequence concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Sequence.html
-       */
+
+      /// Add sequence concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Sequence.html
       template<typename ContainerType>
         ModulePtr sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -296,10 +382,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add back insertion sequence concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/BackInsertionSequence.html
-       */
+
+      /// Add back insertion sequence concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/BackInsertionSequence.html
       template<typename ContainerType>
         ModulePtr back_insertion_sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -322,10 +407,9 @@ namespace chaiscript
         }
 
 
-      /**
-       *Front insertion sequence
-       *http://www.sgi.com/tech/stl/FrontInsertionSequence.html
-       */
+
+      /// Front insertion sequence
+      /// http://www.sgi.com/tech/stl/FrontInsertionSequence.html
       template<typename ContainerType>
         ModulePtr front_insertion_sequence_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
         {
@@ -348,10 +432,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * bootstrap a given PairType
-       * http://www.sgi.com/tech/stl/pair.html
-       */
+
+      /// bootstrap a given PairType
+      /// http://www.sgi.com/tech/stl/pair.html
       template<typename PairType>
         ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -371,10 +454,10 @@ namespace chaiscript
         }
 
 
-      /**
-       * Add pair associative container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/PairAssociativeContainer.html
-       */
+
+      /// Add pair associative container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/PairAssociativeContainer.html
+
       template<typename ContainerType>
         ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -383,22 +466,37 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add unique associative container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
-       */
+
+      /// Add unique associative container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
       template<typename ContainerType>
         ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(boost::function<int (const ContainerType *, const typename ContainerType::key_type &)>(boost::mem_fn(&ContainerType::count))), "count");
+          m->add(fun(boost::function<int (const ContainerType *, const typename ContainerType::key_type &)>(detail::return_int(&ContainerType::count))), "count");
 
+
+          typedef size_t (ContainerType::*erase)(const typename ContainerType::key_type &);
+          erase eraseptr(&ContainerType::erase);
+
+          m->add(fun(boost::function<int (ContainerType *, const typename ContainerType::key_type &)>(detail::return_int(eraseptr))), "erase");
+
+          m->add(fun(&detail::insert<ContainerType>), "insert");
+
+          std::string insert_name;
+          if (typeid(typename ContainerType::mapped_type) == typeid(Boxed_Value))
+          {
+            insert_name = "insert_ref";
+          } else {
+            insert_name = "insert";
+          }
+
+          m->add(fun(&detail::insert_ref<ContainerType>), insert_name);
           return m;
         }
 
-      /**
-       * Add a MapType container
-       * http://www.sgi.com/tech/stl/Map.html
-       */
+
+      /// Add a MapType container
+      /// http://www.sgi.com/tech/stl/Map.html
       template<typename MapType>
         ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -417,10 +515,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * hopefully working List type
-       * http://www.sgi.com/tech/stl/List.html
-       */
+
+      /// hopefully working List type
+      /// http://www.sgi.com/tech/stl/List.html
       template<typename ListType>
         ModulePtr list_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -437,10 +534,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Create a vector type with associated concepts
-       * http://www.sgi.com/tech/stl/Vector.html
-       */
+
+      /// Create a vector type with associated concepts
+      /// http://www.sgi.com/tech/stl/Vector.html
       template<typename VectorType>
         ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -483,10 +579,34 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add a String container
-       * http://www.sgi.com/tech/stl/basic_string.html
-       */
+        namespace detail {
+          template<typename String>
+          struct apple_string_workarounds
+          {
+            /// The latest version of MacOS has a broken std::string implementation which will not allow
+            /// us to take pointers to the members. Code compiles, but does not link
+            /// \todo re-evaluate at some point
+
+            static size_t find(const String *s, const String &w, int pos) { return s->find(w, pos); }
+            static size_t rfind(const String *s, const String &w, size_t pos) { return s->rfind(w, pos); }
+            static size_t find_first_of(const String *s, const String &w, size_t pos) { return s->find_first_of(w, pos); }
+            static size_t find_last_of(const String *s, const String &w, size_t pos) { return s->find_last_of(w, pos); }
+            static size_t find_first_not_of(const String *s, const String &w, size_t pos) { return s->find_first_not_of(w, pos); }
+            static size_t find_last_not_of(const String *s, const String &w, size_t pos) { return s->find_last_not_of(w, pos); }
+
+            static void clear(String *s) { s->clear(); }
+            static bool empty(const String *s) { return s->empty(); }
+            static size_t size(const String *s) { return s->size(); }
+ 
+            static std::string substr(const String *s, size_t pos, size_t len) { return s->substr(pos,len); }
+            static const char *c_str(const String *s) {  return s->c_str(); }
+            static const char *data(const String *s) { return s->data(); }
+          };
+        }
+
+
+      /// Add a String container
+      /// http://www.sgi.com/tech/stl/basic_string.html
       template<typename String>
         ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -497,7 +617,7 @@ namespace chaiscript
           random_access_container_type<String>(type, m);
           sequence_type<String>(type, m);
           default_constructible_type<String>(type, m);
-          container_type<String>(type, m);
+          // container_type<String>(type, m);
           assignable_type<String>(type, m);
           input_range_type<String>(type, m);
 
@@ -511,19 +631,19 @@ namespace chaiscript
           }
           m->add(fun(&String::push_back), push_back_name);
 
-          typedef typename String::size_type (String::*find_func_ptr)(const String &, typename String::size_type) const;
-
-          typedef boost::function<int (const String *, const String &, int)> find_func;
-
-          m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find)))), "find");
-          m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::rfind)))), "rfind");
-          m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_first_of)))), "find_first_of");
-          m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_last_of)))), "find_last_of");
-          m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_first_not_of)))), "find_first_not_of");
-          m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_last_not_of)))), "find_last_not_of");
-
-          m->add(fun(&String::c_str), "c_str");
-          m->add(fun(&String::data), "data");
+            
+          m->add(fun(&detail::apple_string_workarounds<String>::find), "find");
+          m->add(fun(&detail::apple_string_workarounds<String>::rfind), "rfind");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_first_of), "find_first_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_last_of), "find_last_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_first_not_of), "find_first_not_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_last_not_of), "find_last_not_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::clear), "clear");
+          m->add(fun(&detail::apple_string_workarounds<String>::size), "size");
+          m->add(fun(&detail::apple_string_workarounds<String>::empty), "empty");
+          m->add(fun(&detail::apple_string_workarounds<String>::substr), "substr");
+          m->add(fun(&detail::apple_string_workarounds<String>::c_str), "c_str");
+          m->add(fun(&detail::apple_string_workarounds<String>::data), "data");
 
 
           return m;

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -1,11 +1,11 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __boxed_cast_hpp__
-#define __boxed_cast_hpp__
+#ifndef CHAISCRIPT_BOXED_CAST_HPP_
+#define CHAISCRIPT_BOXED_CAST_HPP_
 
 #include "type_info.hpp"
 #include "boxed_value.hpp"
@@ -68,10 +68,10 @@ namespace chaiscript
   /// assert(i == 5);
   /// \endcode
   template<typename Type>
-  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv)
+  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions = 0)
   {
     try {
-      return detail::Cast_Helper<Type>::cast(bv);
+      return detail::Cast_Helper<Type>::cast(bv, t_conversions);
     } catch (const boost::bad_any_cast &) {
 
 #ifdef BOOST_MSVC
@@ -81,14 +81,21 @@ namespace chaiscript
 #pragma warning(disable : 4127)
 #endif
 
-      if (boost::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value)
+      if (boost::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value && t_conversions)
       {
         try {
+          // std::cout << "trying an up conversion " << typeid(Type).name() << std::endl;
           // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
           // either way, we are not responsible if it doesn't work
-          return detail::Cast_Helper<Type>::cast(detail::boxed_dynamic_cast<Type>(bv));
-        } catch (const boost::bad_any_cast &) {
-          throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+          return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_cast<Type>(bv), t_conversions);
+        } 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 boost::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

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
@@ -17,6 +17,8 @@
 
 namespace chaiscript 
 {
+  class Dynamic_Cast_Conversions;
+
   namespace detail
   {
     // Cast_Helper_Inner helper classes
@@ -29,7 +31,7 @@ namespace chaiscript
       {
         typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -71,7 +73,7 @@ namespace chaiscript
       {
         typedef const Result * Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -100,7 +102,7 @@ namespace chaiscript
       {
         typedef Result * Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -119,7 +121,7 @@ namespace chaiscript
       {
         typedef typename boost::reference_wrapper<Result> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -138,7 +140,7 @@ namespace chaiscript
       {
         typedef typename boost::shared_ptr<Result> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
         }
@@ -152,7 +154,7 @@ namespace chaiscript
       {
         typedef typename boost::shared_ptr<const Result> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (!ob.get_type_info().is_const())
           {
@@ -200,7 +202,7 @@ namespace chaiscript
       {
         typedef const Boxed_Value & Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           return ob;    
         }
@@ -261,9 +263,9 @@ namespace chaiscript
       {
         typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
         
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
-          return Cast_Helper_Inner<T>::cast(ob);
+          return Cast_Helper_Inner<T>::cast(ob, t_conversions);
         }
       };
   }

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -0,0 +1,856 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_BOXED_NUMERIC_HPP_
+#define CHAISCRIPT_BOXED_NUMERIC_HPP_
+
+#include "boxed_value.hpp"
+#include "../language/chaiscript_algebraic.hpp"
+#include <boost/cstdint.hpp>
+#include <sstream>
+
+namespace chaiscript 
+{
+ 
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4244 4018 4389 4146)
+#endif
+
+  /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values
+  class Boxed_Number
+  {
+    private:
+      struct boolean
+      {
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &)
+        {
+          switch (t_oper)
+          {
+            case Operators::equals:
+              return const_var(t == u);
+            case Operators::less_than:
+              return const_var(t < u);
+            case Operators::greater_than:
+              return const_var(t > u);
+            case Operators::less_than_equal:
+              return const_var(t <= u);
+            case Operators::greater_than_equal:
+              return const_var(t >= u);
+            case Operators::not_equal:
+              return const_var(t != u);
+            default:
+              throw boost::bad_any_cast();        
+          }
+        }
+      };
+
+      struct binary 
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
+        {
+          switch (t_oper)
+          {
+            case Operators::assign:
+              t = u;
+              break;
+            case Operators::pre_increment:
+              ++t;
+              break;
+            case Operators::pre_decrement:
+              --t;
+              break;
+            case Operators::assign_product:
+              t *= u;
+              break;
+            case Operators::assign_sum:
+              t += u;
+              break;
+            case Operators::assign_quotient:
+              t /= u;
+              break;
+            case Operators::assign_difference:
+              t -= u;
+              break;
+            default:
+              throw boost::bad_any_cast();        
+          }
+
+          return t_lhs;
+        }
+      };
+
+      struct binary_int
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, T &t, const U &u, const Boxed_Value &t_lhs) 
+        {
+          switch (t_oper)
+          {
+            case Operators::assign_bitwise_and:
+              t &= u;
+              break;
+            case Operators::assign_bitwise_or:
+              t |= u;
+              break;
+            case Operators::assign_shift_left:
+              t <<= u;
+              break;
+            case Operators::assign_shift_right:
+              t >>= u;
+              break;
+            case Operators::assign_remainder:
+              t %= u;
+              break;
+            case Operators::assign_bitwise_xor:
+              t ^= u;
+              break;
+            default:
+              throw boost::bad_any_cast();        
+          }
+          return t_lhs;
+        }
+      };
+
+      struct const_binary_int
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &) 
+        {
+          switch (t_oper)
+          {
+            case Operators::shift_left:
+              return const_var(t << u);
+            case Operators::shift_right:
+              return const_var(t >> u);
+            case Operators::remainder:
+              return const_var(t % u);
+            case Operators::bitwise_and:
+              return const_var(t & u);
+            case Operators::bitwise_or:
+              return const_var(t | u);
+            case Operators::bitwise_xor:
+              return const_var(t ^ u);
+            case Operators::bitwise_complement:
+              return const_var(~t);
+            default:
+              throw boost::bad_any_cast();        
+          }
+        }
+      };
+
+      struct const_binary
+      {
+        template<typename T, typename U>
+        static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &) 
+        {
+          switch (t_oper)
+          {
+            case Operators::sum:
+              return const_var(t + u);
+            case Operators::quotient:
+              return const_var(t / u);
+            case Operators::product:
+              return const_var(t * u);
+            case Operators::difference:
+              return const_var(t - u);
+            case Operators::unary_minus:
+              return const_var(-t);
+            case Operators::unary_plus:
+              return const_var(+t);
+            default:
+              throw boost::bad_any_cast();        
+          }
+        }
+      };
+
+      template<typename LHS, typename RHS, bool Float>
+      struct Go
+      {
+        static Boxed_Value go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
+          {
+            return boolean::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
+            return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag && !t_lhs.is_const()) {
+            return binary_int::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
+            return const_binary_int::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::const_flag) {
+            return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else {
+            throw boost::bad_any_cast();
+          }
+        }
+      };
+
+      template<typename LHS, typename RHS>
+      struct Go<LHS, RHS, true>
+      {
+        static Boxed_Value go(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          if (t_oper > Operators::boolean_flag && t_oper < Operators::non_const_flag)
+          {
+            return boolean::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
+            return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag) {
+            throw boost::bad_any_cast();
+          } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
+            throw boost::bad_any_cast();
+          } else if (t_oper > Operators::const_flag) {
+            return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
+          } else {
+            throw boost::bad_any_cast();
+          }
+        }
+      };
+
+      template<typename LHS, bool Float>
+        static Boxed_Value oper_rhs(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          const Type_Info &inp_ = t_rhs.get_type_info();
+
+          if (inp_ == typeid(int)) {
+            return Go<LHS, int, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(double)) {
+            return Go<LHS, double, true>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(float)) {
+            return Go<LHS, float, true>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long double)) {
+            return Go<LHS, long double, true>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(char)) {
+            return Go<LHS, char, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned int)) {
+            return Go<LHS, unsigned int, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long)) {
+            return Go<LHS, long, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned long)) {
+            return Go<LHS, unsigned long, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int8_t)) {
+            return Go<LHS, boost::int8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int16_t)) {
+            return Go<LHS, boost::int16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int32_t)) {
+            return Go<LHS, boost::int32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int64_t)) {
+            return Go<LHS, boost::int64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint8_t)) {
+            return Go<LHS, boost::uint8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint16_t)) {
+            return Go<LHS, boost::uint16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint32_t)) {
+            return Go<LHS, boost::uint32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint64_t)) {
+            return Go<LHS, boost::uint64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else {
+            throw boost::bad_any_cast();
+          }
+        } 
+
+        static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+        {
+          const Type_Info &inp_ = t_lhs.get_type_info();
+
+          if (inp_ == typeid(int)) {
+            return oper_rhs<int, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(double)) {
+            return oper_rhs<double, true>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long double)) {
+            return oper_rhs<long double, true>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(float)) {
+            return oper_rhs<float, true>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(char)) {
+            return oper_rhs<char, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned int)) {
+            return oper_rhs<unsigned int, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(long)) {
+            return oper_rhs<long, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(unsigned long)) {
+            return oper_rhs<unsigned long, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int8_t)) {
+            return oper_rhs<boost::int8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int16_t)) {
+            return oper_rhs<boost::int16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int32_t)) {
+            return oper_rhs<boost::int32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::int64_t)) {
+            return oper_rhs<boost::int64_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint8_t)) {
+            return oper_rhs<boost::uint8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint16_t)) {
+            return oper_rhs<boost::uint16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint32_t)) {
+            return oper_rhs<boost::uint32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(boost::uint64_t)) {
+            return oper_rhs<boost::uint64_t, false>(t_oper, t_lhs, t_rhs);
+          } else  {
+            throw boost::bad_any_cast();
+          }
+        }
+
+        template<typename Target, typename Source>
+          Target get_as_aux() const
+        {
+          return static_cast<Target>(*static_cast<const Source *>(bv.get_const_ptr()));
+        }
+
+        template<typename Source>
+         static std::string to_string_aux(const Boxed_Value &v)
+        {
+          std::ostringstream oss;
+          oss << *static_cast<const Source *>(v.get_const_ptr());
+          return oss.str();
+        }
+
+      
+    public:
+      Boxed_Number()
+        : bv(Boxed_Value(0))
+      {
+      }
+
+      Boxed_Number(const Boxed_Value &v)
+        : bv(v)
+      {
+        validate_boxed_number(v);
+      }
+
+      template<typename T> explicit Boxed_Number(T t)
+        : bv(Boxed_Value(t))
+      {
+        validate_boxed_number(bv);
+      }
+
+      Boxed_Number get_as(const Type_Info &inp_) const
+      {
+        if (inp_.bare_equal_type_info(typeid(int))) {
+          return Boxed_Number(get_as<int>());
+        } else if (inp_.bare_equal_type_info(typeid(double))) {
+          return Boxed_Number(get_as<double>());
+        } else if (inp_.bare_equal_type_info(typeid(float))) {
+          return Boxed_Number(get_as<float>());
+        } else if (inp_.bare_equal_type_info(typeid(long double))) {
+          return Boxed_Number(get_as<long double>());
+        } else if (inp_.bare_equal_type_info(typeid(char))) {
+          return Boxed_Number(get_as<char>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned int))) {
+          return Boxed_Number(get_as<unsigned int>());
+        } else if (inp_.bare_equal_type_info(typeid(long))) {
+          return Boxed_Number(get_as<long>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned long))) {
+          return Boxed_Number(get_as<unsigned long>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::int8_t))) {
+          return Boxed_Number(get_as<boost::int8_t>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::int16_t))) {
+          return Boxed_Number(get_as<boost::int16_t>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::int32_t))) {
+          return Boxed_Number(get_as<boost::int32_t>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::int64_t))) {
+          return Boxed_Number(get_as<boost::int64_t>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::uint8_t))) {
+          return Boxed_Number(get_as<boost::uint8_t>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::uint16_t))) {
+          return Boxed_Number(get_as<boost::uint16_t>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::uint32_t))) {
+          return Boxed_Number(get_as<boost::uint32_t>());
+        } else if (inp_.bare_equal_type_info(typeid(boost::uint64_t))) {
+          return Boxed_Number(get_as<boost::uint64_t>());
+        } else {
+          throw boost::bad_any_cast();
+        }
+
+      }
+
+      template<typename Target> Target get_as() const
+      {
+        const Type_Info &inp_ = bv.get_type_info();
+
+        if (inp_ == typeid(int)) {
+          return get_as_aux<Target, int>();
+        } else if (inp_ == typeid(double)) {
+          return get_as_aux<Target, double>();
+        } else if (inp_ == typeid(float)) {
+          return get_as_aux<Target, float>();
+        } else if (inp_ == typeid(long double)) {
+          return get_as_aux<Target, long double>();
+        } else if (inp_ == typeid(char)) {
+          return get_as_aux<Target, char>();
+        } else if (inp_ == typeid(unsigned int)) {
+          return get_as_aux<Target, unsigned int>();
+        } else if (inp_ == typeid(long)) {
+          return get_as_aux<Target, long>();
+        } else if (inp_ == typeid(unsigned long)) {
+          return get_as_aux<Target, unsigned long>();
+        } else if (inp_ == typeid(boost::int8_t)) {
+          return get_as_aux<Target, boost::int8_t>();
+        } else if (inp_ == typeid(boost::int16_t)) {
+          return get_as_aux<Target, boost::int16_t>();
+        } else if (inp_ == typeid(boost::int32_t)) {
+          return get_as_aux<Target, boost::int32_t>();
+        } else if (inp_ == typeid(boost::int64_t)) {
+          return get_as_aux<Target, boost::int64_t>();
+        } else if (inp_ == typeid(boost::uint8_t)) {
+          return get_as_aux<Target, boost::uint8_t>();
+        } else if (inp_ == typeid(boost::uint16_t)) {
+          return get_as_aux<Target, boost::uint16_t>();
+        } else if (inp_ == typeid(boost::uint32_t)) {
+          return get_as_aux<Target, boost::uint32_t>();
+        } else if (inp_ == typeid(boost::uint64_t)) {
+          return get_as_aux<Target, boost::uint64_t>();
+        } else {
+          throw boost::bad_any_cast();
+        }
+      }
+
+      std::string to_string() const
+      {
+        const Type_Info &inp_ = bv.get_type_info();
+
+        if (inp_ == typeid(int)) {
+          return to_string_aux<int>(bv);
+        } else if (inp_ == typeid(double)) {
+          return to_string_aux<double>(bv);
+        } else if (inp_ == typeid(float)) {
+          return to_string_aux<float>(bv);
+        } else if (inp_ == typeid(long double)) {
+          return to_string_aux<long double>(bv);
+        } else if (inp_ == typeid(char)) {
+          return to_string_aux<int>(Boxed_Value(get_as_aux<int, char>()));
+        } else if (inp_ == typeid(unsigned int)) {
+          return to_string_aux<unsigned int>(bv);
+        } else if (inp_ == typeid(long)) {
+          return to_string_aux<long>(bv);
+        } else if (inp_ == typeid(unsigned long)) {
+          return to_string_aux<unsigned long>(bv);
+        } else if (inp_ == typeid(boost::int8_t)) {
+          return to_string_aux<int>(Boxed_Value(get_as_aux<int, boost::int8_t>()));
+        } else if (inp_ == typeid(boost::int16_t)) {
+          return to_string_aux<boost::int16_t>(bv);
+        } else if (inp_ == typeid(boost::int32_t)) {
+          return to_string_aux<boost::int32_t>(bv);
+        } else if (inp_ == typeid(boost::int64_t)) {
+          return to_string_aux<boost::int64_t>(bv);
+        } else if (inp_ == typeid(boost::uint8_t)) {
+          return to_string_aux<unsigned int>(Boxed_Value(get_as_aux<unsigned int, boost::uint8_t>()));
+        } else if (inp_ == typeid(boost::uint16_t)) {
+          return to_string_aux<boost::uint16_t>(bv);
+        } else if (inp_ == typeid(boost::uint32_t)) {
+          return to_string_aux<boost::uint32_t>(bv);
+        } else if (inp_ == typeid(boost::uint64_t)) {
+          return to_string_aux<boost::uint64_t>(bv);
+        } else {
+          throw boost::bad_any_cast();
+        }
+      }
+
+      bool operator==(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::equals, this->bv, t_rhs.bv));
+      }
+
+      bool operator<(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::less_than, this->bv, t_rhs.bv));
+      }
+
+      bool operator>(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than, this->bv, t_rhs.bv));
+      }
+
+      bool operator>=(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than_equal, this->bv, t_rhs.bv));
+      }
+
+      bool operator<=(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::less_than_equal, this->bv, t_rhs.bv));
+      }
+
+      bool operator!=(const Boxed_Number &t_rhs) const
+      {
+        return boxed_cast<bool>(oper(Operators::not_equal, this->bv, t_rhs.bv));
+      }
+
+      Boxed_Number operator--()
+      {
+        return oper(Operators::pre_decrement, this->bv, var(0));
+      }
+
+      Boxed_Number operator++() 
+      {
+        return oper(Operators::pre_increment, this->bv, var(0));
+      }
+
+      Boxed_Number operator+(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::sum, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator+() const
+      {
+        return oper(Operators::unary_plus, this->bv, Boxed_Value(0));
+      }
+
+      Boxed_Number operator-() const
+      {
+        return oper(Operators::unary_minus, this->bv, Boxed_Value(0));
+      }
+
+      Boxed_Number operator-(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::difference, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator&=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_and, this->bv, t_rhs.bv);
+      }
+
+      static void validate_boxed_number(const Boxed_Value &v)
+      {
+        const Type_Info &inp_ = v.get_type_info();
+        if (inp_ == typeid(bool))
+        {
+          throw boost::bad_any_cast();
+        }
+
+        if (!inp_.is_arithmetic())
+        {
+          throw boost::bad_any_cast();
+        }
+      }
+
+      Boxed_Number operator=(const Boxed_Value &v)
+      {
+        validate_boxed_number(v);
+        bv = v;
+        return *this;
+      }
+
+      Boxed_Number operator=(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::assign, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator|=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_or, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator^=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_xor, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator%=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_remainder, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator<<=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_left, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator>>=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_right, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator&(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::bitwise_and, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator~() const
+      {
+        return oper(Operators::bitwise_complement, this->bv, Boxed_Value(0));
+      }
+
+      Boxed_Number operator^(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::bitwise_xor, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator|(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::bitwise_or, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator*=(const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::assign_product, this->bv, t_rhs.bv);
+      }
+      Boxed_Number operator/=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_quotient, this->bv, t_rhs.bv);
+      }
+      Boxed_Number operator+=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_sum, this->bv, t_rhs.bv);
+      }
+      Boxed_Number operator-=(const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_difference, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator/(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::quotient, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator<<(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::shift_left, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator*(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::product, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator%(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::remainder, this->bv, t_rhs.bv);
+      }
+
+      Boxed_Number operator>>(const Boxed_Number &t_rhs) const
+      {
+        return oper(Operators::shift_right, this->bv, t_rhs.bv);
+      }
+
+
+
+      static bool equals(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::equals, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool less_than(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::less_than, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool greater_than(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool greater_than_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::greater_than_equal, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool less_than_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return boxed_cast<bool>(oper(Operators::less_than_equal, t_lhs.bv, t_rhs.bv));
+      }
+
+      static bool not_equal(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return boxed_cast<bool>(oper(Operators::not_equal, t_lhs.bv, t_rhs.bv));
+      }
+
+      static Boxed_Number pre_decrement(Boxed_Number t_lhs)
+      {
+        return oper(Operators::pre_decrement, t_lhs.bv, var(0));
+      }
+
+      static Boxed_Number pre_increment(Boxed_Number t_lhs) 
+      {
+        return oper(Operators::pre_increment, t_lhs.bv, var(0));
+      }
+
+      static const Boxed_Number sum(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::sum, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number unary_plus(const Boxed_Number &t_lhs) 
+      {
+        return oper(Operators::unary_plus, t_lhs.bv, Boxed_Value(0));
+      }
+
+      static const Boxed_Number unary_minus(const Boxed_Number &t_lhs)
+      {
+        return oper(Operators::unary_minus, t_lhs.bv, Boxed_Value(0));
+      }
+
+      static const Boxed_Number difference(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::difference, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_bitwise_and(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_and, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign(Boxed_Number t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::assign, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_bitwise_or(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_or, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_bitwise_xor(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_bitwise_xor, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_remainder(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_remainder, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_shift_left(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_left, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_shift_right(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_shift_right, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number bitwise_and(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::bitwise_and, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number bitwise_complement(const Boxed_Number &t_lhs)
+      {
+        return oper(Operators::bitwise_complement, t_lhs.bv, Boxed_Value(0));
+      }
+
+      static const Boxed_Number bitwise_xor(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::bitwise_xor, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number bitwise_or(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::bitwise_or, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_product(Boxed_Number t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::assign_product, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_quotient(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_quotient, t_lhs.bv, t_rhs.bv);
+      }
+
+      static Boxed_Number assign_sum(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_sum, t_lhs.bv, t_rhs.bv);
+      }
+      static Boxed_Number assign_difference(Boxed_Number t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::assign_difference, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number quotient(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs) 
+      {
+        return oper(Operators::quotient, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number shift_left(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::shift_left, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number product(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::product, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number remainder(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::remainder, t_lhs.bv, t_rhs.bv);
+      }
+
+      static const Boxed_Number shift_right(const Boxed_Number &t_lhs, const Boxed_Number &t_rhs)
+      {
+        return oper(Operators::shift_right, t_lhs.bv, t_rhs.bv);
+      }
+
+
+
+      static Boxed_Value do_oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
+      {
+        return oper(t_oper, t_lhs, t_rhs);
+      }
+
+      static Boxed_Value do_oper(Operators::Opers t_oper, const Boxed_Value &t_lhs)
+      {
+        return oper(t_oper, t_lhs, const_var(0));
+      }
+
+
+
+      Boxed_Value bv;
+  };
+
+  namespace detail
+  {
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_Number
+     */
+    template<>
+      struct Cast_Helper<Boxed_Number>
+      {
+        typedef Boxed_Number Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          return Boxed_Number(ob);
+        }
+      };
+
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_Number
+     */
+    template<>
+      struct Cast_Helper<const Boxed_Number &> : Cast_Helper<Boxed_Number>
+      {
+      };
+      
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_Number
+     */
+    template<>
+      struct Cast_Helper<const Boxed_Number> : Cast_Helper<Boxed_Number>
+      {
+      };  
+  }
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+}
+
+
+
+#endif
+

include/chaiscript/dispatchkit/boxed_pod_value.hpp

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

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
@@ -13,6 +13,19 @@
 
 #include <map>
 #include <boost/shared_ptr.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
+#include <boost/make_shared.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #include <boost/any.hpp>
 #include <boost/function.hpp>
 #include <boost/ref.hpp>
@@ -23,6 +36,7 @@
 
 namespace chaiscript 
 {
+
   /// \brief A wrapper for holding any valid C++ type. All types in ChaiScript are Boxed_Value objects
   /// \sa chaiscript::boxed_cast
   class Boxed_Value
@@ -41,19 +55,12 @@ namespace chaiscript
        */
       struct Data
       {
-        template<typename T>
-          static bool is_null(boost::any *a)
-          {
-            boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a);
-            return ptr->get() == 0;
-          }
-
         Data(const Type_Info &ti,
             const boost::any &to,
             bool tr,
-            const boost::function<bool (boost::any*)> &t_is_null = boost::function<bool (boost::any*)>())
-          : m_type_info(ti), m_obj(to), 
-          m_is_ref(tr), m_is_null(t_is_null)
+            const void *t_void_ptr)
+          : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?0:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
+            m_is_ref(tr)
         {
         }
 
@@ -62,7 +69,8 @@ namespace chaiscript
           m_type_info = rhs.m_type_info;
           m_obj = rhs.m_obj;
           m_is_ref = rhs.m_is_ref;
-          m_is_null = rhs.m_is_null;
+          m_data_ptr = rhs.m_data_ptr;
+          m_const_data_ptr = rhs.m_const_data_ptr;
 
           return *this;
         }
@@ -73,20 +81,20 @@ namespace chaiscript
 
         Type_Info m_type_info;
         boost::any m_obj;
+        void *m_data_ptr;
+        const void *m_const_data_ptr;
         bool m_is_ref;
-        boost::function<bool (boost::any*)> m_is_null;
-        std::vector<boost::shared_ptr<Data> > m_dependencies;
       };
 
       struct Object_Data
       {
         static boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
         {
-          return boost::shared_ptr<Data> (new Data(
+          return boost::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
                 boost::any(), 
-                false)
-              );
+                false,
+                static_cast<void *>(0));
         }
 
         template<typename T>
@@ -98,12 +106,11 @@ namespace chaiscript
         template<typename T>
           static boost::shared_ptr<Data> get(const boost::shared_ptr<T> &obj)
           {
-            return boost::shared_ptr<Data>(new Data(
+            return boost::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
                   boost::any(obj), 
                   false,
-                  boost::function<bool (boost::any *)>(&Data::is_null<T>))
-                );
+                  obj.get());
           }
 
         template<typename T>
@@ -115,31 +122,31 @@ namespace chaiscript
         template<typename T>
           static boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
           {
-            return boost::shared_ptr<Data>(new Data(
+            return boost::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
-                  boost::any(obj), 
-                  true)
-                );
+                  boost::any(obj),
+                  true,
+                  obj.get_pointer());
           }
 
         template<typename T>
           static boost::shared_ptr<Data> get(const T& t)
           {
-            return boost::shared_ptr<Data>(new Data(
+            boost::shared_ptr<T> p(new T(t));
+            return boost::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(boost::shared_ptr<T>(new T(t))), 
+                  boost::any(p), 
                   false,
-                  boost::function<bool (boost::any *)>(&Data::is_null<T>))
-                );
+                  p.get());
           }
 
         static boost::shared_ptr<Data> get()
         {
-          return boost::shared_ptr<Data> (new Data(
+          return boost::make_shared<Data>(
                 Type_Info(),
                 boost::any(),
-                false)
-              );
+                false,
+                static_cast<void *>(0));
         }
 
       };
@@ -224,12 +231,7 @@ namespace chaiscript
 
       bool is_null() const
       {
-        if (m_data->m_is_null)
-        {
-          return m_data->m_is_null(&m_data->m_obj);
-        } else {
-          return false;
-        }
+        return (m_data->m_data_ptr == 0 && m_data->m_const_data_ptr == 0);
       }
 
       const boost::any & get() const
@@ -247,24 +249,15 @@ namespace chaiscript
         return !is_ref();
       }
 
-      void clear_dependencies()
+      void *get_ptr() const
       {
-        m_data->m_dependencies.clear();
+        return m_data->m_data_ptr;
       }
 
-      template<typename InItr>
-        void add_dependencies(InItr begin, const InItr &end)
-        {
-          while (begin != end)
-          {
-            if (begin->m_data != m_data)
-            {
-              m_data->m_dependencies.push_back(begin->m_data);
-            }
-            ++begin;
-          }
-        }
-
+      const void *get_const_ptr() const
+      {
+        return m_data->m_const_data_ptr;
+      }
 
     private:
       boost::shared_ptr<Data> m_data;

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DISPATCHKIT_HPP_
@@ -12,12 +12,11 @@
 #include <map>
 #include <set>
 #include <boost/shared_ptr.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/tuple/tuple.hpp>
 #include <stdexcept>
 #include <vector>
 #include <iostream>
 #include <deque>
+#include <list>
 
 #include "boxed_value.hpp"
 #include "type_info.hpp"
@@ -32,6 +31,93 @@
 
 namespace chaiscript
 {
+  namespace exception
+  {
+    /**
+     * Exception thrown in the case that an object name is invalid because it is a reserved word
+     */
+    class reserved_word_error : public std::runtime_error
+    {
+      public:
+        reserved_word_error(const std::string &t_word) throw()
+          : std::runtime_error("Reserved word not allowed in object name: " + t_word), m_word(t_word)
+        {
+        }
+
+        virtual ~reserved_word_error() throw() {}
+
+        std::string word() const
+        {
+          return m_word;
+        }
+
+      private:
+        std::string m_word;
+    };
+
+    /**
+     * Exception thrown in the case that an object name is invalid because it contains illegal characters
+     */
+    class illegal_name_error : public std::runtime_error
+    {
+      public:
+        illegal_name_error(const std::string &t_name) throw()
+          : std::runtime_error("Reserved name not allowed in object name: " + t_name), m_name(t_name)
+        {
+        }
+
+        virtual ~illegal_name_error() throw() {}
+
+        std::string name() const
+        {
+          return m_name;
+        }
+
+      private:
+        std::string m_name;
+    };
+
+
+    /**
+     * Exception thrown in the case that an object name is invalid because it already exists in current context
+     */
+    class name_conflict_error : public std::runtime_error
+    {
+      public:
+        name_conflict_error(const std::string &t_name) throw()
+          : std::runtime_error("Name already exists in current context " + t_name), m_name(t_name)
+        {
+        }
+
+        virtual ~name_conflict_error() throw() {}
+
+        std::string name() const
+        {
+          return m_name;
+        }
+
+      private:
+        std::string m_name;
+
+    };
+
+
+    /**
+     * Exception thrown in the case that a non-const object was added as a shared object
+     */
+    class global_non_const : public std::runtime_error
+    {
+      public:
+        global_non_const() throw()
+          : std::runtime_error("a global object must be const")
+        {
+        }
+
+        virtual ~global_non_const() throw() {}
+    };
+  }
+
+
   /// \brief Holds a collection of ChaiScript settings which can be applied to the ChaiScript runtime.
   ///        Used to implement loadable module support.
   class Module
@@ -55,6 +141,17 @@ namespace chaiscript
         return *this;
       }
 
+      Module &add_global_const(const Boxed_Value &t_bv, const std::string &t_name)
+      {
+        if (!t_bv.is_const())
+        {
+          throw exception::global_non_const();
+        }
+
+        m_globals.push_back(std::make_pair(t_bv, t_name));
+        return *this;
+      }
+
 
       //Add a bit of chaiscript to eval during module implementation
       Module &eval(const std::string &str)
@@ -76,11 +173,13 @@ namespace chaiscript
           apply(m_funcs.begin(), m_funcs.end(), t_engine);
           apply_eval(m_evals.begin(), m_evals.end(), t_eval);
           apply_single(m_conversions.begin(), m_conversions.end(), t_engine);
+          apply_globals(m_globals.begin(), m_globals.end(), t_engine);
         }
 
     private:
       std::vector<std::pair<Type_Info, std::string> > m_typeinfos;
       std::vector<std::pair<Proxy_Function, std::string> > m_funcs;
+      std::vector<std::pair<Boxed_Value, std::string> > m_globals;
       std::vector<std::string> m_evals;
       std::vector<Dynamic_Cast_Conversion> m_conversions;
 
@@ -89,7 +188,22 @@ namespace chaiscript
         {
           while (begin != end)
           {
-            t.add(begin->first, begin->second);
+            try {
+              t.add(begin->first, begin->second);
+            } catch (const exception::name_conflict_error &) {
+              /// \todo Should we throw an error if there's a name conflict 
+              ///       while applying a module?
+            }
+            ++begin;
+          }
+        }
+
+      template<typename T, typename InItr>
+        void apply_globals(InItr begin, InItr end, T &t) const
+        {
+          while (begin != end)
+          {
+            t.add_global_const(begin->first, begin->second);
             ++begin;
           }
         }
@@ -130,9 +244,9 @@ namespace chaiscript
       public:
         Dispatch_Function(const std::vector<Proxy_Function> &t_funcs)
           : Proxy_Function_Base(build_type_infos(t_funcs)),
-          m_funcs(t_funcs)
-      {
-      }
+            m_funcs(t_funcs)
+        {
+        }
 
         virtual bool operator==(const dispatch::Proxy_Function_Base &rhs) const
         {
@@ -182,7 +296,7 @@ namespace chaiscript
           return -1; // unknown arity
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           typedef std::vector<Proxy_Function> function_vec;
 
@@ -191,7 +305,7 @@ namespace chaiscript
 
           while (begin != end)
           {
-            if ((*begin)->call_match(vals))
+            if ((*begin)->call_match(vals, t_conversions))
             {
               return true;
             } else {
@@ -208,9 +322,9 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return dispatch::dispatch(m_funcs.begin(), m_funcs.end(), params);
+          return dispatch::dispatch(m_funcs.begin(), m_funcs.end(), params, t_conversions);
         }
 
       private:
@@ -266,48 +380,6 @@ namespace chaiscript
     };  
   }
 
-  namespace exception
-  {
-    /**
-     * Exception thrown in the case that a multi method dispatch fails
-     * because no matching function was found
-     * at runtime due to either an arity_error, a guard_error or a bad_boxed_cast
-     * exception
-     */
-    class reserved_word_error : public std::runtime_error
-    {
-      public:
-        reserved_word_error(const std::string &t_word) throw()
-          : std::runtime_error("Reserved word not allowed in object name: " + t_word), m_word(t_word)
-        {
-        }
-
-        virtual ~reserved_word_error() throw() {}
-
-        std::string word() const
-        {
-          return m_word;
-        }
-
-      private:
-        std::string m_word;
-
-    };
-
-    /**
-     * Exception thrown in the case that a non-const object was added as a shared object
-     */
-    class global_non_const : public std::runtime_error
-    {
-      public:
-        global_non_const() throw()
-          : std::runtime_error("a global object must be const")
-        {
-        }
-
-        virtual ~global_non_const() throw() {}
-    };
-  }
 
   namespace detail
   {
@@ -326,6 +398,7 @@ namespace chaiscript
         struct State
         {
           std::map<std::string, std::vector<Proxy_Function> > m_functions;
+          std::map<std::string, Proxy_Function> m_function_objects;
           std::map<std::string, Boxed_Value> m_global_objects;
           Type_Name_Map m_types;
           std::set<std::string> m_reserved_words;
@@ -338,25 +411,30 @@ namespace chaiscript
 
         ~Dispatch_Engine()
         {
-          detail::Dynamic_Conversions::get().cleanup(m_conversions.begin(), m_conversions.end());
         }
 
+        /// \brief casts an object while applying any Dynamic_Conversion available
+        template<typename Type>
+          typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv) const
+          {
+            return chaiscript::boxed_cast<Type>(bv, &m_conversions);
+          }
+
         /**
          * Add a new conversion for upcasting to a base class
          */
         void add(const Dynamic_Cast_Conversion &d)
         {
-          m_conversions.push_back(d);
-          return detail::Dynamic_Conversions::get().add_conversion(d);
+          m_conversions.add_conversion(d);
         }
 
         /**
          * Add a new named Proxy_Function to the system
          */
-        bool add(const Proxy_Function &f, const std::string &name)
+        void add(const Proxy_Function &f, const std::string &name)
         {
           validate_object_name(name);
-          return add_function(f, name);
+          add_function(f, name);
         }
 
         /**
@@ -380,6 +458,7 @@ namespace chaiscript
 
           add_object(name, obj);
         }
+        
 
         /**
          * Adds a named object to the current scope
@@ -388,7 +467,15 @@ namespace chaiscript
         {
           StackData &stack = get_stack_data();
           validate_object_name(name);
-          stack.back()[name] = obj;
+          
+          Scope &scope = stack.back();
+          Scope::iterator itr = scope.find(name);
+          if (itr != stack.back().end())
+          {
+            throw exception::name_conflict_error(name);
+          } else {
+            stack.back().insert(std::make_pair(name, obj));
+          }
         }
 
         /**
@@ -404,9 +491,33 @@ namespace chaiscript
 
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
 
-          m_state.m_global_objects[name] = obj;
+          if (m_state.m_global_objects.find(name) != m_state.m_global_objects.end())
+          {
+            throw exception::name_conflict_error(name);
+          } else {
+            m_state.m_global_objects.insert(std::make_pair(name, obj));
+          }
         }
 
+
+        /**
+         * Adds a new global (non-const) shared object, between all the threads
+         */
+        void add_global(const Boxed_Value &obj, const std::string &name)
+        {
+          validate_object_name(name);
+
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
+
+          if (m_state.m_global_objects.find(name) != m_state.m_global_objects.end())
+          {
+            throw exception::name_conflict_error(name);
+          } else {
+            m_state.m_global_objects.insert(std::make_pair(name, obj));
+          }
+        }
+
+
         /**
          * Adds a new scope to the stack
          */
@@ -430,28 +541,24 @@ namespace chaiscript
           }
         }
 
-        /**
-         * Swaps out the stack with a new stack
-         * \returns the old stack
-         * \param[in] s The new stack
-         */
-        Stack set_stack(const Stack &s)
-        {
-          Stack old = m_stack_holder->stack;
-          m_stack_holder->stack = s;
-          return old;
-        }
 
-        Stack new_stack() const
+        /// Pushes a new stack on to the list of stacks
+        void new_stack()
         {
           Stack s(new Stack::element_type());
           s->push_back(Scope());
-          return s;
+          m_stack_holder->stacks.push_back(s);
         }
 
+        void pop_stack()
+        {
+          m_stack_holder->stacks.pop_back();
+        }
+
+        /// \returns the current stack
         Stack get_stack() const
         {
-          return m_stack_holder->stack;
+          return m_stack_holder->stacks.back();
         }
 
         /**
@@ -491,21 +598,7 @@ namespace chaiscript
           }
 
           // If all that failed, then check to see if it's a function
-          std::vector<Proxy_Function> funcs = get_function(name);
-
-          if (funcs.empty())
-          {
-            throw std::range_error("Object not known: " + name);
-          } else {
-            if (funcs.size() == 1)
-            {
-              // Return the first item if there is only one,
-              // no reason to take the cast of the extra level of dispatch
-              return const_var(*funcs.begin());
-            } else {
-              return Boxed_Value(Const_Proxy_Function(new Dispatch_Function(funcs)));
-            }
-          }
+          return get_function_object(name);
         }
 
         /**
@@ -588,9 +681,26 @@ namespace chaiscript
             } else {
               return std::vector<Proxy_Function>();
             }
-
           }
 
+        /// \returns a function object (Boxed_Value wrapper) if it exists
+        /// \throws std::range_error if it does not
+        Boxed_Value get_function_object(const std::string &t_name) const
+        {
+          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+          const std::map<std::string, Proxy_Function> &funs = get_function_objects_int();
+
+          std::map<std::string, Proxy_Function>::const_iterator itr = funs.find(t_name);
+
+          if (itr != funs.end())
+          {
+            return const_var(itr->second);
+          } else {
+            throw std::range_error("Object not found: " + t_name);
+          }
+        }
+
         /**
          * Return true if a function exists
          */
@@ -602,6 +712,78 @@ namespace chaiscript
           return functions.find(name) != functions.end();
         }
 
+        /// \returns All values in the local thread state, added through the add() function
+        std::map<std::string, Boxed_Value> get_locals() const
+        {
+          StackData &stack = get_stack_data();
+          Scope &scope = stack.front();
+          return scope;
+        }
+
+        /// \brief Sets all of the locals for the current thread state.
+        ///
+        /// \param[in] t_locals The map<name, value> set of variables to replace the current state with
+        ///
+        /// Any existing locals are removed and the given set of variables is added
+        void set_locals(const std::map<std::string, Boxed_Value> &t_locals)
+        {
+          StackData &stack = get_stack_data();
+          Scope &scope = stack.front();
+          scope = t_locals;
+        }
+
+
+
+        ///
+        /// Get a map of all objects that can be seen from the current scope in a scripting context
+        ///
+        std::map<std::string, Boxed_Value> get_scripting_objects() const
+        {
+          // We don't want the current context, but one up if it exists
+          StackData &stack = (m_stack_holder->stacks.size()==1)?(*(m_stack_holder->stacks.back())):(*m_stack_holder->stacks[m_stack_holder->stacks.size()-2]);
+
+          std::map<std::string, Boxed_Value> retval;
+
+          // note: map insert doesn't overwrite existing values, which is why this works
+         
+          for (StackData::reverse_iterator itr = stack.rbegin(); itr != stack.rend(); ++itr)
+          {
+            retval.insert(itr->begin(), itr->end());
+          } 
+
+          // add the global values
+          {
+            chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
+
+            retval.insert(m_state.m_global_objects.begin(), m_state.m_global_objects.end());
+          }
+
+          return retval;
+        }
+
+
+        ///
+        /// Get a map of all functions that can be seen from a scripting context
+        ///
+        std::map<std::string, Boxed_Value> get_function_objects() const
+        {
+          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+          const std::map<std::string, Proxy_Function> &funs = get_function_objects_int();
+
+          std::map<std::string, Boxed_Value> objs;
+
+          for (std::map<std::string, Proxy_Function>::const_iterator itr = funs.begin();
+               itr != funs.end();
+               ++itr)
+          {
+            objs.insert(std::make_pair(itr->first, const_var(itr->second)));
+          }
+
+          return objs;
+        }
+
+
         /**
          * Get a vector of all registered functions
          */
@@ -635,11 +817,16 @@ namespace chaiscript
           m_state.m_reserved_words.insert(name);
         }
 
+        const Dynamic_Cast_Conversions &conversions() const
+        {
+          return m_conversions;
+        }
+
         Boxed_Value call_function(const std::string &t_name, const std::vector<Boxed_Value> &params) const
         {
           std::vector<Proxy_Function> functions = get_function(t_name);
 
-          return dispatch::dispatch(functions.begin(), functions.end(), params);
+          return dispatch::dispatch(functions.begin(), functions.end(), params, m_conversions);
         }
 
         Boxed_Value call_function(const std::string &t_name) const
@@ -665,10 +852,9 @@ namespace chaiscript
         /**
          * Dump object info to stdout
          */
-        void dump_object(Boxed_Value o) const
+        void dump_object(const Boxed_Value &o) const
         {
-          Type_Info ti = o.get_type_info();
-          std::cout << (ti.is_const()?"const ":"") << get_type_name(ti) << std::endl;
+          std::cout << (o.is_const()?"const ":"") << type_name(o) << std::endl;
         }
 
         /**
@@ -709,6 +895,22 @@ namespace chaiscript
           std::cout << ") " << std::endl;
         }
 
+        /**
+         * Returns true if a call can be made that consists of the first parameter
+         * (the function) with the remaining parameters as its arguments.
+         */
+        Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
+        {
+          if (params.size() < 1)
+          {
+            throw exception::arity_error(static_cast<int>(params.size()), 1);
+          }
+
+          Const_Proxy_Function f = this->boxed_cast<Const_Proxy_Function>(params[0]);
+
+          return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end()), m_conversions));
+        }
+
         /**
          * Dump all system info to stdout
          */
@@ -760,7 +962,7 @@ namespace chaiscript
           return false;
         }
 
-        std::string type_name(Boxed_Value obj) const
+        std::string type_name(const Boxed_Value &obj) const
         {
           return get_type_name(obj.get_type_info());
         }
@@ -781,6 +983,29 @@ namespace chaiscript
           m_state = t_state;
         }
 
+        void save_function_params(const std::vector<Boxed_Value> &t_params)
+        {
+          m_stack_holder->call_params.insert(m_stack_holder->call_params.begin(), t_params.begin(), t_params.end());
+        }
+
+        void new_function_call()
+        {
+          ++m_stack_holder->call_depth;
+        }
+
+        void pop_function_call()
+        {
+          --m_stack_holder->call_depth;
+
+          assert(m_stack_holder->call_depth >= 0);
+
+          if (m_stack_holder->call_depth == 0)
+          {
+            /// \todo Critical: this needs to be smarter, memory can expand quickly
+            ///       in tight loops involving function calls
+            m_stack_holder->call_params.clear();
+          }
+        }
 
       private:
         /**
@@ -789,7 +1014,17 @@ namespace chaiscript
          */
         StackData &get_stack_data() const
         {
-          return *(m_stack_holder->stack);
+          return *(m_stack_holder->stacks.back());
+        }
+
+        const std::map<std::string, Proxy_Function> &get_function_objects_int() const
+        {
+          return m_state.m_function_objects;
+        }
+
+        std::map<std::string, Proxy_Function> &get_function_objects_int() 
+        {
+          return m_state.m_function_objects;
         }
 
         const std::map<std::string, std::vector<Proxy_Function> > &get_functions_int() const
@@ -811,7 +1046,7 @@ namespace chaiscript
           const size_t rhssize = rhsparamtypes.size();
 
           const Type_Info boxed_type = user_type<Boxed_Value>();
-          const Type_Info boxed_pod_type = user_type<Boxed_POD_Value>();
+          const Type_Info boxed_pod_type = user_type<Boxed_Number>();
 
           boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_lhs(boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(lhs));
           boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_rhs(boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(rhs));
@@ -902,6 +1137,10 @@ namespace chaiscript
          */
         void validate_object_name(const std::string &name) const
         {
+          if (name.find("::") != std::string::npos) {
+            throw exception::illegal_name_error(name);
+          }
+
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
           if (m_state.m_reserved_words.find(name) != m_state.m_reserved_words.end())
@@ -911,11 +1150,10 @@ namespace chaiscript
         }
 
         /**
-         * Implementation detail for adding a function. Returns
-         * true if the function was added, false if a function with the
-         * same signature and name already exists.
+         * Implementation detail for adding a function. 
+         * \throws exception::name_conflict_error if there's a function matching the given one being added
          */
-        bool add_function(const Proxy_Function &t_f, const std::string &t_name)
+        void add_function(const Proxy_Function &t_f, const std::string &t_name)
         {
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
@@ -924,6 +1162,8 @@ namespace chaiscript
           std::map<std::string, std::vector<Proxy_Function> >::iterator itr
             = funcs.find(t_name);
 
+          std::map<std::string, Proxy_Function> &func_objs = get_function_objects_int();
+
           if (itr != funcs.end())
           {
             std::vector<Proxy_Function> &vec = itr->second;
@@ -933,19 +1173,29 @@ namespace chaiscript
             {
               if ((*t_f) == *(*itr2))
               {
-                return false;
+                throw exception::name_conflict_error(t_name);
               }
             }
 
             vec.push_back(t_f);
             std::stable_sort(vec.begin(), vec.end(), &function_less_than);
+            func_objs[t_name] = Proxy_Function(new Dispatch_Function(vec));
+          } else if (t_f->has_arithmetic_param()) {
+            // if the function is the only function but it also contains
+            // arithmetic operators, we must wrap it in a dispatch function
+            // to allow for automatic arithmetic type conversions
+            std::vector<Proxy_Function> vec;
+            vec.push_back(t_f);
+            funcs.insert(std::make_pair(t_name, vec));
+            func_objs[t_name] = Proxy_Function(new Dispatch_Function(vec));
           } else {
             std::vector<Proxy_Function> vec;
             vec.push_back(t_f);
             funcs.insert(std::make_pair(t_name, vec));
+            func_objs[t_name] = t_f;
           }
 
-          return true;
+
         }
 
         mutable chaiscript::detail::threading::shared_mutex m_mutex;
@@ -954,15 +1204,20 @@ namespace chaiscript
         struct Stack_Holder
         {
           Stack_Holder()
-            : stack(new StackData())
+            : call_depth(0)
           {
-            stack->push_back(Scope());
+            Stack s(new StackData());
+            s->push_back(Scope());
+            stacks.push_back(s);
           }
 
-          Stack stack;
+          std::deque<Stack> stacks;
+
+          std::list<Boxed_Value> call_params;
+          int call_depth;
         };  
 
-        std::vector<Dynamic_Cast_Conversion> m_conversions;
+        Dynamic_Cast_Conversions m_conversions;
         chaiscript::detail::threading::Thread_Storage<Stack_Holder> m_stack_holder;
 
 

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
@@ -47,12 +47,14 @@ namespace chaiscript
     class Dynamic_Conversion
     {
       public:
-        virtual Boxed_Value convert(const Boxed_Value &derived) = 0;
-        const Type_Info &base()
+        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
         {
           return m_base;
         }
-        const Type_Info &derived()
+        const Type_Info &derived() const
         {
           return m_derived;
         }
@@ -63,14 +65,67 @@ namespace chaiscript
         {
         }
 
+        virtual ~Dynamic_Conversion() {} 
+
       private:
         Type_Info m_base;
         Type_Info m_derived;
 
     };
 
+    template<typename From, typename To> 
+      class Dynamic_Caster
+      {
+        public: 
+          static Boxed_Value cast(const Boxed_Value &t_from)
+          {
+            if (t_from.get_type_info().bare_equal(user_type<From>()))
+            {
+              if (t_from.is_pointer())
+              {
+                // Dynamic cast out the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  boost::shared_ptr<const To> data 
+                    = boost::dynamic_pointer_cast<const To>(detail::Cast_Helper<boost::shared_ptr<const From> >::cast(t_from, 0));
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                } else {
+                  boost::shared_ptr<To> data 
+                    = boost::dynamic_pointer_cast<To>(detail::Cast_Helper<boost::shared_ptr<From> >::cast(t_from, 0));
+
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                }
+              } else {
+                // Pull the reference out of the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  const From &d = detail::Cast_Helper<const From &>::cast(t_from, 0);
+                  const To &data = dynamic_cast<const To &>(d);
+                  return Boxed_Value(boost::cref(data));
+                } else {
+                  From &d = detail::Cast_Helper<From &>::cast(t_from, 0);
+                  To &data = dynamic_cast<To &>(d);
+                  return Boxed_Value(boost::ref(data));
+                }
+              }
+            } else {
+              throw exception::bad_boxed_dynamic_cast(t_from.get_type_info(), typeid(To), "Unknown dynamic_cast_conversion");
+            }
+          }
+      };
+
     template<typename Base, typename Derived>
-    class Dynamic_Conversion_Impl : public Dynamic_Conversion
+      class Dynamic_Conversion_Impl : public Dynamic_Conversion
     {
       public:
         Dynamic_Conversion_Impl()
@@ -78,147 +133,121 @@ namespace chaiscript
         {
         }
 
-        virtual Boxed_Value convert(const Boxed_Value &t_derived)
+        virtual Boxed_Value convert_down(const Boxed_Value &t_base) const
         {
-          if (t_derived.get_type_info().bare_equal(user_type<Derived>()))
-          {
-            if (t_derived.is_pointer())
-            {
-              // Dynamic cast out the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                boost::shared_ptr<const Base> data 
-                  = boost::dynamic_pointer_cast<const Base>(detail::Cast_Helper<boost::shared_ptr<const Derived> >::cast(t_derived));
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
-
-                return Boxed_Value(data);
-              } else {
-                boost::shared_ptr<Base> data 
-                  = boost::dynamic_pointer_cast<Base>(detail::Cast_Helper<boost::shared_ptr<Derived> >::cast(t_derived));
-
-                if (!data)
-                {
-                  throw std::bad_cast();
-                }
-
-                return Boxed_Value(data);
-              }
-            } else {
-              // Pull the reference out of the contained boxed value, which we know is the type we want
-              if (t_derived.is_const())
-              {
-                const Derived &d = detail::Cast_Helper<const Derived &>::cast(t_derived);
-                const Base &data = dynamic_cast<const Base &>(d);
-                return Boxed_Value(boost::cref(data));
-              } else {
-                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived);
-                Base &data = dynamic_cast<Base &>(d);
-                return Boxed_Value(boost::ref(data));
-              }
-            }
-          } else {
-            throw exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
-          }
-        }
-    };
-
-
-    class Dynamic_Conversions
-    {
-      public:
-        static inline Dynamic_Conversions &get()
-        {
-          static Dynamic_Conversions obj;
-          return obj;
+          return Dynamic_Caster<Base, Derived>::cast(t_base);
         }
 
-        template<typename Base, typename Derived>
-        static boost::shared_ptr<Dynamic_Conversion> create()
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const
         {
-          boost::shared_ptr<Dynamic_Conversion> conversion(new Dynamic_Conversion_Impl<Base, Derived>());
-
-          /// \todo this is a hack and a kludge. The idea is to make sure that
-          ///       the conversion is registered both in the module's notion of the static conversion object
-          ///       and in the global notion of the static conversion object
-          ///       someday this will almost certainly have to change. Maybe it is time for ChaiScript
-          ///       to become a library?
-          Dynamic_Conversions::get().add_conversion(conversion);
-          return conversion;
+          return Dynamic_Caster<Derived, Base>::cast(t_derived);
         }
-
-        template<typename InItr>
-        void cleanup(InItr begin, const InItr &end)
-        {
-          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          while (begin != end)
-          {
-            if (begin->unique())
-            {
-              m_conversions.erase(begin->get());
-            }
-
-            ++begin;
-          }
-        }
-
-        void add_conversion(const boost::shared_ptr<Dynamic_Conversion> &conversion)
-        {
-          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          m_conversions.insert(conversion.get());
-        }
-
-        bool has_conversion(const Type_Info &base, const Type_Info &derived) const
-        {
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          return find(base, derived) != m_conversions.end();
-        }
-
-
-        Dynamic_Conversion *get_conversion(const Type_Info &base, const Type_Info &derived) const
-        {
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          std::set<Dynamic_Conversion *>::const_iterator itr =
-            find(base, derived);
-
-          if (itr != m_conversions.end())
-          {
-            return *itr;
-          } else {
-            throw std::out_of_range("No such conversion exists from " + derived.bare_name() + " to " + base.bare_name());
-          }
-        }
-
-      private:
-        Dynamic_Conversions() {}
-
-        std::set<Dynamic_Conversion *>::const_iterator find(
-            const Type_Info &base, const Type_Info &derived) const
-        {
-          for (std::set<Dynamic_Conversion *>::const_iterator itr = m_conversions.begin();
-               itr != m_conversions.end();
-               ++itr)
-          {
-            if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
-            {
-              return itr;
-            }
-          }
-
-          return m_conversions.end();
-        }
-
-        mutable chaiscript::detail::threading::shared_mutex m_mutex;
-        std::set<Dynamic_Conversion *> m_conversions;
     };
   }
 
+  class Dynamic_Cast_Conversions
+  {
+    public:
+      Dynamic_Cast_Conversions()
+      {
+      }
+
+      Dynamic_Cast_Conversions(const Dynamic_Cast_Conversions &t_other)
+        : m_conversions(t_other.get_conversions())
+      {
+      }
+
+      void add_conversion(const boost::shared_ptr<detail::Dynamic_Conversion> &conversion)
+      {
+        chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+        m_conversions.insert(conversion);
+      }
+
+      template<typename Base, typename Derived>
+        bool dynamic_cast_converts() const
+        {
+          return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
+        }
+
+      bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived) const
+      {
+        return has_conversion(base, derived) || has_conversion(derived, base);
+      }
+
+      template<typename Base>
+        Boxed_Value boxed_dynamic_cast(const Boxed_Value &derived) const
+        {
+          try {
+            return get_conversion(user_type<Base>(), derived.get_type_info())->convert(derived);
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
+          }
+        }
+
+      template<typename Derived>
+        Boxed_Value boxed_dynamic_down_cast(const Boxed_Value &base) const
+        {
+          try {
+            return get_conversion(base.get_type_info(), user_type<Derived>())->convert_down(base);
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "Unable to perform dynamic_cast operation");
+          }
+        }
+
+
+      bool has_conversion(const Type_Info &base, const Type_Info &derived) const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+        return find(base, derived) != m_conversions.end();
+      }
+
+      boost::shared_ptr<detail::Dynamic_Conversion> get_conversion(const Type_Info &base, const Type_Info &derived) const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr =
+          find(base, derived);
+
+        if (itr != m_conversions.end())
+        {
+          return *itr;
+        } else {
+          throw std::out_of_range("No such conversion exists from " + derived.bare_name() + " to " + base.bare_name());
+        }
+      }
+
+    private:
+      std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
+          const Type_Info &base, const Type_Info &derived) const
+      {
+        for (std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr = m_conversions.begin();
+            itr != m_conversions.end();
+            ++itr)
+        {
+          if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
+          {
+            return itr;
+          }
+        }
+
+        return m_conversions.end();
+      }
+
+      std::set<boost::shared_ptr<detail::Dynamic_Conversion> > get_conversions() const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        return m_conversions;
+      }
+
+      mutable chaiscript::detail::threading::shared_mutex m_mutex;
+      std::set<boost::shared_ptr<detail::Dynamic_Conversion> > m_conversions;
+  };
+
   typedef boost::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
 
   /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
@@ -242,45 +271,18 @@ namespace chaiscript
   /// chai.add(chaiscript::base_class<Base, Derived>());
   /// \endcode
   /// 
-  /// \todo Move share static type registration code into a mechanism that allows it to be properly
-  ///       shared by all modules
   template<typename Base, typename Derived>
-  Dynamic_Cast_Conversion base_class()
-  {
-    //Can only be used with related polymorphic types
-    //may be expanded some day to support conversions other than child -> parent
-    BOOST_STATIC_ASSERT((boost::is_base_of<Base,Derived>::value));
-    BOOST_STATIC_ASSERT(boost::is_polymorphic<Base>::value);
-    BOOST_STATIC_ASSERT(boost::is_polymorphic<Derived>::value);
-
-    return detail::Dynamic_Conversions::create<Base, Derived>();
-  }
-
-  namespace detail
-  {
-    template<typename Base, typename Derived>
-      bool dynamic_cast_converts()
-      {
-        return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
-      }
-
-    static bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived)
+    Dynamic_Cast_Conversion base_class()
     {
-      return detail::Dynamic_Conversions::get().has_conversion(base, derived);
+      //Can only be used with related polymorphic types
+      //may be expanded some day to support conversions other than child -> parent
+      BOOST_STATIC_ASSERT((boost::is_base_of<Base,Derived>::value));
+      BOOST_STATIC_ASSERT(boost::is_polymorphic<Base>::value);
+      BOOST_STATIC_ASSERT(boost::is_polymorphic<Derived>::value);
+
+      return boost::shared_ptr<detail::Dynamic_Conversion>(new detail::Dynamic_Conversion_Impl<Base, Derived>());
     }
 
-    template<typename Base>
-      Boxed_Value boxed_dynamic_cast(const Boxed_Value &derived)
-      {
-        try {
-          return detail::Dynamic_Conversions::get().get_conversion(user_type<Base>(), derived.get_type_info())->convert(derived);
-        } catch (const std::out_of_range &) {
-          throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "No known conversion");
-        } catch (const std::bad_cast &) {
-          throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
-        }
-      }
-  }
 }
 
 

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
@@ -31,7 +31,7 @@ namespace chaiscript
           return m_attrs[t_attr_name];
         }
 
-        std::map<std::string, Boxed_Value> get_attrs()
+        std::map<std::string, Boxed_Value> get_attrs() const
         {
           return m_attrs;
         }
@@ -44,20 +44,6 @@ namespace chaiscript
 
     namespace detail
     {
-      struct Dynamic_Object_Attribute
-      {
-        static Boxed_Value func(const std::string &t_type_name, const std::string &t_attr_name,
-            Dynamic_Object &t_do)
-        {
-          if (t_do.get_type_name() != t_type_name) 
-          {
-            throw exception::bad_boxed_cast("Dynamic object type mismatch");
-          }
-
-          return t_do.get_attr(t_attr_name);
-        }
-      };
-
       /**
        * A Proxy_Function implementation designed for calling a function
        * that is automatically guarded based on the first param based on the
@@ -71,11 +57,11 @@ namespace chaiscript
               const Proxy_Function &t_func,
               const boost::optional<Type_Info> &t_ti = boost::optional<Type_Info>())
             : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti)),
-            m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
-        {
-          assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-              && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-        }
+              m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
+          {
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
 
           virtual ~Dynamic_Object_Function() {}
 
@@ -90,11 +76,11 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
           {
-            if (dynamic_object_typename_match(vals, m_type_name, m_ti))
+            if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
             {
-              return m_func->call_match(vals);
+              return m_func->call_match(vals, t_conversions);
             } else {
               return false;
             }
@@ -120,19 +106,19 @@ namespace chaiscript
 
 
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
           {
-            if (dynamic_object_typename_match(params, m_type_name, m_ti))
+            if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
             {
-              return (*m_func)(params);
+              return (*m_func)(params, t_conversions);
             } else {
               throw exception::guard_error();
             } 
           }
 
-          virtual bool compare_first_type(const Boxed_Value &bv) const
+          virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
           {
-            return dynamic_object_typename_match(bv, m_type_name, m_ti);
+            return dynamic_object_typename_match(bv, m_type_name, m_ti, t_conversions);
           }
 
         private:
@@ -153,13 +139,13 @@ namespace chaiscript
           }
 
           static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const boost::optional<Type_Info> &ti)
+              const boost::optional<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions)
           {
             static Type_Info doti = user_type<Dynamic_Object>();
             if (bv.get_type_info().bare_equal(doti))
             {
               try {
-                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv);
+                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
                 return name == "Dynamic_Object" || d.get_type_name() == name;
               } catch (const std::bad_cast &) {
                 return false;
@@ -176,11 +162,11 @@ namespace chaiscript
           }
 
           static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const boost::optional<Type_Info> &ti) 
+              const boost::optional<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) 
           {
             if (bvs.size() > 0)
             {
-              return dynamic_object_typename_match(bvs[0], name, ti);
+              return dynamic_object_typename_match(bvs[0], name, ti, t_conversions);
             } else {
               return false;
             }
@@ -206,11 +192,11 @@ namespace chaiscript
               const std::string &t_type_name,
               const Proxy_Function &t_func)
             : Proxy_Function_Base(build_type_list(t_func->get_param_types())),
-            m_type_name(t_type_name), m_func(t_func)
-        {
-          assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-              && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-        }
+              m_type_name(t_type_name), m_func(t_func)
+          {
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
 
           static std::vector<Type_Info> build_type_list(const std::vector<Type_Info> &tl)
           {
@@ -238,13 +224,13 @@ namespace chaiscript
             }
           }
 
-          virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
           {
             std::vector<Boxed_Value> new_vals;
             new_vals.push_back(Boxed_Value(Dynamic_Object(m_type_name)));
             new_vals.insert(new_vals.end(), vals.begin(), vals.end());
 
-            return m_func->call_match(new_vals);
+            return m_func->call_match(new_vals, t_conversions);
           }    
 
 
@@ -260,14 +246,14 @@ namespace chaiscript
           }
 
         protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
           {
             std::vector<Boxed_Value> new_params;
             chaiscript::Boxed_Value bv = var(Dynamic_Object(m_type_name));
             new_params.push_back(bv);
             new_params.insert(new_params.end(), params.begin(), params.end());
 
-            (*m_func)(new_params);
+            (*m_func)(new_params, t_conversions);
 
             return bv;
           }

include/chaiscript/dispatchkit/exception_specification.hpp

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

include/chaiscript/dispatchkit/function_call.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
@@ -32,10 +32,10 @@ namespace chaiscript
      */
     template<typename FunctionType>
       boost::function<FunctionType>
-      functor(const std::vector<Const_Proxy_Function> &funcs)
+      functor(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
       {
         FunctionType *p=0;
-        return detail::build_function_caller_helper(p, funcs);
+        return detail::build_function_caller_helper(p, funcs, t_conversions);
       }
 
     /**
@@ -53,11 +53,11 @@ namespace chaiscript
      */
     template<typename FunctionType>
       boost::function<FunctionType>
-      functor(Const_Proxy_Function func)
+      functor(Const_Proxy_Function func, const Dynamic_Cast_Conversions *t_conversions)
       {
         std::vector<Const_Proxy_Function> funcs;
         funcs.push_back(func);
-        return functor<FunctionType>(funcs);
+        return functor<FunctionType>(funcs, t_conversions);
       }
 
     /**
@@ -66,9 +66,9 @@ namespace chaiscript
      */
     template<typename FunctionType>
       boost::function<FunctionType>
-      functor(const Boxed_Value &bv)
+      functor(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions)
       {
-        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv));
+        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
       }
   }
 
@@ -81,13 +81,13 @@ namespace chaiscript
       {
         typedef boost::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> &>::cast(ob);
+            return Cast_Helper_Inner<const boost::function<Signature> &>::cast(ob, t_conversions);
           }
         }
       };
@@ -100,13 +100,13 @@ namespace chaiscript
       {
         typedef boost::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<boost::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<boost::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };
@@ -119,13 +119,13 @@ namespace chaiscript
       {
         typedef boost::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const boost::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<const boost::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <boost/preprocessor.hpp>
@@ -27,31 +27,44 @@ namespace chaiscript
   {
     namespace detail
     {
-
       /**
        * Internal helper class for handling the return
        * value of a build_function_caller
        */
-      template<typename Ret>
+      template<typename Ret, bool is_arithmetic>
         struct Function_Caller_Ret
         {
           static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params)
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params));
+            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, t_conversions));
           }
         };
 
+      /**
+       * Specialization for arithmetic return types
+       */
+      template<typename Ret>
+        struct Function_Caller_Ret<Ret, true>
+        {
+          static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          {
+            return Boxed_Number(dispatch::dispatch(t_funcs, params, t_conversions)).get_as<Ret>();
+          }
+        };
+
+
       /**
        * Specialization for void return types
        */
       template<>
-        struct Function_Caller_Ret<void>
+        struct Function_Caller_Ret<void, false>
         {
           static void call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params)
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            dispatch::dispatch(t_funcs, params);
+            dispatch::dispatch(t_funcs, params, t_conversions);
           }
         };
     }
@@ -76,14 +89,14 @@ namespace chaiscript
        * used internally for unwrapping a function call's types
        */
       template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        Ret function_caller(const std::vector<Const_Proxy_Function> &funcs 
+        Ret function_caller(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions &t_conversions 
             BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
         {
           std::vector<Boxed_Value> params;
 
-          BOOST_PP_REPEAT(n, addparam, ~)
+          BOOST_PP_REPEAT(n, addparam, ~);
 
-            return Function_Caller_Ret<Ret>::call(funcs, params);
+          return Function_Caller_Ret<Ret, boost::is_arithmetic<Ret>::value>::call(funcs, params, t_conversions);
         }
 
       /**
@@ -91,7 +104,8 @@ namespace chaiscript
        */
       template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
         boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
-        build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<Const_Proxy_Function> &funcs)
+        build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<Const_Proxy_Function> &funcs, 
+            const Dynamic_Cast_Conversions *t_conversions)
         {
           if (funcs.size() == 1)
           {
@@ -107,13 +121,15 @@ namespace chaiscript
             // we cannot make any other guesses or assumptions really, so continuing
           }
 
-          return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs
+          return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs, (t_conversions?*t_conversions:Dynamic_Cast_Conversions())
               BOOST_PP_ENUM_TRAILING(n, curry, ~));
         }
     }
   }
 }
 #undef n
+#undef addparam
+#undef curry 
 
 #endif
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,13 +1,14 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
 #define CHAISCRIPT_HANDLE_RETURN_HPP_
 
 #include "boxed_value.hpp"
+#include "boxed_number.hpp"
 #include "type_info.hpp"
 #include <string>
 #include <boost/function.hpp>
@@ -33,6 +34,15 @@ namespace chaiscript
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<Ret *>
+        {
+          static Boxed_Value handle(Ret *p)
+          {
+            return Boxed_Value(p);
+          }
+        };
+
       template<typename Ret>
         struct Handle_Return<boost::shared_ptr<Ret> &>
         {
@@ -135,6 +145,30 @@ namespace chaiscript
           }
         };
 
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<Boxed_Number>
+        {
+          static Boxed_Value handle(const Boxed_Number &r)
+          {
+            return r.bv;
+          }
+        };
+
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<const Boxed_Number>
+        {
+          static Boxed_Value handle(const Boxed_Number &r)
+          {
+            return r.bv;
+          }
+        };
+
 
       /**
        * Used internally for handling a return value from a Proxy_Function call

include/chaiscript/dispatchkit/operators.hpp

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

include/chaiscript/dispatchkit/proxy_constructors.hpp

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

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 
@@ -20,11 +20,10 @@
 
 namespace chaiscript
 {
-  class Boxed_POD_Value;
+  class Boxed_Number;
   struct AST_Node;
 
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
-
+  typedef boost::shared_ptr<AST_Node> AST_NodePtr;
 
   namespace dispatch
   {
@@ -71,10 +70,9 @@ namespace chaiscript
     {
       public:
         virtual ~Proxy_Function_Base() {}
-        Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Dynamic_Cast_Conversions &t_conversions) const
         {
-          Boxed_Value bv = do_call(params);
-          bv.add_dependencies(params.begin(), params.end());
+          Boxed_Value bv = do_call(params, t_conversions);
           return bv;
         }
 
@@ -85,7 +83,12 @@ namespace chaiscript
         std::vector<Type_Info> get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const = 0;
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
+
+        bool has_arithmetic_param() const 
+        {
+          return m_has_arithmetic_param;
+        }
 
         virtual std::vector<boost::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
         {
@@ -95,7 +98,7 @@ namespace chaiscript
 
         //! Return true if the function is a possible match
         //! to the passed in values
-        bool filter(const std::vector<Boxed_Value> &vals) const
+        bool filter(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           int arity = get_arity();
 
@@ -107,7 +110,7 @@ namespace chaiscript
             {
               return true;
             } else {
-              return compare_first_type(vals[0]);
+              return compare_first_type(vals[0], t_conversions);
             }
           } else {
             return false;
@@ -119,30 +122,15 @@ namespace chaiscript
 
         virtual std::string annotation() const = 0;
 
-      protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const = 0;
-
-        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
-          : m_types(t_types)
+        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions)
         {
-        }
-
-        virtual bool compare_first_type(const Boxed_Value &bv) const
-        {
-          const std::vector<Type_Info> &types = get_param_types();
-
-          if (types.size() < 2)
-          {
-            return true;
-          }
-          const Type_Info &ti = types[1];
           if (ti.is_undef() 
               || ti.bare_equal(user_type<Boxed_Value>())
               || (!bv.get_type_info().is_undef()
-                && (ti.bare_equal(user_type<Boxed_POD_Value>())
+                && (ti.bare_equal(user_type<Boxed_Number>())
                   || ti.bare_equal(bv.get_type_info())
-                  || chaiscript::detail::dynamic_cast_converts(ti, bv.get_type_info()) 
                   || bv.get_type_info().bare_equal(user_type<boost::shared_ptr<const Proxy_Function_Base> >())
+                  || t_conversions.dynamic_cast_converts(ti, bv.get_type_info()) 
                   )
                 )
              )
@@ -152,8 +140,38 @@ namespace chaiscript
             return false;
           }
         }
+      protected:
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
-        bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs) const
+        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
+          : m_types(t_types), m_has_arithmetic_param(false)
+        {
+          for (size_t i = 1; i < m_types.size(); ++i)
+          {
+            if (m_types[i].is_arithmetic())
+            {
+              m_has_arithmetic_param = true;
+              return;
+            }
+          }
+
+        }
+
+        virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
+        {
+          const std::vector<Type_Info> &types = get_param_types();
+
+          if (types.size() < 2)
+          {
+            return true;
+          }
+
+          const Type_Info &ti = types[1];
+          return compare_type_to_param(ti, bv, t_conversions);
+
+        }
+
+        static bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs)
         {
           if (tis.size() - 1 != bvs.size())
           {
@@ -172,6 +190,8 @@ namespace chaiscript
         }
 
         std::vector<Type_Info> m_types;
+        bool m_has_arithmetic_param;
+
     };
   }
 
@@ -219,13 +239,18 @@ namespace chaiscript
 
         virtual bool operator==(const Proxy_Function_Base &rhs) const
         {
-          return this == &rhs;
+          const Dynamic_Proxy_Function *prhs = dynamic_cast<const Dynamic_Proxy_Function *>(&rhs);
+
+          return this == &rhs
+            || (prhs
+                && this->m_arity == prhs->m_arity
+                && !this->m_guard && !prhs->m_guard);
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           return (m_arity < 0 || vals.size() == size_t(m_arity))
-            && test_guard(vals);
+            && test_guard(vals, t_conversions);
         }    
 
         virtual ~Dynamic_Proxy_Function() {}
@@ -252,12 +277,12 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (m_arity < 0 || params.size() == size_t(m_arity))
           {
 
-            if (test_guard(params))
+            if (test_guard(params, t_conversions))
             {
               return m_f(params);
             } else {
@@ -270,12 +295,12 @@ namespace chaiscript
         }
 
       private:
-        bool test_guard(const std::vector<Boxed_Value> &params) const
+        bool test_guard(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (m_guard)
           {
             try {
-              return boxed_cast<bool>((*m_guard)(params));
+              return boxed_cast<bool>((*m_guard)(params, t_conversions));
             } catch (const exception::arity_error &) {
               return false;
             } catch (const exception::bad_boxed_cast &) {
@@ -331,7 +356,7 @@ namespace chaiscript
         Bound_Function(const Const_Proxy_Function &t_f, 
             const std::vector<Boxed_Value> &t_args)
           : Proxy_Function_Base(build_param_type_info(t_f, t_args)),
-          m_f(t_f), m_args(t_args), m_arity(t_f->get_arity()<0?-1:static_cast<int>(get_param_types().size())-1)
+            m_f(t_f), m_args(t_args), m_arity(t_f->get_arity()<0?-1:static_cast<int>(get_param_types().size())-1)
         {
           assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
         }
@@ -343,14 +368,9 @@ namespace chaiscript
 
         virtual ~Bound_Function() {}
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return m_f->call_match(build_param_list(vals));
-        }
-
-        virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
-        {
-          return (*m_f)(build_param_list(params));
+          return m_f->call_match(build_param_list(vals), t_conversions);
         }
 
         virtual std::vector<Const_Proxy_Function> get_contained_functions() const
@@ -427,9 +447,9 @@ namespace chaiscript
           return retval;
         }
 
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return (*m_f)(build_param_list(params));
+          return (*m_f)(build_param_list(params), t_conversions);
         }
 
       private:
@@ -450,8 +470,8 @@ namespace chaiscript
         Proxy_Function_Impl(const boost::function<Func> &f)
           : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(0))),
           m_f(f), m_dummy_func(0)
-      {
-      }
+        {
+        }
 
         virtual ~Proxy_Function_Impl() {}
 
@@ -468,14 +488,14 @@ namespace chaiscript
         }
 
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (int(vals.size()) != get_arity()) 
           {
             return false;
           }
 
-          return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals);
+          return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals, t_conversions);
         }
 
         virtual std::string annotation() const
@@ -489,9 +509,9 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params);
+          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params, t_conversions);
         }
 
       private:
@@ -509,8 +529,8 @@ namespace chaiscript
         Attribute_Access(T Class::* t_attr)
           : Proxy_Function_Base(param_types()),
           m_attr(t_attr)
-      {
-      }
+        {
+        }
 
         virtual ~Attribute_Access() {}
 
@@ -531,7 +551,7 @@ namespace chaiscript
           return 1;
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const
         {
           if (vals.size() != 1)
           {
@@ -547,17 +567,17 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (params.size() == 1)
           {
             const Boxed_Value &bv = params[0];
             if (bv.is_const())
             {
-              const Class *o = boxed_cast<const Class *>(bv);
+              const Class *o = boxed_cast<const Class *>(bv, &t_conversions);
               return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
             } else {
-              Class *o = boxed_cast<Class *>(bv);
+              Class *o = boxed_cast<Class *>(bv, &t_conversions);
               return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
             }
           } else {
@@ -587,22 +607,109 @@ namespace chaiscript
     class dispatch_error : public std::runtime_error
     {
       public:
-        dispatch_error() throw()
-          : std::runtime_error("No matching function to dispatch to")
+        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(bool is_const) throw()
-          : std::runtime_error(std::string("No matching function to dispatch to") + (is_const?", parameter is const":""))
-          {
-          }
-
         virtual ~dispatch_error() throw() {}
+
+        std::vector<Boxed_Value> parameters;
+        std::vector<Const_Proxy_Function> functions;
     };
   } 
 
   namespace dispatch
   {
+    namespace detail 
+    {
+      template<typename FuncType>
+        bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          if (t_func->get_arity() != static_cast<int>(plist.size()))
+          {
+            return false;
+          }
+
+          const std::vector<Type_Info> &types = t_func->get_param_types();
+
+          assert(plist.size() == types.size() - 1);
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (Proxy_Function_Base::compare_type_to_param(types[i+1], plist[i], t_conversions)
+                || (types[i+1].is_arithmetic() && plist[i].get_type_info().is_arithmetic()))
+            {
+              // types continue to match
+            } else {
+              return false;
+            }
+          }
+
+          // all types match
+          return true;
+        }
+
+      template<typename InItr>
+        Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist, 
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          InItr orig(begin);
+
+          InItr matching_func(end);
+
+          while (begin != end)
+          {
+            if (types_match_except_for_arithmetic(*begin, plist, t_conversions))
+            {
+              if (matching_func == end)
+              {
+                matching_func = begin;
+              } else {
+                // More than one function matches, not attempting
+                throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+              }
+            }
+
+            ++begin;
+          }
+
+          if (matching_func == end)
+          {
+            // no appropriate function to attempt arithmetic type conversion on
+            throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+          }
+
+
+          std::vector<Boxed_Value> newplist;
+          const std::vector<Type_Info> &tis = (*matching_func)->get_param_types();
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (tis[i+1].is_arithmetic()
+                && plist[i].get_type_info().is_arithmetic()) {
+              newplist.push_back(Boxed_Number(plist[i]).get_as(tis[i+1]).bv);
+            } else {
+              newplist.push_back(plist[i]);
+            }
+          }
+
+          try {
+            return (*(*matching_func))(newplist, t_conversions);
+          } catch (const exception::bad_boxed_cast &) {
+            //parameter failed to cast
+          } catch (const exception::arity_error &) {
+            //invalid num params
+          } catch (const exception::guard_error &) {
+            //guard failed to allow the function to execute
+          }
+
+          throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+
+        }
+    }
 
     /**
      * Take a vector of functions and a vector of parameters. Attempt to execute
@@ -610,15 +717,16 @@ namespace chaiscript
      * function is found or throw dispatch_error if no matching function is found
      */
     template<typename InItr>
-      Boxed_Value dispatch(InItr begin, InItr end,
-          const std::vector<Boxed_Value> &plist)
+      Boxed_Value dispatch(InItr begin, const InItr &end,
+          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
       {
+        InItr orig(begin);
         while (begin != end)
         {
           try {
-            if ((*begin)->filter(plist))
+            if ((*begin)->filter(plist, t_conversions))
             {
-              return (*(*begin))(plist);
+              return (*(*begin))(plist, t_conversions);
             }
           } catch (const exception::bad_boxed_cast &) {
             //parameter failed to cast, try again
@@ -631,7 +739,7 @@ namespace chaiscript
           ++begin;
         }
 
-        throw exception::dispatch_error(plist.empty()?false:plist[0].is_const());
+        return detail::dispatch_with_conversions(orig, end, plist, t_conversions);
       }
 
     /**
@@ -641,9 +749,9 @@ namespace chaiscript
      */
     template<typename Funcs>
       Boxed_Value dispatch(const Funcs &funcs,
-          const std::vector<Boxed_Value> &plist)
+          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
       {
-        return dispatch::dispatch(funcs.begin(), funcs.end(), plist);
+        return dispatch::dispatch(funcs.begin(), funcs.end(), plist, t_conversions);
       }
   }
 }

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -1,14 +1,14 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <boost/preprocessor.hpp>
 
 #define gettypeinfo(z,n,text)  ti.push_back(chaiscript::detail::Get_Type_Info<Param ## n>::get());
-#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n])
-#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n]);
+#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n], &t_conversions)
+#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n], &t_conversions);
 
 #ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
@@ -21,7 +21,6 @@
 #include <string>
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
 
 #include <stdexcept>
 #include <vector>
@@ -87,9 +86,23 @@ namespace chaiscript
        * if any unboxing fails the execution of the function fails and
        * the bad_boxed_cast is passed up to the caller.
        */
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
       template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
         Ret call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
-            const std::vector<Boxed_Value> &params)
+            const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions & BOOST_PP_IF(n, t_conversions, BOOST_PP_EMPTY))
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
         {
           if (params.size() != n)
           {
@@ -99,16 +112,37 @@ namespace chaiscript
           }
         }
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
       /**
        * Used by Proxy_Function_Impl to determine if it is equivalent to another
        * Proxy_Function_Impl object. This function is primarly used to prevent
        * registration of two functions with the exact same signatures
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
+       template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
         bool compare_types_cast(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)),
-            const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, ))
+            const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, BOOST_PP_EMPTY), const Dynamic_Cast_Conversions &t_conversions)
+
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
         {
           try {
+            (void)t_conversions;
             BOOST_PP_REPEAT(n, trycast, ~);
           } catch (const exception::bad_boxed_cast &) {
             return false;
@@ -116,11 +150,20 @@ namespace chaiscript
 
           return true;
         }
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
     }
   }
 }
 
 #undef n
+#undef gettypeinfo
+#undef casthelper
+#undef trycast
+
 
 #endif
 
@@ -137,9 +180,9 @@ namespace chaiscript
       struct Do_Call
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            return Handle_Return<Ret>::handle(call_func(fun, params));
+            return Handle_Return<Ret>::handle(call_func(fun, params, t_conversions));
           }
       };
 
@@ -147,9 +190,9 @@ namespace chaiscript
       struct Do_Call<void>
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            call_func(fun, params);
+            call_func(fun, params, t_conversions);
             return Handle_Return<void>::handle();
           }
       };

include/chaiscript/dispatchkit/register_function.hpp

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

include/chaiscript/dispatchkit/type_info.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_TYPE_INFO_HPP_
@@ -14,6 +14,8 @@
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_reference.hpp>
 #include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/remove_pointer.hpp>
@@ -36,38 +38,41 @@ namespace chaiscript
   {
     public:
       Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
-          const std::type_info *t_ti, const std::type_info *t_bareti)
-        : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
-        m_is_void(t_is_void),
-        m_type_info(t_ti), m_bare_type_info(t_bareti),
+          bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
+        : m_type_info(t_ti), m_bare_type_info(t_bareti),
+        m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
+        m_is_void(t_is_void), m_is_arithmetic(t_is_arithmetic),
         m_is_undef(false)
       {
       }
 
       Type_Info()
-        : m_is_const(false), m_is_reference(false), m_is_pointer(false),
-        m_is_void(false), m_type_info(0), m_bare_type_info(0),
+        : m_type_info(0), m_bare_type_info(0),
+        m_is_const(false), m_is_reference(false), m_is_pointer(false),
+        m_is_void(false), m_is_arithmetic(false), 
         m_is_undef(true)
       {
       }
 
       Type_Info(const Type_Info &ti)
-        : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
-        m_is_pointer(ti.m_is_pointer),
-        m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
+        : m_type_info(ti.m_type_info), 
         m_bare_type_info(ti.m_bare_type_info),
+        m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
+        m_is_pointer(ti.m_is_pointer),
+        m_is_void(ti.m_is_void), m_is_arithmetic(ti.m_is_arithmetic),
         m_is_undef(ti.m_is_undef)
       {
       }
 
       Type_Info &operator=(const Type_Info &ti)
       {
+        m_type_info = ti.m_type_info;
+        m_bare_type_info = ti.m_bare_type_info;
         m_is_const = ti.m_is_const;
         m_is_reference = ti.m_is_reference;
         m_is_pointer = ti.m_is_pointer;
         m_is_void = ti.m_is_void;
-        m_type_info = ti.m_type_info;
-        m_bare_type_info = ti.m_bare_type_info;
+        m_is_arithmetic = ti.m_is_arithmetic;
         m_is_undef = ti.m_is_undef;
         return *this;
       }
@@ -94,9 +99,16 @@ namespace chaiscript
           || (ti.m_bare_type_info && m_bare_type_info && *ti.m_bare_type_info == *m_bare_type_info);
       }
 
+      bool bare_equal_type_info(const std::type_info &ti) const
+      {
+        return m_bare_type_info != 0 
+          && (*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; }
 
@@ -121,12 +133,13 @@ namespace chaiscript
       }
 
     private:
+      const std::type_info *m_type_info;
+      const std::type_info *m_bare_type_info;
       bool m_is_const;
       bool m_is_reference;
       bool m_is_pointer;
       bool m_is_void;
-      const std::type_info *m_type_info;
-      const std::type_info *m_bare_type_info;
+      bool m_is_arithmetic;
       bool m_is_undef;
   };
 
@@ -144,6 +157,7 @@ namespace chaiscript
         {
           return Type_Info(boost::is_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(T), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -158,6 +172,7 @@ namespace chaiscript
         {
           return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(boost::shared_ptr<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -172,6 +187,7 @@ namespace chaiscript
         {
           return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(const boost::shared_ptr<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -186,6 +202,7 @@ namespace chaiscript
         {
           return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(boost::reference_wrapper<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
@@ -200,6 +217,7 @@ namespace chaiscript
         {
           return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(const boost::reference_wrapper<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -0,0 +1,131 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_ALGEBRAIC_HPP_
+#define	CHAISCRIPT_ALGEBRAIC_HPP_
+
+#include <chaiscript/dispatchkit/dispatchkit.hpp>
+#include <boost/enable_shared_from_this.hpp>
+
+namespace chaiscript
+{
+
+  struct Operators {
+    enum Opers
+    {
+      boolean_flag,
+      equals, less_than, greater_than, less_than_equal, greater_than_equal, not_equal, 
+      non_const_flag, 
+      assign, pre_increment, pre_decrement, assign_product, assign_sum,
+      assign_quotient, assign_difference,
+      non_const_int_flag,
+      assign_bitwise_and, assign_bitwise_or, assign_shift_left, assign_shift_right,
+      assign_remainder, assign_bitwise_xor,
+      const_int_flag,
+      shift_left, shift_right, remainder, bitwise_and, bitwise_or, bitwise_xor, bitwise_complement,
+      const_flag,
+      sum, quotient, product, difference, unary_plus, unary_minus, 
+      invalid
+    };
+
+    static const char *to_string(Opers t_oper) {
+      const char *opers[] = { 
+        "",
+        "==", "<", ">", "<=", ">=", "!=",
+        "",
+        "=", "++", "--", "*=", "+=",
+        "/=", "-=",
+        "",
+        "&=", "|=", "<<=", ">>=",
+        "%=", "^=",
+        "", 
+        "<<", ">>", "%", "&", "|", "^", "~",
+        "",
+        "+", "/", "*", "-", "+", "-",
+        ""
+      };
+      return opers[t_oper];
+    }
+
+    static Opers to_operator(const std::string &t_str, bool t_is_unary = false)
+    {
+      if (t_str == "==")
+      {
+        return equals;
+      } else if (t_str == "<") {
+        return less_than;
+      } else if (t_str == ">") {
+        return greater_than;
+      } else if (t_str == "<=") {
+        return less_than_equal; 
+      } else if (t_str == ">=") {
+        return greater_than_equal;
+      } else if (t_str == "!=") {
+        return not_equal;
+      } else if (t_str == "=") {
+        return assign;
+      } else if (t_str == "++") {
+        return pre_increment;
+      } else if (t_str == "--") {
+        return pre_decrement;
+      } else if (t_str == "*=") {
+        return assign_product;
+      } else if (t_str == "+=") {
+        return assign_sum;
+      } else if (t_str == "-=") {
+        return assign_difference;
+      } else if (t_str == "&=") {
+        return assign_bitwise_and;
+      } else if (t_str == "|=") {
+        return assign_bitwise_or;
+      } else if (t_str == "<<=") {
+        return assign_shift_left;
+      } else if (t_str == ">>=") {
+        return assign_shift_right;
+      } else if (t_str == "%=") {
+        return assign_remainder;
+      } else if (t_str == "^=") {
+        return assign_bitwise_xor;
+      } else if (t_str == "<<") {
+        return shift_left;
+      } else if (t_str == ">>") {
+        return shift_right;
+      } else if (t_str == "%") {
+        return remainder;
+      } else if (t_str == "&") { 
+        return bitwise_and;
+      } else if (t_str == "|") {
+        return bitwise_or;
+      } else if (t_str == "^") {
+        return bitwise_xor;
+      } else if (t_str == "~") {
+        return bitwise_complement;
+      } else if (t_str == "+") {
+        if (t_is_unary) {
+          return unary_plus;
+        } else {
+          return sum;
+        }
+      } else if (t_str == "-") {
+        if (t_is_unary) {
+          return unary_minus;
+        } else {
+          return difference;
+        }
+      } else if (t_str == "/") {
+        return quotient;
+      } else if (t_str == "*") {
+        return product;
+      } else {
+        return invalid;
+      } 
+    }
+
+  };
+}
+
+#endif	/* _CHAISCRIPT_ALGEBRAIC_HPP */
+

include/chaiscript/language/chaiscript_common.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
@@ -15,28 +15,28 @@ namespace chaiscript
   /// Signature of module entry point that all binary loadable modules must implement.
   typedef ModulePtr (*Create_Module_Func)();
 
+
   /// Types of AST nodes available to the parser and eval
   class AST_Node_Type {
   public:
     enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
-                Comparison, Additive, Multiplicative, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
-                Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
+                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
+                Logical_And, Logical_Or, Switch, Case, Default, Ternary_Cond, Noop
     };
   };
 
   namespace
   {
-    /**
-     * Helper lookup to get the name of each node type
-     */
+
+    /// Helper lookup to get the name of each node type
     const char *ast_node_type_to_string(int ast_node_type) {
       const char *ast_node_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Inplace_Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
-                                    "Comparison", "Additive", "Multiplicative", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
-                                    "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
+                                    "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"};
+                                    "Logical_And", "Logical_Or", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
 
       return ast_node_types[ast_node_type];
     }
@@ -54,41 +54,329 @@ namespace chaiscript
   };
 
   /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef boost::shared_ptr<AST_Node> AST_NodePtr;
 
 
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
   namespace exception
   {
-    /**
-     * Errors generated during parsing or evaluation
-     */
+
+    /// Errors generated during parsing or evaluation
     struct eval_error : public std::runtime_error {
       std::string reason;
       File_Position start_position;
       File_Position end_position;
       std::string filename;
+      std::string detail;
       std::vector<AST_NodePtr> call_stack;
 
-      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) throw() :
-        std::runtime_error("Error: \"" + t_why + "\" " +
-            (t_fname != "__EVAL__" ? ("in '" + t_fname + "' ") : "during evaluation ") +
-            + "at (" + boost::lexical_cast<std::string>(t_where.line) + ", " +
-            boost::lexical_cast<std::string>(t_where.column) + ")"),
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
+          const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)  :
+        std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_dot_notation, t_ss)),
+        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss))
+      {}
+
+      eval_error(const std::string &t_why, 
+           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+           bool t_dot_notation,
+           const chaiscript::detail::Dispatch_Engine &t_ss) :
+        std::runtime_error(format(t_why, t_parameters, t_dot_notation, t_ss)),
+        reason(t_why), detail(format_detail(t_functions, t_dot_notation, t_ss))
+      {}
+
+
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) :
+        std::runtime_error(format(t_why, t_where, t_fname)),
         reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
-        { }
+      {}
 
       eval_error(const std::string &t_why) throw()
         : std::runtime_error("Error: \"" + t_why + "\" "),
         reason(t_why) 
       {}
 
+      std::string pretty_print() const
+      {
+        std::ostringstream ss;
+
+        ss << what();
+        if (call_stack.size() > 0) {
+          ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")" << std::endl;
+          ss << std::endl << detail << std::endl;
+          ss << "  " << fname(call_stack[0]) << " (" << startpos(call_stack[0]) << ") '" << pretty(call_stack[0]) << "'";
+          for (size_t j = 1; j < call_stack.size(); ++j) {
+            if (id(call_stack[j]) != chaiscript::AST_Node_Type::Block
+                && id(call_stack[j]) != chaiscript::AST_Node_Type::File)
+            {
+              ss << std::endl;
+              ss << "  from " << fname(call_stack[j]) << " (" << startpos(call_stack[j]) << ") '" << pretty(call_stack[j]) << "'";
+            }
+          }
+        }
+        ss << std::endl;
+        return ss.str();
+      }
+
       virtual ~eval_error() throw() {}
+
+    private:
+
+      template<typename T>
+        static int id(const T& t)
+        {
+          return t->identifier;
+        }
+
+      template<typename T>
+        static std::string pretty(const T& t)
+        {
+          return t->pretty_print();
+        }
+
+      template<typename T>
+        static std::string fname(const T& t)
+        {
+          return *t->filename;
+        }
+
+      template<typename T>
+        static std::string startpos(const T& t)
+        {
+          std::ostringstream oss;
+          oss << t->start.line << ", " << t->start.column;
+          return oss.str();
+        }
+
+      static std::string format_why(const std::string &t_why)
+      {
+        return "Error: \"" + t_why + "\"";
+      }
+
+      static std::string format_types(const Const_Proxy_Function &t_func,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        int arity = t_func->get_arity();
+        std::vector<Type_Info> types = t_func->get_param_types();
+
+        std::string retval;
+        if (arity == -1)
+        {
+          retval = "(...)";
+          if (t_dot_notation)
+          {
+            retval = "(Object)." + retval;
+          }
+        } else if (types.size() <= 1) {
+          retval = "()";
+        } else {
+          std::stringstream ss;
+          ss << "(";
+
+          std::string paramstr;
+
+          for (size_t index = 1;
+               index != types.size();
+               ++index)
+          {
+            paramstr += (types[index].is_const()?"const ":"");
+            paramstr += t_ss.get_type_name(types[index]);
+
+            if (index == 1 && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (types.size() == 2)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+
+          ss << ")";
+          retval = ss.str();
+        }
+
+
+        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfun 
+          = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_func);
+
+        if (dynfun)
+        {
+          Proxy_Function f = dynfun->get_guard();
+
+          if (f)
+          {
+            boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfunguard 
+              = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(f);
+            if (dynfunguard)
+            {
+              retval += " : " + format_guard(dynfunguard->get_parse_tree());
+            }
+          }
+
+          retval += "\n          Defined at " + format_location(dynfun->get_parse_tree());        
+        }
+
+        return retval;
+      }
+
+      template<typename T>
+        static std::string format_guard(const T &t)
+        {
+          return t->pretty_print();
+        }
+
+      template<typename T>
+        static std::string format_location(const T &t)
+        {
+          std::ostringstream oss;
+          oss << "(" << *t->filename << " " << t->start.line << ", " << t->start.column << ")"; 
+
+          return oss.str();
+
+        }
+
+      static std::string format_detail(const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        if (t_functions.size() == 1)
+        {
+          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << std::endl;
+        } else {
+          ss << "  " << t_functions.size() << " overloads available:" << std::endl;
+
+          for (std::vector<chaiscript::Const_Proxy_Function>::const_iterator itr = t_functions.begin();
+               itr != t_functions.end();
+               ++itr)
+          {
+            ss << "      " << format_types((*itr), t_dot_notation, t_ss) << std::endl;
+          }
+
+        }
+
+        return ss.str();
+
+      }
+
+      static std::string format_parameters(const std::vector<Boxed_Value> &t_parameters,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        ss << "(";
+
+        if (!t_parameters.empty())
+        {
+          std::string paramstr;
+
+          for (std::vector<Boxed_Value>::const_iterator itr = t_parameters.begin();
+               itr != t_parameters.end();
+               ++itr)
+          {
+            paramstr += (itr->is_const()?"const ":"");
+            paramstr += t_ss.type_name(*itr);
+
+            if (itr == t_parameters.begin() && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (t_parameters.size() == 1)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+        }
+        ss << ")";
+
+        return ss.str();
+      }
+
+      static std::string format_filename(const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        if (t_fname != "__EVAL__")
+        {
+          ss << "in '" << t_fname << "' ";
+        } else {
+          ss << "during evaluation ";
+        }
+
+        return ss.str();
+      }
+
+      static std::string format_location(const File_Position &t_where)
+      {
+        std::stringstream ss;
+        ss << "at (" << t_where.line << ", " << t_where.column << ")";
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
+          const std::vector<Boxed_Value> &t_parameters, bool t_dot_notation, const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, 
+          const std::vector<Boxed_Value> &t_parameters, 
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
     };
 
-    /**
-     * Errors generated when loading a file
-     */
+
+    /// Errors generated when loading a file
     struct file_not_found_error : public std::runtime_error {
       file_not_found_error(const std::string &t_filename) throw()
         : std::runtime_error("File Not Found: " + t_filename)
@@ -110,9 +398,21 @@ namespace chaiscript
       std::vector<AST_NodePtr> children;
       AST_NodePtr annotation;
 
-      /**
-       * Prints the contents of an AST node, including its children, recursively
-       */
+      virtual std::string pretty_print() const
+      {
+        std::ostringstream oss;
+
+        oss << text;
+
+        for (unsigned int j = 0; j < this->children.size(); ++j) {
+          oss << this->children[j]->pretty_print();
+        }
+
+        return oss.str();
+      }
+
+
+      /// Prints the contents of an AST node, including its children, recursively
       std::string to_string(std::string t_prepend = "") {
         std::ostringstream oss;
 
@@ -135,7 +435,7 @@ namespace chaiscript
           return eval_internal(t_e);
         } catch (exception::eval_error &ee) {
           ee.call_stack.push_back(shared_from_this());
-          throw ee;
+          throw;
         }
       }
 
@@ -174,22 +474,27 @@ namespace chaiscript
   {
     namespace detail
     {
-      /**
-       * Special type for returned values
-       */
+
+      /// Special type for returned values
       struct Return_Value {
         Boxed_Value retval;
 
         Return_Value(const Boxed_Value &t_return_value) : retval(t_return_value) { }
       };
 
-      /**
-       * Special type indicating a call to 'break'
-       */
+
+      /// Special type indicating a call to 'break'
       struct Break_Loop {
         Break_Loop() { }
       };
 
+
+      /// Special type indicating a call to 'continue'
+      struct Continue_Loop {
+        Continue_Loop() { }
+      };
+
+
       /// Creates a new scope then pops it on destruction
       struct Scope_Push_Pop
       {
@@ -212,6 +517,57 @@ namespace chaiscript
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
+
+      /// Creates a new functon call and pops it on destruction
+      struct Function_Push_Pop
+      {
+        Function_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_function_call();
+        }
+
+        ~Function_Push_Pop()
+        {
+          m_de.pop_function_call();
+        }
+
+        void save_params(const std::vector<Boxed_Value> &t_params)
+        {
+          m_de.save_function_params(t_params);
+        }
+
+
+        private:
+        // 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;
+      };
+
+      /// Creates a new scope then pops it on destruction
+      struct Stack_Push_Pop
+      {
+        Stack_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_stack();
+        }
+
+        ~Stack_Push_Pop()
+        {
+          m_de.pop_stack();
+        }
+
+
+        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;
+      };
     }
   }
 }

include/chaiscript/language/chaiscript_engine.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ENGINE_HPP_
@@ -10,7 +10,7 @@
 #include <exception>
 #include <fstream>
 
-#include <chaiscript/language/chaiscript_common.hpp>
+#include "chaiscript_common.hpp"
 
 #ifdef _POSIX_VERSION
 #include <dlfcn.h>
@@ -23,8 +23,9 @@
 #endif
 
 
-#include <chaiscript/language/chaiscript_prelude.hpp>
-#include <chaiscript/language/chaiscript_parser.hpp>
+#include "chaiscript_prelude.hpp"
+#include "chaiscript_parser.hpp"
+#include "../dispatchkit/exception_specification.hpp"
 
 namespace chaiscript
 {
@@ -75,7 +76,7 @@ namespace chaiscript
         struct DLSym
         {
           DLSym(DLModule &t_mod, const std::string &t_symbol)
-            : m_symbol(reinterpret_cast<T>(dlsym(t_mod.m_data, t_symbol.c_str())))
+            : m_symbol(cast_symbol(dlsym(t_mod.m_data, t_symbol.c_str())))
           {
             if (!m_symbol)
             {
@@ -83,6 +84,19 @@ namespace chaiscript
             }
           }
 
+          static T cast_symbol(void *p)
+          {
+            union cast_union
+            {
+              T func_ptr;
+              void *in_ptr;
+            };
+
+            cast_union c;
+            c.in_ptr = p;
+            return c.func_ptr;
+          }
+
           T m_symbol;
         };
 
@@ -237,9 +251,8 @@ namespace chaiscript
     chaiscript::detail::Dispatch_Engine m_engine;
 
 
-    /**
-     * Evaluates the given string in by parsing it and running the results through the evaluator
-     */
+
+    /// Evaluates the given string in by parsing it and running the results through the evaluator
     Boxed_Value do_eval(const std::string &t_input, const std::string &t_filename = "__EVAL__", bool /* t_internal*/  = false) 
     {
       try {
@@ -260,57 +273,36 @@ namespace chaiscript
 
     const Boxed_Value internal_eval_ast(const AST_NodePtr &t_ast)
     {
-      return t_ast->eval(m_engine);
-    }
-
-
-    /**
-     * Evaluates the given string, used during eval() inside of a script
-     */
-    const Boxed_Value internal_eval(const std::string &t_e) {
-      return do_eval(t_e, "__EVAL__", true);
-    }
-
-    void use(const std::string &t_filename)
-    {
-      for (size_t i = 0; i < m_usepaths.size(); ++i)
-      {
-
-        try {
-          const std::string appendedpath = m_usepaths[i] + t_filename;
-
-          chaiscript::detail::threading::lock_guard<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
-          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
-
-          if (m_used_files.count(appendedpath) == 0)
-          {
-            m_used_files.insert(appendedpath);
-            l2.unlock();
-            eval_file(appendedpath);
-          }
-        } catch (const exception::file_not_found_error &) {
-          if (i == m_usepaths.size() - 1)
-          {
-            throw exception::file_not_found_error(t_filename);
-          }
-
-          // failed to load, try the next path
-        }
+      try {
+        return t_ast->eval(m_engine);
+      } catch (const exception::eval_error &t_ee) {
+        throw Boxed_Value(t_ee);
       }
     }
 
-    /**
-     * Returns the current evaluation m_engine
-     */
+
+
+    /// Evaluates the given string, used during eval() inside of a script
+    const Boxed_Value internal_eval(const std::string &t_e) {
+      try {
+        return do_eval(t_e, "__EVAL__", true);
+      } catch (const exception::eval_error &t_ee) {
+        throw Boxed_Value(t_ee);
+      }
+    }
+
+
+
+    /// Returns the current evaluation m_engine
     chaiscript::detail::Dispatch_Engine &get_eval_engine() {
       return m_engine;
     }
 
-    /**
-     * Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
-     */
+
+    /// Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
     void build_eval_system() {
       using namespace bootstrap;
+      m_engine.add_reserved_word("auto");
       m_engine.add_reserved_word("def");
       m_engine.add_reserved_word("fun");
       m_engine.add_reserved_word("while");
@@ -335,6 +327,15 @@ namespace chaiscript
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::is_type, boost::ref(m_engine)), "is_type");
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::type_name, boost::ref(m_engine)), "type_name");
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::function_exists, boost::ref(m_engine)), "function_exists");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_function_objects, boost::ref(m_engine)), "get_functions");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_scripting_objects, boost::ref(m_engine)), "get_objects");
+
+
+      m_engine.add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&chaiscript::detail::Dispatch_Engine::call_exists, boost::ref(m_engine), _1))), 
+          "call_exists");
+      m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base *, const std::vector<Boxed_Value> &)>(boost::bind(&chaiscript::dispatch::Proxy_Function_Base::operator(), _1, _2, boost::ref(m_engine.conversions()))), "call");
+
+
 
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, boost::ref(m_engine)), "name");
 
@@ -357,9 +358,8 @@ namespace chaiscript
       do_eval(chaiscript_prelude, "standard prelude");
     }
 
-    /**
-     * Helper function for loading a file
-     */
+
+    /// Helper function for loading a file
     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 );
 
@@ -403,6 +403,41 @@ namespace chaiscript
       build_eval_system();
     }
 
+    /// \brief Loads and parses a file. If the file is already, it is not reloaded
+    /// The use paths specified at ChaiScript construction time are searched for the 
+    /// requested file.
+    ///
+    /// \param[in] t_filename Filename to load and evaluate
+    void use(const std::string &t_filename)
+    {
+      for (size_t i = 0; i < m_usepaths.size(); ++i)
+      {
+        try {
+          const std::string appendedpath = m_usepaths[i] + t_filename;
+
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
+
+          if (m_used_files.count(appendedpath) == 0)
+          {
+            l2.unlock();
+            eval_file(appendedpath);
+            l2.lock();
+            m_used_files.insert(appendedpath);
+           }
+
+          return; // return, we loaded it, or it was already loaded
+        } catch (const exception::file_not_found_error &) {
+           if (i == m_usepaths.size() - 1)
+          {
+            throw exception::file_not_found_error(t_filename);
+          }
+
+          // failed to load, try the next path
+        }
+      }
+    }
+
     /// \brief Adds a constant object that is available in all contexts and to all threads
     /// \param[in] t_bv Boxed_Value to add as a global
     /// \param[in] t_name Name of the value to add
@@ -414,6 +449,17 @@ namespace chaiscript
       return *this;
     }
 
+    /// \brief Adds a mutable object that is available in all contexts and to all threads
+    /// \param[in] t_bv Boxed_Value to add as a global
+    /// \param[in] t_name Name of the value to add
+    /// \warning The user is responsible for making sure the object is thread-safe if necessary
+    ///          ChaiScript is thread-safe but provides no threading locking mechanism to the script
+    ChaiScript &add_global(const Boxed_Value &t_bv, const std::string &t_name)
+    {
+      m_engine.add_global(t_bv, t_name);
+      return *this;
+    }
+
     /// \brief Represents the current state of the ChaiScript system. State and be saved and restored
     /// \sa ChaiScript::get_state
     /// \sa ChaiScript::set_state
@@ -424,8 +470,12 @@ namespace chaiscript
       std::set<std::string> active_loaded_modules;
     };
 
-    /// \brief Returns a state object that represents the current state of the system
-    /// \return Current state of the system
+    /// \brief Returns a state object that represents the current state of the global system
+    ///
+    /// The global system includes the reserved words, global const objects, functions and types.
+    /// local variables are thread specific and not included.
+    ///
+    /// \return Current state of the global system
     ///
     /// \b Example:
     ///
@@ -446,6 +496,10 @@ namespace chaiscript
     }
 
     /// \brief Sets the state of the system
+    ///
+    /// The global system includes the reserved words, global objects, functions and types.
+    /// local variables are thread specific and not included.
+    ///
     /// \param[in] t_state New state to set
     ///
     /// \b Example:
@@ -465,7 +519,23 @@ namespace chaiscript
       m_engine.set_state(t_state.engine_state);
     }
 
-    /// \brief Adds a type, function or object to ChaiScript
+    /// \returns All values in the local thread state, added through the add() function
+    std::map<std::string, Boxed_Value> get_locals() const
+    {
+      return m_engine.get_locals();
+    }
+
+    /// \brief Sets all of the locals for the current thread state.
+    ///
+    /// \param[in] t_locals The map<name, value> set of variables to replace the current state with
+    ///
+    /// Any existing locals are removed and the given set of variables is added
+    void set_locals(const std::map<std::string, Boxed_Value> &t_locals)
+    {
+      m_engine.set_locals(t_locals);
+    }
+
+    /// \brief Adds a type, function or object to ChaiScript. Objects are added to the local thread state.
     /// \param[in] t_t Item to add
     /// \param[in] t_name Name of item to add
     /// \returns Reference to current ChaiScript object
@@ -598,19 +668,30 @@ namespace chaiscript
     /// \brief Evaluates a string. Equivalent to ChaiScript::eval.
     ///
     /// \param[in] t_script Script to execute
+    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
     ///
     /// \return result of the script execution
     /// 
     /// \throw exception::eval_error In the case that evaluation fails.
-    Boxed_Value operator()(const std::string &t_script)
+    Boxed_Value operator()(const std::string &t_script, const Exception_Handler &t_handler = Exception_Handler())
     {
-      return do_eval(t_script);
+      try {
+        return do_eval(t_script);
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
     /// \brief Evaluates a string and returns a typesafe result.
     ///
     /// \tparam T Type to extract from the result value of the script execution
     /// \param[in] t_input Script to execute
+    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
+    /// \param[in] t_filename Optional filename to report to the user for where the error occured. Useful
+    ///                       in special cases where you are loading a file internally instead of using eval_file
     ///
     /// \return result of the script execution
     /// 
@@ -618,41 +699,82 @@ namespace chaiscript
     /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
     ///        to the requested type.
     template<typename T>
-    T eval(const std::string &t_input)
+    T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
     {
-      return boxed_cast<T>(do_eval(t_input));
+      try {
+        return m_engine.boxed_cast<T>(do_eval(t_input, t_filename));
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
+    /// \brief casts an object while applying any Dynamic_Conversion available
+    template<typename Type>
+      typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv) const
+      {
+        return m_engine.boxed_cast<Type>(bv);
+      }
+ 
+
     /// \brief Evaluates a string.
     ///
     /// \param[in] t_input Script to execute
+    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
+    /// \param[in] t_filename Optional filename to report to the user for where the error occured. Useful
+    ///                       in special cases where you are loading a file internally instead of using eval_file
     ///
     /// \return result of the script execution
     /// 
     /// \throw exception::eval_error In the case that evaluation fails.
-    Boxed_Value eval(const std::string &t_input)
+    Boxed_Value eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
     {
-      return do_eval(t_input);
+      try {
+        return do_eval(t_input, t_filename);
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
     /// \brief Loads the file specified by filename, evaluates it, and returns the result.
     /// \param[in] t_filename File to load and parse.
+    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
     /// \return result of the script execution
     /// \throw exception::eval_error In the case that evaluation fails.
-    Boxed_Value eval_file(const std::string &t_filename) {
-      return do_eval(load_file(t_filename), t_filename);
+    Boxed_Value eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
+      try {
+        return do_eval(load_file(t_filename), t_filename);
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
 
     /// \brief Loads the file specified by filename, evaluates it, and returns the typesafe result.
     /// \tparam T Type to extract from the result value of the script execution
     /// \param[in] t_filename File to load and parse.
+    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
     /// \return result of the script execution
     /// \throw exception::eval_error In the case that evaluation fails.
     /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
     ///        to the requested type.
     template<typename T>
-    T eval_file(const std::string &t_filename) {
-      return boxed_cast<T>(do_eval(load_file(t_filename), t_filename));
+    T eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
+      try {
+        return m_engine.boxed_cast<T>(do_eval(load_file(t_filename), t_filename));
+      } catch (Boxed_Value &bv) {
+        if (t_handler) {
+          t_handler->handle(bv, m_engine);
+        }
+        throw;
+      }
     }
   };
 

include/chaiscript/language/chaiscript_parser.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_PARSER_HPP_
@@ -33,6 +33,8 @@ namespace chaiscript
           ,   bin_alphabet
           ,   id_alphabet
           ,   white_alphabet
+          ,   int_suffix_alphabet
+          ,   float_suffix_alphabet
           ,   max_alphabet
           ,   lengthof_alphabet = 256
       };
@@ -54,7 +56,8 @@ namespace chaiscript
 
       public:
       ChaiScript_Parser()
-        : m_multiline_comment_begin("/*"),
+        : m_line(-1), m_col(-1),
+        m_multiline_comment_begin("/*"),
           m_multiline_comment_end("*/"),
           m_singleline_comment("//")
       {
@@ -66,6 +69,11 @@ namespace chaiscript
 
       void setup_operators()
       {
+        m_operators.push_back(AST_Node_Type::Ternary_Cond);
+        std::vector<std::string> ternary_cond;
+        ternary_cond.push_back("?");
+        m_operator_matches.push_back(ternary_cond);
+
         m_operators.push_back(AST_Node_Type::Logical_Or);
         std::vector<std::string> logical_or;
         logical_or.push_back("||");
@@ -111,29 +119,27 @@ namespace chaiscript
         shift.push_back(">>");
         m_operator_matches.push_back(shift);
 
-        m_operators.push_back(AST_Node_Type::Additive);
-        std::vector<std::string> additive;
-        additive.push_back("+");
-        additive.push_back("-");
-        m_operator_matches.push_back(additive);
+        //We share precedence here but then separate them later
+        m_operators.push_back(AST_Node_Type::Addition);
+        std::vector<std::string> addition;
+        addition.push_back("+");
+        addition.push_back("-");
+        m_operator_matches.push_back(addition);
 
-        m_operators.push_back(AST_Node_Type::Multiplicative);
-        std::vector<std::string> multiplicative;
-        multiplicative.push_back("*");
-        multiplicative.push_back("/");
-        multiplicative.push_back("%");
-        m_operator_matches.push_back(multiplicative);
-
-        m_operators.push_back(AST_Node_Type::Dot_Access);
-        std::vector<std::string> dot_access;
-        dot_access.push_back(".");
-        m_operator_matches.push_back(dot_access);
+        //We share precedence here but then separate them later
+        m_operators.push_back(AST_Node_Type::Multiplication);
+        std::vector<std::string> multiplication;
+        multiplication.push_back("*");
+        multiplication.push_back("/");
+        multiplication.push_back("%");
+        m_operator_matches.push_back(multiplication);
 
         for ( int c = 0 ; c < detail::lengthof_alphabet ; ++c ) {
           for ( int a = 0 ; a < detail::max_alphabet ; a ++ ) {
             m_alphabet[a][c]=false;
           }
         }
+        m_alphabet[detail::symbol_alphabet][static_cast<int>('?')]=true;
         m_alphabet[detail::symbol_alphabet][static_cast<int>('+')]=true;
         m_alphabet[detail::symbol_alphabet][static_cast<int>('-')]=true;
         m_alphabet[detail::symbol_alphabet][static_cast<int>('*')]=true;
@@ -172,6 +178,17 @@ namespace chaiscript
 
         m_alphabet[detail::white_alphabet][static_cast<int>(' ')]=true;
         m_alphabet[detail::white_alphabet][static_cast<int>('\t')]=true;
+
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('l')] = true;
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('L')] = true;
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('u')] = true;
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('U')] = true;
+
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('l')] = true;
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('L')] = true;
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('f')] = true;
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('F')] = true;
+
       }
 
       /**
@@ -249,7 +266,7 @@ namespace chaiscript
           m_match_stack.push_back(t_t);
         }
         else {
-          //todo: fix the fact that a successful match that captured no ast_nodes doesn't have any real start position
+          /// \todo fix the fact that a successful match that captured no ast_nodes doesn't have any real start position
           m_match_stack.push_back(t_t);
         }
       }
@@ -325,7 +342,6 @@ namespace chaiscript
        */
       bool Float_() {
         bool retval = false;
-        std::string::const_iterator start = m_input_pos;
 
         if (has_more_input() && char_in_alphabet(*m_input_pos,detail::float_alphabet) ) {
           while (has_more_input() && char_in_alphabet(*m_input_pos,detail::int_alphabet) ) {
@@ -341,6 +357,12 @@ namespace chaiscript
                 ++m_input_pos;
                 ++m_col;
               }
+
+              while (has_more_input() && char_in_alphabet(*m_input_pos, detail::float_suffix_alphabet))
+              {
+                ++m_input_pos;
+                ++m_col;
+              }
             }
             else {
               --m_input_pos;
@@ -352,7 +374,7 @@ namespace chaiscript
       }
 
       /**
-       * Reads a floating point value from input, without skipping initial whitespace
+       * Reads a hex value from input, without skipping initial whitespace
        */
       bool Hex_() {
         bool retval = false;
@@ -369,6 +391,11 @@ namespace chaiscript
                 ++m_input_pos;
                 ++m_col;
               }
+              while (has_more_input() && char_in_alphabet(*m_input_pos, detail::int_suffix_alphabet))
+              {
+                ++m_input_pos;
+                ++m_col;
+              }
             }
             else {
               --m_input_pos;
@@ -384,8 +411,16 @@ namespace chaiscript
         return retval;
       }
 
+      void IntSuffix_() {
+        while (has_more_input() && char_in_alphabet(*m_input_pos, detail::int_suffix_alphabet))
+        {
+          ++m_input_pos;
+          ++m_col;
+        }
+      }
+
       /**
-       * Reads a floating point value from input, without skipping initial whitespace
+       * Reads a binary value from input, without skipping initial whitespace
        */
       bool Binary_() {
         bool retval = false;
@@ -417,6 +452,173 @@ namespace chaiscript
         return retval;
       }
 
+      Boxed_Value buildFloat(const std::string &t_val)
+      {
+        bool float_ = false;
+        bool long_ = false;
+
+        size_t i = t_val.size();
+
+        for (; i > 0; --i)
+        {
+          char val = t_val[i-1];
+
+          if (val == 'f' || val == 'F')
+          {
+            float_ = true;
+          } else if (val == 'l' || val == 'L') {
+            long_ = true;
+          } else {
+            break;
+          }
+        }
+
+        std::stringstream ss(t_val.substr(0, i));
+
+        if (float_)
+        {
+          float f;
+          ss >> f;   
+          return Boxed_Value(const_var(f));
+        } else if (long_) {
+          long double f;
+          ss >> f;   
+          return Boxed_Value(const_var(f));
+        } else {
+          double f;
+          ss >> f;   
+          return Boxed_Value(const_var(f));
+        }
+      }
+
+
+
+      template<typename IntType>
+      Boxed_Value buildInt(const IntType &t_type, const std::string &t_val)
+      {
+        bool unsigned_ = false;
+        bool long_ = false;
+        bool longlong_ = false;
+
+        size_t i = t_val.size();
+
+        for (; i > 0; --i)
+        {
+          char val = t_val[i-1];
+
+          if (val == 'u' || val == 'U')
+          {
+            unsigned_ = true;
+          } else if (val == 'l' || val == 'L') {
+            if (long_)
+            {
+              longlong_ = true;
+            }
+
+            long_ = true;
+          } else {
+            break;
+          }
+        }
+
+        std::stringstream ss(t_val.substr(0, i));
+        ss >> t_type;
+
+        std::stringstream testu(t_val.substr(0, i));
+        boost::uint64_t u;
+        testu >> t_type >> u;
+
+        bool unsignedrequired = false;
+        size_t size = sizeof(int) * 8;
+
+        if ((u >> (sizeof(int) * 8)) > 0)
+        {
+          //requires something bigger than int
+          long_ = true;
+        }
+
+        BOOST_ASSERT(sizeof(long) == sizeof(boost::uint64_t) || sizeof(long) * 2 == sizeof(boost::uint64_t));
+
+#ifdef BOOST_MSVC
+		//Thank you MSVC, yes we know that a constant value is being used in the if
+		// statment in this compiler / architecture
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+        if ( sizeof(long) < sizeof(boost::uint64_t) && (u >> ((sizeof(boost::uint64_t) - sizeof(long)) * 8)) > 0)
+        {
+          //requires something bigger than long
+          longlong_ = true;
+        }
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+        if (longlong_)
+        {
+          size = sizeof(boost::int64_t) * 8;
+        } else if (long_) {
+          size = sizeof(long) * 8;
+        } 
+
+        if ( (u >> (size - 1)) > 0)
+        {
+          unsignedrequired = true;
+        }
+
+        if (unsignedrequired && !unsigned_)
+        {
+          if (t_type == &std::hex || t_type == &std::oct)
+          {
+            // with hex and octal we are happy to just make it unsigned
+            unsigned_ = true;
+          } else {
+            // with decimal we must bump it up to the next size
+            if (long_)
+            {
+              longlong_ = true;
+            } else if (!long_ && !longlong_) {
+              long_ = true;
+            }
+          }
+        }
+
+        if (unsigned_)
+        {
+          if (longlong_)
+          {
+            boost::uint64_t val;
+            ss >> val;   
+            return Boxed_Value(const_var(val));
+          } else if (long_) {
+            unsigned long val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          } else {
+            unsigned int val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          }
+        } else {
+          if (longlong_)
+          {
+            boost::int64_t val;
+            ss >> val;   
+            return Boxed_Value(const_var(val));
+          } else if (long_) {
+            long val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          } else {
+            int val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          }
+        }
+      }
+
       /**
        * Reads a number from the input, detecting if it's an integer or floating point
        */
@@ -433,19 +635,14 @@ namespace chaiscript
           if (has_more_input() && char_in_alphabet(*m_input_pos, detail::float_alphabet) ) {
             if (Hex_()) {
               std::string match(start, m_input_pos);
-              std::stringstream ss(match);
-              unsigned int temp_int;
-              ss >> std::hex >> temp_int;
-
-              std::ostringstream out_int;
-              out_int << static_cast<int>(temp_int);
-              AST_NodePtr t(new eval::Int_AST_Node(out_int.str(), AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+              Boxed_Value i = buildInt(std::hex, match);
+              AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
             if (Binary_()) {
               std::string match(start, m_input_pos);
-              int temp_int = 0;
+			  boost::int64_t temp_int = 0;
               size_t pos = 0, end = match.length();
 
               while ((pos < end) && (pos < (2 + sizeof(int) * 8))) {
@@ -456,32 +653,36 @@ namespace chaiscript
                 ++pos;
               }
 
-              std::ostringstream out_int;
-              out_int << temp_int;
-              AST_NodePtr t(new eval::Int_AST_Node(out_int.str(), AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+              Boxed_Value i;
+              if (match.length() <= sizeof(int) * 8)
+              {
+                i = Boxed_Value(const_var(int(temp_int)));
+              } else {
+                i = Boxed_Value(const_var(temp_int));
+              }
+
+              AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
             if (Float_()) {
               std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Float_AST_Node(match, AST_Node_Type::Float, m_filename, prev_line, prev_col, m_line, m_col));
+              Boxed_Value f = buildFloat(match);
+              AST_NodePtr t(new eval::Float_AST_Node(match, f, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
             else {
+              IntSuffix_();
               std::string match(start, m_input_pos);
               if ((match.size() > 0) && (match[0] == '0')) {
-                std::stringstream ss(match);
-                unsigned int temp_int;
-                ss >> std::oct >> temp_int;
-
-                std::ostringstream out_int;
-                out_int << int(temp_int);
-                AST_NodePtr t(new eval::Int_AST_Node(out_int.str(), AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+                Boxed_Value i = buildInt(std::oct, match);
+                AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
                 m_match_stack.push_back(t);
               }
               else {
-                AST_NodePtr t(new eval::Int_AST_Node(match, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+                Boxed_Value i = buildInt(std::dec, match);
+                AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
                 m_match_stack.push_back(t);
               }
               return true;
@@ -551,13 +752,13 @@ namespace chaiscript
             if (*start == '`') {
               //Id Literal
               std::string match(start+1, m_input_pos-1);
-              AST_NodePtr t(new eval::Id_AST_Node(match, AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Id_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
             else {
               std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Id_AST_Node(match, AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Id_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -590,7 +791,7 @@ namespace chaiscript
           } while (Symbol("#"));
 
           std::string match(start, m_input_pos);
-          AST_NodePtr t(new eval::Annotation_AST_Node(match, AST_Node_Type::Annotation, m_filename, prev_line, prev_col, m_line, m_col));
+          AST_NodePtr t(new eval::Annotation_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
           m_match_stack.push_back(t);
           return true;
         }
@@ -604,10 +805,9 @@ namespace chaiscript
        */
       bool Quoted_String_() {
         bool retval = false;
-        char prev_char = 0;
         if (has_more_input() && (*m_input_pos == '\"')) {
           retval = true;
-          prev_char = *m_input_pos;
+          char prev_char = *m_input_pos;
           ++m_input_pos;
           ++m_col;
 
@@ -655,7 +855,6 @@ namespace chaiscript
             bool saw_interpolation_marker = false;
             size_t prev_stack_top = m_match_stack.size();
 
-            //for (std::string::iterator s = start + 1, end = m_input_pos - 1; s != end; ++s) {
             std::string::const_iterator s = start + 1, end = m_input_pos - 1;
 
             while (s != end) {
@@ -665,25 +864,20 @@ namespace chaiscript
 
                   if (is_interpolated) {
                     //If we've seen previous interpolation, add on instead of making a new one
-                    AST_NodePtr plus(new eval::Str_AST_Node("+", AST_Node_Type::Str, m_filename, prev_line, prev_col, m_line, m_col));
-                    m_match_stack.push_back(plus);
 
-                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(t);
 
-                    build_match(AST_NodePtr(new eval::Additive_AST_Node()), prev_stack_top);
+                    build_match(AST_NodePtr(new eval::Addition_AST_Node()), prev_stack_top);
                   }
                   else {
-                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(t);
                   }
 
                   //We've finished with the part of the string up to this point, so clear it
                   match = "";
 
-                  AST_NodePtr plus(new eval::Str_AST_Node("+", AST_Node_Type::Str, m_filename, prev_line, prev_col, m_line, m_col));
-                  m_match_stack.push_back(plus);
-
                   std::string eval_match;
 
                   ++s;
@@ -697,17 +891,17 @@ namespace chaiscript
 
                     size_t tostr_stack_top = m_match_stack.size();
 
-                    AST_NodePtr tostr(new eval::Id_AST_Node("to_string", AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr tostr(new eval::Id_AST_Node("to_string", m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(tostr);
 
                     size_t ev_stack_top = m_match_stack.size();
 
-                    AST_NodePtr ev(new eval::Id_AST_Node("eval", AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr ev(new eval::Id_AST_Node("eval", m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(ev);
 
                     size_t arg_stack_top = m_match_stack.size();
 
-                    AST_NodePtr t(new eval::Quoted_String_AST_Node(eval_match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr t(new eval::Quoted_String_AST_Node(eval_match, m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(t);
 
                     build_match(AST_NodePtr(new eval::Arg_List_AST_Node()), arg_stack_top);
@@ -718,7 +912,7 @@ namespace chaiscript
 
                     build_match(AST_NodePtr(new eval::Fun_Call_AST_Node()), tostr_stack_top);
 
-                    build_match(AST_NodePtr(new eval::Additive_AST_Node()), prev_stack_top);
+                    build_match(AST_NodePtr(new eval::Addition_AST_Node()), prev_stack_top);
                   }
                   else {
                     throw exception::eval_error("Unclosed in-string eval", File_Position(prev_line, prev_col), *m_filename);
@@ -765,16 +959,13 @@ namespace chaiscript
               }
             }
             if (is_interpolated) {
-              AST_NodePtr plus(new eval::Str_AST_Node("+", AST_Node_Type::Str, m_filename, prev_line, prev_col, m_line, m_col));
-              m_match_stack.push_back(plus);
-
-              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
 
-              build_match(AST_NodePtr(new eval::Additive_AST_Node()), prev_stack_top);
+              build_match(AST_NodePtr(new eval::Addition_AST_Node()), prev_stack_top);
             }
             else {
-              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
             }
             return true;
@@ -790,10 +981,9 @@ namespace chaiscript
          */
         bool Single_Quoted_String_() {
           bool retval = false;
-          char prev_char = 0;
           if (has_more_input() && (*m_input_pos == '\'')) {
             retval = true;
-            prev_char = *m_input_pos;
+            char prev_char = *m_input_pos;
             ++m_input_pos;
             ++m_col;
 
@@ -866,7 +1056,7 @@ namespace chaiscript
                   is_escaped = false;
                 }
               }
-              AST_NodePtr t(new eval::Single_Quoted_String_AST_Node(match, AST_Node_Type::Single_Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Single_Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -905,7 +1095,7 @@ namespace chaiscript
             int prev_line = m_line;
             if (Char_(t_c)) {
               std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Char_AST_Node(match, AST_Node_Type::Char, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Char_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -957,7 +1147,7 @@ namespace chaiscript
 
           if ( t_capture && retval ) {
             std::string match(start, m_input_pos);
-            AST_NodePtr t(new eval::Str_AST_Node(match, AST_Node_Type::Str, m_filename, prev_line, prev_col, m_line, m_col));
+            AST_NodePtr t(new eval::Str_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
             m_match_stack.push_back(t);
           }
           return retval;
@@ -1005,7 +1195,7 @@ namespace chaiscript
 
           if ( t_capture && retval ) {
             std::string match(start, m_input_pos);
-            AST_NodePtr t(new eval::Str_AST_Node(match, AST_Node_Type::Str, m_filename, prev_line, prev_col, m_line, m_col));
+            AST_NodePtr t(new eval::Str_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
             m_match_stack.push_back(t);
           }
 
@@ -1045,7 +1235,7 @@ namespace chaiscript
             int prev_line = m_line;
             if (Eol_()) {
               std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Eol_AST_Node(match, AST_Node_Type::Eol, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Eol_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -1159,7 +1349,6 @@ namespace chaiscript
         bool Def() {
           bool retval = false;
           bool is_annotated = false;
-          bool is_method = false;
           AST_NodePtr annotation;
 
           if (Annotation()) {
@@ -1178,6 +1367,8 @@ namespace chaiscript
               throw exception::eval_error("Missing function name in definition", File_Position(m_line, m_col), *m_filename);
             }
 
+            bool is_method = false;
+
             if (Symbol("::", false)) {
               //We're now a method
               is_method = true;
@@ -1315,7 +1506,7 @@ namespace chaiscript
               if (Keyword("else", true)) {
                 if (Keyword("if")) {
                   AST_NodePtr back(m_match_stack.back());
-                  m_match_stack.back() = AST_NodePtr(new eval::If_AST_Node("else if", back->identifier)); 
+                  m_match_stack.back() = AST_NodePtr(new eval::If_AST_Node("else if"));
                   m_match_stack.back()->start = back->start;
                   m_match_stack.back()->end = back->end;
                   m_match_stack.back()->children = back->children;
@@ -1383,18 +1574,40 @@ namespace chaiscript
           return retval;
         }
 
+
         /**
          * Reads the C-style for conditions from input
          */
         bool For_Guards() {
-          Equation();
+          if (!(Equation() && Eol()))
+          {
+            if (!Eol())
+            {
+              throw exception::eval_error("'for' loop initial statment missing", File_Position(m_line, m_col), *m_filename);          
+            } else {
+              AST_NodePtr t(new eval::Noop_AST_Node());
+              m_match_stack.push_back(t);
+            }
+          }
 
-          if (Char(';') && Operator() && Char(';') && Equation()) {
-            return true;
+          if (!(Equation() && Eol()))
+          {
+            if (!Eol())
+            {
+              throw exception::eval_error("'for' loop condition missing", File_Position(m_line, m_col), *m_filename);          
+            } else {
+              AST_NodePtr t(new eval::Noop_AST_Node());
+              m_match_stack.push_back(t);
+            }
           }
-          else {
-            throw exception::eval_error("Incomplete conditions in 'for' loop", File_Position(m_line, m_col), *m_filename);
+
+          if (!Equation())
+          {
+            AST_NodePtr t(new eval::Noop_AST_Node());
+            m_match_stack.push_back(t);
           }
+
+          return true; 
         }
 
         /**
@@ -1428,6 +1641,90 @@ namespace chaiscript
           return retval;
         }
 
+        /**
+         * Reads a case block from input
+         */
+        bool Case() {
+          bool retval = false;
+
+          size_t prev_stack_top = m_match_stack.size();
+
+          if (Keyword("case")) {
+            retval = true;
+            
+            if (!Char('(')) {
+              throw exception::eval_error("Incomplete 'case' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            if (!(Operator() && Char(')'))) {
+              throw exception::eval_error("Incomplete 'case' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            while (Eol()) {}
+
+            if (!Block()) {
+              throw exception::eval_error("Incomplete 'case' block", File_Position(m_line, m_col), *m_filename);
+            }
+            
+            build_match(AST_NodePtr(new eval::Case_AST_Node()), prev_stack_top);
+          }
+          else if (Keyword("default")) {
+            while (Eol()) {}
+
+            if (!Block()) {
+              throw exception::eval_error("Incomplete 'default' block", File_Position(m_line, m_col), *m_filename);
+            }
+            
+            build_match(AST_NodePtr(new eval::Default_AST_Node()), prev_stack_top);
+          }            
+          
+          return retval;
+        }
+      
+        /**
+         * Reads a switch statement from input
+         */
+        bool Switch() {
+          size_t prev_stack_top = m_match_stack.size();
+
+          if (Keyword("switch")) {
+
+            if (!Char('(')) {
+              throw exception::eval_error("Incomplete 'switch' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            if (!(Operator() && Char(')'))) {
+              throw exception::eval_error("Incomplete 'switch' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            while (Eol()) {}
+
+            if (Char('{')) {
+              while (Eol()) {}
+              
+              while (Case()) {
+                while (Eol()) { } // eat
+              }
+
+              while (Eol()) { } // eat
+
+              if (!Char('}')) {
+                throw exception::eval_error("Incomplete block", File_Position(m_line, m_col), *m_filename);
+              }
+            }
+            else {
+              throw exception::eval_error("Incomplete block", File_Position(m_line, m_col), *m_filename);
+            }
+            
+            build_match(AST_NodePtr(new eval::Switch_AST_Node()), prev_stack_top);
+            return true;
+
+          } else {
+            return false;
+          }
+
+        }
+      
         /**
          * Reads a curly-brace C-style block from input
          */
@@ -1486,14 +1783,31 @@ namespace chaiscript
         }
 
         /**
-         * Reads an identifier, then proceeds to check if it's a function or array call
+         * Reads a continue statement from input
          */
-        bool Id_Fun_Array() {
+        bool Continue() {
           bool retval = false;
-          std::string::const_iterator prev_pos = m_input_pos;
 
           size_t prev_stack_top = m_match_stack.size();
-          if (Id(true)) {
+
+          if (Keyword("continue")) {
+            retval = true;
+
+            build_match(AST_NodePtr(new eval::Continue_AST_Node()), prev_stack_top);
+          }
+
+          return retval;
+        }
+
+        /**
+         * Reads a dot expression(member access), then proceeds to check if it's a function or array call
+         */
+        bool Dot_Fun_Array() {
+          bool retval = false;
+
+          size_t prev_stack_top = m_match_stack.size();
+          if (Lambda() || Num(true) || Quoted_String(true) || Single_Quoted_String(true) ||
+              Paren_Expression() || Inline_Container() || Id(true)) {
             retval = true;
             bool has_more = true;
 
@@ -1509,6 +1823,19 @@ namespace chaiscript
                 }
 
                 build_match(AST_NodePtr(new eval::Fun_Call_AST_Node()), prev_stack_top);
+                /// \todo Work around for method calls until we have a better solution
+                if (!m_match_stack.back()->children.empty()) {
+                  if (m_match_stack.back()->children[0]->identifier == AST_Node_Type::Dot_Access) {
+                    AST_NodePtr dot_access = m_match_stack.back()->children[0];
+                    AST_NodePtr func_call = m_match_stack.back();
+                    m_match_stack.pop_back();
+                    func_call->children.erase(func_call->children.begin());
+                    func_call->children.insert(func_call->children.begin(), dot_access->children.back());
+                    dot_access->children.pop_back();
+                    dot_access->children.push_back(func_call);
+                    m_match_stack.push_back(dot_access);
+                  }
+                }
               }
               else if (Char('[')) {
                 has_more = true;
@@ -1519,6 +1846,14 @@ namespace chaiscript
 
                 build_match(AST_NodePtr(new eval::Array_Call_AST_Node()), prev_stack_top);
               }
+              else if (Symbol(".", true)) {
+                has_more = true;
+                if (!(Id(true))) {
+                  throw exception::eval_error("Incomplete array access", File_Position(m_line, m_col), *m_filename);
+                }
+
+                build_match(AST_NodePtr(new eval::Dot_Access_AST_Node()), prev_stack_top);
+              }
             }
           }
 
@@ -1574,7 +1909,7 @@ namespace chaiscript
               throw exception::eval_error("Incomplete expression", File_Position(m_line, m_col), *m_filename);
             }
             if (!Char(')')) {
-              throw exception::eval_error("Missing closing parenthesis", File_Position(m_line, m_col), *m_filename);
+              throw exception::eval_error("Missing closing parenthesis ')'", File_Position(m_line, m_col), *m_filename);
             }
           }
           return retval;
@@ -1592,7 +1927,7 @@ namespace chaiscript
             retval = true;
             Container_Arg_List();
             if (!Char(']')) {
-              throw exception::eval_error("Missing closing square bracket", File_Position(m_line, m_col), *m_filename);
+              throw exception::eval_error("Missing closing square bracket ']' in container initializer", File_Position(m_line, m_col), *m_filename);
             }
             if ((prev_stack_top != m_match_stack.size()) && (m_match_stack.back()->children.size() > 0)) {
               if (m_match_stack.back()->children[0]->identifier == AST_Node_Type::Value_Range) {
@@ -1683,8 +2018,7 @@ namespace chaiscript
          * Parses any of a group of 'value' style ast_node groups from input
          */
         bool Value() {
-          if (Var_Decl() || Lambda() || Id_Fun_Array() || Num(true) || Prefix() || Quoted_String(true) || Single_Quoted_String(true) ||
-              Paren_Expression() || Inline_Container()) {
+          if (Var_Decl() || Dot_Fun_Array() || Prefix()) {
             return true;
           }
           else {
@@ -1703,7 +2037,7 @@ namespace chaiscript
 
         bool Operator(size_t t_precedence = 0) {
           bool retval = false;
-
+          AST_NodePtr oper;
           size_t prev_stack_top = m_match_stack.size();
 
           if (t_precedence < m_operators.size()) {
@@ -1711,50 +2045,84 @@ namespace chaiscript
               retval = true;
               if (Operator_Helper(t_precedence)) {
                 do {
+                  while (Eol()) {}
                   if (!Operator(t_precedence+1)) {
                     throw exception::eval_error("Incomplete "
                         + std::string(ast_node_type_to_string(m_operators[t_precedence])) + " expression",
                         File_Position(m_line, m_col), *m_filename);
                   }
-                } while (Operator_Helper(t_precedence));
 
-                switch (m_operators[t_precedence]) {
-                  case(AST_Node_Type::Comparison) :
-                    build_match(AST_NodePtr(new eval::Comparison_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Dot_Access) :
-                    build_match(AST_NodePtr(new eval::Dot_Access_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Additive) :
-                    build_match(AST_NodePtr(new eval::Additive_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Multiplicative) :
-                    build_match(AST_NodePtr(new eval::Multiplicative_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Shift) :
-                    build_match(AST_NodePtr(new eval::Shift_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Equality) :
-                    build_match(AST_NodePtr(new eval::Equality_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Bitwise_And) :
-                    build_match(AST_NodePtr(new eval::Bitwise_And_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Bitwise_Xor) :
-                    build_match(AST_NodePtr(new eval::Bitwise_Xor_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Bitwise_Or) :
-                    build_match(AST_NodePtr(new eval::Bitwise_Or_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Logical_And) :
-                    build_match(AST_NodePtr(new eval::Logical_And_AST_Node()), prev_stack_top);
-                    break;
-                  case(AST_Node_Type::Logical_Or) :
-                    build_match(AST_NodePtr(new eval::Logical_Or_AST_Node()), prev_stack_top);
-                    break;
-                  default:
-                    throw exception::eval_error("Internal error: unhandled ast_node", File_Position(m_line, m_col), *m_filename);
-                }
+                  switch (m_operators[t_precedence]) {
+                    case(AST_Node_Type::Comparison) :
+                      build_match(AST_NodePtr(new eval::Comparison_AST_Node()), prev_stack_top);
+                      break;
+                    case(AST_Node_Type::Ternary_Cond) :
+                      m_match_stack.erase(m_match_stack.begin() + m_match_stack.size() - 2,
+                          m_match_stack.begin() + m_match_stack.size() - 1);
+                      if (Symbol(":")) {
+                        if (!Operator(t_precedence+1)) {
+                          throw exception::eval_error("Incomplete "
+                              + std::string(ast_node_type_to_string(m_operators[t_precedence])) + " expression",
+                              File_Position(m_line, m_col), *m_filename);
+                        }
+                        build_match(AST_NodePtr(new eval::Ternary_Cond_AST_Node()), prev_stack_top);
+                      }
+                      else {
+                        throw exception::eval_error("Incomplete "
+                            + std::string(ast_node_type_to_string(m_operators[t_precedence])) + " expression",
+                            File_Position(m_line, m_col), *m_filename);
+                      }
+                      break;
+                    case(AST_Node_Type::Addition) :
+                      oper = m_match_stack.at(m_match_stack.size()-2);
+                      m_match_stack.erase(m_match_stack.begin() + m_match_stack.size() - 2,
+                          m_match_stack.begin() + m_match_stack.size() - 1);
+                      if (oper->text == "+") {
+                        build_match(AST_NodePtr(new eval::Addition_AST_Node()), prev_stack_top);
+                      }
+                      else if (oper->text == "-") {
+                        build_match(AST_NodePtr(new eval::Subtraction_AST_Node()), prev_stack_top);
+                      }
+                      break;
+                    case(AST_Node_Type::Multiplication) :
+                      oper = m_match_stack.at(m_match_stack.size()-2);
+                      m_match_stack.erase(m_match_stack.begin() + m_match_stack.size() - 2,
+                          m_match_stack.begin() + m_match_stack.size() - 1);
+                      if (oper->text == "*") {
+                        build_match(AST_NodePtr(new eval::Multiplication_AST_Node()), prev_stack_top);
+                      }
+                      else if (oper->text == "/") {
+                        build_match(AST_NodePtr(new eval::Division_AST_Node()), prev_stack_top);
+                      }
+                      else if (oper->text == "%") {
+                        build_match(AST_NodePtr(new eval::Modulus_AST_Node()), prev_stack_top);
+                      }
+                      break;
+                    case(AST_Node_Type::Shift) :
+                      build_match(AST_NodePtr(new eval::Shift_AST_Node()), prev_stack_top);
+                      break;
+                    case(AST_Node_Type::Equality) :
+                      build_match(AST_NodePtr(new eval::Equality_AST_Node()), prev_stack_top);
+                      break;
+                    case(AST_Node_Type::Bitwise_And) :
+                      build_match(AST_NodePtr(new eval::Bitwise_And_AST_Node()), prev_stack_top);
+                      break;
+                    case(AST_Node_Type::Bitwise_Xor) :
+                      build_match(AST_NodePtr(new eval::Bitwise_Xor_AST_Node()), prev_stack_top);
+                      break;
+                    case(AST_Node_Type::Bitwise_Or) :
+                      build_match(AST_NodePtr(new eval::Bitwise_Or_AST_Node()), prev_stack_top);
+                      break;
+                    case(AST_Node_Type::Logical_And) :
+                      build_match(AST_NodePtr(new eval::Logical_And_AST_Node()), prev_stack_top);
+                      break;
+                    case(AST_Node_Type::Logical_Or) :
+                      build_match(AST_NodePtr(new eval::Logical_Or_AST_Node()), prev_stack_top);
+                      break;
+                    default:
+                      throw exception::eval_error("Internal error: unhandled ast_node", File_Position(m_line, m_col), *m_filename);
+                  }
+                } while (Operator_Helper(t_precedence));
               }
             }
           }
@@ -1862,7 +2230,6 @@ namespace chaiscript
           bool saw_eol = true;
 
           while (has_more) {
-            has_more = false;
             int prev_line = m_line;
             int prev_col = m_col;
             if (Def()) {
@@ -1905,6 +2272,14 @@ namespace chaiscript
               retval = true;
               saw_eol = true;
             }
+            else if (Switch()) {
+              if (!saw_eol) {
+                throw exception::eval_error("Two function definitions missing line separator", File_Position(prev_line, prev_col), *m_filename);
+              }
+              has_more = true;
+              retval = true;
+              saw_eol = true;
+            }
             else if (Return()) {
               if (!saw_eol) {
                 throw exception::eval_error("Two expressions missing line separator", File_Position(prev_line, prev_col), *m_filename);
@@ -1921,6 +2296,14 @@ namespace chaiscript
               retval = true;
               saw_eol = false;
             }
+            else if (Continue()) {
+              if (!saw_eol) {
+                throw exception::eval_error("Two expressions missing line separator", File_Position(prev_line, prev_col), *m_filename);
+              }
+              has_more = true;
+              retval = true;
+              saw_eol = false;
+            }
             else if (Equation()) {
               if (!saw_eol) {
                 throw exception::eval_error("Two expressions missing line separator", File_Position(prev_line, prev_col), *m_filename);
@@ -1961,7 +2344,7 @@ namespace chaiscript
             while ((m_input_pos != m_input_end) && (!Eol())) {
               ++m_input_pos;
             }
-            // TODO: respect // -*- coding: utf-8 -*- on line 1 or 2 see: http://evanjones.ca/python-utf8.html)
+            /// \todo respect // -*- coding: utf-8 -*- on line 1 or 2 see: http://evanjones.ca/python-utf8.html)
           }
 
           if (Statements()) {

include/chaiscript/language/chaiscript_prelude.hpp

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

include/chaiscript/utility/utility.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_UTILITY_UTILITY_HPP_
@@ -49,10 +49,20 @@
     CHAISCRIPT_CLASS_METHODS((_module)(_class_name)(_class_name_translator)(_method_name_translator), _methods) \
   }
 
+#define CHAISCRIPT_CLASS_NO_CONSTRUCTOR_EX(_module, _class_name, _class_name_translator, _method_name_translator, _methods) \
+  { \
+    _module->add(chaiscript::user_type<_class_name>(), _class_name_translator (BOOST_PP_STRINGIZE(_class_name))); \
+    CHAISCRIPT_CLASS_METHODS((_module)(_class_name)(_class_name_translator)(_method_name_translator), _methods) \
+  }
+
 #define CHAISCRIPT_CLASS(_module, _class_name, _constructors, _methods) \
   CHAISCRIPT_CLASS_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
       chaiscript::utility::method_name_translator, _constructors, _methods)
 
+#define CHAISCRIPT_CLASS_NO_CONSTRUCTOR(_module, _class_name, _methods) \
+  CHAISCRIPT_CLASS_NO_CONSTRUCTOR_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
+      chaiscript::utility::method_name_translator, _methods)
+
 namespace chaiscript 
 {
   /// \brief Classes and functions which provide general utility to the end user.

license.txt

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

readme.md

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

readme.txt

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

releasenotes.txt

@@ -1,5 +1,71 @@
-Changes since 2.3.3
+Current Version: 4.3.1
 
+Note: this is scheduled to be the last release that requires boost, new releases after this will require a C++11 compiler.
+
+### Changes since 4.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
+
+### Changes since 4.2.0
+* Enhanced unit tests
+* Add `continue` statement, fix various use cases for `for`  loops
+* Fix use of suffixed numbers in vector initialization
+* Code cleanups
+* Eliminate global data, which makes code more portable and thread safe
+* Fix issue #79
+* Merge pretty_print fixes from @mgee #82
+* Compiler warning fixes for latest compiler releases
+* Fix threading problems
+* Fix linking error on MacOS Mavericks #88
+* Allow non-const globals
+* Make sure user cannot name a variable with `::` in it #91
+* Fix various string / map / vector `size` and `count` calls for compilers which have weird overloads for them. #90 #93 #95
+* Make module search path relative to the currently running executable
+* Build and work with wstring windows builds
+
+### Changes since 4.1.1
+* Add support for automatic conversion of arithmetic types when possible
+  and when no ambiguous method dispatch exists.
+
+### Changes since 4.1.0
+* Fix missed gcc build error in 4.1.0
+
+Changes since 4.0.0
+* Fix sizing of numeric constants to match that of the C++ standard
+* Add support for u,ll,l,f suffixes for numeric constants
+* Siginificant improvement in error reporting
+
+Changes since 3.1.0
+* svenstaro: Unused variables and CMake consistency fixes
+* Added support for returning pointers from functions (#13)
+* Compile with -pedantic (#9)
+* Fix issues with multiple ChaiScript object types having the same attribute name (#15)
+* Prevent variable redeclaration in same scope (#22)
+* mgee: Boxed_Number improvements (#27)
+* Support switch statements (#34)
+* Fix uint16 comparions (#26)
+* Add ability to add const_var globals in Module objects (#14)
+* Add support for ternary operators ?:
+* Add headers to CMakeLists so they show up in IDEs
+* Add ability to get vector of defined objects and vector of defined functions
+* Fix memory leak in cyclical references
+* Clean up static analysis issues discovered
+* Fix vector construction to be consistent with map construction
+* Increased unit tests to 161
+* Performance enhancements
+
+### Changes since 3.0.0
+* Numeric operations performance increased approximately 10x
+* Looping operations performance increased up to 2x
+* Engine start up time decreased
+* Several parsing bugs related to index operators fixed
+* Added full support for all C algebraic types: double, long double, float, int, long, char,
+  uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t
+* Enhanced support for capturing of exceptions thrown from ChaiScript in C++
+
+### Changes since 2.3.3
 * Code simplifications
 * Fully integrate documentation with source code in doxygen style comments
 * Unit tests increased from 114 to 137

samples/example.cpp

@@ -9,7 +9,18 @@
 #include <chaiscript/chaiscript.hpp>
 #include <chaiscript/dispatchkit/function_call.hpp>
 #include <boost/function.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
 #include <boost/date_time/posix_time/posix_time.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #include <boost/regex.hpp>
 
 void log(const std::string &msg)
@@ -43,9 +54,9 @@ struct System
   std::map<std::string, boost::function<std::string (const std::string &) > > m_callbacks;
 
   void add_callback(const std::string &t_name, 
-      const chaiscript::Proxy_Function &t_func)
+      const boost::function<std::string (const std::string &)> &t_func)
   {
-    m_callbacks[t_name] = chaiscript::dispatch::functor<std::string (const std::string &)>(t_func);
+    m_callbacks[t_name] = t_func;
   }
 
 
@@ -141,7 +152,9 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //Creating a functor on the stack and using it immediatly 
   int x = chai.eval<boost::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
 
-  log("Functor test output", boost::lexical_cast<std::string>(x));
+  std::stringstream ss;
+  ss << x;
+  log("Functor test output", ss.str());
 
   chai.add(var(boost::shared_ptr<int>()), "nullvar");
   chai("print(\"This should be true.\"); print(nullvar.is_var_null())");
@@ -165,7 +178,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //Dynamic objects test
   chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Function("TestType", fun(&hello_world))), "hello_world");
   chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Constructor("TestType", fun(&hello_constructor))), "TestType");
-  chai.add(fun(boost::function<Boxed_Value (dispatch::Dynamic_Object &)>(boost::bind(&dispatch::detail::Dynamic_Object_Attribute::func, "TestType", "attr", _1))), "attr");
+//  chai.add(fun(boost::function<Boxed_Value (dispatch::Dynamic_Object &)>(boost::bind(&dispatch::detail::Dynamic_Object_Attribute::func, "TestType", "attr", _1))), "attr");
 
   chai.eval("var x = TestType()");
 //  chai.eval("x.attr = \"hi\"");

samples/range.chai

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

src/main.cpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <iostream>
@@ -30,6 +30,86 @@ void add_history(const char*){}
 void using_history(){}
 #endif
 
+
+void *cast_module_symbol(std::string (*t_path)())
+{
+  union cast_union
+  {
+    std::string (*in_ptr)();
+    void *out_ptr;
+  };
+
+  cast_union c;
+  c.in_ptr = t_path;
+  return c.out_ptr;
+}
+
+std::string default_search_path()
+{
+#ifdef BOOST_WINDOWS  // force no unicode
+  CHAR path[4096];
+  int size = GetModuleFileNameA(0, path, sizeof(path)-1);
+
+  std::string exepath(path, size);
+
+  size_t secondtolastslash = exepath.rfind('\\', exepath.rfind('\\') - 1);
+  if (secondtolastslash != std::string::npos)
+  {
+    return exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\";
+  } else {
+    return "";
+  }
+
+#else
+
+  std::string exepath;
+
+  std::vector<char> buf(2048);
+  ssize_t size = -1;
+
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  {
+    exepath = std::string(&buf.front(), size);
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    Dl_info rInfo; 
+    memset( &rInfo, 0, sizeof(rInfo) ); 
+    if ( !dladdr(cast_module_symbol(&default_search_path), &rInfo)  || !rInfo.dli_fname ) { 
+      return "";
+    }
+
+    exepath = std::string(rInfo.dli_fname);
+  }
+
+  size_t secondtolastslash = exepath.rfind('/', exepath.rfind('/') - 1);
+  if (secondtolastslash != std::string::npos)
+  {
+    return exepath.substr(0, secondtolastslash) + "/lib/chaiscript/";
+  } else {
+    return "";
+  }
+#endif
+}
+
+
 void help(int n) {
   if ( n >= 0 ) {
     std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>." << std::endl;
@@ -80,7 +160,18 @@ std::string get_next_command() {
     char *input_raw = readline("eval> ");
     if ( input_raw ) {
       add_history(input_raw);
-      retval = boost::trim_copy_if(std::string(input_raw),boost::is_any_of(" \t"));
+      std::string val(input_raw);     
+      size_t pos = val.find_first_not_of("\t \n");    
+      if (pos != std::string::npos)   
+      {      
+        val.erase(0, pos);  
+      }    
+      pos = val.find_last_not_of("\t \n");   
+      if (pos != std::string::npos)   
+      {      
+        val.erase(pos+1, std::string::npos);    
+      }   
+      retval = val;
       ::free(input_raw);
     }
   }
@@ -156,6 +247,8 @@ int main(int argc, char *argv[])
     usepaths.push_back(usepath);
   }
 
+  std::string searchpath = default_search_path();
+  modulepaths.push_back(searchpath);
   modulepaths.push_back("");
   if (modulepath)
   {
@@ -215,21 +308,11 @@ int main(int argc, char *argv[])
         case eInteractive : interactive(chai); break;
         case eCommand     : val = chai.eval(arg); break;
         case eFile        : val = chai.eval_file(arg); break;
+        default           : std::cout << "Unrecognized execution mode" << std::endl; return EXIT_FAILURE;
       }
     }
     catch (const chaiscript::exception::eval_error &ee) {
-      std::cout << ee.what();
-      if (ee.call_stack.size() > 0) {
-        std::cout << "during evaluation at (" << *(ee.call_stack[0]->filename) << " " << ee.call_stack[0]->start.line << ", " << ee.call_stack[0]->start.column << ")";
-        for (size_t j = 1; j < ee.call_stack.size(); ++j) {
-          if (ee.call_stack[j]->identifier != chaiscript::AST_Node_Type::Block
-              && ee.call_stack[j]->identifier != chaiscript::AST_Node_Type::File)
-          {
-            std::cout << std::endl;
-            std::cout << "  from " << *(ee.call_stack[j]->filename) << " (" << ee.call_stack[j]->start.line << ", " << ee.call_stack[j]->start.column << ")";
-          }
-        }
-      }
+      std::cout << ee.pretty_print();
       std::cout << std::endl;
       return EXIT_FAILURE;
     }

src/multithreaded.cpp

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

src/reflection.cpp

@@ -1,3 +1,9 @@
+// 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/utility/utility.hpp>
@@ -18,7 +24,12 @@ bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
     = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
   if (pf)
   {
-    return pf->get_parse_tree();
+    if (pf->get_parse_tree())
+    {
+      return true;
+    } else {
+      return false;
+    }
   } else {
     return false;
   }
@@ -42,6 +53,12 @@ chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t
 }
 
 
+#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());
@@ -49,12 +66,12 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
   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<boost::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
 
-  CHAISCRIPT_CLASS( m,
+  CHAISCRIPT_CLASS_NO_CONSTRUCTOR( m,
       chaiscript::exception::eval_error,
-      ,
       ((reason))
       ((call_stack))
     );
@@ -67,9 +84,8 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
       ((column))
     );
 
-  CHAISCRIPT_CLASS( m, 
+  CHAISCRIPT_CLASS_NO_CONSTRUCTOR( m, 
       chaiscript::AST_Node,
-      ,
       ((text))
       ((identifier))
       ((filename))
@@ -91,6 +107,11 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
   return m;
 }
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+
 
 #ifdef BOOST_MSVC
 #pragma warning(pop)

src/stl_extra.cpp

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

src/test_module.cpp

@@ -5,25 +5,70 @@
 class TestBaseType
 {
   public:
-    TestBaseType() {}
-    TestBaseType(int) {}
+    TestBaseType() : val(10), const_val(15) { }
+    TestBaseType(int) : val(10), const_val(15) {}
+    TestBaseType(int *) : val(10), const_val(15) {}
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
 
+    int base_only_func() { return -9; }
+
+    const TestBaseType &constMe() const { return *this; }
+
+    int val;
+    const int const_val;
+
+  private:
+    TestBaseType &operator=(const TestBaseType &);
 };
 
+enum TestEnum
+{
+  TestValue1 = 1
+};
+
+int to_int(TestEnum t)
+{
+  return t;
+}
+
 class TestDerivedType : public TestBaseType
 {
   public:
     virtual ~TestDerivedType() {}
     virtual int func() { return 1; }
+    int derived_only_func() { return 19; }
+
+  private:
+    TestDerivedType &operator=(const TestDerivedType &);
 };
 
+class TestMoreDerivedType : public TestDerivedType
+{
+  public:
+    virtual ~TestMoreDerivedType() {}
+};
+
+boost::shared_ptr<TestBaseType> derived_type_factory()
+{
+  return boost::shared_ptr<TestBaseType>(new TestDerivedType());
+}
+
+boost::shared_ptr<TestBaseType> more_derived_type_factory()
+{
+  return boost::shared_ptr<TestBaseType>(new TestMoreDerivedType());
+}
+
 std::string hello_world()
 {
   return "Hello World";
 }
 
+int *get_new_int()
+{
+  return new int(1);
+}
+
 // MSVC doesn't like that we are using C++ return types from our C declared module
 // but this is the best way to do it for cross platform compatibility
 #ifdef BOOST_MSVC
@@ -31,6 +76,10 @@ std::string hello_world()
 #pragma warning(disable : 4190)
 #endif
 
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
 
 CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_module()
 {
@@ -40,22 +89,55 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
 
   m->add(chaiscript::user_type<TestBaseType>(), "TestBaseType");
   m->add(chaiscript::user_type<TestDerivedType>(), "TestDerivedType");
+  m->add(chaiscript::user_type<TestMoreDerivedType>(), "TestMoreDerivedType");
 
   m->add(chaiscript::constructor<TestBaseType ()>(), "TestBaseType");
 //  m->add(chaiscript::constructor<TestBaseType (int)>(), "TestBaseType");
   m->add(chaiscript::constructor<TestBaseType (const TestBaseType &)>(), "TestBaseType");
+  m->add(chaiscript::constructor<TestBaseType (int *)>(), "TestBaseType");
 
   m->add(chaiscript::constructor<TestDerivedType ()>(), "TestDerivedType");
   m->add(chaiscript::constructor<TestDerivedType (const TestDerivedType &)>(), "TestDerivedType");
 
+  m->add(chaiscript::constructor<TestMoreDerivedType ()>(), "TestMoreDerivedType");
+  m->add(chaiscript::constructor<TestMoreDerivedType (const TestMoreDerivedType &)>(), "TestMoreDerivedType");
+
+  /// \todo automatic chaining of base classes?
   m->add(chaiscript::base_class<TestBaseType, TestDerivedType>());
+  m->add(chaiscript::base_class<TestBaseType, TestMoreDerivedType>());
+  m->add(chaiscript::base_class<TestDerivedType, TestMoreDerivedType>());
+
+  m->add(chaiscript::fun(&TestDerivedType::derived_only_func), "derived_only_func");
+
+  m->add(chaiscript::fun(&derived_type_factory), "derived_type_factory");
+  m->add(chaiscript::fun(&more_derived_type_factory), "more_derived_type_factory");
+
+  m->add(chaiscript::fun(&TestDerivedType::func), "func");
 
   m->add(chaiscript::fun(&TestBaseType::func), "func");
+  m->add(chaiscript::fun(&TestBaseType::val), "val");
+  m->add(chaiscript::fun(&TestBaseType::const_val), "const_val");
+  m->add(chaiscript::fun(&TestBaseType::base_only_func), "base_only_func");
+
+  m->add(chaiscript::fun(&get_new_int), "get_new_int");
+
+
+  m->add_global_const(chaiscript::const_var(TestValue1), "TestValue1");
+
+  m->add(chaiscript::user_type<TestEnum>(), "TestEnum");
+
+  m->add(chaiscript::fun(&to_int), "to_int");
+  m->add(chaiscript::fun(&TestBaseType::constMe), "constMe");
+
 
   return m;
 }
 
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif

src/work.chai

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

unittests/arithmetic_conversions_test.cpp

@@ -0,0 +1,70 @@
+// Tests to make sure that type conversions happen only when they should
+
+#include <chaiscript/chaiscript.hpp>
+
+void f1(int)
+{
+}
+
+void f4(std::string)
+{
+}
+
+void f2(int)
+{
+}
+
+void f3(double)
+{
+}
+
+void f_func_return(const boost::function<unsigned int (unsigned long)> &f)
+{
+  // test the ability to return an unsigned with auto conversion
+  f(4);
+}
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+
+  chai.add(chaiscript::fun(&f1), "f1");
+  chai.add(chaiscript::fun(&f2), "f2");
+  chai.add(chaiscript::fun(&f3), "f2");
+  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)");
+  chai.eval("f1(0ul)");
+  chai.eval("f1(0ll)");
+  chai.eval("f1(0ull)");
+  chai.eval("f1(0.0)");
+  chai.eval("f1(0.0f)");
+  chai.eval("f1(0.0l)");
+
+  // expected overloads
+  chai.eval("f2(1)");
+  chai.eval("f2(1.0)");
+
+  // 1 non-arithmetic overload
+  chai.eval("f2(1.0)");
+
+  // 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 &) {
+    return EXIT_SUCCESS;
+  }
+
+  // if the last one did not throw, we failed
+  return EXIT_FAILURE;
+}

unittests/boxed_cast_test.cpp

@@ -58,8 +58,8 @@ bool do_test(const Boxed_Value &bv, bool T, bool ConstT, bool TRef, bool ConstTR
     bool ConstTPtrConst, bool SharedPtrT, bool SharedConstPtrT,
     bool ConstSharedPtrT, bool ConstSharedConstPtrT, bool ConstSharedPtrTRef, bool ConstSharedPtrTConstRef,
     bool BoostRef, bool BoostConstRef, bool ConstBoostRef, bool ConstBoostConstRef,
-    bool ConstBoostRefRef, bool ConstBoostConstRefRef, bool PODValue,
-    bool ConstPODValue, bool ConstPODValueRef, bool TPtrConstRef, bool ConstTPtrConstRef)
+    bool ConstBoostRefRef, bool ConstBoostConstRefRef, bool Number,
+    bool ConstNumber, bool ConstNumberRef, bool TPtrConstRef, bool ConstTPtrConstRef)
 {
   bool passed = true;
   passed &= test_type_conversion<Type>(bv, T);
@@ -86,14 +86,14 @@ bool do_test(const Boxed_Value &bv, bool T, bool ConstT, bool TRef, bool ConstTR
   passed &= test_type_conversion<const boost::reference_wrapper<const Type> >(bv, ConstBoostConstRef);
   passed &= test_type_conversion<const boost::reference_wrapper<Type> &>(bv, ConstBoostRefRef);
   passed &= test_type_conversion<const boost::reference_wrapper<const Type> &>(bv, ConstBoostConstRefRef);
-  passed &= test_type_conversion<Boxed_POD_Value>(bv, PODValue);
-  passed &= test_type_conversion<const Boxed_POD_Value>(bv, ConstPODValue);
-  passed &= test_type_conversion<Boxed_POD_Value &>(bv, false);
-  passed &= test_type_conversion<const Boxed_POD_Value &>(bv, ConstPODValueRef);
-  passed &= test_type_conversion<Boxed_POD_Value *>(bv, false);
-  passed &= test_type_conversion<const Boxed_POD_Value *>(bv, false);
-  passed &= test_type_conversion<Boxed_POD_Value * const>(bv, false);
-  passed &= test_type_conversion<const Boxed_POD_Value *const>(bv, false);
+  passed &= test_type_conversion<Boxed_Number>(bv, Number);
+  passed &= test_type_conversion<const Boxed_Number>(bv, ConstNumber);
+  passed &= test_type_conversion<Boxed_Number &>(bv, false);
+  passed &= test_type_conversion<const Boxed_Number &>(bv, ConstNumberRef);
+  passed &= test_type_conversion<Boxed_Number *>(bv, false);
+  passed &= test_type_conversion<const Boxed_Number *>(bv, false);
+  passed &= test_type_conversion<Boxed_Number * const>(bv, false);
+  passed &= test_type_conversion<const Boxed_Number *const>(bv, false);
   passed &= test_type_conversion<Type *&>(bv, false);
   passed &= test_type_conversion<const Type *&>(bv, false);
   passed &= test_type_conversion<Type * const&>(bv, TPtrConstRef);
@@ -295,13 +295,15 @@ int main()
   bool ConstTPtr, bool TPtrConst, bool ConstTPtrConst, bool SharedPtrT, bool SharedConstPtrT,
     bool ConstSharedPtrT, bool ConstSharedConstPtrT, bool ConstSharedPtrTRef, bool ConstSharedPtrTConstRef, bool BoostRef, 
     bool BoostConstRef, bool ConstBoostRef, bool ConstBoostConstRef, bool ConstBoostRefRef, bool ConstBoostConstRefRef, 
-    bool PODValue, bool ConstPODValue, bool ConstPODValueRef
+    bool Number, bool ConstNumber, bool ConstNumberRef
     */
 
   passed &= built_in_type_test<int>(5, true);
   passed &= built_in_type_test<double>(1.1, true);
   passed &= built_in_type_test<char>('a', true);
-  passed &= built_in_type_test<bool>(false, true);
+  passed &= built_in_type_test<boost::uint8_t>('a', true);
+  passed &= built_in_type_test<boost::int64_t>('a', true);
+  passed &= built_in_type_test<bool>(false, false);
   passed &= built_in_type_test<std::string>("Hello World", false);
   
   // storing a pointer 

unittests/break_for.chai

@@ -0,0 +1,11 @@
+var j = 0;
+
+for (var i = 0; i < 10; ++i) {
+  if (i == 5) {
+    break
+  }
+
+  j = i
+}
+
+assert_equal(4, j);

unittests/c_linkage_test.cpp

@@ -0,0 +1,20 @@
+#include <chaiscript/chaiscript.hpp>
+
+
+extern "C"
+{
+  int dosomething(int i)
+  {
+    return i % 2;
+  }
+}
+
+int main()
+{
+
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::fun(&dosomething), "dosomething");
+
+  return chai.eval<int>("dosomething(101)") == 101 % 2?EXIT_SUCCESS:EXIT_FAILURE;
+
+}

unittests/continue_for.chai

@@ -0,0 +1,16 @@
+var j = 0;
+var k = 0;
+
+for (var i = 0; i < 10; ++i)
+{
+  j = i
+  if (i > 5)
+  {
+    continue
+  } 
+
+  k = i
+}
+
+assert_equal(5, k);
+assert_equal(9, j);

unittests/continue_while.chai

@@ -0,0 +1,14 @@
+var i = 0
+var j = 0
+
+while (i < 10) {
+  if (++i > 5)
+  {
+    continue
+  }
+
+  j = i;
+}
+
+assert_equal(10, i);
+assert_equal(5, j);

unittests/eval_catch_exception_test.cpp

@@ -2,20 +2,121 @@
 
 #include <chaiscript/chaiscript.hpp>
 
-
-int main()
+int test_generic()
 {
   chaiscript::ChaiScript chai;
   
   try {
     chai.eval("throw(runtime_error(\"error\"));");
   } catch (const chaiscript::Boxed_Value &bv) {
-    const std::exception &e = chaiscript::boxed_cast<const std::exception &>(bv);
+    const std::exception &e = chai.boxed_cast<const std::exception &>(bv);
     if (e.what() == std::string("error"))
     {
       return EXIT_SUCCESS;
     }
   }
 
+  std::cout << "test_generic failed" << std::endl;
   return EXIT_FAILURE;
 }
+
+int test_1()
+{
+  chaiscript::ChaiScript chai;
+  
+  try {
+    chai.eval("throw(1)", chaiscript::exception_specification<int>());
+  } catch (int e) {
+    if (e == 1)
+    {
+      return EXIT_SUCCESS;
+    }
+  }
+
+  std::cout << "test_1 failed" << std::endl;
+  return EXIT_FAILURE;
+}
+
+int test_2()
+{
+  chaiscript::ChaiScript chai;
+  
+  try {
+    chai.eval("throw(1.0)", chaiscript::exception_specification<int, double>());
+  } catch (const double e) {
+    if (e == 1.0)
+    {
+      return EXIT_SUCCESS;
+    }
+  }
+
+  std::cout << "test_2 failed" << std::endl;
+  return EXIT_FAILURE;
+}
+
+int test_5()
+{
+  chaiscript::ChaiScript chai;
+
+  try {
+    chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+  } catch (const double) {
+    std::cout << "test_5 failed with double" << std::endl;
+    return EXIT_FAILURE;
+  } catch (int) {
+    std::cout << "test_5 failed with int" << std::endl;
+    return EXIT_FAILURE;
+  } catch (float) {
+    std::cout << "test_5 failed with float" << std::endl;
+    return EXIT_FAILURE;
+  } catch (const std::string &) {
+    std::cout << "test_5 failed with string" << std::endl;
+    return EXIT_FAILURE;
+  } catch (const std::exception &) {
+    return EXIT_SUCCESS;
+  }
+
+  std::cout << "test_5 failed" << std::endl;
+  return EXIT_FAILURE;
+}
+
+int test_unhandled()
+{
+  chaiscript::ChaiScript chai;
+
+  try {
+    chai.eval("throw(\"error\")", chaiscript::exception_specification<int, double, float, const std::exception &>());
+  } catch (double) {
+    std::cout << "test_unhandled failed with double" << std::endl;
+    return EXIT_FAILURE;
+  } catch (int) {
+    std::cout << "test_unhandled failed with int" << std::endl;
+    return EXIT_FAILURE;
+  } catch (float) {
+    std::cout << "test_unhandled failed with float" << std::endl;
+    return EXIT_FAILURE;
+  } catch (const std::exception &) {
+    std::cout << "test_unhandled failed with std::exception" << std::endl;
+    return EXIT_FAILURE;
+  } catch (const chaiscript::Boxed_Value &) {
+    return EXIT_SUCCESS;
+  }
+
+  std::cout << "test_unhandled failed" << std::endl;
+  return EXIT_FAILURE;
+}
+
+
+int main()
+{
+  if (test_generic() == EXIT_SUCCESS
+    && test_1() == EXIT_SUCCESS
+    && test_2() == EXIT_SUCCESS
+    && test_5() == EXIT_SUCCESS
+    && test_unhandled() == EXIT_SUCCESS) 
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+}

unittests/expected_eval_errors_test.cpp

@@ -0,0 +1,111 @@
+// Tests to make sure no arity, dispatch or guard errors leak up past eval
+
+#include <chaiscript/utility/utility.hpp>
+
+int test_one(const int &)
+{
+  return 1;
+}
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::fun(&test_one), "test_fun");
+
+  chai.eval("def guard_fun(i) : i.get_type_info().is_type_arithmetic() {} ");
+
+  bool eval_error = true;
+
+  // Dot notation
+
+  try {
+    // non-existant function
+    chai.eval("\"test\".test_one()");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong parameter type
+    chai.eval("\"test\".test_fun()");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong number of parameters
+    chai.eval("\"test\".test_fun(1)");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // guard failure
+    chai.eval("\"test\".guard_fun(1)");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+
+
+  // regular notation
+
+  try {
+    // non-existant function
+    chai.eval("test_one(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong parameter type
+    chai.eval("test_fun(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong number of parameters
+    chai.eval("test_fun(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // guard failure
+    chai.eval("guard_fun(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+
+  // index operator
+  try {
+    chai.eval("var a = [1,2,3]; a[\"bob\"];");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  // unary operator
+  try {
+    chai.eval("++\"bob\"");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  // binary operator
+  try {
+    chai.eval("\"bob\" + 1");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+
+  if (eval_error)
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+
+}

unittests/for.chai

@@ -5,3 +5,57 @@ for (var i = 0; i < 5; ++i) {
 }
 
 assert_equal([0,1,2,3,4], ret);
+
+
+var j = 0;
+
+for (;j<10; ++j)
+{
+}
+
+assert_equal(10, j);
+
+
+var k = 0;
+
+for (;k<10; )
+{
+  ++k;
+}
+
+assert_equal(10, k);
+
+
+for (;;)
+{
+  break;
+}
+
+var l = 0;
+
+for (;;l = 1)
+{
+  break;
+}
+
+assert_equal(0, l)
+
+def isNotFive(x)
+{
+  if (x != 5) 
+  {
+    return true
+  } else {
+    return false
+  }
+}
+
+var m;
+
+for (m = 0; isNotFive(m); m = m + 1)
+{
+  
+}
+
+assert_equal(5, m);
+

unittests/function_array_adjacent.chai

@@ -0,0 +1 @@
+assert_equal(2, `+`.get_contained_functions()[0].get_arity())

unittests/function_ordering_test.cpp

@@ -17,7 +17,7 @@ int main()
   chaiscript::ChaiScript chai;
   chai.eval("def test_fun(x) { return 3; }");
   chai.eval("def test_fun(x) : x == \"hi\" { return 4; }");
-  chai.eval("def test_fun(x) { return 5; }");
+//  chai.eval("def test_fun(x) { return 5; }");
   chai.add(chaiscript::fun(&test_one), "test_fun");
   chai.add(chaiscript::fun(&test_two), "test_fun");
 

unittests/function_redefinition.chai

@@ -0,0 +1,2 @@
+assert_throws("Function already defined", fun() { def foo(x) { x + 1 }; def foo(x) { x + 1 } } );
+

unittests/global_const_in_module.chai

@@ -0,0 +1,7 @@
+load_module("test_module")
+
+
+assert_equal(to_int(TestValue1), 1)
+
+assert_equal(TestValue1.type_name(), "TestEnum")
+

unittests/hashbang.chai

@@ -0,0 +1,4 @@
+#!/usr/bin/env chai
+
+//We just have to reach this point for success
+assert_equal(true, true);

unittests/index_operator.chai

@@ -0,0 +1,10 @@
+
+// tests more complex parses of the index operator
+
+def Bob::bob3() { return [1,2,3]; }
+def Bob::Bob() {}
+var b = Bob();
+
+
+assert_equal(b.bob3()[0], 1);
+assert_equal((b.bob3())[1], 2);

unittests/inheritance.chai

@@ -6,3 +6,35 @@ var t = TestDerivedType();
 assert_equal(t0.func(), 0);
 assert_equal(t.func(), 1);
 
+assert_equal(10, t0.val);
+assert_equal(15, t0.const_val);
+
+assert_equal(10, t.val);
+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/integer_literal_test.cpp

@@ -0,0 +1,88 @@
+#include <chaiscript/chaiscript.hpp>
+
+#define TEST_LITERAL(v) test_literal(v, #v)
+
+template<typename T>
+bool test_literal(T val, const std::string &str)
+{
+  chaiscript::ChaiScript chai;
+  T val2 = chai.eval<T>(str);
+  std::cout << "Comparing : " << val << " " << val2 << std::endl;
+  return val == val2;
+}
+
+int main()
+{
+  if( TEST_LITERAL(0xF)
+ && TEST_LITERAL(0xFF)
+ && TEST_LITERAL(0xFFF)
+ && TEST_LITERAL(0xFFFF)
+ && TEST_LITERAL(0xFFFFF)
+ && TEST_LITERAL(0xFFFFFF)
+ && TEST_LITERAL(0xFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFFFFF) 
+ 
+ 
+ && TEST_LITERAL(01)
+ && TEST_LITERAL(017)
+ && TEST_LITERAL(0177)
+ && TEST_LITERAL(01777)
+ && TEST_LITERAL(017777)
+ && TEST_LITERAL(0177777)
+ && TEST_LITERAL(01777777)
+ && TEST_LITERAL(017777777)
+ && TEST_LITERAL(0177777777)
+ && TEST_LITERAL(01777777777)
+ && TEST_LITERAL(017777777777)
+ && TEST_LITERAL(0177777777777)
+ && TEST_LITERAL(01777777777777)
+ && TEST_LITERAL(017777777777777)
+ && TEST_LITERAL(0177777777777777)
+ && TEST_LITERAL(01777777777777777)
+ && TEST_LITERAL(017777777777777777)
+ && TEST_LITERAL(0177777777777777777)
+ && TEST_LITERAL(01777777777777777777)
+ && TEST_LITERAL(017777777777777777777)
+ && TEST_LITERAL(0177777777777777777777)
+ && TEST_LITERAL(01777777777777777777777)
+
+ && TEST_LITERAL(1)
+ && TEST_LITERAL(17)
+ && TEST_LITERAL(177)
+ && TEST_LITERAL(1777)
+ && TEST_LITERAL(17777)
+ && TEST_LITERAL(177777)
+ && TEST_LITERAL(1777777)
+ && TEST_LITERAL(17777777)
+ && TEST_LITERAL(177777777)
+ && TEST_LITERAL(1777777777)
+ && TEST_LITERAL(17777777777)
+ && TEST_LITERAL(177777777777)
+ && TEST_LITERAL(1777777777777)
+ && TEST_LITERAL(17777777777777)
+ && TEST_LITERAL(177777777777777)
+ && TEST_LITERAL(1777777777777777)
+ && TEST_LITERAL(17777777777777777)
+ && TEST_LITERAL(177777777777777777)
+ && TEST_LITERAL(1777777777777777777)
+
+)
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+
+
+
+
+
+}

unittests/load_module.chai

@@ -1,2 +1,4 @@
 load_module("test_module")
 assert_equal("Hello World", hello_world());
+
+

unittests/map.chai

@@ -1 +1,29 @@
 assert_equal([true, false, true], map([1,2,3], odd))
+
+
+
+var m = ["a":1, "b":2];
+
+assert_equal(1, m.count("a"))
+assert_equal(0, m.count("c"))
+assert_equal(1, m.erase("a"))
+assert_equal(1, m.size())
+assert_equal(0, m.erase("a"))
+
+assert_equal(1, m.size());
+
+var m2 = ["c":3, "b":4]
+m.insert(m2);
+
+assert_equal(3, m["c"])
+// The inserted values do not overwrite the existing ones
+assert_equal(2, m["b"])
+assert_equal(2, m.size())
+
+var v = "bob";
+
+m.insert_ref(Map_Pair("d", v))
+
+assert_equal("bob", m["d"])
+v = "bob2"
+assert_equal("bob2", m["d"])

unittests/map_count.chai

@@ -0,0 +1,5 @@
+
+assert_equal(1, ["a":1].count("a"))
+assert_equal(0, ["A":1].count("a"))
+
+

unittests/map_inplace_init.chai

@@ -1,3 +1,14 @@
 var x = ["bob":1, "fred":2]
 
 assert_equal(2, x.size());
+
+
+// Make sure vector elements are copied into place for consistency with
+// map inplace construction
+var i = 1;
+var y = ["a":i];
+
+assert_equal(1, y["a"]);
+i = 3;
+assert_equal(3, i);
+assert_equal(1, y["a"]);

unittests/member_variable_access.chai

@@ -0,0 +1,11 @@
+load_module("test_module")
+
+var t0 = TestBaseType()
+t0.val = 13
+
+assert_equal(15, t0.const_val)
+assert_equal(13, t0.val)
+assert_equal(15, t0.constMe().const_val)
+assert_equal(13, t0.constMe().val)
+
+

unittests/multiline_oper.chai

@@ -0,0 +1,4 @@
+var x = 3 + 
+  4
+
+assert_equal(x, 7);

unittests/multithreaded_test.cpp

@@ -0,0 +1,96 @@
+#include <iostream>
+
+#include <list>
+#include <algorithm>
+
+#include <chaiscript/chaiscript.hpp>
+#include <boost/thread.hpp>
+
+int expected_value(int num_iters)
+{
+  int i = 0;
+  for (int k = 0; k<num_iters * 10; ++k)
+  {
+    i += k;
+  }
+
+  return i;
+}
+
+void do_work(chaiscript::ChaiScript &c, int id)
+{
+  try{
+    std::stringstream ss;
+    ss << "MyVar" << rand();
+    c.add(chaiscript::var(5), ss.str());
+    ss.str("");
+    ss << id;
+    c.use("multithreaded_work.inc");
+    c("do_chai_work(4000, " + ss.str() + ");");
+  } catch (const std::exception &e) {
+    std::cout << "exception: " << e.what() << " thread:  " << id;
+  }
+}
+
+int main()
+{
+  // Disable deprecation warning for getenv call.
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+  const char *usepath = getenv("CHAI_USE_PATH");
+  const char *modulepath = getenv("CHAI_MODULE_PATH");
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+  std::vector<std::string> usepaths;
+  usepaths.push_back("");
+  if (usepath)
+  {
+    usepaths.push_back(usepath);
+  }
+
+  std::vector<std::string> modulepaths;
+  modulepaths.push_back("");
+  if (modulepath)
+  {
+    modulepaths.push_back(modulepath);
+  }
+
+  chaiscript::ChaiScript chai(modulepaths,usepaths);
+
+  boost::thread_group threads;
+
+  // Ensure at least two, but say only 7 on an 8 core processor
+  int num_threads = std::max<unsigned int>(boost::thread::hardware_concurrency() - 1, 2u);
+
+  for (int i = 0; i < num_threads; ++i)
+  {
+    threads.create_thread(boost::bind(&do_work, boost::ref(chai), i));
+  }
+
+  threads.join_all();
+
+
+  for (int i = 0; i < num_threads; ++i)
+  {
+    std::stringstream ss;
+    ss << i;
+    if (chai.eval<int>("getvalue(" + ss.str() + ")") != expected_value(4000))
+    {
+      return EXIT_FAILURE;
+    }
+
+    if (chai.eval<int>("getid(" + ss.str() + ")") != i)
+    {
+      return EXIT_FAILURE;
+    }
+  }
+
+  return EXIT_SUCCESS;
+}
+

unittests/multithreaded_work.inc

@@ -0,0 +1,15 @@
+def do_chai_work(num_iters, id)
+{
+  var i = 0;
+  for (var k = 0; k<num_iters * 10; ++k)
+  {
+    if (k == 1000)
+    {
+      eval("def getid(id) : id == " + to_string(id) + " { return " + to_string(id) + "}");
+    }
+    i += k;
+  }
+
+  eval("def getvalue(id) : id == " + to_string(id) + " { return " + to_string(i) + "}");
+
+}

unittests/number_suffixes.chai

@@ -0,0 +1,11 @@
+assert_equal(true, int_type.bare_equal(1.get_type_info()))
+assert_equal(true, unsigned_int_type.bare_equal(1u.get_type_info()))
+assert_equal(true, unsigned_long_type.bare_equal(1lu.get_type_info()))
+assert_equal(true, long_type.bare_equal(1l.get_type_info()))
+assert_equal(true, int64_t_type.bare_equal(1ll.get_type_info()))
+assert_equal(true, uint64_t_type.bare_equal(1ull.get_type_info()))
+
+assert_equal(true, double_type.bare_equal(1.6.get_type_info()))
+assert_equal(true, float_type.bare_equal(1.6f.get_type_info()))
+assert_equal(true, long_double_type.bare_equal(1.6l.get_type_info()))
+

unittests/object_attr_same_name.chai

@@ -0,0 +1,9 @@
+attr bob::z
+def bob::bob() { this.z = 10 }
+
+attr bob2::z
+def bob2::bob2() { this.z = 12 }
+
+var b = bob();
+var b2 = bob2();
+

unittests/object_lifetime_test.cpp

@@ -38,19 +38,19 @@ int main()
 
   chaiscript::ChaiScript chai;
   chai.add(m);
-  chai.add(chaiscript::fun(&Test::count), "count");
+//  chai.add(chaiscript::fun(&Test::count), "count");
 
   int count = chai.eval<int>("count()");
 
   int count2 = chai.eval<int>("var i = 0; { var t = Test(); } return i;");
 
-  int count3 = chai.eval<int>("var i = 0; { var t = Test(); i = count(); } return i;");
+  int count3 = chai.eval<int>("i = 0; { var t = Test(); i = count(); } return i;");
 
-  int count4 = chai.eval<int>("var i = 0; { var t = Test(); { var t2 = Test(); i = count(); } } return i;");
+  int count4 = chai.eval<int>("i = 0; { var t = Test(); { var t2 = Test(); i = count(); } } return i;");
  
-  int count5 = chai.eval<int>("var i = 0; { var t = Test(); { var t2 = Test(); } i = count(); } return i;");
+  int count5 = chai.eval<int>("i = 0; { var t = Test(); { var t2 = Test(); } i = count(); } return i;");
 
-  int count6 = chai.eval<int>("var i = 0; { var t = Test(); { var t2 = Test(); }  } i = count(); return i;");
+  int count6 = chai.eval<int>("i = 0; { var t = Test(); { var t2 = Test(); }  } i = count(); return i;");
 
   if (count == 0
       && count2 == 0

unittests/operator_scoping.chai

@@ -0,0 +1,8 @@
+load_module("reflection")
+
+try {
+  eval("def `+`(x, y) \n { \n print(i); \n } \n \n var i = 10; \n \"1\" + 1;\n")
+  assert_false(true); // we should never get here
+} catch (e) {
+  assert_equal("Error: \"Can not find object: i\" ", e.what()); 
+}

unittests/pass_by_reference.chai

@@ -0,0 +1,19 @@
+def f(x) { x+= 2; }
+
+var i = 1;
+
+assert_equal(i, 1);
+
+f(i);
+
+assert_equal(i, 3);
+
+def g(x) { x+= " World"; }
+
+var s = "Hello";
+
+assert_equal(s, "Hello");
+
+g(s);
+
+assert_equal(s, "Hello World");

unittests/pointer_passed_to_constructor.chai

@@ -0,0 +1,8 @@
+load_module("test_module")
+
+var i = 1;
+var t0 = TestBaseType(i);
+
+var t1 = TestBaseType(get_new_int())
+
+

unittests/set_state_test.cpp

@@ -0,0 +1,61 @@
+#include <chaiscript/chaiscript.hpp>
+
+
+int myfun()
+{
+  return 2;
+}
+
+int main()
+{
+
+  chaiscript::ChaiScript chai;
+
+  // save the initial state of globals and locals
+  chaiscript::ChaiScript::State firststate = chai.get_state();
+  std::map<std::string, chaiscript::Boxed_Value> locals = chai.get_locals();
+  
+  // add some new globals and locals
+  chai.add(chaiscript::var(1), "i");
+
+  chai.add(chaiscript::fun(&myfun), "myfun");
+
+
+  bool didcall = chai.eval<int>("myfun()") == 2;
+
+  bool hadi = chai.eval<int>("i") == 1;
+
+  chai.set_state(firststate);
+
+  // set state should have reverted the state of the functions and dropped
+  // the 'myfun'
+  bool didnotcall = false;
+
+  try {
+    chai.eval<int>("myfun()");
+  } catch (const chaiscript::exception::eval_error &) {
+    didnotcall = true;
+  }
+
+  // set state should not affect the local variables
+  bool stillhasid = chai.eval<int>("i") == 1;
+
+  // After resetting the locals we expect the 'i' to be gone
+  chai.set_locals(locals);
+
+
+  bool nolongerhasid = false;
+
+  try {
+    chai.eval<int>("i");
+  } catch (const chaiscript::exception::eval_error &) {
+    nolongerhasid = true;
+  }
+
+  if (didcall && hadi && didnotcall && stillhasid && nolongerhasid)
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+}

unittests/short_comparison_test.cpp

@@ -0,0 +1,29 @@
+#include <chaiscript/utility/utility.hpp>
+
+class Test {
+ public:
+  Test() : value_(5) {}
+
+  short get_value() { return value_; }
+
+  short value_;
+};
+
+int main()
+{
+
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::user_type<Test>(), "Test");
+  chai.add(chaiscript::constructor<Test()>(), "Test");
+
+  chai.add(chaiscript::fun(&Test::get_value), "get_value");
+
+  chai.eval("var t := Test();");
+
+  if (chai.eval<bool>("t.get_value() == 5"))
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+}

unittests/simultaneous_chaiscript_test.cpp

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

unittests/string_literal_access.chai

@@ -0,0 +1 @@
+assert_equal('b', "abc"[1])

unittests/string_size.chai

@@ -0,0 +1,2 @@
+assert_equal(true, "".empty())
+assert_equal(3, "123".size())

unittests/string_substr.chai

@@ -0,0 +1 @@
+assert_equal("3ab", "123abab".substr(2,3))

unittests/switch_break.chai

@@ -0,0 +1,22 @@
+var total = 0;
+
+switch(2) { 
+  case (1) { 
+    total += 1; 
+    break;
+  } 
+  case (2) { 
+    total += 2; 
+    break;
+  } 
+  case (3) { 
+    total += 4;
+    break;
+  } 
+  case (4) { 
+    total += 8; 
+    break;
+  } 
+}
+
+assert_equal(total, 2)

unittests/switch_default.chai

@@ -0,0 +1,18 @@
+var total = 0;
+
+switch(2) { 
+  case (1) { 
+    total += 1; 
+  } 
+  case (3) { 
+    total += 4;
+  } 
+  case (4) { 
+    total += 8; 
+  } 
+  default {
+    total += 16;
+  }
+}
+
+assert_equal(total, 16)

unittests/switch_empty.chai

@@ -0,0 +1,4 @@
+switch(true) { }
+
+// We just have to get here without error for success
+assert_equal(true, true);

unittests/switch_fallthru.chai

@@ -0,0 +1,18 @@
+var total = 0;
+
+switch(2) { 
+  case (1) { 
+    total += 1; 
+  } 
+  case (2) { 
+    total += 2; 
+  } 
+  case (3) { 
+    total += 4;
+  } 
+  case (4) { 
+    total += 8; 
+  } 
+}
+
+assert_equal(total, 14); 

unittests/switch_fallthru_and_break.chai

@@ -0,0 +1,19 @@
+var total = 0;
+
+switch(2) { 
+  case (1) { 
+    total += 1; 
+  } 
+  case (2) { 
+    total += 2; 
+  } 
+  case (3) { 
+    total += 4;
+    break;
+  } 
+  case (4) { 
+    total += 8; 
+  } 
+}
+
+assert_equal(total, 6)

unittests/system_introspection.chai

@@ -0,0 +1,18 @@
+
+var funcs = get_functions();
+
+assert_true(funcs.size() > 0);
+assert_true(funcs["to_string"].get_type_info().bare_equal(Function_type));
+
+
+var i = 1;
+var objs = get_objects();
+
+assert_true(objs.size() > 0);
+assert_true(objs["i"].get_type_info().bare_equal(int_type));
+assert_true(objs.count("j") == 0);
+
+
+
+
+

unittests/temporary_lifetime.chai

@@ -0,0 +1,3 @@
+for_each(range([1..10]), fun(x) {print(x);} );
+
+assert_true(true);

unittests/ternary_condition.chai

@@ -0,0 +1,2 @@
+var x = 4;
+assert_equal(x < 3 ? 4 < 1 : 5 > 3, true);

unittests/unit_test.inc

@@ -5,7 +5,7 @@ def assert_equal(x, y)
     // Passes
   } else {
     // Fails
-    print("assert_equal failure: got " + to_string(y) + " expected " + to_string(x));
+    print("assert_equal failure: got '" + to_string(y) + "' expected '" + to_string(x) + "'");
     exit(-1);
   }
 }
@@ -23,7 +23,7 @@ def assert_true(f)
 {
   if (!f)
   {
-    print("assert_false failure");
+    print("assert_true failure");
     exit(-1);
   }
 }

unittests/utility_test.cpp

@@ -30,8 +30,8 @@ int main()
   chaiscript::ChaiScript chai;
   chai.add(m);
   if (chai.eval<std::string>("var t = Test(); t.function2(); ") == "Function2"
-      && chai.eval<std::string>("var t = Test(); t.functionOverload(1); ") == "int"
-      && chai.eval<std::string>("var t = Test(); t.functionOverload(1.1); ") == "double")
+      && chai.eval<std::string>("var t2 = Test(); t2.functionOverload(1); ") == "int"
+      && chai.eval<std::string>("var t3 = Test(); t3.functionOverload(1.1); ") == "double")
   {
     chai.eval("t = Test();");
     return EXIT_SUCCESS;

unittests/variable_redefinition.chai

@@ -0,0 +1,2 @@
+assert_throws("Variable already defined", fun() { var y = 10; var y = 20; })
+

unittests/vector_inplace_init.chai

@@ -1,2 +1,14 @@
 var x = [1, 2, 3]
 assert_equal(3, x.size())
+
+
+
+// Make sure vector elements are copied into place for consistency with
+// map inplace construction
+var i = 1;
+var y = [i];
+
+assert_equal(1, y[0]);
+i = 3;
+assert_equal(3, i);
+assert_equal(1, y[0]);