Prep for 5.0.0 release

to improve compile time.

CMakeLists.txt

@@ -16,21 +16,19 @@ set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt")
 set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.txt")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
 
-set(CPACK_PACKAGE_VERSION_MAJOR 3)
-set(CPACK_PACKAGE_VERSION_MINOR 1)
+set(CPACK_PACKAGE_VERSION_MAJOR 5)
+set(CPACK_PACKAGE_VERSION_MINOR 0)
 set(CPACK_PACKAGE_VERSION_PATCH 0)
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
 set(CPACK_PACKAGE_CONTACT "contact@chaiscript.com")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "An embedded scripting language for C++")
 
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libboost-dev (>=1.36.0)")
 set(CPACK_DEBIAN_PACKAGE_SECTION "devel")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 
 set(CPACK_RPM_PACKAGE_LICENSE "BSD")
 set(CPACK_RPM_PACKAGE_GROUP "Programming")
-set(CPACK_RPM_PACKAGE_REQUIRES "boost-devel >= 1.36.0, boost-thread >= 1.36.0")
 
 set(CHAI_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
 
@@ -39,96 +37,101 @@ 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()
-  ADD_DEFINITIONS(-Wall -Wextra -Wshadow) 
+if(MSVC)
+  add_definitions(/W4)
+  if(CMAKE_CL_64)
+    add_definitions(/bigobj)
+   endif()
+else()
+  add_definitions(-Wall -Wextra -Wshadow -pedantic -std=c++0x)
 
-  IF (APPLE)
-    # -Wno-missing-field-initializers is for boost on macos
-    ADD_DEFINITIONS(-Wno-missing-field-initializers -Wno-sign-compare)
-  ENDIF()
-ENDIF()
+  if (APPLE)
+    add_definitions(-Wno-sign-compare)
+  endif()
+endif()
+
+if (CMAKE_CXX_COMPILER MATCHES ".*clang")
+
+  option(USE_LIBCXX "Use clang's libcxx" TRUE)
+
+  if (USE_LIBCXX)
+    add_definitions(-stdlib=libc++)
+    set (EXTRA_LINKER_FLAGS -std=c++0x -stdlib=libc++)
+  else ()
+    set (EXTRA_LINKER_FLAGS -std=c++0x )
+  endif()
+else()
+  set (EXTRA_LINKER_FLAGS )
+endif()
 
 include_directories(include)
- 
-SET(Boost_ADDITIONAL_VERSIONS "1.44" "1.44.0" "1.43" "1.43.0" "1.42" "1.42.0" "1.41")
-SET(Boost_USE_MULTITHREADED ON)
+
+
+set (Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.hpp include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
+
+set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
 
 if (MULTITHREAD_SUPPORT_ENABLED)
-  find_package(Boost 1.36.0 COMPONENTS thread)
-
-  if (Boost_FOUND)
-    link_directories( ${Boost_LIBRARY_DIRS} )
-  else()
-    message(FATAL_ERROR "Can not find Boost")
-  endif(Boost_FOUND)
 else()
-  ADD_DEFINITIONS(-DCHAISCRIPT_NO_THREADS)
+  add_definitions(-DCHAISCRIPT_NO_THREADS)
 endif()
 
 if (CMAKE_HOST_UNIX)
-  SET(DYNAMIC_LOADER "dl")
+  set(DYNAMIC_LOADER "dl")
 endif(CMAKE_HOST_UNIX)
 
-if (MSVC)
-  # Boost on MSVC does automatic linking
-  SET(LIBS ${DYNAMIC_LOADER} ${READLINE_LIB})
-else()
-  SET(LIBS ${DYNAMIC_LOADER} ${Boost_LIBRARIES} ${READLINE_LIB})
-endif()
+set(LIBS ${DYNAMIC_LOADER} ${READLINE_LIB})
 
 if (CMAKE_COMPILER_2005)
   # vs2005 is a bit too loud about possible loss of data warnings
 #  ADD_DEFINITIONS(/wd4244)
 endif()
 
-include_directories(${Boost_INCLUDE_DIRS})
-include_directories(${Boost_INCLUDE_DIR})
-add_executable(chai src/main.cpp)
-target_link_libraries(chai ${LIBS})
+add_library(chaiscript_stdlib MODULE src/chaiscript_stdlib.cpp)
+target_link_libraries(chaiscript_stdlib ${LIBS} ${EXTRA_LINKER_FLAGS})
+
+add_executable(chai src/main.cpp ${Chai_INCLUDES})
+target_link_libraries(chai ${LIBS} ${EXTRA_LINKER_FLAGS})
+add_dependencies(chai chaiscript_stdlib)
 
 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()
 
-file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai)
+file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/3.x/*.chai)
 
 list(SORT UNIT_TESTS)
 
-IF(BUILD_TESTING)
+if(BUILD_TESTING)
   option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
 
   foreach(filename ${UNIT_TESTS})
@@ -136,81 +139,89 @@ 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(cpp_lambda_test unittests/cpp_lambda_test.cpp)
+    target_link_libraries(cpp_lambda_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    add_test(NAME cpp_lambda_test COMMAND cpp_lambda_test)
+
+
     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/codeanalysis.sh

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

contrib/codeanalysis/is_prime.chai

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

contrib/geshi/chaiscript.php

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

contrib/vim/syntax/chaiscript.vim

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

include/chaiscript/chaiscript.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -74,16 +74,16 @@
 /// <hr>
 /// \subsection compiling Compiling ChaiScript Applications
 ///
-/// ChaiScript is a header only library with only two dependecies. boost::threads (optional) and the
+/// ChaiScript is a header only library with only one dependecy: The
 /// operating system provided dynamic library loader, which has to be specified on some platforms.
 /// 
 /// \subsubsection compilinggcc Compiling with GCC
 /// 
 /// To compile the above application on a Unix like operating system (MacOS, Linux) with GCC you need to link
-/// both boost::threads and the dynamic loader. For example:
+/// the dynamic loader. For example:
 ///
 /// \code
-/// gcc main.cpp -I/path/to/chaiscript/headers -ldl -lboost_threads
+/// gcc main.cpp -I/path/to/chaiscript/headers -ldl 
 /// \endcode
 ///
 /// Alternatively, you may compile without threading support.
@@ -192,8 +192,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.
@@ -245,7 +245,9 @@
 ///
 /// std::string append_string_int(const std::string &t_lhs, int t_rhs)
 /// {
-///   return t_lhs + boost::lexical_cast<std::string>(t_rhs);
+///   std::stringstream ss;
+///   ss << t_lhs << t_rhs;
+///   return ss.str();
 /// }
 ///
 /// chai.add(fun(append_string_int), "+");
@@ -297,8 +299,8 @@
 /// <hr>
 /// \subsection pointerconversions Pointer / Object Conversions
 ///
-/// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, boost::shared_ptr<T>,
-/// boost::shared_ptr<const T>, boost::reference_wrapper<T>, boost::reference_wrapper<const T> and value types automatically.
+/// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, std::shared_ptr<T>,
+/// std::shared_ptr<const T>, std::reference_wrapper<T>, std::reference_wrapper<const T> and value types automatically.
 ///
 /// If a chaiscript::var object was created in C++ from a pointer, it cannot be convered to a shared_ptr (this would add invalid reference counting).
 /// Const may be added, but never removed. 
@@ -311,12 +313,12 @@
 /// void fun3(int);
 /// void fun4(int &);
 /// void fun5(const int &);
-/// void fun5(boost::shared_ptr<int>);
-/// void fun6(boost::shared_ptr<const int>);
-/// void fun7(const boost::shared_ptr<int> &);
-/// void fun8(const boost::shared_ptr<const int> &);
-/// void fun9(boost::reference_wrapper<int>);
-/// void fun10(boost::reference_wrapper<const int>);
+/// void fun5(std::shared_ptr<int>);
+/// void fun6(std::shared_ptr<const int>);
+/// void fun7(const std::shared_ptr<int> &);
+/// void fun8(const std::shared_ptr<const int> &);
+/// void fun9(std::reference_wrapper<int>);
+/// void fun10(std::reference_wrapper<const int>);
 ///
 /// int main()
 /// {
@@ -377,10 +379,10 @@
 /// \subsection functionobjects Function Objects
 ///
 /// Functions are first class objects in Chaiscript and ChaiScript supports automatic conversion
-/// between ChaiScript functions and boost::function objects.
+/// between ChaiScript functions and std::function objects.
 ///
 /// \code
-/// void callafunc(const boost::function<void (const std::string &)> &t_func)
+/// void callafunc(const std::function<void (const std::string &)> &t_func)
 /// {
 ///   t_func("bob");
 /// }
@@ -390,9 +392,9 @@
 ///   chaiscript::ChaiScript chai;
 ///   chai.add(chaiscript::fun(&callafunc), "callafunc");
 ///   chai("callafunc(fun(x) { print(x); })"); // pass a lambda function to the registered function
-///                                            // which expects a typed boost::function
+///                                            // which expects a typed std::function
 ///
-///   boost::function<void ()> f = chai.eval<boost::function<void ()> >("dump_system");
+///   std::function<void ()> f = chai.eval<std::function<void ()> >("dump_system");
 ///   f(); // call the ChaiScript function dump_system, from C++
 /// }
 /// \endcode
@@ -407,7 +409,7 @@
 /// 
 /// Thread safety can be disabled by defining CHAISCRIPT_NO_THREADS when using the library.
 ///
-/// Disabling thread safety increases performance and removes the requirement for boost_threads.
+/// Disabling thread safety increases performance in many cases.
 ///
 /// <hr>
 ///
@@ -743,20 +745,16 @@
 /// \namespace chaiscript::detail
 /// \brief Classes and functions reserved for internal use. Items in this namespace are not supported.
 
+#include "chaiscript_defines.hpp"
+
 #include "dispatchkit/dispatchkit.hpp"
-#include "dispatchkit/bootstrap.hpp"
-#include "dispatchkit/bootstrap_stl.hpp"
 #include "dispatchkit/function_call.hpp"
 #include "dispatchkit/dynamic_object.hpp"
 #include "dispatchkit/boxed_number.hpp"
 
-#ifdef  BOOST_HAS_DECLSPEC
-#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
-#else
-#define CHAISCRIPT_MODULE_EXPORT extern "C" 
-#endif
-
 #include "language/chaiscript_eval.hpp"
 #include "language/chaiscript_engine.hpp"
 
+
+
 #endif /* CHAISCRIPT_HPP_ */

include/chaiscript/chaiscript_defines.hpp

@@ -0,0 +1,28 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// and Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_DEFINES_HPP_
+#define CHAISCRIPT_DEFINES_HPP_
+
+#ifdef _MSC_VER
+#define CHAISCRIPT_MSVC _MSC_VER
+#define CHAISCRIPT_HAS_DECLSPEc
+#endif
+
+#ifdef _WIN32
+#define CHAISCRIPT_WINDOWS
+#endif
+
+
+#ifdef  CHAISCRIPT_HAS_DECLSPEC
+#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
+#else
+#define CHAISCRIPT_MODULE_EXPORT extern "C" 
+#endif
+
+
+#endif
+

include/chaiscript/chaiscript_stdlib.hpp

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

include/chaiscript/chaiscript_threading.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -8,7 +8,8 @@
 #define CHAISCRIPT_THREADING_HPP_
 
 #ifndef CHAISCRIPT_NO_THREADS
-#include <boost/thread.hpp>
+#include <thread>
+#include <mutex>
 #else
 #pragma message ("ChaiScript is compiling without thread safety.")
 #endif
@@ -25,48 +26,81 @@ namespace chaiscript
 {
   namespace detail
   {
-    /// If threading is enabled, then this namespace contains boost::thread classes.
+    /// If threading is enabled, then this namespace contains std thread classes.
     /// If threading is not enabled, then stubbed in wrappers that do nothing are provided.
     /// This allows us to avoid \#ifdef code in the sections that need thread safety.
     namespace threading
     {
 
 #ifndef CHAISCRIPT_NO_THREADS
-      using boost::unique_lock; 
-      using boost::shared_lock;
-      using boost::lock_guard;
-      using boost::shared_mutex;
-      using boost::recursive_mutex;
+
+      template<typename T>
+      class unique_lock : public std::unique_lock<T>
+      {
+        public:
+          unique_lock(T &t) : std::unique_lock<T>(t) {}
+      };
+
+      template<typename T>
+      class shared_lock : public std::unique_lock<T>
+      {
+        public:
+          shared_lock(T &t) : std::unique_lock<T>(t) {}
+          void unlock() {}
+      };
+
+      template<typename T>
+      class lock_guard : public std::lock_guard<T>
+      {
+        public:
+          lock_guard(T &t) : std::lock_guard<T>(t) {}
+      };
+
+      class shared_mutex : public std::mutex { };
+
+      using std::mutex;
+
+      using std::recursive_mutex;
 
 
-      /// Typesafe thread specific storage. If threading is enabled, this class uses boost::thread_specific_ptr<T>. If
+
+      /// Typesafe thread specific storage. If threading is enabled, this class uses a mutex protected map. If
       /// threading is not enabled, the class always returns the same data, regardless of which thread it is called from.
+      /// 
+      /// \todo move to thread_local when it exists 
       template<typename T>
         class Thread_Storage
         {
           public:
-            ~Thread_Storage()
-            {
-              m_thread_storage.reset();
-            }
-
             inline T *operator->() const
             {
-              if (!m_thread_storage.get())
-              {
-                m_thread_storage.reset(new T());
-              }
-
-              return m_thread_storage.get();
+              return get_tls().get();
             }
 
             inline T &operator*() const
             {
-              return *(this->operator->());
+              return *get_tls();
             }
 
+
           private:
-            mutable boost::thread_specific_ptr<T> m_thread_storage;
+            std::shared_ptr<T> get_tls() const
+            {
+              unique_lock<mutex> lock(m_mutex);
+             
+              auto itr = m_instances.find(std::this_thread::get_id());
+
+              if (itr != m_instances.end()) { return itr->second; }
+             
+              std::shared_ptr<T> new_instance(new T());
+
+              m_instances.insert(std::make_pair(std::this_thread::get_id(), new_instance));
+
+              return new_instance;
+            }
+
+            mutable mutex m_mutex;
+            mutable std::map<std::thread::id, std::shared_ptr<T> > m_instances;
         };
 
 #else

include/chaiscript/dispatchkit/any.hpp

@@ -0,0 +1,162 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// and Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_ANY_HPP_
+#define CHAISCRIPT_ANY_HPP_
+
+namespace chaiscript {
+  namespace detail {
+    namespace exception
+    {
+      /// \brief Thrown in the event that an Any cannot be cast to the desired type
+      ///
+      /// It is used internally during function dispatch.
+      ///
+      /// \sa chaiscript::detail::Any
+      class bad_any_cast : public std::bad_cast
+      {
+        public:
+          bad_any_cast() noexcept
+            : m_what("bad any cast")
+          {
+          }
+
+          virtual ~bad_any_cast() noexcept {}
+
+          /// \brief Description of what error occured
+          virtual const char * what() const noexcept
+          {
+            return m_what.c_str();
+          }
+
+        private:
+          std::string m_what;
+      };
+    }
+  
+
+    class Any {
+      private:
+        struct Data
+        {
+          virtual void *data() = 0;
+          virtual const std::type_info &type() const = 0;
+          virtual std::shared_ptr<Data> clone() const = 0;
+        };
+
+        template<typename T>
+          struct Data_Impl : Data
+          {
+            Data_Impl(const T &t_type)
+              : m_type(typeid(T)),
+                m_data(t_type)
+            {
+            }
+
+            virtual void *data()
+            {
+              return &m_data;
+            }
+
+            const std::type_info &type() const
+            {
+              return m_type;
+            }
+
+            std::shared_ptr<Data> clone() const
+            {
+              return std::shared_ptr<Data>(new Data_Impl<T>(m_data));
+            }
+
+            const std::type_info &m_type;
+            T m_data;
+          };
+
+        std::shared_ptr<Data> m_data;
+
+      public:
+        // construct/copy/destruct
+        Any() = default;
+
+        Any(const Any &t_any) 
+        { 
+          if (!t_any.empty())
+          {
+            m_data = t_any.m_data->clone(); 
+          } else {
+            m_data.reset();
+          }
+        }
+
+        template<typename ValueType> 
+          Any(const ValueType &t_value)
+        {
+          m_data = std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value));
+        }
+
+        Any & operator=(const Any &t_any)
+        {
+          Any copy(t_any);
+          swap(copy);
+          return *this; 
+        }
+
+        template<typename ValueType> 
+          Any & operator=(const ValueType &t_value)
+        {
+          m_data = std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value));
+          return *this;
+        }
+
+        template<typename ToType>
+          ToType &cast() const
+          {
+            if (m_data && typeid(ToType) == m_data->type())
+            {
+              return *static_cast<ToType *>(m_data->data());
+            } else {
+              throw chaiscript::detail::exception::bad_any_cast();
+            }
+ 
+          }
+
+
+        ~Any()
+        {
+        }
+
+        // modifiers
+        Any & swap(Any &t_other)
+        {
+          std::shared_ptr<Data> data = t_other.m_data;
+          t_other.m_data = m_data;
+          m_data = data;
+          return *this;
+        }
+
+        // queries
+        bool empty() const
+        {
+          return !bool(m_data);
+        }
+
+        const std::type_info & type() const
+        {
+          if (m_data)
+          {
+            return m_data->type();
+          } else {
+            return typeid(void);
+          }
+        }
+    };
+
+  }
+}
+
+#endif
+
+

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -22,25 +22,25 @@ namespace chaiscript
     {
       public:
         bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) throw()
+            const std::string &t_what) noexcept
           : from(t_from), to(&t_to), m_what(t_what)
         {
         }
 
-        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
+        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) noexcept
           : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
         {
         }
 
-        bad_boxed_cast(const std::string &t_what) throw()
-          : m_what(t_what)
+        bad_boxed_cast(const std::string &t_what) noexcept
+          : to(0), m_what(t_what)
         {
         }
 
-        virtual ~bad_boxed_cast() throw() {}
+        virtual ~bad_boxed_cast() noexcept {} 
 
         /// \brief Description of what error occured
-        virtual const char * what() const throw()
+        virtual const char * what() const noexcept
         {
           return m_what.c_str();
         }

include/chaiscript/dispatchkit/bind_first.hpp

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

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -12,7 +12,8 @@
 #include "register_function.hpp"
 #include "operators.hpp"
 #include "boxed_number.hpp"
-#include <boost/function_types/result_type.hpp>
+#include <sstream>
+#include <type_traits>
 
 namespace chaiscript 
 {
@@ -25,9 +26,9 @@ namespace chaiscript
       /// \param[in] v Boxed_Number to copy into the new object
       /// \returns The newly created object.
       template<typename P1>
-      boost::shared_ptr<P1> construct_pod(Boxed_Number v)
+      std::shared_ptr<P1> construct_pod(Boxed_Number v)
       {
-        boost::shared_ptr<P1> p(new P1());
+        std::shared_ptr<P1> p(new P1());
         Boxed_Value bv(p);
         Boxed_Number nb(bv);
         nb = v;
@@ -93,27 +94,30 @@ namespace chaiscript
 
 
     /**
-    * to_string function for internal use. Uses ostream operator<<
-    */
+     * to_string function for internal use. Uses ostream operator<<
+     */
     template<typename Input>
     std::string to_string(Input i)
     {
-      return boost::lexical_cast<std::string>(i);
+      std::stringstream ss;
+      ss << i;
+      return ss.str();
     }
 
-
     /**
-    * Internal function for converting from a string to a value
-    * uses ostream operator >> to perform the conversion
-    */
+     * Internal function for converting from a string to a value
+     * uses ostream operator >> to perform the conversion
+     */
     template<typename Input>
     Input parse_string(const std::string &i)
     {
-      return boost::lexical_cast<Input>(i);
+      std::stringstream ss(i);
+      Input t;
+      ss >> t;
+      return t;
     }
-
-
-
+      
+            
     /**
     * Add all common functions for a POD type. All operators, and
     * common conversions
@@ -139,7 +143,7 @@ namespace chaiscript
     * function variables.
     */
     template<typename Type>
-    boost::shared_ptr<Type> shared_ptr_clone(const boost::shared_ptr<Type> &p)
+    std::shared_ptr<Type> shared_ptr_clone(const std::shared_ptr<Type> &p)
     {
       return p;
     }
@@ -148,10 +152,10 @@ namespace chaiscript
      * Specific version of shared_ptr_clone just for Proxy_Functions
      */
     template<typename Type>
-    boost::shared_ptr<typename boost::remove_const<Type>::type> 
-        shared_ptr_unconst_clone(const boost::shared_ptr<typename boost::add_const<Type>::type> &p)
+    std::shared_ptr<typename std::remove_const<Type>::type> 
+        shared_ptr_unconst_clone(const std::shared_ptr<typename std::add_const<Type>::type> &p)
     {
-      return boost::const_pointer_cast<typename boost::remove_const<Type>::type>(p);
+      return std::const_pointer_cast<typename std::remove_const<Type>::type>(p);
     }
 
 
@@ -162,7 +166,7 @@ namespace chaiscript
     * Similar to shared_ptr_clone. Used for Proxy_Function.
     */
     template<typename Type>
-    Boxed_Value ptr_assign(Boxed_Value lhs, const boost::shared_ptr<Type> &rhs)
+    Boxed_Value ptr_assign(Boxed_Value lhs, const std::shared_ptr<Type> &rhs)
     {
       if (lhs.is_undef() 
           || (!lhs.get_type_info().is_const() && lhs.get_type_info().bare_equal(chaiscript::detail::Get_Type_Info<Type>::get())))
@@ -283,10 +287,10 @@ namespace chaiscript
 
       static bool has_guard(const Const_Proxy_Function &t_pf)
       {
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
-          return pf->get_guard();
+          return bool(pf->get_guard());
         } else {
           return false;
         }
@@ -294,7 +298,7 @@ namespace chaiscript
 
       static Const_Proxy_Function get_guard(const Const_Proxy_Function &t_pf)
       {
-        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
           if (pf->get_guard())
@@ -312,7 +316,9 @@ namespace chaiscript
         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()))
+      static std::shared_ptr<chaiscript::detail::Dispatch_Engine> bootstrap2(
+          std::shared_ptr<chaiscript::detail::Dispatch_Engine> e 
+             = std::shared_ptr<chaiscript::detail::Dispatch_Engine> (new chaiscript::detail::Dispatch_Engine()))
       {
         e->add(user_type<void>(), "void");
         return e;
@@ -340,24 +346,22 @@ namespace chaiscript
         static std::vector<Boxed_Value> do_return_boxed_value_vector(FunctionType f,
             const dispatch::Proxy_Function_Base *b)
         {
-          typedef typename boost::function_types::result_type<FunctionType>::type Vector;
-          Vector v = (b->*f)();
+          auto v = (b->*f)();
  
           std::vector<Boxed_Value> vbv;
-          for (typename Vector::const_iterator itr = v.begin();
-               itr != v.end();
-               ++itr)
+
+          for (const auto &o: v)
           {
-            vbv.push_back(const_var(*itr));
+            vbv.push_back(const_var(o));
           }
 
           return vbv;
         }
 
       template<typename Function>
-      static boost::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
+      static std::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
       {
-        return boost::bind(&do_return_boxed_value_vector<Function>, f, _1);
+        return std::bind(&do_return_boxed_value_vector<Function>, f, std::placeholders::_1);
       }
 
     public:
@@ -388,7 +392,7 @@ namespace chaiscript
  
 
         m->add(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
-        m->add(fun(boost::function<std::string (const std::runtime_error &)>(&what)), "what");     
+        m->add(fun(std::function<std::string (const std::runtime_error &)>(&what)), "what");     
 
         m->add(user_type<dispatch::Dynamic_Object>(), "Dynamic_Object");
         m->add(constructor<dispatch::Dynamic_Object (const std::string &)>(), "Dynamic_Object");
@@ -396,7 +400,7 @@ namespace chaiscript
         m->add(fun(&dispatch::Dynamic_Object::get_attrs), "get_attrs");
         m->add(fun(&dispatch::Dynamic_Object::get_attr), "get_attr");
 
-        m->eval("def Dynamic_Object::clone() { var new_o := Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
+        m->eval("def Dynamic_Object::clone() { auto &new_o = Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
 
         m->add(fun(&has_guard), "has_guard");
         m->add(fun(&get_guard), "get_guard");
@@ -422,9 +426,6 @@ namespace chaiscript
         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);
@@ -445,14 +446,14 @@ namespace chaiscript
         bootstrap_pod_type<unsigned long>("unsigned_long", m);
         bootstrap_pod_type<size_t>("size_t", m);
         bootstrap_pod_type<char>("char", m);
-        bootstrap_pod_type<boost::int8_t>("int8_t", m);
-        bootstrap_pod_type<boost::int16_t>("int16_t", m);
-        bootstrap_pod_type<boost::int32_t>("int32_t", m);
-        bootstrap_pod_type<boost::int64_t>("int64_t", m);
-        bootstrap_pod_type<boost::uint8_t>("uint8_t", m);
-        bootstrap_pod_type<boost::uint16_t>("uint16_t", m);
-        bootstrap_pod_type<boost::uint32_t>("uint32_t", m);
-        bootstrap_pod_type<boost::uint64_t>("uint64_t", m);
+        bootstrap_pod_type<std::int8_t>("int8_t", m);
+        bootstrap_pod_type<std::int16_t>("int16_t", m);
+        bootstrap_pod_type<std::int32_t>("int32_t", m);
+        bootstrap_pod_type<std::int64_t>("int64_t", m);
+        bootstrap_pod_type<std::uint8_t>("uint8_t", m);
+        bootstrap_pod_type<std::uint16_t>("uint16_t", m);
+        bootstrap_pod_type<std::uint32_t>("uint32_t", m);
+        bootstrap_pod_type<std::uint64_t>("uint64_t", m);
 
         operators::logical_compliment<bool>(m);
 
@@ -462,17 +463,17 @@ namespace chaiscript
         m->add(fun(&print), "print_string");
         m->add(fun(&println), "println_string");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&bind_function, _1))), 
+        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&bind_function, std::placeholders::_1))), 
           "bind");
 
         m->add(fun(&shared_ptr_unconst_clone<dispatch::Proxy_Function_Base>), "clone");
-        m->add(fun(&ptr_assign<boost::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
-        m->add(fun(&ptr_assign<boost::add_const<dispatch::Proxy_Function_Base>::type>), "=");
+        m->add(fun(&ptr_assign<std::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
+        m->add(fun(&ptr_assign<std::add_const<dispatch::Proxy_Function_Base>::type>), "=");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), 
+        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&call_exists, std::placeholders::_1))), 
           "call_exists");
 
-        m->add(fun(&type_match), "type_match");
+        m->add(fun(&Boxed_Value::type_match), "type_match");
 
         return m;
       }

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -17,6 +17,7 @@
 #define CHAISCRIPT_BOOTSTRAP_STL_HPP_
 
 #include "dispatchkit.hpp"
+#include "bootstrap.hpp"
 #include "register_function.hpp"
 
 namespace chaiscript 
@@ -147,6 +148,7 @@ namespace chaiscript
         };
 
       namespace detail {
+
         /**
          * Add Bidir_Range support for the given ContainerType
          */
@@ -227,11 +229,11 @@ namespace chaiscript
           //In the interest of runtime safety for the m, we prefer the at() method for [] access,
           //to throw an exception in an out of bounds condition.
           m->add(
-              fun(boost::function<typename ContainerType::reference (ContainerType *, int)>
-                (boost::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
+              fun(std::function<typename ContainerType::reference (ContainerType *, int)>
+                (std::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
           m->add(
-              fun(boost::function<typename ContainerType::const_reference (const ContainerType *, int)>
-                (boost::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
+              fun(std::function<typename ContainerType::const_reference (const ContainerType *, int)>
+                (std::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
 
           return m;
         }
@@ -255,10 +257,9 @@ namespace chaiscript
       template<typename ContainerType>
         ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(boost::function<int (const ContainerType *)>(boost::mem_fn(&ContainerType::size))), "size");
-          m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
-          m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
-
+          m->add(fun( std::function<int (const ContainerType *)>( [](const ContainerType *a) { return a->size(); } ) ), "size");
+          m->add(fun( std::function<bool (const ContainerType *)>( [](const ContainerType *a) { return a->empty(); } ) ), "empty");
+          m->add(fun( std::function<void (ContainerType *)>( [](ContainerType *a) { a->clear(); } ) ), "clear");
           return m;
         }
 
@@ -390,7 +391,7 @@ namespace chaiscript
       template<typename ContainerType>
         ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(boost::function<int (const ContainerType *, const typename ContainerType::key_type &)>(boost::mem_fn(&ContainerType::count))), "count");
+          m->add(fun<int (const ContainerType *, const typename ContainerType::key_type &)>(&ContainerType::count), "count");
 
           return m;
         }
@@ -464,8 +465,8 @@ namespace chaiscript
                        if ( rhs.size() != this.size() ) {    \
                          return false;  \
                        } else {  \
-                         var r1 = range(this); \
-                         var r2 = range(rhs);  \
+                         auto r1 = range(this); \
+                         auto r2 = range(rhs);  \
                          while (!r1.empty()) \
                          {  \
                            if (!eq(r1.front(), r2.front())) \
@@ -511,19 +512,17 @@ namespace chaiscript
           }
           m->add(fun(&String::push_back), push_back_name);
 
-          typedef typename String::size_type (String::*find_func_ptr)(const String &, typename String::size_type) const;
+          typedef std::function<int (const String *, const String &, int)> find_func;
 
-          typedef boost::function<int (const String *, const String &, int)> find_func;
+          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find(f, pos); } )), "find");
+          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->rfind(f, pos); } ) ), "rfind");
+          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_first_of(f, pos); } ) ), "find_first_of");
+          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_last_of(f, pos); } ) ), "find_last_of");
+          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_last_not_of(f, pos); } ) ), "find_last_not_of");
+          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_first_not_of(f, pos); } ) ), "find_first_not_of");
 
-          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( std::function<const char *(const String *)>( [](const String *s) { return s->c_str(); } ) ), "c_str");
+          m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->data(); } ) ), "data");
 
 
           return m;

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -1,11 +1,13 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __boxed_cast_hpp__
-#define __boxed_cast_hpp__
+#ifndef CHAISCRIPT_BOXED_CAST_HPP_
+#define CHAISCRIPT_BOXED_CAST_HPP_
+
+#include "../chaiscript_defines.hpp"
 
 #include "type_info.hpp"
 #include "boxed_value.hpp"
@@ -13,14 +15,6 @@
 #include "dynamic_cast_conversion.hpp"
 
 #include "../chaiscript_threading.hpp"
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/integer_traits.hpp>
 
 namespace chaiscript 
 {
@@ -31,39 +25,39 @@ namespace chaiscript
   /// \returns Type equivalent to the requested type 
   /// \throws exception::bad_boxed_cast If the requested conversion is not possible
   /// 
-  /// boxed_cast will attempt to make conversions between value, &, *, boost::shared_ptr, boost::reference_wrapper,
-  /// and boost::function (const and non-const) where possible. boxed_cast is used internally during function
+  /// boxed_cast will attempt to make conversions between value, &, *, std::shared_ptr, std::reference_wrapper,
+  /// and std::function (const and non-const) where possible. boxed_cast is used internally during function
   /// dispatch. This means that all of these conversions will be attempted automatically for you during
   /// ChaiScript function calls.
   ///
   /// \li non-const values can be extracted as const or non-const
   /// \li const values can be extracted only as const
-  /// \li Boxed_Value constructed from pointer or boost::reference_wrapper can be extracted as reference,
+  /// \li Boxed_Value constructed from pointer or std::reference_wrapper can be extracted as reference,
   ///     pointer or value types
-  /// \li Boxed_Value constructed from boost::shared_ptr or value types can be extracted as reference,
-  ///     pointer, value, or boost::shared_ptr types
+  /// \li Boxed_Value constructed from std::shared_ptr or value types can be extracted as reference,
+  ///     pointer, value, or std::shared_ptr types
   ///
-  /// Conversions to boost::function objects are attempted as well
+  /// Conversions to std::function objects are attempted as well
   ///
   /// Example:
   /// \code
   /// // All of the following should succeed
   /// chaiscript::Boxed_Value bv(1);
-  /// boost::shared_ptr<int> spi = chaiscript::boxed_cast<boost::shared_ptr<int> >(bv);
+  /// std::shared_ptr<int> spi = chaiscript::boxed_cast<std::shared_ptr<int> >(bv);
   /// int i = chaiscript::boxed_cast<int>(bv);
   /// int *ip = chaiscript::boxed_cast<int *>(bv);
   /// int &ir = chaiscript::boxed_cast<int &>(bv);
-  /// boost::shared_ptr<const int> cspi = chaiscript::boxed_cast<boost::shared_ptr<const int> >(bv);
+  /// std::shared_ptr<const int> cspi = chaiscript::boxed_cast<std::shared_ptr<const int> >(bv);
   /// const int ci = chaiscript::boxed_cast<const int>(bv);
   /// const int *cip = chaiscript::boxed_cast<const int *>(bv);
   /// const int &cir = chaiscript::boxed_cast<const int &>(bv);
   /// \endcode
   ///
-  /// boost::function conversion example
+  /// std::function conversion example
   /// \code
   /// chaiscript::ChaiScript chai;
   /// Boxed_Value bv = chai.eval("`+`"); // Get the functor for the + operator which is built in 
-  /// boost::function<int (int, int)> f = chaiscript::boxed_cast<boost::function<int (int, int)> >(bv);
+  /// std::function<int (int, int)> f = chaiscript::boxed_cast<std::function<int (int, int)> >(bv);
   /// int i = f(2,3);
   /// assert(i == 5);
   /// \endcode
@@ -72,22 +66,23 @@ namespace chaiscript
   {
     try {
       return detail::Cast_Helper<Type>::cast(bv);
-    } catch (const boost::bad_any_cast &) {
+    } catch (const chaiscript::detail::exception::bad_any_cast &) {
 
-#ifdef BOOST_MSVC
+
+#ifdef CHAISCRIPT_MSVC
       //Thank you MSVC, yes we know that a constant value is being used in the if
       // statment in THIS VERSION of the template instantiation
 #pragma warning(push)
 #pragma warning(disable : 4127)
 #endif
 
-      if (boost::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value)
+      if (std::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value)
       {
         try {
           // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
           // either way, we are not responsible if it doesn't work
           return detail::Cast_Helper<Type>::cast(detail::boxed_dynamic_cast<Type>(bv));
-        } catch (const boost::bad_any_cast &) {
+        } catch (const chaiscript::detail::exception::bad_any_cast &) {
           throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
         }
       } else {
@@ -96,7 +91,7 @@ namespace chaiscript
         throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
       }
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
 

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -10,10 +10,6 @@
 #include "type_info.hpp"
 #include "boxed_value.hpp"
 
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/ref.hpp>
-#include <boost/type_traits/add_const.hpp>
 
 namespace chaiscript 
 {
@@ -27,7 +23,7 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner
       {
-        typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
+        typedef typename std::reference_wrapper<typename std::add_const<Result>::type > Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob)
         {
@@ -35,16 +31,16 @@ namespace chaiscript
           {
             if (!ob.get_type_info().is_const())
             {
-              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
+              return std::cref((ob.get().cast<std::reference_wrapper<Result> >()).get());
             } else {
-              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
+              return ob.get().cast<std::reference_wrapper<const Result> >();
             }
           } else {
             if (!ob.get_type_info().is_const())
             {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
+              return std::cref(*(ob.get().cast<std::shared_ptr<Result> >()));   
             } else {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
+              return std::cref(*(ob.get().cast<std::shared_ptr<const Result> >()));   
             }
           }
         }
@@ -77,16 +73,16 @@ namespace chaiscript
           {
             if (!ob.get_type_info().is_const())
             {
-              return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+              return &(ob.get().cast<std::reference_wrapper<Result> >()).get();
             } else {
-              return (boost::any_cast<boost::reference_wrapper<const Result> >(ob.get())).get_pointer();
+              return &(ob.get().cast<std::reference_wrapper<const Result> >()).get();
             }
           } else {
             if (!ob.get_type_info().is_const())
             {
-              return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+              return (ob.get().cast<std::shared_ptr<Result> >()).get();
             } else {
-              return (boost::any_cast<boost::shared_ptr<const Result> >(ob.get())).get();
+              return (ob.get().cast<std::shared_ptr<const Result> >()).get();
             }
           }
         }
@@ -104,9 +100,9 @@ namespace chaiscript
         {
           if (ob.is_ref())
           {
-            return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+            return &(ob.get().cast<std::reference_wrapper<Result> >()).get();
           } else {
-            return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+            return (ob.get().cast<std::shared_ptr<Result> >()).get();
           }
         }
       };
@@ -117,76 +113,77 @@ namespace chaiscript
     template<typename Result>
       struct Cast_Helper_Inner<Result &>
       {
-        typedef typename boost::reference_wrapper<Result> Result_Type;
+        typedef Result& Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result &cast(const Boxed_Value &ob)
         {
           if (ob.is_ref())
           {
-            return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
+            return ob.get().cast<std::reference_wrapper<Result> >();
           } else {
-            return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
+            Result &r = *(ob.get().cast<std::shared_ptr<Result> >());
+            return r;
           }
         }
       };
 
     /**
-     * Cast_Helper_Inner for casting to a boost::shared_ptr<> type
+     * Cast_Helper_Inner for casting to a std::shared_ptr<> type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<typename boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<typename std::shared_ptr<Result> >
       {
-        typedef typename boost::shared_ptr<Result> Result_Type;
+        typedef typename std::shared_ptr<Result> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob)
         {
-          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
+          return ob.get().cast<std::shared_ptr<Result> >();
         }
       };
 
     /**
-     * Cast_Helper_Inner for casting to a boost::shared_ptr<const> type
+     * Cast_Helper_Inner for casting to a std::shared_ptr<const> type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<typename boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<typename std::shared_ptr<const Result> >
       {
-        typedef typename boost::shared_ptr<const Result> Result_Type;
+        typedef typename std::shared_ptr<const Result> Result_Type;
 
         static Result_Type cast(const Boxed_Value &ob)
         {
           if (!ob.get_type_info().is_const())
           {
-            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
+            return std::const_pointer_cast<const Result>(ob.get().cast<std::shared_ptr<Result> >());
           } else {
-            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
+            return ob.get().cast<std::shared_ptr<const Result> >();
           }
         }
       };
 
     /**
-     * Cast_Helper_Inner for casting to a const boost::shared_ptr<> & type
+     * Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<Result> > : Cast_Helper_Inner<boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<Result> > : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<Result> &> : Cast_Helper_Inner<boost::shared_ptr<Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<Result> &> : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
       };
 
 
     /**
-     * Cast_Helper_Inner for casting to a const boost::shared_ptr<const> & type
+     * Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<const Result> > : Cast_Helper_Inner<boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<const Result> > : Cast_Helper_Inner<std::shared_ptr<const Result> >
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::shared_ptr<const Result> &> : Cast_Helper_Inner<boost::shared_ptr<const Result> >
+      struct Cast_Helper_Inner<const std::shared_ptr<const Result> &> : Cast_Helper_Inner<std::shared_ptr<const Result> >
       {
       };
 
@@ -221,35 +218,35 @@ namespace chaiscript
     
 
 	/**
-     * Cast_Helper_Inner for casting to a boost::reference_wrapper type
+     * Cast_Helper_Inner for casting to a std::reference_wrapper type
      */
     template<typename Result>
-      struct Cast_Helper_Inner<boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
       {
       };
 
     template<typename Result>
-      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> & > : Cast_Helper_Inner<const Result &>
+      struct Cast_Helper_Inner<const std::reference_wrapper<const Result> & > : Cast_Helper_Inner<const Result &>
       {
       };
 

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -9,18 +9,25 @@
 
 #include "boxed_value.hpp"
 #include "../language/chaiscript_algebraic.hpp"
-#include <boost/cstdint.hpp>
 
 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 &)
         {
@@ -39,9 +46,9 @@ namespace chaiscript
             case Operators::not_equal:
               return const_var(t != u);
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
-          throw boost::bad_any_cast();        
+          throw chaiscript::detail::exception::bad_any_cast();        
         }
       };
 
@@ -74,7 +81,7 @@ namespace chaiscript
               t -= u;
               break;
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
 
           return t_lhs;
@@ -107,7 +114,7 @@ namespace chaiscript
               t ^= u;
               break;
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
           return t_lhs;
         }
@@ -135,9 +142,9 @@ namespace chaiscript
             case Operators::bitwise_complement:
               return const_var(~t);
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
-          throw boost::bad_any_cast();        
+          throw chaiscript::detail::exception::bad_any_cast();        
         }
       };
 
@@ -161,9 +168,9 @@ namespace chaiscript
             case Operators::unary_plus:
               return const_var(+t);
             default:
-              throw boost::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();        
           }
-          throw boost::bad_any_cast();        
+          throw chaiscript::detail::exception::bad_any_cast();        
         }
       };
 
@@ -184,7 +191,7 @@ namespace chaiscript
           } else if (t_oper > Operators::const_flag) {
             return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
           } else {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -200,13 +207,13 @@ namespace chaiscript
           } else if (t_oper > Operators::non_const_flag && t_oper < Operators::non_const_int_flag && !t_lhs.is_const()) {
             return binary::go<LHS, RHS>(t_oper, *static_cast<LHS *>(t_lhs.get_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
           } else if (t_oper > Operators::non_const_int_flag && t_oper < Operators::const_int_flag) {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           } else if (t_oper > Operators::const_int_flag && t_oper < Operators::const_flag) {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           } else if (t_oper > Operators::const_flag) {
             return const_binary::go<LHS, RHS>(t_oper, *static_cast<const LHS *>(t_lhs.get_const_ptr()), *static_cast<const RHS *>(t_rhs.get_const_ptr()), t_lhs);
           } else {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -232,24 +239,24 @@ namespace chaiscript
             return Go<LHS, long, Float>::go(t_oper, t_lhs, t_rhs);
           } else if (inp_ == typeid(unsigned long)) {
             return Go<LHS, unsigned long, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int8_t)) {
-            return Go<LHS, boost::int8_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int16_t)) {
-            return Go<LHS, boost::int16_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int32_t)) {
-            return Go<LHS, boost::int32_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int64_t)) {
-            return Go<LHS, boost::int64_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint8_t)) {
-            return Go<LHS, boost::uint8_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint16_t)) {
-            return Go<LHS, boost::uint16_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint32_t)) {
-            return Go<LHS, boost::uint32_t, Float>::go(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint64_t)) {
-            return Go<LHS, boost::uint64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int8_t)) {
+            return Go<LHS, std::int8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int16_t)) {
+            return Go<LHS, std::int16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int32_t)) {
+            return Go<LHS, std::int32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int64_t)) {
+            return Go<LHS, std::int64_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint8_t)) {
+            return Go<LHS, std::uint8_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint16_t)) {
+            return Go<LHS, std::uint16_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint32_t)) {
+            return Go<LHS, std::uint32_t, Float>::go(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint64_t)) {
+            return Go<LHS, std::uint64_t, Float>::go(t_oper, t_lhs, t_rhs);
           } else {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         } 
 
@@ -273,43 +280,39 @@ namespace chaiscript
             return oper_rhs<long, false>(t_oper, t_lhs, t_rhs);
           } else if (inp_ == typeid(unsigned long)) {
             return oper_rhs<unsigned long, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int8_t)) {
-            return oper_rhs<boost::int8_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int16_t)) {
-            return oper_rhs<boost::int32_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int32_t)) {
-            return oper_rhs<boost::int32_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::int64_t)) {
-            return oper_rhs<boost::int64_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint8_t)) {
-            return oper_rhs<boost::uint8_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint16_t)) {
-            return oper_rhs<boost::uint16_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint32_t)) {
-            return oper_rhs<boost::uint32_t, false>(t_oper, t_lhs, t_rhs);
-          } else if (inp_ == typeid(boost::uint64_t)) {
-            return oper_rhs<boost::uint64_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int8_t)) {
+            return oper_rhs<std::int8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int16_t)) {
+            return oper_rhs<std::int16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int32_t)) {
+            return oper_rhs<std::int32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::int64_t)) {
+            return oper_rhs<std::int64_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint8_t)) {
+            return oper_rhs<std::uint8_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint16_t)) {
+            return oper_rhs<std::uint16_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint32_t)) {
+            return oper_rhs<std::uint32_t, false>(t_oper, t_lhs, t_rhs);
+          } else if (inp_ == typeid(std::uint64_t)) {
+            return oper_rhs<std::uint64_t, false>(t_oper, t_lhs, t_rhs);
           } else  {
-            throw boost::bad_any_cast();
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       
 
       
     public:
+      Boxed_Number()
+        : bv(Boxed_Value(0))
+      {
+      }
+
       Boxed_Number(const Boxed_Value &v)
         : bv(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();
-        }
+        validate_boxed_number(v);
       }
 
 
@@ -378,6 +381,27 @@ namespace chaiscript
         return oper(Operators::assign_bitwise_and, this->bv, t_rhs.bv);
       }
 
+      void validate_boxed_number(const Boxed_Value &v)
+      {
+        const Type_Info &inp_ = v.get_type_info();
+        if (inp_ == typeid(bool))
+        {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+
+        if (!inp_.is_arithmetic())
+        {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }
+
+      Boxed_Number operator=(const Boxed_Value &v)
+      {
+        validate_boxed_number(v);
+        bv = v;
+        return *this;
+      }
+
       Boxed_Number operator=(const Boxed_Number &t_rhs) const
       {
         return oper(Operators::assign, this->bv, t_rhs.bv);
@@ -680,7 +704,11 @@ namespace chaiscript
       {
       };  
   }
-  
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 }
 
 

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -12,14 +12,7 @@
 #include "../chaiscript_threading.hpp"
 
 #include <map>
-#include <boost/shared_ptr.hpp>
-#include <boost/any.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-#include <boost/bind.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/integer_traits.hpp>
+#include "any.hpp"
 
 namespace chaiscript 
 {
@@ -43,7 +36,7 @@ namespace chaiscript
       struct Data
       {
         Data(const Type_Info &ti,
-            const boost::any &to,
+            const chaiscript::detail::Any &to,
             bool tr,
             const void *t_void_ptr)
           : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?0:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
@@ -67,78 +60,77 @@ namespace chaiscript
         }
 
         Type_Info m_type_info;
-        boost::any m_obj;
+        chaiscript::detail::Any m_obj;
         void *m_data_ptr;
         const void *m_const_data_ptr;
         bool m_is_ref;
-        std::vector<boost::shared_ptr<Data> > m_dependencies;
       };
 
       struct Object_Data
       {
-        static boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
+        static std::shared_ptr<Data> get(Boxed_Value::Void_Type)
         {
-          return boost::shared_ptr<Data> (new Data(
+          return std::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
-                boost::any(), 
+                chaiscript::detail::Any(), 
                 false,
-                0)
-              );
+                nullptr)
+              ;
         }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> *obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> *obj)
           {
             return get(*obj);
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> &obj)
+          static std::shared_ptr<Data> get(const std::shared_ptr<T> &obj)
           {
-            return boost::shared_ptr<Data>(new Data(
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(obj), 
+                  chaiscript::detail::Any(obj), 
                   false,
-                  obj.get())
+                  obj.get()
                 );
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(T *t)
+          static std::shared_ptr<Data> get(T *t)
           {
-            return get(boost::ref(*t));
+            return get(std::ref(*t));
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
+          static std::shared_ptr<Data> get(std::reference_wrapper<T> obj)
           {
-            return boost::shared_ptr<Data>(new Data(
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
-                  boost::any(obj),
+                  chaiscript::detail::Any(obj),
                   true,
-                  obj.get_pointer())
+                  &obj.get()
                 );
           }
 
         template<typename T>
-          static boost::shared_ptr<Data> get(const T& t)
+          static std::shared_ptr<Data> get(const T& t)
           {
-            boost::shared_ptr<T> p(new T(t));
-            return boost::shared_ptr<Data>(new Data(
+            auto p = std::make_shared<T>(t);
+            return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(p), 
+                  chaiscript::detail::Any(p), 
                   false,
-                  p.get())
+                  p.get()
                 );
           }
 
-        static boost::shared_ptr<Data> get()
+        static std::shared_ptr<Data> get()
         {
-          return boost::shared_ptr<Data> (new Data(
+          return std::make_shared<Data>(
                 Type_Info(),
-                boost::any(),
+                chaiscript::detail::Any(),
                 false,
-                0)
+                nullptr 
               );
         }
 
@@ -227,7 +219,7 @@ namespace chaiscript
         return (m_data->m_data_ptr == 0 && m_data->m_const_data_ptr == 0);
       }
 
-      const boost::any & get() const
+      const chaiscript::detail::Any & get() const
       {
         return m_data->m_obj;
       }
@@ -242,24 +234,6 @@ namespace chaiscript
         return !is_ref();
       }
 
-      void clear_dependencies()
-      {
-        m_data->m_dependencies.clear();
-      }
-
-      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;
-          }
-        }
-
       void *get_ptr() const
       {
         return m_data->m_data_ptr;
@@ -270,11 +244,17 @@ namespace chaiscript
         return m_data->m_const_data_ptr;
       }
 
+      /// \returns true if the two Boxed_Values share the same internal type
+      static bool type_match(Boxed_Value l, Boxed_Value r)
+      {
+        return l.get_type_info() == r.get_type_info();
+      }
+
     private:
-      boost::shared_ptr<Data> m_data;
+      std::shared_ptr<Data> m_data;
   };
 
-  /// \brief Creates a Boxed_Value. If the object passed in is a value type, it is copied. If it is a pointer, boost::shared_ptr, or boost::reference_type
+  /// \brief Creates a Boxed_Value. If the object passed in is a value type, it is copied. If it is a pointer, std::shared_ptr, or std::reference_type
   ///        a copy is not made.
   /// \param t The value to box
   /// 
@@ -301,7 +281,7 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(const T &t)
       {
-        return Boxed_Value(boost::shared_ptr<typename boost::add_const<T>::type >(new T(t)));
+        return Boxed_Value(std::shared_ptr<typename std::add_const<T>::type >(new T(t)));
       }
 
     /// \brief Takes a pointer to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
@@ -312,33 +292,33 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(T *t)
       {
-        return Boxed_Value( const_cast<typename boost::add_const<T>::type *>(t) );
+        return Boxed_Value( const_cast<typename std::add_const<T>::type *>(t) );
       }
 
-    /// \brief Takes a boost::shared_ptr to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
+    /// \brief Takes a std::shared_ptr to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
     ///        Does not copy the pointed to value.
     /// \param[in] t Pointer to make immutable
     /// \returns Immutable Boxed_Value
     /// \sa Boxed_Value::is_const
     template<typename T>
-      Boxed_Value const_var_impl(const boost::shared_ptr<T> &t)
+      Boxed_Value const_var_impl(const std::shared_ptr<T> &t)
       {
-        return Boxed_Value( boost::const_pointer_cast<typename boost::add_const<T>::type>(t) );
+        return Boxed_Value( std::const_pointer_cast<typename std::add_const<T>::type>(t) );
       }
 
-    /// \brief Takes a boost::reference_wrapper value, adds const to the referenced type and returns an immutable Boxed_Value.
+    /// \brief Takes a std::reference_wrapper value, adds const to the referenced type and returns an immutable Boxed_Value.
     ///        Does not copy the referenced value.
     /// \param[in] t Reference object to make immutable
     /// \returns Immutable Boxed_Value
     /// \sa Boxed_Value::is_const
     template<typename T>
-      Boxed_Value const_var_impl(const boost::reference_wrapper<T> &t)
+      Boxed_Value const_var_impl(const std::reference_wrapper<T> &t)
       {
-        return Boxed_Value( boost::cref(t.get()) );
+        return Boxed_Value( std::cref(t.get()) );
       }
   }
 
-  /// \brief Takes an object and returns an immutable Boxed_Value. If the object is a boost::reference or pointer type
+  /// \brief Takes an object and returns an immutable Boxed_Value. If the object is a std::reference or pointer type
   ///        the value is not copied. If it is an object type, it is copied.
   /// \param[in] t Object to make immutable
   /// \returns Immutable Boxed_Value
@@ -368,11 +348,6 @@ namespace chaiscript
 
 
 
-  /// \returns true if the two Boxed_Values share the same internal type
-  static bool type_match(Boxed_Value l, Boxed_Value r)
-  {
-    return l.get_type_info() == r.get_type_info();
-  }
 }
 
 #endif

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -11,13 +11,12 @@
 #include <string>
 #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 <algorithm>
 
 #include "boxed_value.hpp"
 #include "type_info.hpp"
@@ -32,6 +31,71 @@
 
 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) noexcept
+          : std::runtime_error("Reserved word not allowed in object name: " + t_word), m_word(t_word)
+        {
+        }
+
+        virtual ~reserved_word_error() noexcept {}
+
+        std::string word() const
+        {
+          return m_word;
+        }
+
+      private:
+        std::string m_word;
+
+    };
+
+    /**
+     * Exception thrown in the case that an object name is invalid because it 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() noexcept
+          : std::runtime_error("a global object must be const")
+        {
+        }
+
+        virtual ~global_non_const() noexcept {}
+    };
+  }
+
+
   /// \brief Holds a collection of ChaiScript settings which can be applied to the ChaiScript runtime.
   ///        Used to implement loadable module support.
   class Module
@@ -55,6 +119,17 @@ namespace chaiscript
         return *this;
       }
 
+      Module &add_global_const(const Boxed_Value &t_bv, const std::string &t_name)
+      {
+        if (!t_bv.is_const())
+        {
+          throw chaiscript::exception::global_non_const();
+        }
+
+        m_globals.push_back(std::make_pair(t_bv, t_name));
+        return *this;
+      }
+
 
       //Add a bit of chaiscript to eval during module implementation
       Module &eval(const std::string &str)
@@ -63,7 +138,7 @@ namespace chaiscript
         return *this;
       }
 
-      Module &add(const boost::shared_ptr<Module> &m)
+      Module &add(const std::shared_ptr<Module> &m)
       {
         m->apply(*this, *this);
         return *m;
@@ -76,11 +151,18 @@ namespace chaiscript
           apply(m_funcs.begin(), m_funcs.end(), t_engine);
           apply_eval(m_evals.begin(), m_evals.end(), t_eval);
           apply_single(m_conversions.begin(), m_conversions.end(), t_engine);
+          apply_globals(m_globals.begin(), m_globals.end(), t_engine);
         }
 
+      ~Module()
+      {
+        detail::Dynamic_Conversions::get().cleanup(m_conversions.begin(), m_conversions.end());
+      }
+
     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 +171,22 @@ namespace chaiscript
         {
           while (begin != end)
           {
-            t.add(begin->first, begin->second);
+            try {
+              t.add(begin->first, begin->second);
+            } catch (const chaiscript::exception::name_conflict_error &) {
+              /// \todo Should we throw an error if there's a name conflict 
+              ///       while applying a module?
+            }
+            ++begin;
+          }
+        }
+
+      template<typename T, typename InItr>
+        void apply_globals(InItr begin, InItr end, T &t) const
+        {
+          while (begin != end)
+          {
+            t.add_global_const(begin->first, begin->second);
             ++begin;
           }
         }
@@ -116,7 +213,7 @@ namespace chaiscript
   };
 
   /// Convenience typedef for Module objects to be added to the ChaiScript runtime
-  typedef boost::shared_ptr<Module> ModulePtr;
+  typedef std::shared_ptr<Module> ModulePtr;
 
   namespace detail
   {
@@ -266,48 +363,6 @@ namespace chaiscript
     };  
   }
 
-  namespace exception
-  {
-    /**
-     * Exception thrown in the case that a multi method dispatch fails
-     * because no matching function was found
-     * at runtime due to either an arity_error, a guard_error or a bad_boxed_cast
-     * exception
-     */
-    class reserved_word_error : public std::runtime_error
-    {
-      public:
-        reserved_word_error(const std::string &t_word) throw()
-          : std::runtime_error("Reserved word not allowed in object name: " + t_word), m_word(t_word)
-        {
-        }
-
-        virtual ~reserved_word_error() throw() {}
-
-        std::string word() const
-        {
-          return m_word;
-        }
-
-      private:
-        std::string m_word;
-
-    };
-
-    /**
-     * Exception thrown in the case that a non-const object was added as a shared object
-     */
-    class global_non_const : public std::runtime_error
-    {
-      public:
-        global_non_const() throw()
-          : std::runtime_error("a global object must be const")
-        {
-        }
-
-        virtual ~global_non_const() throw() {}
-    };
-  }
 
   namespace detail
   {
@@ -321,18 +376,21 @@ namespace chaiscript
         typedef std::map<std::string, chaiscript::Type_Info> Type_Name_Map;
         typedef std::map<std::string, Boxed_Value> Scope;
         typedef std::deque<Scope> StackData;
-        typedef boost::shared_ptr<StackData> Stack;
+        typedef std::shared_ptr<StackData> Stack;
 
         struct State
         {
           std::map<std::string, std::vector<Proxy_Function> > m_functions;
+          std::map<std::string, Proxy_Function> m_function_objects;
           std::map<std::string, Boxed_Value> m_global_objects;
           Type_Name_Map m_types;
           std::set<std::string> m_reserved_words;
+
+          State &operator=(const State &) = default;
         };
 
         Dispatch_Engine()
-          : m_place_holder(boost::shared_ptr<dispatch::Placeholder_Object>(new dispatch::Placeholder_Object()))
+          : m_place_holder(std::shared_ptr<dispatch::Placeholder_Object>(new dispatch::Placeholder_Object()))
         {
         }
 
@@ -353,10 +411,10 @@ namespace chaiscript
         /**
          * 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 +438,7 @@ namespace chaiscript
 
           add_object(name, obj);
         }
+        
 
         /**
          * Adds a named object to the current scope
@@ -388,7 +447,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 chaiscript::exception::name_conflict_error(name);
+          } else {
+            stack.back().insert(std::make_pair(name, obj));
+          }
         }
 
         /**
@@ -399,12 +466,17 @@ namespace chaiscript
           validate_object_name(name);
           if (!obj.is_const())
           {
-            throw exception::global_non_const();
+            throw chaiscript::exception::global_non_const();
           }
 
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
 
-          m_state.m_global_objects[name] = obj;
+          if (m_state.m_global_objects.find(name) != m_state.m_global_objects.end())
+          {
+            throw chaiscript::exception::name_conflict_error(name);
+          } else {
+            m_state.m_global_objects.insert(std::make_pair(name, obj));
+          }
         }
 
         /**
@@ -430,28 +502,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 +559,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 +642,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 +673,57 @@ namespace chaiscript
           return functions.find(name) != functions.end();
         }
 
+
+        ///
+        /// 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
          */
@@ -665,10 +787,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;
         }
 
         /**
@@ -760,7 +881,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 +902,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 +933,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
@@ -813,8 +967,8 @@ namespace chaiscript
           const Type_Info boxed_type = user_type<Boxed_Value>();
           const Type_Info boxed_pod_type = user_type<Boxed_Number>();
 
-          boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_lhs(boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(lhs));
-          boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_rhs(boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(rhs));
+          std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_lhs(std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(lhs));
+          std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynamic_rhs(std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(rhs));
 
           if (dynamic_lhs && dynamic_rhs)
           {
@@ -906,16 +1060,15 @@ namespace chaiscript
 
           if (m_state.m_reserved_words.find(name) != m_state.m_reserved_words.end())
           {
-            throw exception::reserved_word_error(name);
+            throw chaiscript::exception::reserved_word_error(name);
           }
         }
 
         /**
-         * Implementation detail for adding a function. Returns
-         * 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 +1077,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 +1088,21 @@ namespace chaiscript
             {
               if ((*t_f) == *(*itr2))
               {
-                return false;
+                throw chaiscript::exception::name_conflict_error(t_name);
               }
             }
 
             vec.push_back(t_f);
             std::stable_sort(vec.begin(), vec.end(), &function_less_than);
+            func_objs[t_name] = Proxy_Function(new Dispatch_Function(vec));
           } else {
             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,12 +1111,17 @@ 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;

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -11,9 +11,6 @@
 #include "boxed_value.hpp"
 #include "boxed_cast_helper.hpp"
 #include "bad_boxed_cast.hpp"
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 
 namespace chaiscript
 {
@@ -23,22 +20,22 @@ namespace chaiscript
     {
       public:
         bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) throw()
+            const std::string &t_what) noexcept
           : bad_boxed_cast(t_from, t_to, t_what)
         {
         }
 
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) noexcept
           : bad_boxed_cast(t_from, t_to)
         {
         }
 
-        bad_boxed_dynamic_cast(const std::string &w) throw()
+        bad_boxed_dynamic_cast(const std::string &w) noexcept
           : bad_boxed_cast(w)
         {
         }
 
-        virtual ~bad_boxed_dynamic_cast() throw() {}
+        virtual ~bad_boxed_dynamic_cast() noexcept {}
     };
   }
 
@@ -48,6 +45,7 @@ namespace chaiscript
     {
       public:
         virtual Boxed_Value convert(const Boxed_Value &derived) = 0;
+
         const Type_Info &base()
         {
           return m_base;
@@ -63,6 +61,8 @@ namespace chaiscript
         {
         }
 
+        virtual ~Dynamic_Conversion() {} 
+
       private:
         Type_Info m_base;
         Type_Info m_derived;
@@ -87,8 +87,8 @@ namespace chaiscript
               // 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));
+                std::shared_ptr<const Base> data 
+                  = std::dynamic_pointer_cast<const Base>(detail::Cast_Helper<std::shared_ptr<const Derived> >::cast(t_derived));
                 if (!data)
                 {
                   throw std::bad_cast();
@@ -96,8 +96,8 @@ namespace chaiscript
 
                 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));
+                std::shared_ptr<Base> data 
+                  = std::dynamic_pointer_cast<Base>(detail::Cast_Helper<std::shared_ptr<Derived> >::cast(t_derived));
 
                 if (!data)
                 {
@@ -112,15 +112,15 @@ namespace chaiscript
               {
                 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));
+                return Boxed_Value(std::cref(data));
               } else {
                 Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived);
                 Base &data = dynamic_cast<Base &>(d);
-                return Boxed_Value(boost::ref(data));
+                return Boxed_Value(std::ref(data));
               }
             }
           } else {
-            throw exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
+            throw chaiscript::exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
           }
         }
     };
@@ -136,9 +136,9 @@ namespace chaiscript
         }
 
         template<typename Base, typename Derived>
-        static boost::shared_ptr<Dynamic_Conversion> create()
+        static std::shared_ptr<Dynamic_Conversion> create()
         {
-          boost::shared_ptr<Dynamic_Conversion> conversion(new Dynamic_Conversion_Impl<Base, Derived>());
+          std::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
@@ -165,7 +165,7 @@ namespace chaiscript
           }
         }
 
-        void add_conversion(const boost::shared_ptr<Dynamic_Conversion> &conversion)
+        void add_conversion(const std::shared_ptr<Dynamic_Conversion> &conversion)
         {
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
@@ -219,7 +219,7 @@ namespace chaiscript
     };
   }
 
-  typedef boost::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
+  typedef std::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
 
   /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
   ///        want automatic conversions up your inheritance hierarchy.
@@ -249,9 +249,9 @@ namespace chaiscript
   {
     //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);
+    static_assert(std::is_base_of<Base,Derived>::value, "Classes are not related by inheritance");
+    static_assert(std::is_polymorphic<Base>::value, "Base class must be polymorphic");
+    static_assert(std::is_polymorphic<Derived>::value, "Derived class must be polymorphic");
 
     return detail::Dynamic_Conversions::create<Base, Derived>();
   }
@@ -275,9 +275,9 @@ namespace chaiscript
         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");
+          throw chaiscript::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");
+          throw chaiscript::exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
         }
       }
   }

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,13 +1,12 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 #define CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 
-#include <boost/optional.hpp>
 
 namespace chaiscript
 {
@@ -44,20 +43,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
@@ -66,16 +51,26 @@ namespace chaiscript
       class Dynamic_Object_Function : public Proxy_Function_Base
       {
         public:
+          Dynamic_Object_Function(
+              const std::string &t_type_name,
+              const Proxy_Function &t_func)
+            : Proxy_Function_Base(t_func->get_param_types()),
+            m_type_name(t_type_name), m_func(t_func)
+          {
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
+
           Dynamic_Object_Function(
               const std::string &t_type_name,
               const Proxy_Function &t_func,
-              const boost::optional<Type_Info> &t_ti = boost::optional<Type_Info>())
+              const Type_Info &t_ti)
             : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti)),
-            m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
-        {
-          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(new Type_Info(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() {}
 
@@ -102,9 +97,7 @@ namespace chaiscript
 
           virtual std::vector<Const_Proxy_Function> get_contained_functions() const
           {
-            std::vector<Const_Proxy_Function> fs;
-            fs.push_back(m_func);
-            return fs;
+            return {m_func};
           }
 
 
@@ -137,23 +130,18 @@ namespace chaiscript
 
         private:
           static std::vector<Type_Info> build_param_types(
-              const std::vector<Type_Info> &t_inner_types, boost::optional<Type_Info> t_objectti)
+              const std::vector<Type_Info> &t_inner_types, const Type_Info& t_objectti)
           {
-            if (t_objectti)
-            {
-              std::vector<Type_Info> types(t_inner_types);
+            std::vector<Type_Info> types(t_inner_types);
 
-              assert(types.size() > 1);
-              assert(types[1].bare_equal(user_type<Boxed_Value>()));
-              types[1] = *t_objectti;
-              return types;
-            } else {
-              return t_inner_types;
-            }
+            assert(types.size() > 1);
+            assert(types[1].bare_equal(user_type<Boxed_Value>()));
+            types[1] = t_objectti;
+            return types;
           }
 
           static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const boost::optional<Type_Info> &ti)
+              const std::shared_ptr<Type_Info> &ti)
           {
             static Type_Info doti = user_type<Dynamic_Object>();
             if (bv.get_type_info().bare_equal(doti))
@@ -176,7 +164,7 @@ 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 std::shared_ptr<Type_Info> &ti) 
           {
             if (bvs.size() > 0)
             {
@@ -188,7 +176,7 @@ namespace chaiscript
 
           std::string m_type_name;
           Proxy_Function m_func;
-          boost::optional<Type_Info> m_ti;
+          std::shared_ptr<Type_Info> m_ti;
 
       };
 
@@ -207,10 +195,10 @@ namespace chaiscript
               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)");
-        }
+          {
+            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)
           {

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -21,7 +21,7 @@ namespace chaiscript
         template<typename T>
         void throw_type(const Boxed_Value &bv)
         {
-          try { T t = boxed_cast<T>(bv); throw t; } catch (const exception::bad_boxed_cast &) {}
+          try { T t = boxed_cast<T>(bv); throw t; } catch (const chaiscript::exception::bad_boxed_cast &) {}
         }
     };
 
@@ -128,7 +128,7 @@ namespace chaiscript
   ///
   /// \sa chaiscript::exception_specification for creation of chaiscript::Exception_Handler objects
   /// \sa \ref exceptions
-  typedef boost::shared_ptr<detail::Exception_Handler_Base> Exception_Handler;
+  typedef std::shared_ptr<detail::Exception_Handler_Base> Exception_Handler;
 
   /// \brief creates a chaiscript::Exception_Handler which handles one type of exception unboxing
   /// \sa \ref exceptions

include/chaiscript/dispatchkit/function_call.hpp

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

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,22 +1,12 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#define addparam(z,n,text)  params.push_back((boost::is_reference<Param ## n>::value&&!(boost::is_same<chaiscript::Boxed_Value, typename boost::remove_const<typename boost::remove_reference<Param ## n>::type>::type>::value))?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
-#define curry(z,n,text)  BOOST_PP_CAT(_, BOOST_PP_INC(n))
-
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 #define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 
-#include <boost/shared_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
 #include <string>
 #include <vector>
 #include "proxy_functions.hpp"
@@ -54,50 +44,41 @@ namespace chaiscript
             dispatch::dispatch(t_funcs, params);
           }
         };
-    }
-  }
-}
 
-#define BOOST_PP_ITERATION_LIMITS ( 0, 9 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/function_call_detail.hpp>
-#include BOOST_PP_ITERATE()
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
-  namespace dispatch
-  {
-    namespace detail
-    {
       /**
        * used internally for unwrapping a function call's types
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        Ret function_caller(const std::vector<Const_Proxy_Function> &funcs 
-            BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
+      template<typename Ret, typename ... Param>
+        struct Build_Function_Caller_Helper
         {
-          std::vector<Boxed_Value> params;
+          Build_Function_Caller_Helper(const std::vector<Const_Proxy_Function> &t_funcs)
+            : m_funcs(t_funcs)
+          {
+          }
 
-          BOOST_PP_REPEAT(n, addparam, ~)
+          Ret operator()(Param...param)
+          {
+            return Function_Caller_Ret<Ret>::call(m_funcs, { 
+(std::is_reference<Param>::value&&!(std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<Param>::type>::type>::value))?Boxed_Value(std::ref(param)):Boxed_Value(param)... 
+          }
+          
+          );
 
-            return Function_Caller_Ret<Ret>::call(funcs, params);
-        }
+          }
 
-      /**
-       * used internally for unwrapping a function call's types
-       */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
-        build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<Const_Proxy_Function> &funcs)
+          std::vector<Const_Proxy_Function> m_funcs;
+        };
+
+
+
+      template<typename Ret, typename ... Params>
+        std::function<Ret (Params...)> build_function_caller_helper(Ret (Params...), const std::vector<Const_Proxy_Function> &funcs)
         {
           if (funcs.size() == 1)
           {
-            boost::shared_ptr<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> > pfi = 
-              boost::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> >
-              (funcs[0]);
+            std::shared_ptr<const Proxy_Function_Impl<Ret (Params...)>> pfi = 
+              std::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (Params...)> >
+                (funcs[0]);
 
             if (pfi)
             {
@@ -107,13 +88,11 @@ namespace chaiscript
             // we cannot make any other guesses or assumptions really, so continuing
           }
 
-          return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs
-              BOOST_PP_ENUM_TRAILING(n, curry, ~));
+          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs));
         }
     }
   }
 }
-#undef n
 
 #endif
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -11,7 +11,6 @@
 #include "boxed_number.hpp"
 #include "type_info.hpp"
 #include <string>
-#include <boost/function.hpp>
 
 #include <stdexcept>
 #include <vector>
@@ -35,27 +34,36 @@ namespace chaiscript
         };
 
       template<typename Ret>
-        struct Handle_Return<boost::shared_ptr<Ret> &>
+        struct Handle_Return<Ret *>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(Ret *p)
+          {
+            return Boxed_Value(p);
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<std::shared_ptr<Ret> &>
+        {
+          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
             return Boxed_Value(r);
           }
         };
 
       template<typename Ret>
-        struct Handle_Return<boost::shared_ptr<Ret> >
+        struct Handle_Return<std::shared_ptr<Ret> >
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
             return Boxed_Value(r);
           }
         };
 
       template<typename Ret>
-        struct Handle_Return<const boost::shared_ptr<Ret> &>
+        struct Handle_Return<const std::shared_ptr<Ret> &>
         {
-          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          static Boxed_Value handle(const std::shared_ptr<Ret> &r)
           {
             return Boxed_Value(r);
           }
@@ -66,7 +74,7 @@ namespace chaiscript
         {
           static Boxed_Value handle(const Ret &r)
           {
-            return Boxed_Value(boost::cref(r));
+            return Boxed_Value(std::cref(r));
           }
         };
 
@@ -79,12 +87,12 @@ namespace chaiscript
         {
           static Boxed_Value handle(Ret &r)
           {
-            return Boxed_Value(boost::ref(r));
+            return Boxed_Value(std::ref(r));
           }
 
           static Boxed_Value handle(const Ret &r)
           {
-            return Boxed_Value(boost::cref(r));
+            return Boxed_Value(std::cref(r));
           }
         };
 

include/chaiscript/dispatchkit/operators.hpp

@@ -1,12 +1,14 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_OPERATORS_HPP_
 #define CHAISCRIPT_OPERATORS_HPP_
 
+#include "../chaiscript_defines.hpp"
+
 namespace chaiscript 
 {
   namespace bootstrap
@@ -154,7 +156,7 @@ namespace chaiscript
       template<typename Ret, typename L>
         Ret unary_minus(L l)
         {
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4146)
           return (-l);

include/chaiscript/dispatchkit/proxy_constructors.hpp

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

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -12,10 +12,10 @@
 #include "boxed_value.hpp"
 #include "type_info.hpp"
 #include <string>
-#include <boost/function.hpp>
-#include <boost/type_traits/add_reference.hpp>
+#include <type_traits>
 #include <stdexcept>
 #include <vector>
+#include <cassert>
 #include "proxy_functions_detail.hpp"
 
 namespace chaiscript
@@ -23,42 +23,11 @@ namespace chaiscript
   class Boxed_Number;
   struct AST_Node;
 
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<struct AST_Node> AST_NodePtr;
 
 
   namespace dispatch
   {
-    /**
-     * Helper for building a list of parameters for calling a Proxy_Function
-     * it does automatic conversion to Boxed_Value types via operator<<
-     *
-     * example usage:
-     * Boxed_Value retval = dispatch(dispatchengine.get_function("+"), 
-     *                               chaiscript::Param_List_Builder() << 5 << 6);
-     */
-    struct Param_List_Builder
-    {
-      Param_List_Builder &operator<<(const Boxed_Value &so)
-      {
-        objects.push_back(so);
-        return *this;
-      }
-
-      template<typename T>
-        Param_List_Builder &operator<<(T t)
-        {
-          objects.push_back(Boxed_Value(t));
-          return *this;
-        }
-
-      operator const std::vector<Boxed_Value> &() const
-      {
-        return objects;
-      }
-
-      std::vector<Boxed_Value> objects;
-    };
-
     /**
      * Pure virtual base class for all Proxy_Function implementations
      * Proxy_Functions are a type erasure of type safe C++
@@ -74,7 +43,6 @@ namespace chaiscript
         Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
         {
           Boxed_Value bv = do_call(params);
-          bv.add_dependencies(params.begin(), params.end());
           return bv;
         }
 
@@ -82,14 +50,14 @@ namespace chaiscript
         /// if the function is variadic or takes no arguments (arity of 0 or -1), the returned
         /// value containes exactly 1 Type_Info object: the return type
         /// \returns the types of all parameters. 
-        std::vector<Type_Info> get_param_types() const { return m_types; }
+        const std::vector<Type_Info> &get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
         virtual bool call_match(const std::vector<Boxed_Value> &vals) const = 0;
 
-        virtual std::vector<boost::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
+        virtual std::vector<std::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
         {
-          return std::vector<boost::shared_ptr<const Proxy_Function_Base> >();
+          return std::vector<std::shared_ptr<const Proxy_Function_Base> >();
         }
 
 
@@ -142,7 +110,7 @@ namespace chaiscript
                 && (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> >())
+                  || bv.get_type_info().bare_equal(user_type<std::shared_ptr<const Proxy_Function_Base> >())
                   )
                 )
              )
@@ -176,11 +144,11 @@ namespace chaiscript
   }
 
   /// \brief Common typedef used for passing of any registered function in ChaiScript
-  typedef boost::shared_ptr<dispatch::Proxy_Function_Base> Proxy_Function;
+  typedef std::shared_ptr<dispatch::Proxy_Function_Base> Proxy_Function;
 
   /// \brief Const version of Proxy_Function chaiscript. Points to a const Proxy_Function. This is how most registered functions
   ///        are handled internally.
-  typedef boost::shared_ptr<const dispatch::Proxy_Function_Base> Const_Proxy_Function;
+  typedef std::shared_ptr<const dispatch::Proxy_Function_Base> Const_Proxy_Function;
 
   namespace exception
   {
@@ -188,11 +156,11 @@ namespace chaiscript
     class guard_error : public std::runtime_error
     {
       public:
-        guard_error() throw()
+        guard_error() noexcept
           : std::runtime_error("Guard evaluation failed")
         { }
 
-        virtual ~guard_error() throw()
+        virtual ~guard_error() noexcept
         { }
     };
   }
@@ -207,7 +175,7 @@ namespace chaiscript
     {
       public:
         Dynamic_Proxy_Function(
-            const boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, 
+            const std::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, 
             int t_arity=-1,
             const AST_NodePtr &t_parsenode = AST_NodePtr(),
             const std::string &t_description = "",
@@ -219,7 +187,12 @@ 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
@@ -293,7 +266,7 @@ namespace chaiscript
           // For the return type
           types.push_back(chaiscript::detail::Get_Type_Info<Boxed_Value>::get());
 
-          if (arity >= 0)
+          if (arity > 0)
           {
             for (int i = 0; i < arity; ++i)
             {
@@ -304,7 +277,7 @@ namespace chaiscript
           return types;
         }
 
-        boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
+        std::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
         int m_arity;
         std::string m_description;
         Proxy_Function m_guard;
@@ -409,6 +382,7 @@ namespace chaiscript
             const std::vector<Boxed_Value> &t_args)
         {
           assert(t_f->get_arity() < 0 || t_f->get_arity() == static_cast<int>(t_args.size()));
+
           if (t_f->get_arity() < 0) { return std::vector<Type_Info>(); }
 
           std::vector<Type_Info> types = t_f->get_param_types();
@@ -440,18 +414,18 @@ namespace chaiscript
 
     /**
      * The standard typesafe function call implementation of Proxy_Function
-     * It takes a boost::function<> object and performs runtime 
+     * It takes a std::function<> object and performs runtime 
      * type checking of Boxed_Value parameters, in a type safe manner
      */
     template<typename Func>
       class Proxy_Function_Impl : public Proxy_Function_Base
     {
       public:
-        Proxy_Function_Impl(const boost::function<Func> &f)
+        Proxy_Function_Impl(const std::function<Func> &f)
           : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(0))),
           m_f(f), m_dummy_func(0)
-      {
-      }
+        {
+        }
 
         virtual ~Proxy_Function_Impl() {}
 
@@ -461,13 +435,11 @@ namespace chaiscript
           return pimpl != 0;
         }
 
-
         virtual int get_arity() const
         {
           return static_cast<int>(m_types.size()) - 1;
         }
 
-
         virtual bool call_match(const std::vector<Boxed_Value> &vals) const
         {
           if (int(vals.size()) != get_arity()) 
@@ -483,7 +455,7 @@ namespace chaiscript
           return "";
         }
 
-        boost::function<Func> internal_function() const
+        std::function<Func> internal_function() const
         {
           return m_f;
         }
@@ -491,11 +463,11 @@ namespace chaiscript
       protected:
         virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
         {
-          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params);
+          return detail::Do_Call<typename std::function<Func>::result_type>::go(m_f, params);
         }
 
       private:
-        boost::function<Func> m_f;
+        std::function<Func> m_f;
         Func *m_dummy_func;
     };
 
@@ -509,8 +481,8 @@ namespace chaiscript
         Attribute_Access(T Class::* t_attr)
           : Proxy_Function_Base(param_types()),
           m_attr(t_attr)
-      {
-      }
+        {
+        }
 
         virtual ~Attribute_Access() {}
 
@@ -518,6 +490,7 @@ namespace chaiscript
         {
           const Attribute_Access<T, Class> * aa 
             = dynamic_cast<const Attribute_Access<T, Class> *>(&t_func);
+
           if (aa) {
             return m_attr == aa->m_attr;
           } else {
@@ -555,10 +528,10 @@ namespace chaiscript
             if (bv.is_const())
             {
               const Class *o = boxed_cast<const Class *>(bv);
-              return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
+              return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
             } else {
               Class *o = boxed_cast<Class *>(bv);
-              return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
+              return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
             }
           } else {
             throw exception::arity_error(static_cast<int>(params.size()), 1);
@@ -568,11 +541,9 @@ namespace chaiscript
       private:
         static std::vector<Type_Info> param_types()
         {
-          std::vector<Type_Info> v;
-          v.push_back(user_type<T>());
-          v.push_back(user_type<Class>());
-          return v;
+          return {user_type<T>(), user_type<Class>()};
         }
+
         T Class::* m_attr;
     };
   }
@@ -587,17 +558,14 @@ 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_bvs)
+          : std::runtime_error("Error with function dispatch"), parameters(t_bvs)
         {
         }
 
-        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() noexcept {}
 
-        virtual ~dispatch_error() throw() {}
+        std::vector<Boxed_Value> parameters;
     };
   } 
 
@@ -610,7 +578,7 @@ namespace chaiscript
      * function is found or throw dispatch_error if no matching function is found
      */
     template<typename InItr>
-      Boxed_Value dispatch(InItr begin, InItr end,
+      Boxed_Value dispatch(InItr begin, const InItr &end,
           const std::vector<Boxed_Value> &plist)
       {
         while (begin != end)
@@ -631,7 +599,7 @@ namespace chaiscript
           ++begin;
         }
 
-        throw exception::dispatch_error(plist.empty()?false:plist[0].is_const());
+        throw exception::dispatch_error(plist);
       }
 
     /**

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -1,16 +1,9 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#define gettypeinfo(z,n,text)  ti.push_back(chaiscript::detail::Get_Type_Info<Param ## n>::get());
-#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n])
-#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n]);
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 #define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
@@ -19,9 +12,6 @@
 #include "type_info.hpp"
 #include "handle_return.hpp"
 #include <string>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
 
 #include <stdexcept>
 #include <vector>
@@ -42,26 +32,13 @@ namespace chaiscript
       {
       }
 
-      virtual ~arity_error() throw() {}
+      virtual ~arity_error() noexcept {}
 
       int got;
       int expected;
     };
   }
 
-}
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_functions_detail.hpp>
-#include BOOST_PP_ITERATE()
-
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
   namespace dispatch
   {
     namespace detail
@@ -70,62 +47,105 @@ namespace chaiscript
        * Used by Proxy_Function_Impl to return a list of all param types
        * it contains.
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-        std::vector<Type_Info> build_param_type_list(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
+      template<typename Ret, typename ... Params>
+        std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
         {
-          std::vector<Type_Info> ti;
-          ti.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
-
-          BOOST_PP_REPEAT(n, gettypeinfo, ~) 
-
-          return ti;
+          return std::vector<Type_Info> { chaiscript::detail::Get_Type_Info<Ret>::get(),
+              chaiscript::detail::Get_Type_Info<Params>::get()... };
         }
 
+
+      // Forward declaration
+      template<typename ... Rest> 
+        struct Try_Cast; 
+
+      // implementation
+      template<typename Param, typename ... Rest>
+        struct Try_Cast<Param, Rest...>
+        {
+          static void do_try(const std::vector<Boxed_Value> &params, int generation)
+          {
+            boxed_cast<Param>(params[generation]);
+            Try_Cast<Rest...>::do_try(params, generation+1);
+          }
+        };
+
+      // 0th case
+      template<>
+        struct Try_Cast<>
+        {
+          static void do_try(const std::vector<Boxed_Value> &, int)
+          {
+          }
+        };
+      
+
+
+      /**
+       * Used by Proxy_Function_Impl to determine if it is equivalent to another
+       * Proxy_Function_Impl object. This function is primarly used to prevent
+       * registration of two functions with the exact same signatures
+       */
+      template<typename Ret, typename ... Params>
+        bool compare_types_cast(Ret (*)(Params...),
+             const std::vector<Boxed_Value> &params)
+        {
+          try {
+            Try_Cast<Params...>::do_try(params, 0);
+          } catch (const exception::bad_boxed_cast &) {
+            return false;
+          }
+
+          return true;
+        }
+
+      template<typename Ret, int count, typename ... Params>
+        struct Call_Func
+        {
+
+          template<typename ... InnerParams>
+          static Ret do_call(const std::function<Ret (Params...)> &f,
+              const std::vector<Boxed_Value> &params, InnerParams &&... innerparams)
+          {
+            return Call_Func<Ret, count - 1, Params...>::do_call(f, params, std::forward<InnerParams>(innerparams)..., params[sizeof...(Params) - count]);
+          } 
+        };
+
+      template<typename Ret, typename ... Params>
+        struct Call_Func<Ret, 0, Params...>
+        {
+          template<typename ... InnerParams>
+            static Ret do_call(const std::function<Ret (Params...)> &f,
+                const std::vector<Boxed_Value> &, InnerParams &&... innerparams)
+            {
+              return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams))...);
+            }
+        };
+
       /**
        * Used by Proxy_Function_Impl to perform typesafe execution of a function.
        * The function attempts to unbox each paramter to the expected type.
        * if any unboxing fails the execution of the function fails and
        * the bad_boxed_cast is passed up to the caller.
        */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-        Ret call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
+      template<typename Ret, typename ... Params>
+        Ret call_func(const std::function<Ret (Params...)> &f,
             const std::vector<Boxed_Value> &params)
         {
-          if (params.size() != n)
+          if (params.size() == sizeof...(Params))
           {
-            throw exception::arity_error(static_cast<int>(params.size()), n);
-          } else {
-            return f(BOOST_PP_REPEAT(n, casthelper, ~));
-          }
-        }
-
-      /**
-       * Used by Proxy_Function_Impl to determine if it is equivalent to another
-       * Proxy_Function_Impl object. This function is primarly used to prevent
-       * registration of two functions with the exact same signatures
-       */
-      template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-        bool compare_types_cast(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)),
-            const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, ))
-        {
-          try {
-            BOOST_PP_REPEAT(n, trycast, ~);
-          } catch (const exception::bad_boxed_cast &) {
-            return false;
+            return Call_Func<Ret, sizeof...(Params), Params...>::do_call(f, params);
           }
 
-          return true;
+          throw exception::arity_error(static_cast<int>(params.size()), sizeof...(Params));
         }
+          
     }
   }
+
+
 }
 
-#undef n
-
-#endif
-
-
-#ifndef BOOST_PP_IS_ITERATING
 
 namespace chaiscript
 {
@@ -137,7 +157,7 @@ namespace chaiscript
       struct Do_Call
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params)
           {
             return Handle_Return<Ret>::handle(call_func(fun, params));
           }
@@ -147,7 +167,7 @@ namespace chaiscript
       struct Do_Call<void>
       {
         template<typename Fun>
-          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params)
           {
             call_func(fun, params);
             return Handle_Return<void>::handle();

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -9,12 +9,6 @@
 
 #include "dispatchkit.hpp"
 #include "bind_first.hpp"
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/function_types/components.hpp>
-#include <boost/function_types/function_type.hpp>
-#include <boost/function_types/is_member_object_pointer.hpp>
-#include <boost/function_types/is_member_function_pointer.hpp>
 
 namespace chaiscript
 {
@@ -22,39 +16,48 @@ namespace chaiscript
   {
     namespace detail
     {
-      template<bool Object, bool MemFn>
+      template<typename T>
+        struct FunctionSignature
+        {
+        };
+
+      template<typename Sig>
+        struct FunctionSignature<std::function<Sig> >
+        {
+          typedef Sig Signature;
+        };
+
+      template<typename Ret, typename ... Args> 
+        std::function<Ret (Args...) > to_function(Ret (*func)(Args...))
+        {
+          return std::function<Ret (Args...)>(func);
+        }
+
+      template<typename Ret, typename Class, typename ... Args> 
+        std::function<Ret (Class &, Args...) > to_function(Ret (Class::*func)(Args...))
+        {
+          return std::function<Ret (Class &, Args...)>(func);
+        }
+
+      template<typename Ret, typename Class, typename ... Args> 
+        std::function<Ret (const Class &, Args...) > to_function(Ret (Class::*func)(Args...) const)
+        {
+          return std::function<Ret (const Class &, Args...)>(func);
+        }
+
+      template<bool Object>
         struct Fun_Helper
         {
           template<typename T>
             static Proxy_Function go(T t)
             {
               return Proxy_Function(
-                  new Proxy_Function_Impl<
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(t)));
+                  new Proxy_Function_Impl<typename FunctionSignature<decltype(to_function(t)) >::Signature>(to_function(t)));
             }      
         };
 
       template<>
-        struct Fun_Helper<false, true>
-        {
-          template<typename T>
-            static Proxy_Function go(T t)
-            {
-              return Proxy_Function(
-                  new Proxy_Function_Impl<
-                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
-                    boost::function< 
-                    typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-                    >(boost::mem_fn(t))));
-            }      
-        };
-
-
-      template<>
-        struct Fun_Helper<true, false>
+        struct Fun_Helper<true>
         {
           template<typename T, typename Class>
             static Proxy_Function go(T Class::* m)
@@ -65,19 +68,19 @@ namespace chaiscript
     }
   }
 
-  /// \brief Creates a new Proxy_Function object from a boost::function object
-  /// \param[in] f boost::function to expose to ChaiScript
+  /// \brief Creates a new Proxy_Function object from a std::function object
+  /// \param[in] f std::function to expose to ChaiScript
   ///
   /// \b Example:
   /// \code
-  /// boost::function<int (char, float, std::string)> f = get_some_function();
+  /// std::function<int (char, float, std::string)> f = get_some_function();
   /// chaiscript::ChaiScript chai;
   /// chai.add(fun(f), "some_function");
   /// \endcode
   /// 
   /// \sa \ref addingfunctions
   template<typename T>
-    Proxy_Function fun(const boost::function<T> &f)
+    Proxy_Function fun(const std::function<T> &f)
     {
       return Proxy_Function(new dispatch::Proxy_Function_Impl<T>(f));
     }
@@ -105,7 +108,7 @@ namespace chaiscript
   template<typename T>
     Proxy_Function fun(T t)
     {
-      return dispatch::detail::Fun_Helper<boost::function_types::is_member_object_pointer<T>::value, boost::function_types::is_member_function_pointer<T>::value>::go(t);
+      return dispatch::detail::Fun_Helper<std::is_member_object_pointer<T>::value>::go(t);
     }
 
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member and binds the first parameter of it
@@ -122,7 +125,7 @@ namespace chaiscript
   /// MyClass obj;
   /// chaiscript::ChaiScript chai;
   /// // Add function taking only one argument, an int, and permanently bound to "obj"
-  /// chai.add(fun(&MyClass::memberfunction, boost::ref(obj)), "memberfunction"); 
+  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj)), "memberfunction"); 
   /// \endcode
   /// 
   /// \sa \ref addingfunctions
@@ -148,7 +151,7 @@ namespace chaiscript
   /// chaiscript::ChaiScript chai;
   /// // Add function taking only no arguments, and permanently bound to "obj" and "1"
   /// // memberfunction() will be equivalent to obj.memberfunction(1)
-  /// chai.add(fun(&MyClass::memberfunction, boost::ref(obj), 1), "memberfunction"); 
+  /// chai.add(fun(&MyClass::memberfunction, std::ref(obj), 1), "memberfunction"); 
   /// \endcode
   /// 
   /// \sa \ref addingfunctions

include/chaiscript/dispatchkit/type_info.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -9,17 +9,8 @@
 
 #include <string>
 #include <typeinfo>
-#include <boost/shared_ptr.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/ref.hpp>
+#include <memory>
+#include <type_traits>
 
 namespace chaiscript
 {
@@ -29,7 +20,7 @@ namespace chaiscript
     template<typename T>
       struct Bare_Type
       {
-        typedef typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type type;
+        typedef typename std::remove_cv<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::type type;
       };
   }
 
@@ -39,39 +30,40 @@ namespace chaiscript
     public:
       Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
           bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
-        : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
+        : m_type_info(t_ti), m_bare_type_info(t_bareti),
+        m_is_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_type_info(t_ti), m_bare_type_info(t_bareti),
         m_is_undef(false)
       {
       }
 
       Type_Info()
-        : m_is_const(false), m_is_reference(false), m_is_pointer(false),
-        m_is_void(false), m_is_arithmetic(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_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_type_info(ti.m_type_info), 
-        m_bare_type_info(ti.m_bare_type_info),
         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_is_arithmetic = ti.m_is_arithmetic;
-        m_type_info = ti.m_type_info;
-        m_bare_type_info = ti.m_bare_type_info;
         m_is_undef = ti.m_is_undef;
         return *this;
       }
@@ -126,13 +118,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;
       bool m_is_arithmetic;
-      const std::type_info *m_type_info;
-      const std::type_info *m_bare_type_info;
       bool m_is_undef;
   };
 
@@ -148,70 +140,70 @@ namespace chaiscript
 
         static Type_Info get()
         {
-          return Type_Info(boost::is_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
+          return Type_Info(std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
               &typeid(T), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<boost::shared_ptr<T> >
+      struct Get_Type_Info<std::shared_ptr<T> >
       {
         typedef T type;
 
         static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(boost::shared_ptr<T> ), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(std::shared_ptr<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<const boost::shared_ptr<T> &>
+      struct Get_Type_Info<const std::shared_ptr<T> &>
       {
         typedef T type;
 
         static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(const boost::shared_ptr<T> &), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(const std::shared_ptr<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<boost::reference_wrapper<T> >
+      struct Get_Type_Info<std::reference_wrapper<T> >
       {
         typedef T type;
 
         static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(boost::reference_wrapper<T> ), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(std::reference_wrapper<T> ), 
               &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
-      struct Get_Type_Info<const boost::reference_wrapper<T> &>
+      struct Get_Type_Info<const std::reference_wrapper<T> &>
       {
         typedef T type;
 
         static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-              boost::is_void<T>::value,
-              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
-              &typeid(const boost::reference_wrapper<T> &), 
+          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
+              std::is_void<T>::value,
+              std::is_arithmetic<T>::value && !std::is_same<typename std::remove_const<T>::type, bool>::value,
+              &typeid(const std::reference_wrapper<T> &), 
               &typeid(typename Bare_Type<T>::type));
         }
       };

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -1,14 +1,13 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ALGEBRAIC_HPP_
 #define	CHAISCRIPT_ALGEBRAIC_HPP_
 
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
-#include <boost/enable_shared_from_this.hpp>
+#include "../dispatchkit/dispatchkit.hpp"
 
 namespace chaiscript
 {

include/chaiscript/language/chaiscript_common.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)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
 #define	CHAISCRIPT_COMMON_HPP_
 
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
-#include <boost/enable_shared_from_this.hpp>
+#include <sstream>
+#include "../dispatchkit/dispatchkit.hpp"
 
 namespace chaiscript
 {
@@ -23,7 +23,7 @@ namespace chaiscript
                 Comparison, Addition, Subtraction, Multiplication, Division, Modulus, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
                 Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
                 Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl, Shift, Equality, Bitwise_And, Bitwise_Xor, Bitwise_Or, 
-                Logical_And, Logical_Or
+                Logical_And, Logical_Or, Reference, Switch, Case, Default, Ternary_Cond
     };
   };
 
@@ -37,7 +37,7 @@ namespace chaiscript
                                     "Comparison", "Addition", "Subtraction", "Multiplication", "Division", "Modulus", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
                                     "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
                                     "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Shift", "Equality", "Bitwise_And", "Bitwise_Xor", "Bitwise_Or", 
-                                    "Logical_And", "Logical_Or"};
+                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Ternary Condition"};
 
       return ast_node_types[ast_node_type];
     }
@@ -55,7 +55,7 @@ namespace chaiscript
   };
 
   /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<struct AST_Node> AST_NodePtr;
 
 
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
@@ -71,42 +71,151 @@ namespace chaiscript
       std::string filename;
       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 chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
+        std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_ss)),
         reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
-        { }
+      {}
 
-      eval_error(const std::string &t_why) throw()
+      eval_error(const std::string &t_why, 
+           const std::vector<Boxed_Value> &t_parameters, const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
+        std::runtime_error(format(t_why, t_parameters, t_ss)),
+        reason(t_why)
+      {}
+
+
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) noexcept :
+        std::runtime_error(format(t_why, t_where, t_fname)),
+        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
+      {}
+
+      eval_error(const std::string &t_why) noexcept
         : std::runtime_error("Error: \"" + t_why + "\" "),
         reason(t_why) 
       {}
 
-      virtual ~eval_error() throw() {}
+      virtual ~eval_error() noexcept {}
+
+    private:
+      static std::string format_why(const std::string &t_why)
+      {
+        return "Error: \"" + t_why + "\"";
+      }
+
+      static std::string format_parameters(const std::vector<Boxed_Value> &t_parameters,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        ss << "With parameters: (";
+
+        if (!t_parameters.empty())
+        {
+          std::string paramstr;
+
+          for (const Boxed_Value &bv: t_parameters)
+          {
+            paramstr += (bv.is_const()?"const ":"");
+            paramstr += t_ss.type_name(bv);
+            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, const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << format_parameters(t_parameters, 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, const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << format_parameters(t_parameters, t_ss);
+        ss << " ";
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
     };
 
     /**
      * Errors generated when loading a file
      */
     struct file_not_found_error : public std::runtime_error {
-      file_not_found_error(const std::string &t_filename) throw()
+      file_not_found_error(const std::string &t_filename) noexcept
         : std::runtime_error("File Not Found: " + t_filename)
       { }
 
-      virtual ~file_not_found_error() throw() {}
+      virtual ~file_not_found_error() noexcept {}
     };
 
   }
 
  
   /// \brief Struct that doubles as both a parser ast_node and an AST node.
-  struct AST_Node : boost::enable_shared_from_this<AST_Node> {
+  struct AST_Node : std::enable_shared_from_this<AST_Node> {
     public:
       const std::string text;
-      const int identifier;
-      boost::shared_ptr<const std::string> filename;
+      const int identifier; //< \todo shouldn't this be a strongly typed enum value?
+      std::shared_ptr<const std::string> filename;
       File_Position start, end;
       std::vector<AST_NodePtr> children;
       AST_NodePtr annotation;
@@ -147,14 +256,14 @@ namespace chaiscript
       }
 
     protected:
-      AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname, 
+      AST_Node(const std::string &t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname, 
           int t_start_line, int t_start_col, int t_end_line, int t_end_col) :
         text(t_ast_node_text), identifier(t_id), filename(t_fname),
         start(t_start_line, t_start_col), end(t_end_line, t_end_col)
       {
       }
 
-      AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname) :
+      AST_Node(const std::string &t_ast_node_text, int t_id, const std::shared_ptr<std::string> &t_fname) :
         text(t_ast_node_text), identifier(t_id), filename(t_fname) {}
 
       virtual ~AST_Node() {}
@@ -213,6 +322,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,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -10,12 +10,17 @@
 #include <exception>
 #include <fstream>
 
-#include <chaiscript/language/chaiscript_common.hpp>
+#include "../chaiscript_defines.hpp"
+#include "chaiscript_common.hpp"
+
+#if defined(__linux__) || defined(__unix__) || defined(__APPLE__)
+#include <unistd.h>
+#endif
 
 #ifdef _POSIX_VERSION
 #include <dlfcn.h>
 #else
-#ifdef BOOST_WINDOWS
+#ifdef CHAISCRIPT_WINDOWS
 #define VC_EXTRA_LEAN
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
@@ -23,8 +28,8 @@
 #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
@@ -34,12 +39,12 @@ namespace chaiscript
     /// \brief Thrown if an error occurs while attempting to load a binary module
     struct load_module_error : std::runtime_error
     {
-      load_module_error(const std::string &t_reason) throw()
+      load_module_error(const std::string &t_reason) noexcept
         : std::runtime_error(t_reason)
       {
       }
 
-      virtual ~load_module_error() throw()
+      virtual ~load_module_error() noexcept
       {
       }
     };
@@ -57,7 +62,7 @@ namespace chaiscript
         {
           if (!m_data)
           {
-            throw exception::load_module_error(dlerror());
+            throw chaiscript::exception::load_module_error(dlerror());
           }
         }
 
@@ -76,14 +81,27 @@ namespace chaiscript
         struct DLSym
         {
           DLSym(DLModule &t_mod, const std::string &t_symbol)
-            : m_symbol(reinterpret_cast<T>(dlsym(t_mod.m_data, t_symbol.c_str())))
+            : m_symbol(cast_symbol(dlsym(t_mod.m_data, t_symbol.c_str())))
           {
             if (!m_symbol)
             {
-              throw exception::load_module_error(dlerror());
+              throw chaiscript::exception::load_module_error(dlerror());
             }
           }
 
+          static T cast_symbol(void *p)
+          {
+            union cast_union
+            {
+              T func_ptr;
+              void *in_ptr;
+            };
+
+            cast_union c;
+            c.in_ptr = p;
+            return c.func_ptr;
+          }
+
           T m_symbol;
         };
 
@@ -167,7 +185,7 @@ namespace chaiscript
         {
           if (!m_data)
           {
-            throw exception::load_module_error(GetErrorMessage(GetLastError()));
+            throw chaiscript::exception::load_module_error(GetErrorMessage(GetLastError()));
           }
         }
 
@@ -187,7 +205,7 @@ namespace chaiscript
           {
             if (!m_symbol)
             {
-              throw exception::load_module_error(GetErrorMessage(GetLastError()));
+              throw chaiscript::exception::load_module_error(GetErrorMessage(GetLastError()));
             }
           }
 
@@ -210,7 +228,7 @@ namespace chaiscript
     {
       Loadable_Module(const std::string &, const std::string &)
       {
-        throw exception::load_module_error("Loadable module support not available for your platform");
+        throw chaiscript::exception::load_module_error("Loadable module support not available for your platform");
       }
 
       ModulePtr m_moduleptr;
@@ -218,7 +236,7 @@ namespace chaiscript
 #endif
 #endif
 
-    typedef boost::shared_ptr<Loadable_Module> Loadable_Module_Ptr;
+    typedef std::shared_ptr<Loadable_Module> Loadable_Module_Ptr;
   }
 
 
@@ -261,7 +279,11 @@ namespace chaiscript
 
     const Boxed_Value internal_eval_ast(const AST_NodePtr &t_ast)
     {
-      return t_ast->eval(m_engine);
+      try {
+        return t_ast->eval(m_engine);
+      } catch (const exception::eval_error &t_ee) {
+        throw Boxed_Value(t_ee);
+      }
     }
 
 
@@ -269,34 +291,10 @@ namespace chaiscript
      * 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 do_eval(t_e, "__EVAL__", true);
+      } catch (const exception::eval_error &t_ee) {
+        throw Boxed_Value(t_ee);
       }
     }
 
@@ -310,8 +308,7 @@ namespace chaiscript
     /**
      * Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
      */
-    void build_eval_system() {
-      using namespace bootstrap;
+    void build_eval_system(const ModulePtr &t_lib) {
       m_engine.add_reserved_word("def");
       m_engine.add_reserved_word("fun");
       m_engine.add_reserved_word("while");
@@ -321,23 +318,27 @@ namespace chaiscript
       m_engine.add_reserved_word("&&");
       m_engine.add_reserved_word("||");
       m_engine.add_reserved_word(",");
-      m_engine.add_reserved_word(":=");
-      m_engine.add_reserved_word("var");
+      m_engine.add_reserved_word("auto");
       m_engine.add_reserved_word("return");
       m_engine.add_reserved_word("break");
       m_engine.add_reserved_word("true");
       m_engine.add_reserved_word("false");
       m_engine.add_reserved_word("_");
 
-      add(Bootstrap::bootstrap());
+      if (t_lib)
+      {
+        add(t_lib);
+      }
 
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_system, boost::ref(m_engine)), "dump_system");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_object, boost::ref(m_engine)), "dump_object");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::is_type, boost::ref(m_engine)), "is_type");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::type_name, boost::ref(m_engine)), "type_name");
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::function_exists, boost::ref(m_engine)), "function_exists");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_system, std::ref(m_engine)), "dump_system");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::dump_object, std::ref(m_engine)), "dump_object");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::is_type, std::ref(m_engine)), "is_type");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::type_name, std::ref(m_engine)), "type_name");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::function_exists, std::ref(m_engine)), "function_exists");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_function_objects, std::ref(m_engine)), "get_functions");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_scripting_objects, std::ref(m_engine)), "get_objects");
 
-      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, boost::ref(m_engine)), "name");
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::ref(m_engine)), "name");
 
 
       typedef void (ChaiScript::*load_mod_1)(const std::string&);
@@ -346,11 +347,6 @@ namespace chaiscript
       m_engine.add(fun(static_cast<load_mod_1>(&ChaiScript::load_module), this), "load_module");
       m_engine.add(fun(static_cast<load_mod_2>(&ChaiScript::load_module), this), "load_module");
 
-      add(standard_library::vector_type<std::vector<Boxed_Value> >("Vector"));
-      add(standard_library::string_type<std::string>("string"));
-      add(standard_library::map_type<std::map<std::string, Boxed_Value> >("Map"));
-      add(standard_library::pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair"));
-
       m_engine.add(fun(&ChaiScript::use, this), "use");
       m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
       m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
@@ -365,7 +361,7 @@ namespace chaiscript
       std::ifstream infile(t_filename.c_str(), std::ios::in | std::ios::ate | std::ios::binary );
 
       if (!infile.is_open()) {
-        throw exception::file_not_found_error(t_filename);
+        throw chaiscript::exception::file_not_found_error(t_filename);
       }
 
       std::streampos size = infile.tellg();
@@ -385,9 +381,11 @@ namespace chaiscript
 
   public:
     /// \brief Constructor for ChaiScript
+    /// \param[in] t_lib Standard library to apply to this ChaiScript instance
     /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
     /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
-    ChaiScript(const std::vector<std::string> &t_modulepaths = std::vector<std::string>(),
+    ChaiScript(const ModulePtr &t_lib,
+               const std::vector<std::string> &t_modulepaths = std::vector<std::string>(),
                       const std::vector<std::string> &t_usepaths = std::vector<std::string>())
       : m_modulepaths(t_modulepaths), m_usepaths(t_usepaths) 
     {
@@ -401,13 +399,112 @@ namespace chaiscript
         m_usepaths.push_back("");
       }
 
-      build_eval_system();
+      build_eval_system(t_lib);
+    }
+
+    /// \brief Constructor for ChaiScript.
+    /// 
+    /// This version of the ChaiScript constructor attempts to find the stdlib module to load
+    /// at runtime generates an error if it cannot be found.
+    ///
+    /// \param[in] t_modulepaths Vector of paths to search when attempting to load a binary module
+    /// \param[in] t_usepaths Vector of paths to search when attempting to "use" an included ChaiScript file
+    ChaiScript( const std::vector<std::string> &t_modulepaths = std::vector<std::string>(),
+                      const std::vector<std::string> &t_usepaths = std::vector<std::string>())
+      : m_modulepaths(t_modulepaths), m_usepaths(t_usepaths) 
+    {
+      if (m_modulepaths.empty())
+      {
+        m_modulepaths.push_back("");
+      }
+
+      if (m_usepaths.empty())
+      {
+        m_usepaths.push_back("");
+      }
+
+
+#ifdef _POSIX_VERSION
+      // If on Unix, add the path of the current executable to the module search path
+      // as windows would do
+
+      union cast_union
+      {
+        void (ChaiScript::*in_ptr)(const std::string&);
+        void *out_ptr;
+      };
+
+      Dl_info rInfo; 
+      memset( &rInfo, 0, sizeof(rInfo) ); 
+      cast_union u;
+      u.in_ptr = &ChaiScript::use;
+      if ( dladdr((void*)(u.out_ptr), &rInfo) && rInfo.dli_fname ) { 
+        std::string dllpath(rInfo.dli_fname);
+        size_t lastslash = dllpath.rfind('/');
+        if (lastslash != std::string::npos)
+        {
+          dllpath.erase(lastslash);
+        }
+
+        // Let's see if this is a link that we should expand
+        std::vector<char> buf(2048);
+        size_t pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
+        if (pathlen > 0 && pathlen < buf.size())
+        {
+          dllpath = std::string(&buf.front(), pathlen);
+        }
+
+        m_modulepaths.push_back(dllpath+"/");
+      } 
+#endif    
+
+
+      // attempt to load the stdlib
+      load_module("chaiscript_stdlib");
+
+      build_eval_system(ModulePtr());
+    }
+
+
+
+    /// \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::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);
+          }
+
+          return; // return, we loaded it, or it was already loaded
+        } catch (const exception::file_not_found_error &) {
+          if (i == m_usepaths.size() - 1)
+          {
+            throw exception::file_not_found_error(t_filename);
+          }
+
+          // failed to load, try the next path
+        }
+      }
     }
 
     /// \brief Adds a constant object that is available in all contexts and to all threads
     /// \param[in] t_bv Boxed_Value to add as a global
     /// \param[in] t_name Name of the value to add
-    /// \throw exception::global_non_const If t_bv is not a constant object
+    /// \throw chaiscript::exception::global_non_const If t_bv is not a constant object
     /// \sa Boxed_Value::is_const
     ChaiScript &add_global_const(const Boxed_Value &t_bv, const std::string &t_name)
     {
@@ -523,7 +620,7 @@ namespace chaiscript
     /// If no file can be found matching the search criteria and containing the appropriate entry point 
     /// (the symbol mentioned above), an exception is thrown.
     ///
-    /// \throw exception::load_module_error In the event that no matching module can be found.
+    /// \throw chaiscript::exception::load_module_error In the event that no matching module can be found.
     void load_module(const std::string &t_module_name)
     {
       std::vector<exception::load_module_error> errors;
@@ -547,7 +644,7 @@ namespace chaiscript
                     std::string name = m_modulepaths[i] + prefixes[j] + t_module_name + postfixes[k];
                     load_module(t_module_name, name);
                     return;
-                  } catch (const exception::load_module_error &e) {
+                  } catch (const chaiscript::exception::load_module_error &e) {
                     errors.push_back(e);
                     // Try next set
                   }
@@ -569,7 +666,7 @@ namespace chaiscript
         errstring += itr->what();
       }
 
-      throw exception::load_module_error("Unable to find module: " + t_module_name + " Errors: " + errstring);
+      throw chaiscript::exception::load_module_error("Unable to find module: " + t_module_name + " Errors: " + errstring);
     }
 
     /// \brief Load a binary module from a dynamic library. Works on platforms that support
@@ -603,7 +700,7 @@ namespace chaiscript
     ///
     /// \return result of the script execution
     /// 
-    /// \throw exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
     Boxed_Value operator()(const std::string &t_script, const Exception_Handler &t_handler = Exception_Handler())
     {
       try {
@@ -624,8 +721,8 @@ namespace chaiscript
     ///
     /// \return result of the script execution
     /// 
-    /// \throw exception::eval_error In the case that evaluation fails.
-    /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
     ///        to the requested type.
     template<typename T>
     T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler())
@@ -647,7 +744,7 @@ namespace chaiscript
     ///
     /// \return result of the script execution
     /// 
-    /// \throw exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
     Boxed_Value eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler())
     {
       try {
@@ -664,7 +761,7 @@ namespace chaiscript
     /// \param[in] t_filename File to load and parse.
     /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
     /// \return result of the script execution
-    /// \throw exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
     Boxed_Value eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
       try {
         return do_eval(load_file(t_filename), t_filename);
@@ -681,8 +778,8 @@ namespace chaiscript
     /// \param[in] t_filename File to load and parse.
     /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
     /// \return result of the script execution
-    /// \throw exception::eval_error In the case that evaluation fails.
-    /// \throw exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
+    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
+    /// \throw chaiscript::exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
     ///        to the requested type.
     template<typename T>
     T eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {

include/chaiscript/language/chaiscript_parser.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -10,6 +10,7 @@
 #include <exception>
 #include <fstream>
 #include <sstream>
+#include <cstring>
 
 #include "chaiscript_prelude.hpp"
 #include "chaiscript_common.hpp"
@@ -45,7 +46,7 @@ namespace chaiscript
       std::string m_multiline_comment_begin;
       std::string m_multiline_comment_end;
       std::string m_singleline_comment;
-      boost::shared_ptr<std::string> m_filename;
+      std::shared_ptr<std::string> m_filename;
       std::vector<AST_NodePtr> m_match_stack;
       bool m_alphabet[detail::max_alphabet][detail::lengthof_alphabet];
 
@@ -66,6 +67,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("||");
@@ -131,6 +137,7 @@ namespace chaiscript
             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;
@@ -322,7 +329,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) ) {
@@ -1416,6 +1422,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
          */
@@ -1478,7 +1568,6 @@ namespace chaiscript
          */
         bool Dot_Fun_Array() {
           bool retval = false;
-          std::string::const_iterator prev_pos = m_input_pos;
 
           size_t prev_stack_top = m_match_stack.size();
           if (Lambda() || Num(true) || Quoted_String(true) || Single_Quoted_String(true) ||
@@ -1543,10 +1632,10 @@ namespace chaiscript
 
           size_t prev_stack_top = m_match_stack.size();
 
-          if (Keyword("var")) {
+          if (Keyword("auto") || Keyword("var")) {
             retval = true;
 
-            if (!Id(true)) {
+            if (!(Reference() || Id(true))) {
               throw exception::eval_error("Incomplete variable declaration", File_Position(m_line, m_col), *m_filename);
             }
 
@@ -1584,7 +1673,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;
@@ -1602,7 +1691,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 brace '}' 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) {
@@ -1623,6 +1712,25 @@ namespace chaiscript
           return retval;
         }
 
+        bool Reference() {
+          bool retval = false;
+
+          size_t prev_stack_top = m_match_stack.size();
+
+          if (Symbol("&", false)) {
+            retval = true;
+
+            if (!Id(true)) {
+              throw exception::eval_error("Incomplete '&' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            build_match(AST_NodePtr(
+                  new eval::Reference_AST_Node()), prev_stack_top);
+          }
+
+          return retval;
+        }
+
         /**
          * Reads a unary prefixed expression from input
          */
@@ -1685,6 +1793,15 @@ namespace chaiscript
 
             build_match(AST_NodePtr(new eval::Prefix_AST_Node()), prev_stack_top);
           }
+          else if (Char('&', true)) {
+            retval = true;
+
+            if (!Operator(m_operators.size()-1)) {
+              throw exception::eval_error("Incomplete '~' expression", File_Position(m_line, m_col), *m_filename);
+            }
+
+            build_match(AST_NodePtr(new eval::Prefix_AST_Node()), prev_stack_top);
+          }
 
           return retval;
         }
@@ -1720,6 +1837,7 @@ 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",
@@ -1730,6 +1848,23 @@ namespace chaiscript
                     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,
@@ -1887,7 +2022,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()) {
@@ -1930,6 +2064,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);
@@ -1946,6 +2088,11 @@ namespace chaiscript
               retval = true;
               saw_eol = false;
             }
+            else if (Block()) {
+              has_more = true;
+              retval = true;
+              saw_eol = true;
+            }
             else if (Equation()) {
               if (!saw_eol) {
                 throw exception::eval_error("Two expressions missing line separator", File_Position(prev_line, prev_col), *m_filename);
@@ -1959,11 +2106,6 @@ namespace chaiscript
               retval = true;
               saw_eol = true;
             }
-            else if (Block()) {
-              has_more = true;
-              retval = true;
-              saw_eol = true;
-            }
             else {
               has_more = false;
             }
@@ -1980,7 +2122,7 @@ namespace chaiscript
           m_input_end = t_input.end();
           m_line = 1;
           m_col = 1;
-          m_filename = boost::shared_ptr<std::string>(new std::string(t_fname));
+          m_filename = std::shared_ptr<std::string>(new std::string(t_fname));
 
           if ((t_input.size() > 1) && (t_input[0] == '#') && (t_input[1] == '!')) {
             while ((m_input_pos != m_input_end) && (!Eol())) {

include/chaiscript/language/chaiscript_prelude.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -54,8 +54,8 @@ def push_front(container, x) : call_exists(push_front_ref, container, x) { conta
 def insert_at(container, pos, x) { container.insert_ref_at(pos, clone(x)); } \n\
 # Returns the reverse of the given container\n\
 def reverse(container) {\n\
-  var retval = new(container); \n\
-  var r = range(container); \n\
+  auto retval = new(container); \n\
+  auto r = range(container); \n\
   while (!r.empty()) { \n\
     retval.push_back(r.back()); \n\
     r.pop_back(); \n\
@@ -82,7 +82,7 @@ def retro::pop_front()  { pop_back(this.m_range) } \n\
 def retro::empty() { empty(this.m_range); } \n\
 # Performs the second value function over the container first value\n\
 def for_each(container, func) : call_exists(range, container) { \n\
-  var t_range = range(container); \n\
+  auto t_range = range(container); \n\
   while (!t_range.empty()) { \n\
     func(t_range.front()); \n\
     t_range.pop_front(); \n\
@@ -93,7 +93,7 @@ def back_inserter(container) { \n\
 }\n\
 \n\
 def contains(container, item, compare_func) : call_exists(range, container) { \n\
-  var t_range = range(container); \n\
+  auto t_range = range(container); \n\
   while (!t_range.empty()) { \n\
     if ( compare_func(t_range.front(), item) ) { return true; } \n\
     t_range.pop_front(); \n\
@@ -102,7 +102,7 @@ def contains(container, item, compare_func) : call_exists(range, container) { \n
 } \n\
 def contains(container, item) { return contains(container, item, eq) } \n\
 def map(container, func, inserter) : call_exists(range, container) { \n\
-  var range = range(container); \n\
+  auto range = range(container); \n\
   while (!range.empty()) { \n\
     inserter(func(range.front())); \n\
     range.pop_front(); \n\
@@ -110,14 +110,14 @@ def map(container, func, inserter) : call_exists(range, container) { \n\
 } \n\
 # Performs the second value function over the container first value. Creates a new container with the results\n\
 def map(container, func) { \n\
-  var retval = new(container); \n\
+  auto retval = new(container); \n\
   map(container, func, back_inserter(retval));\n\
   retval;\n\
 }\n\
 # Performs the second value function over the container first value. Starts with initial and continues with each element.\n\
 def foldl(container, func, initial) : call_exists(range, container){ \n\
-  var retval = initial; \n\
-  var range = range(container); \n\
+  auto retval = initial; \n\
+  auto range = range(container); \n\
   while (!range.empty()) { \n\
     retval = (func(range.front(), retval)); \n\
     range.pop_front(); \n\
@@ -130,9 +130,9 @@ def sum(container) { foldl(container, `+`, 0.0) } \n\
 def product(container) { foldl(container, `*`, 1.0) } \n\
 # Returns a new container with the elements of the first value concatenated with the elements of the second value\n\
 def concat(x, y) : call_exists(clone, x) { \n\
-  var retval = x; \n\
-  var inserter = back_inserter(retval); \n\
-  var range = range(y); \n\
+  auto retval = x; \n\
+  auto inserter = back_inserter(retval); \n\
+  auto range = range(y); \n\
   while (!range.empty()) { \n\
     inserter(range.front()); \n\
     range.pop_front(); \n\
@@ -140,8 +140,8 @@ def concat(x, y) : call_exists(clone, x) { \n\
   retval; \n\
 } \n\
 def take(container, num, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \n\
-  var i = num; \n\
+  auto r = range(container); \n\
+  auto i = num; \n\
   while ((i > 0) && (!r.empty())) { \n\
     inserter(r.front()); \n\
     r.pop_front(); \n\
@@ -150,12 +150,12 @@ def take(container, num, inserter) : call_exists(range, container) { \n\
 } \n\
 # Returns a new container with the given number of elements taken from the container\n\
 def take(container, num) {\n\
-  var retval = new(container); \n\
+  auto retval = new(container); \n\
   take(container, num, back_inserter(retval)); \n\
   retval; \n\
 }\n\
 def take_while(container, f, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \n\
+  auto r = range(container); \n\
   while ((!r.empty()) && f(r.front())) { \n\
     inserter(r.front()); \n\
     r.pop_front(); \n\
@@ -163,13 +163,13 @@ def take_while(container, f, inserter) : call_exists(range, container) { \n\
 } \n\
 # Returns a new container with the given elements match the second value function\n\
 def take_while(container, f) {\n\
-  var retval = new(container); \n\
+  auto retval = new(container); \n\
   take_while(container, f, back_inserter(retval)); \n\
   retval;\n\
 }\n\
 def drop(container, num, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \n\
-  var i = num; \n\
+  auto r = range(container); \n\
+  auto i = num; \n\
   while ((i > 0) && (!r.empty())) { \n\
     r.pop_front(); \n\
     --i; \n\
@@ -181,12 +181,12 @@ def drop(container, num, inserter) : call_exists(range, container) { \n\
 } \n\
 # Returns a new container with the given number of elements dropped from the given container \n\
 def drop(container, num) {\n\
-  var retval = new(container); \n\
+  auto retval = new(container); \n\
   drop(container, num, back_inserter(retval)); \n\
   retval; \n\
 }\n\
 def drop_while(container, f, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \n\
+  auto r = range(container); \n\
   while ((!r.empty())&& f(r.front())) { \n\
     r.pop_front(); \n\
   } \n\
@@ -197,14 +197,14 @@ def drop_while(container, f, inserter) : call_exists(range, container) { \n\
 } \n\
 # Returns a new container with the given elements dropped that match the second value function\n\
 def drop_while(container, f) {\n\
-  var retval = new(container); \n\
+  auto retval = new(container); \n\
   drop_while(container, f, back_inserter(retval)); \n\
   retval; \n\
 }\n\
 # Applies the second value function to the container. Starts with the first two elements. Expects at least 2 elements.\n\
 def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { \n\
-  var r = range(container); \n\
-  var retval = r.front(); \n\
+  auto r = range(container); \n\
+  auto retval = r.front(); \n\
   r.pop_front(); \n\
   retval = func(retval, r.front()); \n\
   r.pop_front(); \n\
@@ -216,8 +216,8 @@ def reduce(container, func) : container.size() >= 2 && call_exists(range, contai
 } \n\
 # Returns a string of the elements in container delimited by the second value string\n\
 def join(container, delim) { \n\
-  var retval = ""; \n\
-  var range = range(container); \n\
+  auto retval = ""; \n\
+  auto range = range(container); \n\
   if (!range.empty()) { \n\
     retval += to_string(range.front()); \n\
     range.pop_front(); \n\
@@ -230,7 +230,7 @@ def join(container, delim) { \n\
   retval; \n\
 } \n\
 def filter(container, f, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \n\
+  auto r = range(container); \n\
   while (!r.empty()) { \n\
     if (f(r.front())) { \n\
       inserter(r.front()); \n\
@@ -240,12 +240,12 @@ def filter(container, f, inserter) : call_exists(range, container) { \n\
 } \n\
 # Returns a new Vector which match the second value function\n\
 def filter(container, f) { \n\
-  var retval = new(container); \n\
+  auto retval = new(container); \n\
   filter(container, f, back_inserter(retval));\n\
   retval;\n\
 }\n\
 def generate_range(x, y, inserter) { \n\
-  var i = x; \n\
+  auto i = x; \n\
   while (i <= y) { \n\
     inserter(i); \n\
     ++i; \n\
@@ -253,17 +253,17 @@ def generate_range(x, y, inserter) { \n\
 } \n\
 # Returns a new Vector which represents the range from the first value to the second value\n\
 def generate_range(x, y) { \n\
-  var retval = Vector(); \n\
+  auto retval = Vector(); \n\
   generate_range(x,y,back_inserter(retval)); \n\
   retval; \n\
 }\n\
 # Returns a new Vector with the first value to the second value as its elements\n\
 def collate(x, y) { \n\
-  [x, y]; \n\
+  return [x, y]; \n\
 } \n\
 def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { \n\
-  var r_x = range(x); \n\
-  var r_y = range(y); \n\
+  auto r_x = range(x); \n\
+  auto r_y = range(y); \n\
   while (!r_x.empty() && !r_y.empty()) { \n\
     inserter(f(r_x.front(), r_y.front())); \n\
     r_x.pop_front(); \n\
@@ -272,7 +272,7 @@ def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y)
 } \n\
 # Returns a new Vector which joins matching elements of the second and third value with the first value function\n\
 def zip_with(f, x, y) { \n\
-  var retval = Vector(); \n\
+  auto retval = Vector(); \n\
   zip_with(f,x,y,back_inserter(retval)); \n\
   retval;\n\
 }\n\
@@ -314,7 +314,7 @@ def string::trim() { \n\
   ltrim(rtrim(this)); \n\
 } \n\
 def find(container, value, compare_func) : call_exists(range, container) && is_type(compare_func, "Function") { \n\
-  var range = range(container); \n\
+  auto range = range(container); \n\
   while (!range.empty()) { \n\
     if (compare_func(range.front(), value)) { \n\
       return range; \n\

include/chaiscript/utility/utility.hpp

@@ -1,6 +1,6 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2011, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
 // and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
@@ -8,80 +8,33 @@
 #define CHAISCRIPT_UTILITY_UTILITY_HPP_
 
 #include "../chaiscript.hpp"
-#include <boost/preprocessor.hpp>
 #include <string>
 
-#define CHAISCRIPT_MODULE(_info) BOOST_PP_SEQ_ELEM(0, _info)
-
-#define CHAISCRIPT_CLASS_ELEM(_info) BOOST_PP_SEQ_ELEM(1, _info)
-
-#define CHAISCRIPT_METHOD(_info, _method) & CHAISCRIPT_CLASS_ELEM(_info) :: BOOST_PP_SEQ_ELEM(0, _method)
-
-#define CHAISCRIPT_METHOD_NAME(_info, _method) \
-  BOOST_PP_SEQ_ELEM(3, _info) (BOOST_PP_STRINGIZE(BOOST_PP_SEQ_ELEM(0, _method ) ) )
-
-#define CHAISCRIPT_CLASS_NAME(_info) \
-  BOOST_PP_SEQ_ELEM(2, _info) (BOOST_PP_STRINGIZE(CHAISCRIPT_CLASS_ELEM(_info) ) )
-
-#define CHAISCRIPT_METHOD_SIGNATURE_PART(_r, _info, _i, _method_part) \
-  BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(_i, 1), < _method_part > )
-
-#define CHAISCRIPT_METHOD_SIGNATURE(_info, _method) \
-  BOOST_PP_SEQ_FOR_EACH_I(CHAISCRIPT_METHOD_SIGNATURE_PART, _info, _method)
-
-#define CHAISCRIPT_CLASS_CONSTRUCTOR(_r, _info, _constructor) \
-  CHAISCRIPT_MODULE(_info) ->add BOOST_PP_LPAREN() chaiscript::constructor<_constructor>() BOOST_PP_COMMA() CHAISCRIPT_CLASS_NAME(_info) BOOST_PP_RPAREN() ;
-
-#define CHAISCRIPT_CLASS_METHOD(_r, _info, _method) \
-  CHAISCRIPT_MODULE(_info) ->add BOOST_PP_LPAREN() chaiscript::fun CHAISCRIPT_METHOD_SIGNATURE(_info, _method) \
-      BOOST_PP_LPAREN() CHAISCRIPT_METHOD(_info, _method) BOOST_PP_RPAREN() BOOST_PP_COMMA() CHAISCRIPT_METHOD_NAME(_info, _method)BOOST_PP_RPAREN() ;
-  
-#define CHAISCRIPT_CLASS_CONSTRUCTORS(_info, _constructors) \
-  BOOST_PP_SEQ_FOR_EACH(CHAISCRIPT_CLASS_CONSTRUCTOR, _info, _constructors)
-
-#define CHAISCRIPT_CLASS_METHODS(_info, _methods) \
-  BOOST_PP_SEQ_FOR_EACH(CHAISCRIPT_CLASS_METHOD, _info, _methods)
-
-#define CHAISCRIPT_CLASS_EX(_module, _class_name, _class_name_translator, _method_name_translator, _constructors, _methods) \
-  { \
-    _module->add(chaiscript::user_type<_class_name>(), _class_name_translator (BOOST_PP_STRINGIZE(_class_name))); \
-    CHAISCRIPT_CLASS_CONSTRUCTORS((_module)(_class_name)(_class_name_translator), _constructors) \
-    CHAISCRIPT_CLASS_METHODS((_module)(_class_name)(_class_name_translator)(_method_name_translator), _methods) \
-  }
-
-#define CHAISCRIPT_CLASS(_module, _class_name, _constructors, _methods) \
-  CHAISCRIPT_CLASS_EX(_module, _class_name, chaiscript::utility::class_name_translator, \
-      chaiscript::utility::method_name_translator, _constructors, _methods)
 
 namespace chaiscript 
 {
-  /// \brief Classes and functions which provide general utility to the end user.
   namespace utility
   {
-    inline std::string class_name_translator(const std::string &t_name)
-    {
-      size_t colon = t_name.rfind("::");
-      if (colon != std::string::npos)
+
+    template<typename Class, typename ModuleType>
+      void add_class(ModuleType &t_module,
+          const std::string &t_classname,
+          const std::vector<chaiscript::Proxy_Function> &t_constructors,
+          const std::vector<std::pair<chaiscript::Proxy_Function, std::string>> &t_funcs)
       {
-        return t_name.substr(colon+2, std::string::npos);
-      } else {
-        return t_name;
+        t_module.add(chaiscript::user_type<Class>(), t_classname); 
+
+        for(const chaiscript::Proxy_Function &ctor: t_constructors)
+        {
+          t_module.add(ctor, t_classname);
+        }
+
+        for(auto fun: t_funcs)
+        {
+          t_module.add(fun.first, fun.second);
+        }
+        
       }
-    }
-
-    inline std::string method_name_translator(const std::string &t_name)
-    {
-      size_t namestart = t_name.rfind("operator");
-      namestart = (namestart == std::string::npos)?0:namestart+strlen("operator");
-
-      if (namestart == 0)
-      {
-        namestart = t_name.rfind("::");
-        namestart = (namestart == std::string::npos)?0:namestart+strlen("::");
-      } 
-
-      return t_name.substr(namestart, std::string::npos);
-    }
   }
 }
 

license.txt

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

readme.txt

@@ -1,6 +1,6 @@
 ChaiScript
 http://www.chaiscript.com
-(c) 2009-2011 Jason Turner and Jonathan Turner
+(c) 2009-2012 Jason Turner and Jonathan Turner
 Release under the BSD license, see "license.txt" for details.
 
 [Introduction]
@@ -13,7 +13,7 @@ ChaiScript is one of the only embedded scripting language designed from the grou
 
 [Requirements]
 
-ChaiScript requires a recent version of Boost (http://www.boost.org) to build.
+ChaiScript requires a C++11 compiler to build with support for variadic templates.  It has been tested with gcc 4.7 and clang 3.1 (with libcxx).
 
 [Usage]
 

releasenotes.txt

@@ -1,3 +1,35 @@
+Changes since 4.0.0
+* Dropped boost in favor of C++11
+* Separated out stdlib to make more options for compile time improvements
+
+Changes since 3.1.0
+* svenstaro: Unused variables and CMake consistency fixes
+* Added support for returning pointers from functions (#13)
+* Compile with -pedantic (#9)
+* Fix issues with multiple ChaiScript object types having the same attribute name (#15)
+* Prevent variable redeclaration in same scope (#22)
+* mgee: Boxed_Number improvements (#27)
+* Support switch statements (#34)
+* Fix uint16 comparions (#26)
+* Add ability to add const_var globals in Module objects (#14)
+* Add support for ternary operators ?:
+* Add headers to CMakeLists so they show up in IDEs
+* Add ability to get vector of defined objects and vector of defined functions
+* Fix memory leak in cyclical references
+* Clean up static analysis issues discovered
+* Fix vector construction to be consistent with map construction
+* Increased unit tests to 161
+* Performance enhancements
+
+Changes since 3.0.0
+* Numeric operations performance increased approximately 10x
+* Looping operations performance increased up to 2x
+* Engine start up time decreased
+* Several parsing bugs related to index operators fixed
+* Added full support for all C algebraic types: double, long double, float, int, long, char,
+  uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t
+* Enhanced support for capturing of exceptions thrown from ChaiScript in C++
+
 Changes since 2.3.3
 
 * Code simplifications

samples/example.cpp

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

samples/memory_leak_test.cpp

@@ -1,13 +1,14 @@
 #include <iostream>
 
-#include "chaiscript/chaiscript.hpp"
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+
 #ifdef READLINE_AVAILABLE
 #include <readline/readline.h>
 #include <readline/history.h>
 #endif
 
 
-using namespace chaiscript;
 
 std::string get_next_command() {
 #ifdef READLINE_AVAILABLE
@@ -30,30 +31,32 @@ void fuction(void)
 
 class test
 {
-  ChaiScript chai;
-  ChaiScript::State backupState;
+  chaiscript::ChaiScript chai;
+  chaiscript::ChaiScript::State backupState;
+
   public:
-  test()
-  {		
-    backupState = chai.get_state();
-  }
-  ~test(){}
-
-  void ResetState()
-  {
-    chai.set_state(backupState);
-    chai.add(fun(&fuction),"Whatever()");
-  }
-
-  void RunFile(std::string sFile)
-  {
-    try {
-      chaiscript::Boxed_Value val = chai.eval_file(sFile);
+    test()
+      : chai(chaiscript::Std_Lib::library())
+    {		
+      backupState = chai.get_state();
     }
-    catch (std::exception &e) {
-      std::cout << e.what() << std::endl;
+    ~test(){}
+
+    void ResetState()
+    {
+      chai.set_state(backupState);
+      chai.add(chaiscript::fun(&fuction),"Whatever()");
+    }
+
+    void RunFile(std::string sFile)
+    {
+      try {
+        chaiscript::Boxed_Value val = chai.eval_file(sFile);
+      }
+      catch (std::exception &e) {
+        std::cout << e.what() << std::endl;
+      }
     }
-  }
 
 };
 

src/chaiscript_stdlib.cpp

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

src/main.cpp

@@ -6,7 +6,7 @@
 
 #include <iostream>
 #include <list>
-#include <boost/algorithm/string/trim.hpp>
+#include <regex>
 
 #define _CRT_SECURE_NO_WARNINGS
 #include <chaiscript/chaiscript.hpp>
@@ -20,7 +20,7 @@ char* readline(const char* p)
   std::string retval;
   std::cout << p ;
   std::getline(std::cin, retval);
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
   return std::cin.eof() ? NULL : _strdup(retval.c_str());
 #else
   return std::cin.eof() ? NULL : strdup(retval.c_str());
@@ -52,7 +52,7 @@ void version(int){
   std::cout << "chai: compiled " << __TIME__ << " " << __DATE__ << std::endl;
 }
 
-bool throws_exception(const boost::function<void ()> &f)
+bool throws_exception(const std::function<void ()> &f)
 {
   try {
     f();
@@ -63,7 +63,7 @@ bool throws_exception(const boost::function<void ()> &f)
   return false;
 }
 
-chaiscript::exception::eval_error get_eval_error(const boost::function<void ()> &f)
+chaiscript::exception::eval_error get_eval_error(const std::function<void ()> &f)
 {
   try {
     f();
@@ -80,7 +80,21 @@ std::string get_next_command() {
     char *input_raw = readline("eval> ");
     if ( input_raw ) {
       add_history(input_raw);
-      retval = boost::trim_copy_if(std::string(input_raw),boost::is_any_of(" \t"));
+
+      std::string val(input_raw);
+      size_t pos = val.find_first_not_of("\t \n");
+      if (pos != std::string::npos)
+      {
+        val.erase(0, pos);
+      }
+      pos = val.find_last_not_of("\t \n");
+      if (pos != std::string::npos)
+      {
+        val.erase(pos+1, std::string::npos);
+      }
+
+      retval = val;
+
       ::free(input_raw);
     }
   }
@@ -113,7 +127,7 @@ void interactive(chaiscript::ChaiScript& chai)
       //Then, we try to print the result of the evaluation to the user
       if (!val.get_type_info().bare_equal(chaiscript::user_type<void>())) {
         try {
-          std::cout << chai.eval<boost::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
+          std::cout << chai.eval<std::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
         }
         catch (...) {} //If we can't, do nothing
       }
@@ -138,7 +152,7 @@ int main(int argc, char *argv[])
   std::vector<std::string> modulepaths;
 
   // Disable deprecation warning for getenv call.
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4996)
 #endif
@@ -146,7 +160,7 @@ int main(int argc, char *argv[])
   const char *usepath = getenv("CHAI_USE_PATH");
   const char *modulepath = getenv("CHAI_MODULE_PATH");
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
 
@@ -215,6 +229,7 @@ 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) {

src/multithreaded.cpp

@@ -9,32 +9,33 @@
 #include <list>
 
 #include <chaiscript/chaiscript.hpp>
-#include <boost/thread.hpp>
+#include <thread>
 
 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);
+  std::stringstream ss;
+  ss << "MyVar" << rand();
+  c.add(chaiscript::var(5), ss.str());
   c("use(\"work.chai\"); do_chai_work(10000);");
 }
 
 int main(int argc, char *argv[]) {
-    std::string input;
-    chaiscript::ChaiScript chai;
+  std::string input;
+  chaiscript::ChaiScript chai;
 
-    //chai.add_shared_object(chaiscript::Boxed_Value(10000), "num_iterations");
+  //chai.add_shared_object(chaiscript::Boxed_Value(10000), "num_iterations");
 
-    std::vector<boost::shared_ptr<boost::thread> > threads;
+  std::vector<std::shared_ptr<std::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.push_back(std::shared_ptr<std::thread>(new std::thread(std::bind(do_work, std::ref(chai)))));
+  }
 
-    for (int i = 0; i < argc - 1; ++i)
-    {
-      threads[i]->join();
-    }
+  for (int i = 0; i < argc - 1; ++i)
+  {
+    threads[i]->join();
+  }
 }
 

src/reflection.cpp

@@ -1,12 +1,14 @@
 
 #include <chaiscript/chaiscript.hpp>
+#include <chaiscript/dispatchkit/bootstrap.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
 #include <chaiscript/utility/utility.hpp>
 #include <string>
 
 
 // MSVC doesn't like that we are using C++ return types from our C declared module
 // but this is the best way to do it for cross platform compatibility
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4190)
 #endif
@@ -14,11 +16,11 @@
 
 bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
 {
-  boost::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf
-    = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+  std::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf
+    = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
   if (pf)
   {
-    return pf->get_parse_tree();
+    return bool(pf->get_parse_tree());
   } else {
     return false;
   }
@@ -26,8 +28,8 @@ bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
 
 chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
 {
-  boost::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf 
-    = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+  std::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf 
+    = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
   if (pf)
   {
     if (pf->get_parse_tree())
@@ -49,49 +51,54 @@ 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::bootstrap::standard_library::vector_type<std::vector<std::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
 
-  CHAISCRIPT_CLASS( m,
-      chaiscript::exception::eval_error,
-      ,
-      ((reason))
-      ((call_stack))
+  using namespace chaiscript;
+
+  chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
+      "eval_error",
+      { },
+      { {fun(&chaiscript::exception::eval_error::reason), "reason"},
+        {fun(&chaiscript::exception::eval_error::call_stack), "call_stack"} }
+      );
+
+  chaiscript::utility::add_class<chaiscript::File_Position>(*m,
+      "File_Position",
+      { constructor<File_Position()>(),
+        constructor<File_Position(int, int)>() },
+      { {fun(&File_Position::line), "line"},
+        {fun(&File_Position::column), "column"} }
+      );
+
+  chaiscript::utility::add_class<AST_Node>(*m,
+      "AST_Node",
+      {  },
+      { {fun(&AST_Node::text), "text"},
+        {fun(&AST_Node::identifier), "identifier"},
+        {fun(&AST_Node::filename), "filename"},
+        {fun(&AST_Node::start), "start"},
+        {fun(&AST_Node::end), "end"},
+        {fun(&AST_Node::internal_to_string), "internal_to_string"},
+        {fun(&AST_Node::children), "children"},
+        {fun(&AST_Node::replace_child), "replace_child"}
+      }
     );
 
-  CHAISCRIPT_CLASS( m,
-      chaiscript::File_Position,
-      (chaiscript::File_Position())
-      (chaiscript::File_Position(int,int)),
-      ((line))
-      ((column))
-    );
+  chaiscript::utility::add_class<parser::ChaiScript_Parser>(*m,
+      "ChaiScript_Parser",
+      { constructor<parser::ChaiScript_Parser ()>() },
+      { {fun(&parser::ChaiScript_Parser::parse), "parse"},
+        {fun(&parser::ChaiScript_Parser::ast), "ast"} }
+      );
 
-  CHAISCRIPT_CLASS( m, 
-      chaiscript::AST_Node,
-      ,
-      ((text))
-      ((identifier))
-      ((filename))
-      ((start))
-      ((end))
-      ((internal_to_string))
-      ((children))
-      ((replace_child))
-    );
-
-  CHAISCRIPT_CLASS( m, 
-      chaiscript::parser::ChaiScript_Parser,
-      (chaiscript::parser::ChaiScript_Parser ()),
-      ((parse))
-      ((ast))
-    );
 
 
   return m;
 }
 
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

src/stl_extra.cpp

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

src/test_module.cpp

@@ -7,11 +7,22 @@ class TestBaseType
   public:
     TestBaseType() {}
     TestBaseType(int) {}
+    TestBaseType(int *) {}
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
 
 };
 
+enum TestEnum
+{
+  TestValue1 = 1
+};
+
+int to_int(TestEnum t)
+{
+  return t;
+}
+
 class TestDerivedType : public TestBaseType
 {
   public:
@@ -24,9 +35,14 @@ std::string hello_world()
   return "Hello World";
 }
 
+int *get_new_int()
+{
+  return new int(1);
+}
+
 // MSVC doesn't like that we are using C++ return types from our C declared module
 // but this is the best way to do it for cross platform compatibility
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4190)
 #endif
@@ -44,6 +60,7 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   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");
@@ -52,10 +69,19 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
 
   m->add(chaiscript::fun(&TestBaseType::func), "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");
+
+
   return m;
 }
 
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

unittests/3.x/assign_const.chai

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

unittests/3.x/bind.chai

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

unittests/3.x/bind2.chai

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

unittests/3.x/block_start.chai

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

unittests/3.x/bool_not.chai

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

unittests/3.x/break_while.chai

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

unittests/3.x/char_init.chai

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

unittests/3.x/classification.chai

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

unittests/3.x/collate.chai

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

unittests/3.x/compare_gt.chai

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

unittests/3.x/compare_lt.chai

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

unittests/3.x/concat.chai

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

unittests/3.x/const_range_test.chai

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

unittests/3.x/convert_double_string.chai

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

unittests/3.x/convert_int_string.chai

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

unittests/3.x/convert_string_double.chai

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

unittests/3.x/convert_string_int.chai

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

unittests/3.x/deep_array_lookup.chai

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

unittests/3.x/dispatch_functions.chai

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

unittests/3.x/drop.chai

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

unittests/3.x/drop_while.chai

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

unittests/3.x/equ_shortform.chai

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

unittests/3.x/eval.chai

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

unittests/3.x/eval_error.chai

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

unittests/3.x/even.chai

@@ -0,0 +1 @@
+assert_equal(true, even(4))

unittests/3.x/exception.chai

@@ -0,0 +1,9 @@
+var x = 1
+try {
+  throw(x)
+  x = 2
+}
+catch(e) {
+  x = e + 3
+}
+assert_equal(4, x);

unittests/3.x/exception_finally.chai

@@ -0,0 +1,32 @@
+var finallyone = false;
+
+try {
+  throw(3)
+}
+catch(x) { 
+  assert_equal(3, x)
+}
+finally {
+  finallyone = true;
+}
+
+assert_equal(true, finallyone);
+
+var try2 = false;
+var catch2 = false;
+var finally2 = false;
+
+
+try {
+  try2 = true;
+}
+catch {
+  catch2 = true;
+}
+finally {
+  finally2 = true;
+}
+
+assert_equal(true, try2);
+assert_equal(false, catch2);
+assert_equal(true, finally2);

unittests/3.x/exception_guards.chai

@@ -0,0 +1,34 @@
+var results = [];
+
+for (var i = 2; i < 6; ++i) {
+  try {
+    throw(i)
+  }
+  catch(e) : e < 2 {
+    results.push_back("c1: " + e.to_string());
+  }
+  catch(e) : e < 4 {
+    results.push_back("c2: " + e.to_string());
+  }
+  catch(e) {
+    results.push_back("c3: " + e.to_string());
+  }
+  catch {
+    // Should never get called
+    assert_equal(false, true)
+  }
+}
+
+try {
+  throw(3)
+}
+catch(e) : e < 3 
+{
+  // Should never get called
+  assert_equal(false, true);
+}
+catch {
+  results.push_back("defaultcatch");
+}
+
+assert_equal(["c2: 2", "c2: 3", "c3: 4", "c3: 5", "defaultcatch"], results);

unittests/3.x/filter.chai

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

unittests/3.x/float.chai

@@ -0,0 +1,7 @@
+assert_equal(true, 1.2 < 2)
+assert_equal(true, 1.2 > 1)
+assert_equal(1.2, 1.2)
+
+assert_equal(true, .5 > 0)
+assert_equal(true, .5 < 1)
+assert_equal(0.5, .5)

unittests/3.x/foldl.chai

@@ -0,0 +1 @@
+assert_equal(10, foldl([1, 2, 3, 4], `+`, 0))

unittests/3.x/for.chai

@@ -0,0 +1,7 @@
+var ret = []
+
+for (var i = 0; i < 5; ++i) {
+  ret.push_back(i);
+}
+
+assert_equal([0,1,2,3,4], ret);

unittests/3.x/for_each.chai

@@ -0,0 +1 @@
+for_each([1, 2, 3], print)

unittests/3.x/for_each_range.chai

@@ -0,0 +1,3 @@
+var v = [1,2,3];
+var r = range(v);
+for_each(r, fun(x) { assert_equal(true, x>0); } )

unittests/3.x/for_each_retro.chai

@@ -0,0 +1,4 @@
+// Don't bother checking the output from this one, just makes sure it executes
+var v = [1,2,3];
+var r = retro(range(v));
+for_each(r, print)

unittests/3.x/function_array_adjacent.chai

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

unittests/3.x/function_introspection.chai

@@ -0,0 +1,76 @@
+
+#Test Function Description
+def test_function(a)
+{
+  return a;
+}
+
+
+
+
+// test_function tests
+assert_equal(test_function.get_arity(), 1);
+assert_equal(trim(test_function.get_annotation()), "#Test Function Description");
+assert_equal(test_function.get_contained_functions().size(), 0);
+assert_equal(test_function.get_param_types().size(), 2);
+
+assert_equal(test_function, test_function);
+
+assert_not_equal(test_function, `+`);
+
+assert_equal(test_function.call([1]), 1);
+
+// dynamic object function tests
+
+def int::test_fun()
+{
+  return this;
+}
+
+assert_equal(test_fun.get_arity(), 1);
+assert_equal(test_fun.get_contained_functions.size(), 1);
+assert_equal(test_fun.get_param_types().size(), 2);
+assert_equal(test_fun, test_fun);
+var test_fun_types = test_fun.get_param_types();
+assert_equal(true, test_fun_types[0].bare_equal(Object_type));
+assert_equal(true, test_fun_types[1].bare_equal(int_type));
+
+
+// built-ins tests
+
+assert_equal(2, `==`.get_arity());
+
+// < should be the merging of two functions bool <(PODObject, PODObject) and bool <(string, string)
+// we want to peel it apart and make sure that's true
+var types = `<`.get_param_types();
+assert_equal(3, types.size());
+assert_equal(true, types[0].bare_equal(bool_type));
+assert_equal(true, types[1].bare_equal(Object_type));
+assert_equal(true, types[2].bare_equal(Object_type));
+assert_equal(2, `<`.get_contained_functions().size());
+
+
+// guard existence tests
+
+def with_guard(x) : x > 3 {}
+def without_guard(x) {}
+
+def group_guard(x) {}
+def group_guard(x) : x > 3 {}
+
+assert_equal(true, with_guard.has_guard());
+assert_equal(false, without_guard.has_guard());
+
+assert_equal(2, group_guard.get_contained_functions().size());
+var group = group_guard.get_contained_functions();
+
+assert_equal(true, group[0].has_guard())
+assert_equal(false, group[1].has_guard())
+
+assert_throws("Function does not have a guard", fun() { group[0].get_guard(); } );
+assert_throws("Function does not have a guard", fun() { without_guard.get_guard(); } );
+
+var guard = with_guard.get_guard();
+
+assert_equal(false, guard.has_guard());
+assert_throws("Function does not have a guard", fun() { guard.get_guard(); } );

unittests/3.x/function_reassignment.chai

@@ -0,0 +1,3 @@
+var x = `+`
+x = `-`
+assert_equal(1, x(5,4))

unittests/3.x/generate_range.chai

@@ -0,0 +1 @@
+assert_equal([1,2,3,4,5,6,7,8,9,10], generate_range(1, 10))

unittests/3.x/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/3.x/if.chai

@@ -0,0 +1,7 @@
+var t = false;
+
+if (true) {
+  t = true;
+}
+
+assert_equal(true, t);

unittests/3.x/if_else.chai

@@ -0,0 +1,13 @@
+var i = 3
+var b1 = false;
+var b2 = false;
+
+if (i == 2) {
+  b1 = true;
+}
+else {
+  b2 = true;
+}
+
+assert_equal(false, b1);
+assert_equal(true, b2);

unittests/3.x/if_elseif.chai

@@ -0,0 +1,18 @@
+var b1 = false;
+var b2 = false;
+var b3 = false;
+
+var i = 3
+if (i == 2) {
+  b1 = true;
+}
+else if (i == 4) {
+  b2 = true;
+}
+else if (i == 3) {
+  b3 = true;
+}
+
+assert_equal(false, b1);
+assert_equal(false, b2);
+assert_equal(true, b3);

unittests/3.x/if_elseif_else.chai

@@ -0,0 +1,14 @@
+var i = 3
+var b = false
+if (i == 2) {
+  assert_equal(false, true)
+}
+else if (i == 4) {
+  assert_equal(false, true)
+}
+else {
+  assert_equal(true, true)
+  b = true
+}
+
+assert_equal(true, b)

unittests/3.x/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/3.x/inheritance.chai

@@ -0,0 +1,8 @@
+load_module("test_module")
+
+var t0 = TestBaseType()
+var t = TestDerivedType();
+
+assert_equal(t0.func(), 0);
+assert_equal(t.func(), 1);
+

unittests/3.x/instring_eval.chai

@@ -0,0 +1,3 @@
+var bob = 5.5
+assert_equal("5.5", "${bob}")
+assert_equal("val: 8 and 8", "val: ${5.5 + 2.5} and ${bob + 2.5}")

unittests/3.x/instring_eval_more.chai

@@ -0,0 +1,4 @@
+assert_equal("\$ {4 + 5}", "$ {4 + 5}")
+assert_equal("\$9", "$${4+5}")
+assert_equal("Value: \${4 + 5}", "Value: \${4 + 5}")
+assert_equal("Value: \$9", "Value: \$${4 + 5}")

unittests/3.x/invalid_function_assignment.chai

@@ -0,0 +1 @@
+assert_throws("Illegal const function assignment", fun() { clone = `-` } );

unittests/3.x/invalid_function_reassignment.chai

@@ -0,0 +1 @@
+assert_throws("Invalid function reassignment", fun() { var x = 5; x = `-`; } );