Update release notes for release 4.3.1

for returns from chaiscript function wrappers

.travis.yml

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

CMakeLists.txt

@@ -6,6 +6,18 @@ option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
 option(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
 option(BUILD_SAMPLES "Build Samples Folder" FALSE)
 
+set(EXTRA_LINKER_FLAGS "")
+
+if (CMAKE_COMPILER_IS_GNUCC)
+  option(ENABLE_COVERAGE "Enable Coverage Reporting in GCC" FALSE)
+
+  if (ENABLE_COVERAGE)
+    add_definitions(--coverage -O0)
+    SET(EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} "--coverage")
+  endif()
+
+endif()
+
 list(APPEND CPACK_SOURCE_IGNORE_FILES "${CMAKE_CURRENT_BINARY_DIR}")
 list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.svn")
 list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.git")
@@ -17,8 +29,8 @@ set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
 
 set(CPACK_PACKAGE_VERSION_MAJOR 4)
-set(CPACK_PACKAGE_VERSION_MINOR 2)
-set(CPACK_PACKAGE_VERSION_PATCH 0)
+set(CPACK_PACKAGE_VERSION_MINOR 3)
+set(CPACK_PACKAGE_VERSION_PATCH 1)
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
 set(CPACK_PACKAGE_CONTACT "contact@chaiscript.com")
@@ -95,9 +107,9 @@ else()
   add_definitions(-DCHAISCRIPT_NO_THREADS)
 endif()
 
-if (CMAKE_HOST_UNIX)
+if (CMAKE_HOST_UNIX AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
   list(APPEND LIBS "dl")
-endif(CMAKE_HOST_UNIX)
+endif()
   
 list(APPEND LIBS ${READLINE_LIB})
 
@@ -114,22 +126,22 @@ endif()
 include_directories(${Boost_INCLUDE_DIRS})
 include_directories(${Boost_INCLUDE_DIR})
 add_executable(chai src/main.cpp ${Chai_INCLUDES})
-target_link_libraries(chai ${LIBS})
+target_link_libraries(chai ${LIBS} ${EXTRA_LINKER_FLAGS})
 
 if (BUILD_SAMPLES)
   add_executable(example samples/example.cpp)
-  target_link_libraries(example ${LIBS})
+  target_link_libraries(example ${LIBS} ${EXTRA_LINKER_FLAGS})
   add_executable(memory_leak_test samples/memory_leak_test.cpp)
-  target_link_libraries(memory_leak_test ${LIBS})
+  target_link_libraries(memory_leak_test ${LIBS} ${EXTRA_LINKER_FLAGS})
 endif()
 
 
 if (BUILD_MODULES)
   add_library(stl_extra MODULE src/stl_extra.cpp)
-  target_link_libraries(stl_extra ${LIBS})
+  target_link_libraries(stl_extra ${LIBS} ${EXTRA_LINKER_FLAGS})
 
   add_library(reflection MODULE src/reflection.cpp)
-  target_link_libraries(reflection ${LIBS})
+  target_link_libraries(reflection ${LIBS} ${EXTRA_LINKER_FLAGS})
   set(MODULES stl_extra reflection)
 endif()
 
@@ -153,72 +165,72 @@ if(BUILD_TESTING)
 
   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})
+    target_link_libraries(short_comparison_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Short_Comparison_Test COMMAND short_comparison_test)
 
     add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
-    target_link_libraries(expected_eval_errors_test ${LIBS})
+    target_link_libraries(expected_eval_errors_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Expected_Eval_Errors_Test COMMAND expected_eval_errors_test)
 
     add_executable(set_state_test unittests/set_state_test.cpp)
-    target_link_libraries(set_state_test ${LIBS})
+    target_link_libraries(set_state_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Set_State_Test COMMAND set_state_test)
 
     add_executable(simultaneous_chaiscript_test unittests/simultaneous_chaiscript_test.cpp)
-    target_link_libraries(simultaneous_chaiscript_test ${LIBS})
+    target_link_libraries(simultaneous_chaiscript_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Simultaneous_Chaiscript_Test COMMAND simultaneous_chaiscript_test)
 
     add_executable(c_linkage_test unittests/c_linkage_test.cpp)
-    target_link_libraries(c_linkage_test ${LIBS})
+    target_link_libraries(c_linkage_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME C_Linkage_Test COMMAND c_linkage_test)
 
     add_executable(integer_literal_test unittests/integer_literal_test.cpp)
-    target_link_libraries(integer_literal_test ${LIBS})
+    target_link_libraries(integer_literal_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Integer_Literal_Test COMMAND integer_literal_test)
 
     add_executable(arithmetic_conversions_test unittests/arithmetic_conversions_test.cpp)
-    target_link_libraries(arithmetic_conversions_test ${LIBS})
+    target_link_libraries(arithmetic_conversions_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Arithmetic_Conversions_Test COMMAND arithmetic_conversions_test)
 
     if (MULTITHREAD_SUPPORT_ENABLED)
       add_executable(multithreaded_test unittests/multithreaded_test.cpp)
-      target_link_libraries(multithreaded_test ${LIBS})
+      target_link_libraries(multithreaded_test ${LIBS} ${EXTRA_LINKER_FLAGS})
       add_test(NAME Multithreaded_Test COMMAND multithreaded_test)
       set_property(TEST Multithreaded_Test
         PROPERTY ENVIRONMENT
@@ -231,17 +243,18 @@ if(BUILD_TESTING)
 
     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)
 
 install(TARGETS chai ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript )
+
 install(DIRECTORY include/chaiscript DESTINATION include
    PATTERN "*.hpp"
    PATTERN "*/.svn*" EXCLUDE

contrib/codeanalysis/heterogenous_array_loop.chai

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

contrib/codeanalysis/runcppcheck.sh

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

include/chaiscript/chaiscript.hpp

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

include/chaiscript/chaiscript_threading.hpp

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

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

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

include/chaiscript/dispatchkit/bind_first.hpp

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

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
@@ -273,28 +273,17 @@ namespace chaiscript
           std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
       }
 
-      /**
-      * Returns true if a call can be made that consists of the first parameter
-      * (the function) with the remaining parameters as its arguments.
-      */
-      static Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
-      {
-        if (params.size() < 1)
-        {
-          throw exception::arity_error(static_cast<int>(params.size()), 1);
-        }
-
-        Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
-
-        return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end())));
-      }
 
       static bool has_guard(const Const_Proxy_Function &t_pf)
       {
         boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
-          return pf->get_guard();
+          if (pf->get_guard()) {
+            return true;
+          } else {
+            return false;
+          }
         } else {
           return false;
         }
@@ -319,12 +308,6 @@ namespace chaiscript
       static void throw_exception(const Boxed_Value &bv) {
         throw bv;
       }
-      
-      static boost::shared_ptr<chaiscript::detail::Dispatch_Engine> bootstrap2(boost::shared_ptr<chaiscript::detail::Dispatch_Engine> e = boost::shared_ptr<chaiscript::detail::Dispatch_Engine> (new chaiscript::detail::Dispatch_Engine()))
-      {
-        e->add(user_type<void>(), "void");
-        return e;
-      }
 
       static std::string what(const std::exception &e)
       {
@@ -383,7 +366,6 @@ namespace chaiscript
 
         m->add(fun(&dispatch::Proxy_Function_Base::get_arity), "get_arity");
         m->add(fun(&dispatch::Proxy_Function_Base::annotation), "get_annotation");
-        m->add(fun(&dispatch::Proxy_Function_Base::operator()), "call");
         m->add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
 
         
@@ -476,9 +458,6 @@ namespace chaiscript
         m->add(fun(&ptr_assign<boost::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
         m->add(fun(&ptr_assign<boost::add_const<dispatch::Proxy_Function_Base>::type>), "=");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), 
-          "call_exists");
-
         m->add(fun(&type_match), "type_match");
 
         return m;

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -1,16 +1,13 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-/**
- * \file
- * This file contains utility functions for registration of STL container
- * classes. The methodology used is based on the SGI STL concepts.
- * http://www.sgi.com/tech/stl/table_of_contents.html
- */
-
+/// \file
+/// This file contains utility functions for registration of STL container
+/// classes. The methodology used is based on the SGI STL concepts.
+/// http://www.sgi.com/tech/stl/table_of_contents.html
 
 
 #ifndef CHAISCRIPT_BOOTSTRAP_STL_HPP_
@@ -25,11 +22,10 @@ namespace chaiscript
   {
     namespace standard_library
     {
-      /**
-       * Bidir_Range, based on the D concept of ranges.
-       * \todo Update the Range code to base its capabilities on
-       *       the user_typetraits of the iterator passed in
-       */
+
+      /// Bidir_Range, based on the D concept of ranges.
+      /// \todo Update the Range code to base its capabilities on
+      ///       the user_typetraits of the iterator passed in
       template<typename Container>
         struct Bidir_Range
         {
@@ -245,9 +241,8 @@ namespace chaiscript
 
 
 
-        /**
-         * Add Bidir_Range support for the given ContainerType
-         */
+
+        /// Add Bidir_Range support for the given ContainerType
         template<typename Bidir_Type>
           ModulePtr input_range_type_impl(const std::string &type, ModulePtr m = ModulePtr(new Module()))
           {
@@ -266,9 +261,8 @@ namespace chaiscript
             return m;
           } 
 
-        /**
-         * Algorithm for inserting at a specific position into a container
-         */
+
+        /// Algorithm for inserting at a specific position into a container
         template<typename Type>
           void insert_at(Type &container, int pos, const typename Type::value_type &v)
           {
@@ -284,9 +278,8 @@ namespace chaiscript
             container.insert(itr, v);
           }
 
-        /**
-         * Algorithm for erasing a specific position from a container
-         */
+
+        /// Algorithm for erasing a specific position from a container
         template<typename Type>
           void erase_at(Type &container, int pos)
           {
@@ -312,10 +305,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add random_access_container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/RandomAccessContainer.html
-       */
+
+      /// Add random_access_container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/RandomAccessContainer.html
       template<typename ContainerType>
         ModulePtr random_access_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -334,10 +326,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add assignable concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Assignable.html
-       */
+
+      /// Add assignable concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Assignable.html
       template<typename ContainerType>
         ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -346,26 +337,22 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Container.html
-       */
+
+      /// Add container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Container.html
       template<typename ContainerType>
         ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
           boost::function<int (const ContainerType *)> f = detail::return_int(&ContainerType::size);
           m->add(fun(f), "size");
-//          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");
-
           return m;
         }
 
-      /**
-       * Add default constructable concept to the given Type
-       * http://www.sgi.com/tech/stl/DefaultConstructible.html
-       */
+
+      /// Add default constructable concept to the given Type
+      /// http://www.sgi.com/tech/stl/DefaultConstructible.html
       template<typename Type>
         ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -375,10 +362,9 @@ namespace chaiscript
 
 
 
-      /**
-       * Add sequence concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Sequence.html
-       */
+
+      /// Add sequence concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Sequence.html
       template<typename ContainerType>
         ModulePtr sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -396,10 +382,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add back insertion sequence concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/BackInsertionSequence.html
-       */
+
+      /// Add back insertion sequence concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/BackInsertionSequence.html
       template<typename ContainerType>
         ModulePtr back_insertion_sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -422,10 +407,9 @@ namespace chaiscript
         }
 
 
-      /**
-       *Front insertion sequence
-       *http://www.sgi.com/tech/stl/FrontInsertionSequence.html
-       */
+
+      /// Front insertion sequence
+      /// http://www.sgi.com/tech/stl/FrontInsertionSequence.html
       template<typename ContainerType>
         ModulePtr front_insertion_sequence_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
         {
@@ -448,10 +432,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * bootstrap a given PairType
-       * http://www.sgi.com/tech/stl/pair.html
-       */
+
+      /// bootstrap a given PairType
+      /// http://www.sgi.com/tech/stl/pair.html
       template<typename PairType>
         ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -471,10 +454,10 @@ namespace chaiscript
         }
 
 
-      /**
-       * Add pair associative container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/PairAssociativeContainer.html
-       */
+
+      /// Add pair associative container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/PairAssociativeContainer.html
+
       template<typename ContainerType>
         ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -483,10 +466,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add unique associative container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
-       */
+
+      /// Add unique associative container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
       template<typename ContainerType>
         ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
@@ -512,10 +494,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add a MapType container
-       * http://www.sgi.com/tech/stl/Map.html
-       */
+
+      /// Add a MapType container
+      /// http://www.sgi.com/tech/stl/Map.html
       template<typename MapType>
         ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -534,10 +515,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * hopefully working List type
-       * http://www.sgi.com/tech/stl/List.html
-       */
+
+      /// hopefully working List type
+      /// http://www.sgi.com/tech/stl/List.html
       template<typename ListType>
         ModulePtr list_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -554,10 +534,9 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Create a vector type with associated concepts
-       * http://www.sgi.com/tech/stl/Vector.html
-       */
+
+      /// Create a vector type with associated concepts
+      /// http://www.sgi.com/tech/stl/Vector.html
       template<typename VectorType>
         ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -600,10 +579,34 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add a String container
-       * http://www.sgi.com/tech/stl/basic_string.html
-       */
+        namespace detail {
+          template<typename String>
+          struct apple_string_workarounds
+          {
+            /// The latest version of MacOS has a broken std::string implementation which will not allow
+            /// us to take pointers to the members. Code compiles, but does not link
+            /// \todo re-evaluate at some point
+
+            static size_t find(const String *s, const String &w, int pos) { return s->find(w, pos); }
+            static size_t rfind(const String *s, const String &w, size_t pos) { return s->rfind(w, pos); }
+            static size_t find_first_of(const String *s, const String &w, size_t pos) { return s->find_first_of(w, pos); }
+            static size_t find_last_of(const String *s, const String &w, size_t pos) { return s->find_last_of(w, pos); }
+            static size_t find_first_not_of(const String *s, const String &w, size_t pos) { return s->find_first_not_of(w, pos); }
+            static size_t find_last_not_of(const String *s, const String &w, size_t pos) { return s->find_last_not_of(w, pos); }
+
+            static void clear(String *s) { s->clear(); }
+            static bool empty(const String *s) { return s->empty(); }
+            static size_t size(const String *s) { return s->size(); }
+ 
+            static std::string substr(const String *s, size_t pos, size_t len) { return s->substr(pos,len); }
+            static const char *c_str(const String *s) {  return s->c_str(); }
+            static const char *data(const String *s) { return s->data(); }
+          };
+        }
+
+
+      /// Add a String container
+      /// http://www.sgi.com/tech/stl/basic_string.html
       template<typename String>
         ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
@@ -614,7 +617,7 @@ namespace chaiscript
           random_access_container_type<String>(type, m);
           sequence_type<String>(type, m);
           default_constructible_type<String>(type, m);
-          container_type<String>(type, m);
+          // container_type<String>(type, m);
           assignable_type<String>(type, m);
           input_range_type<String>(type, m);
 
@@ -628,20 +631,19 @@ namespace chaiscript
           }
           m->add(fun(&String::push_back), push_back_name);
 
-          typedef typename String::size_type (String::*find_func_ptr)(const String &, typename String::size_type) const;
-          typedef boost::function<int (const String *, const String &, int)> find_func;
-
-          m->add(fun(find_func(detail::return_int(static_cast<find_func_ptr>(&String::find)))), "find");
-          m->add(fun(find_func(detail::return_int(static_cast<find_func_ptr>(&String::rfind)))), "rfind");
-          m->add(fun(find_func(detail::return_int(static_cast<find_func_ptr>(&String::find_first_of)))), "find_first_of");
-          m->add(fun(find_func(detail::return_int(static_cast<find_func_ptr>(&String::find_last_of)))), "find_last_of");
-          m->add(fun(find_func(detail::return_int(static_cast<find_func_ptr>(&String::find_first_not_of)))), "find_first_not_of");
-          m->add(fun(find_func(detail::return_int(static_cast<find_func_ptr>(&String::find_last_not_of)))), "find_last_not_of");
-
-          m->add(fun(&detail::substr_helper<String, &String::substr>), "substr");
-
-          m->add(fun(&String::c_str), "c_str");
-          m->add(fun(&String::data), "data");
+            
+          m->add(fun(&detail::apple_string_workarounds<String>::find), "find");
+          m->add(fun(&detail::apple_string_workarounds<String>::rfind), "rfind");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_first_of), "find_first_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_last_of), "find_last_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_first_not_of), "find_first_not_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_last_not_of), "find_last_not_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::clear), "clear");
+          m->add(fun(&detail::apple_string_workarounds<String>::size), "size");
+          m->add(fun(&detail::apple_string_workarounds<String>::empty), "empty");
+          m->add(fun(&detail::apple_string_workarounds<String>::substr), "substr");
+          m->add(fun(&detail::apple_string_workarounds<String>::c_str), "c_str");
+          m->add(fun(&detail::apple_string_workarounds<String>::data), "data");
 
 
           return m;

include/chaiscript/dispatchkit/boxed_cast.hpp

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

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

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

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_NUMERIC_HPP_
@@ -10,6 +10,7 @@
 #include "boxed_value.hpp"
 #include "../language/chaiscript_algebraic.hpp"
 #include <boost/cstdint.hpp>
+#include <sstream>
 
 namespace chaiscript 
 {
@@ -306,7 +307,7 @@ namespace chaiscript
         }
 
         template<typename Source>
-          std::string to_string_aux(const Boxed_Value &v) const
+         static std::string to_string_aux(const Boxed_Value &v)
         {
           std::ostringstream oss;
           oss << *static_cast<const Source *>(v.get_const_ptr());
@@ -519,7 +520,7 @@ namespace chaiscript
         return oper(Operators::assign_bitwise_and, this->bv, t_rhs.bv);
       }
 
-      void validate_boxed_number(const Boxed_Value &v)
+      static void validate_boxed_number(const Boxed_Value &v)
       {
         const Type_Info &inp_ = v.get_type_info();
         if (inp_ == typeid(bool))
@@ -820,7 +821,7 @@ namespace chaiscript
       {
         typedef Boxed_Number Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           return Boxed_Number(ob);
         }

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
@@ -13,7 +13,19 @@
 
 #include <map>
 #include <boost/shared_ptr.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
 #include <boost/make_shared.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #include <boost/any.hpp>
 #include <boost/function.hpp>
 #include <boost/ref.hpp>

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DISPATCHKIT_HPP_
@@ -53,9 +53,31 @@ namespace chaiscript
 
       private:
         std::string m_word;
-
     };
 
+    /**
+     * Exception thrown in the case that an object name is invalid because it contains illegal characters
+     */
+    class illegal_name_error : public std::runtime_error
+    {
+      public:
+        illegal_name_error(const std::string &t_name) throw()
+          : std::runtime_error("Reserved name not allowed in object name: " + t_name), m_name(t_name)
+        {
+        }
+
+        virtual ~illegal_name_error() throw() {}
+
+        std::string name() const
+        {
+          return m_name;
+        }
+
+      private:
+        std::string m_name;
+    };
+
+
     /**
      * Exception thrown in the case that an object name is invalid because it already exists in current context
      */
@@ -222,9 +244,9 @@ namespace chaiscript
       public:
         Dispatch_Function(const std::vector<Proxy_Function> &t_funcs)
           : Proxy_Function_Base(build_type_infos(t_funcs)),
-          m_funcs(t_funcs)
-      {
-      }
+            m_funcs(t_funcs)
+        {
+        }
 
         virtual bool operator==(const dispatch::Proxy_Function_Base &rhs) const
         {
@@ -274,7 +296,7 @@ namespace chaiscript
           return -1; // unknown arity
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           typedef std::vector<Proxy_Function> function_vec;
 
@@ -283,7 +305,7 @@ namespace chaiscript
 
           while (begin != end)
           {
-            if ((*begin)->call_match(vals))
+            if ((*begin)->call_match(vals, t_conversions))
             {
               return true;
             } else {
@@ -300,9 +322,9 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return dispatch::dispatch(m_funcs.begin(), m_funcs.end(), params);
+          return dispatch::dispatch(m_funcs.begin(), m_funcs.end(), params, t_conversions);
         }
 
       private:
@@ -389,16 +411,21 @@ namespace chaiscript
 
         ~Dispatch_Engine()
         {
-          detail::Dynamic_Conversions::get().cleanup(m_conversions.begin(), m_conversions.end());
         }
 
+        /// \brief casts an object while applying any Dynamic_Conversion available
+        template<typename Type>
+          typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv) const
+          {
+            return chaiscript::boxed_cast<Type>(bv, &m_conversions);
+          }
+
         /**
          * Add a new conversion for upcasting to a base class
          */
         void add(const Dynamic_Cast_Conversion &d)
         {
-          m_conversions.push_back(d);
-          return detail::Dynamic_Conversions::get().add_conversion(d);
+          m_conversions.add_conversion(d);
         }
 
         /**
@@ -472,6 +499,25 @@ namespace chaiscript
           }
         }
 
+
+        /**
+         * Adds a new global (non-const) shared object, between all the threads
+         */
+        void add_global(const Boxed_Value &obj, const std::string &name)
+        {
+          validate_object_name(name);
+
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_global_object_mutex);
+
+          if (m_state.m_global_objects.find(name) != m_state.m_global_objects.end())
+          {
+            throw exception::name_conflict_error(name);
+          } else {
+            m_state.m_global_objects.insert(std::make_pair(name, obj));
+          }
+        }
+
+
         /**
          * Adds a new scope to the stack
          */
@@ -771,11 +817,16 @@ namespace chaiscript
           m_state.m_reserved_words.insert(name);
         }
 
+        const Dynamic_Cast_Conversions &conversions() const
+        {
+          return m_conversions;
+        }
+
         Boxed_Value call_function(const std::string &t_name, const std::vector<Boxed_Value> &params) const
         {
           std::vector<Proxy_Function> functions = get_function(t_name);
 
-          return dispatch::dispatch(functions.begin(), functions.end(), params);
+          return dispatch::dispatch(functions.begin(), functions.end(), params, m_conversions);
         }
 
         Boxed_Value call_function(const std::string &t_name) const
@@ -844,6 +895,22 @@ namespace chaiscript
           std::cout << ") " << std::endl;
         }
 
+        /**
+         * Returns true if a call can be made that consists of the first parameter
+         * (the function) with the remaining parameters as its arguments.
+         */
+        Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
+        {
+          if (params.size() < 1)
+          {
+            throw exception::arity_error(static_cast<int>(params.size()), 1);
+          }
+
+          Const_Proxy_Function f = this->boxed_cast<Const_Proxy_Function>(params[0]);
+
+          return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end()), m_conversions));
+        }
+
         /**
          * Dump all system info to stdout
          */
@@ -1070,6 +1137,10 @@ namespace chaiscript
          */
         void validate_object_name(const std::string &name) const
         {
+          if (name.find("::") != std::string::npos) {
+            throw exception::illegal_name_error(name);
+          }
+
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
           if (m_state.m_reserved_words.find(name) != m_state.m_reserved_words.end())
@@ -1146,7 +1217,7 @@ namespace chaiscript
           int call_depth;
         };  
 
-        std::vector<Dynamic_Cast_Conversion> m_conversions;
+        Dynamic_Cast_Conversions m_conversions;
         chaiscript::detail::threading::Thread_Storage<Stack_Holder> m_stack_holder;
 
 

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

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

include/chaiscript/dispatchkit/dynamic_object.hpp

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

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
@@ -15,65 +15,77 @@ namespace chaiscript
   {
     struct Exception_Handler_Base
     {
-      virtual void handle(const Boxed_Value &bv) = 0;
+      virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) = 0;
+
+      virtual ~Exception_Handler_Base() {}
 
       protected:
         template<typename T>
-        void throw_type(const Boxed_Value &bv)
+        void throw_type(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
-          try { T t = boxed_cast<T>(bv); throw t; } catch (const exception::bad_boxed_cast &) {}
+          try { T t = t_engine.boxed_cast<T>(bv); throw t; } catch (const exception::bad_boxed_cast &) {}
         }
     };
 
     template<typename T1>
       struct Exception_Handler_Impl1 : Exception_Handler_Base
       {
-        virtual void handle(const Boxed_Value &bv)
+        virtual ~Exception_Handler_Impl1() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
-          throw_type<T1>(bv);
+          throw_type<T1>(bv, t_engine);
         }
       };
     template<typename T1, typename T2>
       struct Exception_Handler_Impl2 : Exception_Handler_Base
       {
-        virtual void handle(const Boxed_Value &bv)
+        virtual ~Exception_Handler_Impl2() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
         }
       };
 
     template<typename T1, typename T2, typename T3>
       struct Exception_Handler_Impl3 : Exception_Handler_Base
       {
-        virtual void handle(const Boxed_Value &bv)
+        virtual ~Exception_Handler_Impl3() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
-          throw_type<T3>(bv);
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
+          throw_type<T3>(bv, t_engine);
         }
       };
     template<typename T1, typename T2, typename T3, typename T4>
       struct Exception_Handler_Impl4 : Exception_Handler_Base
       {
-        virtual void handle(const Boxed_Value &bv)
+        virtual ~Exception_Handler_Impl4() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
-          throw_type<T3>(bv);
-          throw_type<T4>(bv);
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
+          throw_type<T3>(bv, t_engine);
+          throw_type<T4>(bv, t_engine);
         }
       };
     template<typename T1, typename T2, typename T3, typename T4, typename T5>
       struct Exception_Handler_Impl5 : Exception_Handler_Base
       {
-        virtual void handle(const Boxed_Value &bv)
+        virtual ~Exception_Handler_Impl5() {}
+
+        virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine)
         {
-          throw_type<T1>(bv);
-          throw_type<T2>(bv);
-          throw_type<T3>(bv);
-          throw_type<T4>(bv);
-          throw_type<T5>(bv);
+          throw_type<T1>(bv, t_engine);
+          throw_type<T2>(bv, t_engine);
+          throw_type<T3>(bv, t_engine);
+          throw_type<T4>(bv, t_engine);
+          throw_type<T5>(bv, t_engine);
         }
       };
   }

include/chaiscript/dispatchkit/function_call.hpp

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

include/chaiscript/dispatchkit/function_call_detail.hpp

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

include/chaiscript/dispatchkit/handle_return.hpp

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

include/chaiscript/dispatchkit/operators.hpp

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

include/chaiscript/dispatchkit/proxy_constructors.hpp

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

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 
@@ -23,7 +23,7 @@ namespace chaiscript
   class Boxed_Number;
   struct AST_Node;
 
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef boost::shared_ptr<AST_Node> AST_NodePtr;
 
   namespace dispatch
   {
@@ -70,9 +70,9 @@ namespace chaiscript
     {
       public:
         virtual ~Proxy_Function_Base() {}
-        Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Dynamic_Cast_Conversions &t_conversions) const
         {
-          Boxed_Value bv = do_call(params);
+          Boxed_Value bv = do_call(params, t_conversions);
           return bv;
         }
 
@@ -83,7 +83,7 @@ namespace chaiscript
         std::vector<Type_Info> get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const = 0;
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
         bool has_arithmetic_param() const 
         {
@@ -98,7 +98,7 @@ namespace chaiscript
 
         //! Return true if the function is a possible match
         //! to the passed in values
-        bool filter(const std::vector<Boxed_Value> &vals) const
+        bool filter(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           int arity = get_arity();
 
@@ -110,7 +110,7 @@ namespace chaiscript
             {
               return true;
             } else {
-              return compare_first_type(vals[0]);
+              return compare_first_type(vals[0], t_conversions);
             }
           } else {
             return false;
@@ -122,15 +122,15 @@ namespace chaiscript
 
         virtual std::string annotation() const = 0;
 
-        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv)
+        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions)
         {
           if (ti.is_undef() 
               || ti.bare_equal(user_type<Boxed_Value>())
               || (!bv.get_type_info().is_undef()
                 && (ti.bare_equal(user_type<Boxed_Number>())
                   || ti.bare_equal(bv.get_type_info())
-                  || chaiscript::detail::dynamic_cast_converts(ti, bv.get_type_info()) 
                   || bv.get_type_info().bare_equal(user_type<boost::shared_ptr<const Proxy_Function_Base> >())
+                  || t_conversions.dynamic_cast_converts(ti, bv.get_type_info()) 
                   )
                 )
              )
@@ -141,12 +141,12 @@ namespace chaiscript
           }
         }
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const = 0;
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
         Proxy_Function_Base(const std::vector<Type_Info> &t_types)
           : m_types(t_types), m_has_arithmetic_param(false)
         {
-          for (int i = 1; i < m_types.size(); ++i)
+          for (size_t i = 1; i < m_types.size(); ++i)
           {
             if (m_types[i].is_arithmetic())
             {
@@ -157,7 +157,7 @@ namespace chaiscript
 
         }
 
-        virtual bool compare_first_type(const Boxed_Value &bv) const
+        virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
         {
           const std::vector<Type_Info> &types = get_param_types();
 
@@ -167,11 +167,11 @@ namespace chaiscript
           }
 
           const Type_Info &ti = types[1];
-          return compare_type_to_param(ti, bv);
+          return compare_type_to_param(ti, bv, t_conversions);
 
         }
 
-        bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs) const
+        static bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs)
         {
           if (tis.size() - 1 != bvs.size())
           {
@@ -247,10 +247,10 @@ namespace chaiscript
                 && !this->m_guard && !prhs->m_guard);
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           return (m_arity < 0 || vals.size() == size_t(m_arity))
-            && test_guard(vals);
+            && test_guard(vals, t_conversions);
         }    
 
         virtual ~Dynamic_Proxy_Function() {}
@@ -277,12 +277,12 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (m_arity < 0 || params.size() == size_t(m_arity))
           {
 
-            if (test_guard(params))
+            if (test_guard(params, t_conversions))
             {
               return m_f(params);
             } else {
@@ -295,12 +295,12 @@ namespace chaiscript
         }
 
       private:
-        bool test_guard(const std::vector<Boxed_Value> &params) const
+        bool test_guard(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (m_guard)
           {
             try {
-              return boxed_cast<bool>((*m_guard)(params));
+              return boxed_cast<bool>((*m_guard)(params, t_conversions));
             } catch (const exception::arity_error &) {
               return false;
             } catch (const exception::bad_boxed_cast &) {
@@ -356,7 +356,7 @@ namespace chaiscript
         Bound_Function(const Const_Proxy_Function &t_f, 
             const std::vector<Boxed_Value> &t_args)
           : Proxy_Function_Base(build_param_type_info(t_f, t_args)),
-          m_f(t_f), m_args(t_args), m_arity(t_f->get_arity()<0?-1:static_cast<int>(get_param_types().size())-1)
+            m_f(t_f), m_args(t_args), m_arity(t_f->get_arity()<0?-1:static_cast<int>(get_param_types().size())-1)
         {
           assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
         }
@@ -368,14 +368,9 @@ namespace chaiscript
 
         virtual ~Bound_Function() {}
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return m_f->call_match(build_param_list(vals));
-        }
-
-        virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
-        {
-          return (*m_f)(build_param_list(params));
+          return m_f->call_match(build_param_list(vals), t_conversions);
         }
 
         virtual std::vector<Const_Proxy_Function> get_contained_functions() const
@@ -452,9 +447,9 @@ namespace chaiscript
           return retval;
         }
 
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return (*m_f)(build_param_list(params));
+          return (*m_f)(build_param_list(params), t_conversions);
         }
 
       private:
@@ -475,8 +470,8 @@ namespace chaiscript
         Proxy_Function_Impl(const boost::function<Func> &f)
           : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(0))),
           m_f(f), m_dummy_func(0)
-      {
-      }
+        {
+        }
 
         virtual ~Proxy_Function_Impl() {}
 
@@ -493,14 +488,14 @@ namespace chaiscript
         }
 
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (int(vals.size()) != get_arity()) 
           {
             return false;
           }
 
-          return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals);
+          return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals, t_conversions);
         }
 
         virtual std::string annotation() const
@@ -514,9 +509,9 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
-          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params);
+          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params, t_conversions);
         }
 
       private:
@@ -534,8 +529,8 @@ namespace chaiscript
         Attribute_Access(T Class::* t_attr)
           : Proxy_Function_Base(param_types()),
           m_attr(t_attr)
-      {
-      }
+        {
+        }
 
         virtual ~Attribute_Access() {}
 
@@ -556,7 +551,7 @@ namespace chaiscript
           return 1;
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const
         {
           if (vals.size() != 1)
           {
@@ -572,17 +567,17 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
         {
           if (params.size() == 1)
           {
             const Boxed_Value &bv = params[0];
             if (bv.is_const())
             {
-              const Class *o = boxed_cast<const Class *>(bv);
+              const Class *o = boxed_cast<const Class *>(bv, &t_conversions);
               return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
             } else {
-              Class *o = boxed_cast<Class *>(bv);
+              Class *o = boxed_cast<Class *>(bv, &t_conversions);
               return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
             }
           } else {
@@ -630,9 +625,10 @@ namespace chaiscript
     namespace detail 
     {
       template<typename FuncType>
-        bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist)
+        bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
+            const Dynamic_Cast_Conversions &t_conversions)
         {
-          if (t_func->get_arity() != plist.size())
+          if (t_func->get_arity() != static_cast<int>(plist.size()))
           {
             return false;
           }
@@ -641,9 +637,9 @@ namespace chaiscript
 
           assert(plist.size() == types.size() - 1);
 
-          for (int i = 0; i < plist.size(); ++i)
+          for (size_t i = 0; i < plist.size(); ++i)
           {
-            if (Proxy_Function_Base::compare_type_to_param(types[i+1], plist[i])
+            if (Proxy_Function_Base::compare_type_to_param(types[i+1], plist[i], t_conversions)
                 || (types[i+1].is_arithmetic() && plist[i].get_type_info().is_arithmetic()))
             {
               // types continue to match
@@ -657,7 +653,8 @@ namespace chaiscript
         }
 
       template<typename InItr>
-        Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist)
+        Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist, 
+            const Dynamic_Cast_Conversions &t_conversions)
         {
           InItr orig(begin);
 
@@ -665,7 +662,7 @@ namespace chaiscript
 
           while (begin != end)
           {
-            if (types_match_except_for_arithmetic(*begin, plist))
+            if (types_match_except_for_arithmetic(*begin, plist, t_conversions))
             {
               if (matching_func == end)
               {
@@ -689,7 +686,7 @@ namespace chaiscript
           std::vector<Boxed_Value> newplist;
           const std::vector<Type_Info> &tis = (*matching_func)->get_param_types();
 
-          for (int i = 0; i < plist.size(); ++i)
+          for (size_t i = 0; i < plist.size(); ++i)
           {
             if (tis[i+1].is_arithmetic()
                 && plist[i].get_type_info().is_arithmetic()) {
@@ -700,7 +697,7 @@ namespace chaiscript
           }
 
           try {
-            return (*(*matching_func))(newplist);
+            return (*(*matching_func))(newplist, t_conversions);
           } catch (const exception::bad_boxed_cast &) {
             //parameter failed to cast
           } catch (const exception::arity_error &) {
@@ -721,15 +718,15 @@ namespace chaiscript
      */
     template<typename InItr>
       Boxed_Value dispatch(InItr begin, const InItr &end,
-          const std::vector<Boxed_Value> &plist)
+          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
       {
         InItr orig(begin);
         while (begin != end)
         {
           try {
-            if ((*begin)->filter(plist))
+            if ((*begin)->filter(plist, t_conversions))
             {
-              return (*(*begin))(plist);
+              return (*(*begin))(plist, t_conversions);
             }
           } catch (const exception::bad_boxed_cast &) {
             //parameter failed to cast, try again
@@ -742,7 +739,7 @@ namespace chaiscript
           ++begin;
         }
 
-        return detail::dispatch_with_conversions(orig, end, plist);
+        return detail::dispatch_with_conversions(orig, end, plist, t_conversions);
       }
 
     /**
@@ -752,9 +749,9 @@ namespace chaiscript
      */
     template<typename Funcs>
       Boxed_Value dispatch(const Funcs &funcs,
-          const std::vector<Boxed_Value> &plist)
+          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
       {
-        return dispatch::dispatch(funcs.begin(), funcs.end(), plist);
+        return dispatch::dispatch(funcs.begin(), funcs.end(), plist, t_conversions);
       }
   }
 }

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

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

include/chaiscript/dispatchkit/register_function.hpp

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

include/chaiscript/dispatchkit/type_info.hpp

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

include/chaiscript/language/chaiscript_algebraic.hpp

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

include/chaiscript/language/chaiscript_common.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
@@ -21,23 +21,22 @@ namespace chaiscript
   public:
     enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
                 Comparison, Addition, Subtraction, Multiplication, Division, Modulus, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
-                Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
+                Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Continue, Map_Pair, Value_Range,
                 Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl, Shift, Equality, Bitwise_And, Bitwise_Xor, Bitwise_Or, 
-                Logical_And, Logical_Or, Switch, Case, Default, Ternary_Cond
+                Logical_And, Logical_Or, Switch, Case, Default, Ternary_Cond, Noop
     };
   };
 
   namespace
   {
-    /**
-     * Helper lookup to get the name of each node type
-     */
+
+    /// Helper lookup to get the name of each node type
     const char *ast_node_type_to_string(int ast_node_type) {
       const char *ast_node_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Inplace_Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
                                     "Comparison", "Addition", "Subtraction", "Multiplication", "Division", "Modulus", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
-                                    "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
+                                    "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Continue", "Map_Pair", "Value_Range",
                                     "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Shift", "Equality", "Bitwise_And", "Bitwise_Xor", "Bitwise_Or", 
-                                    "Logical_And", "Logical_Or", "Switch", "Case", "Default", "Ternary Condition"};
+                                    "Logical_And", "Logical_Or", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
 
       return ast_node_types[ast_node_type];
     }
@@ -55,15 +54,14 @@ namespace chaiscript
   };
 
   /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
-  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+  typedef boost::shared_ptr<AST_Node> AST_NodePtr;
 
 
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
   namespace exception
   {
-    /**
-     * Errors generated during parsing or evaluation
-     */
+
+    /// Errors generated during parsing or evaluation
     struct eval_error : public std::runtime_error {
       std::string reason;
       File_Position start_position;
@@ -377,9 +375,8 @@ namespace chaiscript
       }
     };
 
-    /**
-     * Errors generated when loading a file
-     */
+
+    /// Errors generated when loading a file
     struct file_not_found_error : public std::runtime_error {
       file_not_found_error(const std::string &t_filename) throw()
         : std::runtime_error("File Not Found: " + t_filename)
@@ -414,9 +411,8 @@ namespace chaiscript
         return oss.str();
       }
 
-      /**
-       * Prints the contents of an AST node, including its children, recursively
-       */
+
+      /// Prints the contents of an AST node, including its children, recursively
       std::string to_string(std::string t_prepend = "") {
         std::ostringstream oss;
 
@@ -439,7 +435,7 @@ namespace chaiscript
           return eval_internal(t_e);
         } catch (exception::eval_error &ee) {
           ee.call_stack.push_back(shared_from_this());
-          throw ee;
+          throw;
         }
       }
 
@@ -478,22 +474,27 @@ namespace chaiscript
   {
     namespace detail
     {
-      /**
-       * Special type for returned values
-       */
+
+      /// Special type for returned values
       struct Return_Value {
         Boxed_Value retval;
 
         Return_Value(const Boxed_Value &t_return_value) : retval(t_return_value) { }
       };
 
-      /**
-       * Special type indicating a call to 'break'
-       */
+
+      /// Special type indicating a call to 'break'
       struct Break_Loop {
         Break_Loop() { }
       };
 
+
+      /// Special type indicating a call to 'continue'
+      struct Continue_Loop {
+        Continue_Loop() { }
+      };
+
+
       /// Creates a new scope then pops it on destruction
       struct Scope_Push_Pop
       {

include/chaiscript/language/chaiscript_engine.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ENGINE_HPP_
@@ -251,9 +251,8 @@ namespace chaiscript
     chaiscript::detail::Dispatch_Engine m_engine;
 
 
-    /**
-     * Evaluates the given string in by parsing it and running the results through the evaluator
-     */
+
+    /// Evaluates the given string in by parsing it and running the results through the evaluator
     Boxed_Value do_eval(const std::string &t_input, const std::string &t_filename = "__EVAL__", bool /* t_internal*/  = false) 
     {
       try {
@@ -282,9 +281,8 @@ namespace chaiscript
     }
 
 
-    /**
-     * Evaluates the given string, used during eval() inside of a script
-     */
+
+    /// Evaluates the given string, used during eval() inside of a script
     const Boxed_Value internal_eval(const std::string &t_e) {
       try {
         return do_eval(t_e, "__EVAL__", true);
@@ -294,16 +292,14 @@ namespace chaiscript
     }
 
 
-    /**
-     * Returns the current evaluation m_engine
-     */
+
+    /// Returns the current evaluation m_engine
     chaiscript::detail::Dispatch_Engine &get_eval_engine() {
       return m_engine;
     }
 
-    /**
-     * Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
-     */
+
+    /// Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
     void build_eval_system() {
       using namespace bootstrap;
       m_engine.add_reserved_word("auto");
@@ -334,6 +330,13 @@ namespace chaiscript
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_function_objects, boost::ref(m_engine)), "get_functions");
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_scripting_objects, boost::ref(m_engine)), "get_objects");
 
+
+      m_engine.add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&chaiscript::detail::Dispatch_Engine::call_exists, boost::ref(m_engine), _1))), 
+          "call_exists");
+      m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base *, const std::vector<Boxed_Value> &)>(boost::bind(&chaiscript::dispatch::Proxy_Function_Base::operator(), _1, _2, boost::ref(m_engine.conversions()))), "call");
+
+
+
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, boost::ref(m_engine)), "name");
 
 
@@ -355,9 +358,8 @@ namespace chaiscript
       do_eval(chaiscript_prelude, "standard prelude");
     }
 
-    /**
-     * Helper function for loading a file
-     */
+
+    /// Helper function for loading a file
     std::string load_file(const std::string &t_filename) {
       std::ifstream infile(t_filename.c_str(), std::ios::in | std::ios::ate | std::ios::binary );
 
@@ -413,19 +415,20 @@ namespace chaiscript
         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);
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
+          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
 
           if (m_used_files.count(appendedpath) == 0)
           {
-            m_used_files.insert(appendedpath);
             l2.unlock();
             eval_file(appendedpath);
-          }
+            l2.lock();
+            m_used_files.insert(appendedpath);
+           }
 
           return; // return, we loaded it, or it was already loaded
         } catch (const exception::file_not_found_error &) {
-          if (i == m_usepaths.size() - 1)
+           if (i == m_usepaths.size() - 1)
           {
             throw exception::file_not_found_error(t_filename);
           }
@@ -446,6 +449,17 @@ namespace chaiscript
       return *this;
     }
 
+    /// \brief Adds a mutable object that is available in all contexts and to all threads
+    /// \param[in] t_bv Boxed_Value to add as a global
+    /// \param[in] t_name Name of the value to add
+    /// \warning The user is responsible for making sure the object is thread-safe if necessary
+    ///          ChaiScript is thread-safe but provides no threading locking mechanism to the script
+    ChaiScript &add_global(const Boxed_Value &t_bv, const std::string &t_name)
+    {
+      m_engine.add_global(t_bv, t_name);
+      return *this;
+    }
+
     /// \brief Represents the current state of the ChaiScript system. State and be saved and restored
     /// \sa ChaiScript::get_state
     /// \sa ChaiScript::set_state
@@ -665,9 +679,9 @@ namespace chaiscript
         return do_eval(t_script);
       } catch (Boxed_Value &bv) {
         if (t_handler) {
-          t_handler->handle(bv);
+          t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -688,15 +702,23 @@ namespace chaiscript
     T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
     {
       try {
-        return boxed_cast<T>(do_eval(t_input, t_filename));
+        return m_engine.boxed_cast<T>(do_eval(t_input, t_filename));
       } catch (Boxed_Value &bv) {
         if (t_handler) {
-          t_handler->handle(bv);
+          t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
+    /// \brief casts an object while applying any Dynamic_Conversion available
+    template<typename Type>
+      typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv) const
+      {
+        return m_engine.boxed_cast<Type>(bv);
+      }
+ 
+
     /// \brief Evaluates a string.
     ///
     /// \param[in] t_input Script to execute
@@ -713,9 +735,9 @@ namespace chaiscript
         return do_eval(t_input, t_filename);
       } catch (Boxed_Value &bv) {
         if (t_handler) {
-          t_handler->handle(bv);
+          t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -729,9 +751,9 @@ namespace chaiscript
         return do_eval(load_file(t_filename), t_filename);
       } catch (Boxed_Value &bv) {
         if (t_handler) {
-          t_handler->handle(bv);
+          t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
 
@@ -746,12 +768,12 @@ namespace chaiscript
     template<typename T>
     T eval_file(const std::string &t_filename, const Exception_Handler &t_handler = Exception_Handler()) {
       try {
-        return boxed_cast<T>(do_eval(load_file(t_filename), t_filename));
+        return m_engine.boxed_cast<T>(do_eval(load_file(t_filename), t_filename));
       } catch (Boxed_Value &bv) {
         if (t_handler) {
-          t_handler->handle(bv);
+          t_handler->handle(bv, m_engine);
         }
-        throw bv;
+        throw;
       }
     }
   };

include/chaiscript/language/chaiscript_eval.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_EVAL_HPP_
@@ -38,7 +38,7 @@ namespace chaiscript
 
     struct Binary_Operator_AST_Node : public AST_Node {
       public:
-        Binary_Operator_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Bitwise_Xor, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+        Binary_Operator_AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
           AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col)
       { }
 
@@ -92,19 +92,19 @@ namespace chaiscript
 
     struct Error_AST_Node : public AST_Node {
       public:
-        Error_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Error, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Error_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Error, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
 
         virtual ~Error_AST_Node() {}
     };
 
     struct Int_AST_Node : public AST_Node {
       public:
-        Int_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Int, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col), 
+        Int_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Int, t_fname, t_start_line, t_start_col, t_end_line, t_end_col), 
           m_value(const_var(int(atoi(t_ast_node_text.c_str())))) { }
-        Int_AST_Node(const std::string &t_ast_node_text, const Boxed_Value &t_bv, int t_id = AST_Node_Type::Int, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col), 
+        Int_AST_Node(const std::string &t_ast_node_text, const Boxed_Value &t_bv, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Int, t_fname, t_start_line, t_start_col, t_end_line, t_end_col), 
           m_value(t_bv) { }
         virtual ~Int_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
@@ -118,11 +118,11 @@ namespace chaiscript
 
     struct Float_AST_Node : public AST_Node {
       public:
-        Float_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Float, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
+        Float_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Float, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
           m_value(const_var(double(atof(t_ast_node_text.c_str())))) { }
-        Float_AST_Node(const std::string &t_ast_node_text, const Boxed_Value &t_bv, int t_id = AST_Node_Type::Float, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
+        Float_AST_Node(const std::string &t_ast_node_text, const Boxed_Value &t_bv, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Float, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
           m_value(t_bv) { }
         virtual ~Float_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
@@ -136,8 +136,8 @@ namespace chaiscript
 
     struct Id_AST_Node : public AST_Node {
       public:
-        Id_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Id, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
+        Id_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
           m_value(get_value(t_ast_node_text))
       { }
 
@@ -180,22 +180,22 @@ namespace chaiscript
 
     struct Char_AST_Node : public AST_Node {
       public:
-        Char_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Char, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Char_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Char, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Char_AST_Node() {}
     };
 
     struct Str_AST_Node : public AST_Node {
       public:
-        Str_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Str, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Str_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Str, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Str_AST_Node() {}
     };
 
     struct Eol_AST_Node : public AST_Node {
       public:
-        Eol_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Eol, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Eol_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Eol, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Eol_AST_Node() {}
 
         virtual std::string pretty_print() const 
@@ -206,8 +206,8 @@ namespace chaiscript
 
     struct Fun_Call_AST_Node : public AST_Node {
       public:
-        Fun_Call_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Fun_Call, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Fun_Call_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Fun_Call, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Fun_Call_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           chaiscript::eval::detail::Function_Push_Pop fpp(t_ss);
@@ -225,7 +225,7 @@ namespace chaiscript
 
           try {
             chaiscript::eval::detail::Stack_Push_Pop spp(t_ss);
-            const Boxed_Value &retval = (*boxed_cast<const Const_Proxy_Function &>(fn))(plb);
+            const Boxed_Value &retval = (*t_ss.boxed_cast<const Const_Proxy_Function &>(fn))(plb, t_ss.conversions());
             return retval;
           }
           catch(const exception::dispatch_error &e){
@@ -233,7 +233,7 @@ namespace chaiscript
           }
           catch(const exception::bad_boxed_cast &){
             try {
-              Const_Proxy_Function f = boxed_cast<const Const_Proxy_Function &>(fn);
+              Const_Proxy_Function f = t_ss.boxed_cast<const Const_Proxy_Function &>(fn);
               // handle the case where there is only 1 function to try to call and dispatch fails on it
               std::vector<Const_Proxy_Function> funcs;
               funcs.push_back(f);
@@ -275,8 +275,8 @@ namespace chaiscript
 
     struct Inplace_Fun_Call_AST_Node : public AST_Node {
       public:
-        Inplace_Fun_Call_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Inplace_Fun_Call, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Inplace_Fun_Call_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Inplace_Fun_Call, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Inplace_Fun_Call_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           dispatch::Param_List_Builder plb;
@@ -293,11 +293,11 @@ namespace chaiscript
           try {
             bv = this->children[0]->eval(t_ss);
             try {
-              fn = boxed_cast<const Const_Proxy_Function &>(bv);
+              fn = t_ss.boxed_cast<const Const_Proxy_Function &>(bv);
             } catch (const exception::bad_boxed_cast &) {
               throw exception::eval_error("'" + this->children[0]->pretty_print() + "' does not evaluate to a function.");
             }
-            return (*fn)(plb);
+            return (*fn)(plb, t_ss.conversions());
           }
           catch(const exception::dispatch_error &e){
             throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'", e.parameters, e.functions, false, t_ss);
@@ -340,8 +340,8 @@ namespace chaiscript
 
     struct Arg_List_AST_Node : public AST_Node {
       public:
-        Arg_List_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Arg_List, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Arg_List_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Arg_List, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Arg_List_AST_Node() {}
 
         virtual std::string pretty_print() const 
@@ -362,15 +362,15 @@ namespace chaiscript
 
     struct Variable_AST_Node : public AST_Node {
       public:
-        Variable_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Variable, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Variable_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Variable, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Variable_AST_Node() {}
     };
 
     struct Equation_AST_Node : public AST_Node {
       public:
-        Equation_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Equation, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col)
+        Equation_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Equation, t_fname, t_start_line, t_start_col, t_end_line, t_end_col)
         {}
 
         virtual ~Equation_AST_Node() {}
@@ -429,8 +429,8 @@ namespace chaiscript
 
     struct Var_Decl_AST_Node : public AST_Node {
       public:
-        Var_Decl_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Var_Decl, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Var_Decl_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Var_Decl, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Var_Decl_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           try {
@@ -453,17 +453,17 @@ namespace chaiscript
 
     struct Comparison_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Comparison_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Comparison, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Comparison_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Comparison, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Comparison_AST_Node() {}
     };
 
     struct Addition_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Addition_AST_Node(const std::string &t_ast_node_text = "+", int t_id = AST_Node_Type::Addition,
+        Addition_AST_Node(const std::string &t_ast_node_text = "+",
             const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(),
             int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Addition, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Addition_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           return do_oper(t_ss, Operators::sum, "+", this->children[0]->eval(t_ss), this->children[1]->eval(t_ss));
@@ -472,10 +472,10 @@ namespace chaiscript
 
     struct Subtraction_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Subtraction_AST_Node(const std::string &t_ast_node_text = "-", int t_id = AST_Node_Type::Subtraction,
+        Subtraction_AST_Node(const std::string &t_ast_node_text = "-",
             const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0,
             int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Subtraction, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Subtraction_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           return do_oper(t_ss, Operators::difference, "-", this->children[0]->eval(t_ss), this->children[1]->eval(t_ss));
@@ -484,10 +484,10 @@ namespace chaiscript
 
     struct Multiplication_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Multiplication_AST_Node(const std::string &t_ast_node_text = "*", int t_id = AST_Node_Type::Multiplication,
+        Multiplication_AST_Node(const std::string &t_ast_node_text = "*",
             const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0,
             int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Multiplication, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Multiplication_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           return do_oper(t_ss, Operators::product, "*", this->children[0]->eval(t_ss), this->children[1]->eval(t_ss));
@@ -496,10 +496,10 @@ namespace chaiscript
 
     struct Division_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Division_AST_Node(const std::string &t_ast_node_text = "/", int t_id = AST_Node_Type::Division,
+        Division_AST_Node(const std::string &t_ast_node_text = "/",
             const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0,
             int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Division, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Division_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           return do_oper(t_ss, Operators::quotient, "/", this->children[0]->eval(t_ss), this->children[1]->eval(t_ss));
@@ -508,10 +508,10 @@ namespace chaiscript
 
     struct Modulus_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Modulus_AST_Node(const std::string &t_ast_node_text = "%", int t_id = AST_Node_Type::Modulus,
+        Modulus_AST_Node(const std::string &t_ast_node_text = "%",
             const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0,
             int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Modulus, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Modulus_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           return do_oper(t_ss, Operators::remainder, "%", this->children[0]->eval(t_ss), this->children[1]->eval(t_ss));
@@ -520,8 +520,8 @@ namespace chaiscript
 
     struct Array_Call_AST_Node : public AST_Node {
       public:
-        Array_Call_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Array_Call, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Array_Call_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Array_Call, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Array_Call_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           chaiscript::eval::detail::Function_Push_Pop fpp(t_ss);
@@ -568,8 +568,8 @@ namespace chaiscript
 
     struct Dot_Access_AST_Node : public AST_Node {
       public:
-        Dot_Access_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Dot_Access, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Dot_Access_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Dot_Access, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Dot_Access_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           Boxed_Value retval = this->children[0]->eval(t_ss);
@@ -635,8 +635,8 @@ namespace chaiscript
 
     struct Quoted_String_AST_Node : public AST_Node {
       public:
-        Quoted_String_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Quoted_String, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
+        Quoted_String_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Quoted_String, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
           m_value(const_var(t_ast_node_text)) { }
         virtual ~Quoted_String_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &) {
@@ -655,8 +655,8 @@ namespace chaiscript
 
     struct Single_Quoted_String_AST_Node : public AST_Node {
       public:
-        Single_Quoted_String_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Single_Quoted_String, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
+        Single_Quoted_String_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Single_Quoted_String, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
           m_value(const_var(char(t_ast_node_text.at(0)))) { }
         virtual ~Single_Quoted_String_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
@@ -674,8 +674,8 @@ namespace chaiscript
 
     struct Lambda_AST_Node : public AST_Node {
       public:
-        Lambda_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Lambda, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Lambda_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Lambda, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Lambda_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           std::vector<std::string> t_param_names;
@@ -702,8 +702,8 @@ namespace chaiscript
 
     struct Block_AST_Node : public AST_Node {
       public:
-        Block_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Block, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Block_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Block, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Block_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           const size_t num_children = this->children.size();
@@ -731,8 +731,8 @@ namespace chaiscript
 
     struct Def_AST_Node : public AST_Node {
       public:
-        Def_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Def, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Def_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Def, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Def_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           std::vector<std::string> t_param_names;
@@ -787,35 +787,28 @@ namespace chaiscript
 
     struct While_AST_Node : public AST_Node {
       public:
-        While_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::While, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        While_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::While, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~While_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
-          bool cond;
-
           chaiscript::eval::detail::Scope_Push_Pop spp(t_ss);
 
           try {
-            cond = boxed_cast<bool>(this->children[0]->eval(t_ss));
-          }
-          catch (const exception::bad_boxed_cast &) {
-            throw exception::eval_error("While condition not boolean");
-          }
-          while (cond) {
-            try {
-              this->children[1]->eval(t_ss);
-
+            while (boxed_cast<bool>(this->children[0]->eval(t_ss))) {
               try {
-                cond = boxed_cast<bool>(this->children[0]->eval(t_ss));
+                this->children[1]->eval(t_ss);
+              } catch (detail::Continue_Loop &) {
+                // we got a continue exception, which means all of the remaining 
+                // loop implementation is skipped and we just need to continue to
+                // the next condition test
               }
-              catch (const exception::bad_boxed_cast &) {
-                throw exception::eval_error("While condition not boolean");
-              }
-            }
-            catch (detail::Break_Loop &) {
-              cond = false;
-            }
+            } 
+          } catch (const exception::bad_boxed_cast &) {
+            throw exception::eval_error("While condition not boolean");
+          } catch (detail::Break_Loop &) {
+            // loop was broken intentionally
           }
+
           return Boxed_Value();
         }
 
@@ -823,8 +816,8 @@ namespace chaiscript
 
     struct Ternary_Cond_AST_Node : public AST_Node {
       public:
-        Ternary_Cond_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::If, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Ternary_Cond_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::If, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Ternary_Cond_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           bool cond;
@@ -832,7 +825,7 @@ namespace chaiscript
             cond = boxed_cast<bool>(this->children[0]->eval(t_ss));
           }
           catch (const exception::bad_boxed_cast &) {
-            throw exception::eval_error("If condition not boolean");
+            throw exception::eval_error("Ternary if condition not boolean");
           }
 
           if (cond) {
@@ -846,8 +839,8 @@ namespace chaiscript
 
     struct If_AST_Node : public AST_Node {
       public:
-        If_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::If, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        If_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::If, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~If_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           bool cond;
@@ -891,49 +884,38 @@ namespace chaiscript
 
     struct For_AST_Node : public AST_Node {
       public:
-        For_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::For, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        For_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::For, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~For_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
-          bool cond;
-
           chaiscript::eval::detail::Scope_Push_Pop spp(t_ss);
 
-          try {
-            if (this->children.size() == 4) {
-              this->children[0]->eval(t_ss);
+          // initial expression
+          this->children[0]->eval(t_ss);
 
-              cond = boxed_cast<bool>(this->children[1]->eval(t_ss));
-            } else {
-              cond = boxed_cast<bool>(this->children[0]->eval(t_ss));
+          try {
+            // while condition evals to true
+            while (boxed_cast<bool>(this->children[1]->eval(t_ss))) {
+              try {
+                // Body of Loop
+                this->children[3]->eval(t_ss);
+              } catch (detail::Continue_Loop &) {
+                // we got a continue exception, which means all of the remaining 
+                // loop implementation is skipped and we just need to continue to
+                // the next iteration step
+              }
+
+              // loop expression
+              this->children[2]->eval(t_ss);
             }
           }
           catch (const exception::bad_boxed_cast &) {
             throw exception::eval_error("For condition not boolean");
           }
-          while (cond) {
-            try {
-              if (this->children.size() == 4) {
-                this->children[3]->eval(t_ss);
-                this->children[2]->eval(t_ss);
-
-                cond = boxed_cast<bool>(this->children[1]->eval(t_ss));
-              }
-              else {
-                this->children[2]->eval(t_ss);
-
-                this->children[1]->eval(t_ss);
-
-                cond = boxed_cast<bool>(this->children[0]->eval(t_ss));
-              }
-            }
-            catch (const exception::bad_boxed_cast &) {
-              throw exception::eval_error("For condition not boolean");
-            }
-            catch (detail::Break_Loop &) {
-              cond = false;
-            }
+          catch (detail::Break_Loop &) {
+            // loop broken
           }
+
           return Boxed_Value();
         }
 
@@ -941,8 +923,8 @@ namespace chaiscript
 
     struct Switch_AST_Node : public AST_Node {
       public:
-        Switch_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Switch, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Switch_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Switch, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Switch_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           Boxed_Value match_value;
@@ -984,8 +966,8 @@ namespace chaiscript
 
     struct Case_AST_Node : public AST_Node {
       public:
-        Case_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Case, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Case_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Case, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Case_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           chaiscript::eval::detail::Scope_Push_Pop spp(t_ss);
@@ -998,8 +980,8 @@ namespace chaiscript
    
     struct Default_AST_Node : public AST_Node {
       public:
-        Default_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Default, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Default_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Default, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Default_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           chaiscript::eval::detail::Scope_Push_Pop spp(t_ss);
@@ -1012,8 +994,8 @@ namespace chaiscript
        
     struct Inline_Array_AST_Node : public AST_Node {
       public:
-        Inline_Array_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Inline_Array, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Inline_Array_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Inline_Array, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Inline_Array_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           try {
@@ -1032,19 +1014,23 @@ namespace chaiscript
 
         }
 
+        virtual std::string pretty_print() const
+        {
+          return "[" + AST_Node::pretty_print() + "]";
+        }
     };
 
     struct Inline_Map_AST_Node : public AST_Node {
       public:
-        Inline_Map_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Inline_Map, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Inline_Map_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Inline_Map, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Inline_Map_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           try {
             std::map<std::string, Boxed_Value> retval;
             for (size_t i = 0; i < this->children[0]->children.size(); ++i) {
               Boxed_Value bv = t_ss.call_function("clone", this->children[0]->children[i]->children[1]->eval(t_ss));
-              retval[boxed_cast<std::string>(this->children[0]->children[i]->children[0]->eval(t_ss))] 
+              retval[t_ss.boxed_cast<std::string>(this->children[0]->children[i]->children[0]->eval(t_ss))] 
                 = bv;
             }
             return const_var(retval);
@@ -1058,8 +1044,8 @@ namespace chaiscript
 
     struct Return_AST_Node : public AST_Node {
       public:
-        Return_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Return, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Return_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Return, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Return_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           if (this->children.size() > 0) {
@@ -1074,8 +1060,8 @@ namespace chaiscript
 
     struct File_AST_Node : public AST_Node {
       public:
-        File_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::File, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        File_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::File, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~File_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) {
           const size_t size = this->children.size(); 
@@ -1091,8 +1077,8 @@ namespace chaiscript
 
     struct Prefix_AST_Node : public AST_Node {
       public:
-        Prefix_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Prefix, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col)
+        Prefix_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Prefix, t_fname, t_start_line, t_start_col, t_end_line, t_end_col)
         { }
 
         virtual ~Prefix_AST_Node() {}
@@ -1102,6 +1088,7 @@ namespace chaiscript
 
           Operators::Opers oper = Operators::to_operator(children[0]->text, true);
           try {
+            // short circuit arithmetic operations
             if (bv.get_type_info().is_arithmetic() && oper != Operators::invalid)
             {
               return Boxed_Number::do_oper(oper, bv);
@@ -1121,32 +1108,59 @@ namespace chaiscript
 
     struct Break_AST_Node : public AST_Node {
       public:
-        Break_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Break, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Break_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Break, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Break_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
           throw detail::Break_Loop();
         }
     };
 
+    struct Continue_AST_Node : public AST_Node {
+      public:
+        Continue_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Continue, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        virtual ~Continue_AST_Node() {}
+        virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
+          throw detail::Continue_Loop();
+        }
+    };
+
+    struct Noop_AST_Node : public AST_Node {
+      public:
+        Noop_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Noop, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
+          m_value(const_var(true))
+        { }
+
+        virtual ~Noop_AST_Node() {}
+        virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
+          // It's a no-op, that evaluates to "true"
+          return m_value;
+        }
+
+      private:
+        Boxed_Value m_value;
+    };
+
     struct Map_Pair_AST_Node : public AST_Node {
       public:
-        Map_Pair_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Map_Pair, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Map_Pair_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Map_Pair, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Map_Pair_AST_Node() {}
     };
 
     struct Value_Range_AST_Node : public AST_Node {
       public:
-        Value_Range_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Value_Range, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Value_Range_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Value_Range, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Value_Range_AST_Node() {}
     };
 
     struct Inline_Range_AST_Node : public AST_Node {
       public:
-        Inline_Range_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Inline_Range, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Inline_Range_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Inline_Range, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Inline_Range_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           try {
@@ -1163,15 +1177,15 @@ namespace chaiscript
 
     struct Annotation_AST_Node : public AST_Node {
       public:
-        Annotation_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Annotation, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Annotation_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Annotation, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Annotation_AST_Node() {}
     };
 
     struct Try_AST_Node : public AST_Node {
       public:
-        Try_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Try, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Try_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Try, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Try_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           Boxed_Value retval;        
@@ -1299,22 +1313,22 @@ namespace chaiscript
 
     struct Catch_AST_Node : public AST_Node {
       public:
-        Catch_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Catch, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Catch_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Catch, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Catch_AST_Node() {}
     };
 
     struct Finally_AST_Node : public AST_Node {
       public:
-        Finally_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Finally, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Finally_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Finally, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Finally_AST_Node() {}
     };
 
     struct Method_AST_Node : public AST_Node {
       public:
-        Method_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Method, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Method_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Method, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Method_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
 
@@ -1392,8 +1406,8 @@ namespace chaiscript
 
     struct Attr_Decl_AST_Node : public AST_Node {
       public:
-        Attr_Decl_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Attr_Decl, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Attr_Decl_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Attr_Decl, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Attr_Decl_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           try {
@@ -1421,43 +1435,43 @@ namespace chaiscript
 
     struct Shift_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Shift_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Shift, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Shift_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Shift, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Shift_AST_Node() {}
     };
 
     struct Equality_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Equality_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Equality, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Equality_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Equality, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Equality_AST_Node() {}
     };
 
     struct Bitwise_And_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Bitwise_And_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Bitwise_And, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Bitwise_And_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Bitwise_And, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Bitwise_And_AST_Node() {}
     };
 
     struct Bitwise_Xor_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Bitwise_Xor_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Bitwise_Xor, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Bitwise_Xor_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Bitwise_Xor, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Bitwise_Xor_AST_Node() {}
     };
 
     struct Bitwise_Or_AST_Node : public Binary_Operator_AST_Node {
       public:
-        Bitwise_Or_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Bitwise_Or, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Bitwise_Or_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          Binary_Operator_AST_Node(t_ast_node_text, AST_Node_Type::Bitwise_Or, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Bitwise_Or_AST_Node() {}
     };
 
     struct Logical_And_AST_Node : public AST_Node {
       public:
-        Logical_And_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Logical_And, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Logical_And_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Logical_And, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Logical_And_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           Boxed_Value retval = this->children[0]->eval(t_ss);
@@ -1490,8 +1504,8 @@ namespace chaiscript
 
     struct Logical_Or_AST_Node : public AST_Node {
       public:
-        Logical_Or_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Logical_Or, const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
-          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
+        Logical_Or_AST_Node(const std::string &t_ast_node_text = "", const boost::shared_ptr<std::string> &t_fname=boost::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, AST_Node_Type::Logical_Or, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
         virtual ~Logical_Or_AST_Node() {}
         virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss){
           Boxed_Value retval;

include/chaiscript/language/chaiscript_parser.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_PARSER_HPP_
@@ -56,7 +56,8 @@ namespace chaiscript
 
       public:
       ChaiScript_Parser()
-        : m_multiline_comment_begin("/*"),
+        : m_line(-1), m_col(-1),
+        m_multiline_comment_begin("/*"),
           m_multiline_comment_end("*/"),
           m_singleline_comment("//")
       {
@@ -635,7 +636,7 @@ namespace chaiscript
             if (Hex_()) {
               std::string match(start, m_input_pos);
               Boxed_Value i = buildInt(std::hex, match);
-              AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -660,14 +661,14 @@ namespace chaiscript
                 i = Boxed_Value(const_var(temp_int));
               }
 
-              AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
             if (Float_()) {
               std::string match(start, m_input_pos);
               Boxed_Value f = buildFloat(match);
-              AST_NodePtr t(new eval::Float_AST_Node(match, f, AST_Node_Type::Float, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Float_AST_Node(match, f, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -676,12 +677,12 @@ namespace chaiscript
               std::string match(start, m_input_pos);
               if ((match.size() > 0) && (match[0] == '0')) {
                 Boxed_Value i = buildInt(std::oct, match);
-                AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+                AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
                 m_match_stack.push_back(t);
               }
               else {
                 Boxed_Value i = buildInt(std::dec, match);
-                AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+                AST_NodePtr t(new eval::Int_AST_Node(match, i, m_filename, prev_line, prev_col, m_line, m_col));
                 m_match_stack.push_back(t);
               }
               return true;
@@ -751,13 +752,13 @@ namespace chaiscript
             if (*start == '`') {
               //Id Literal
               std::string match(start+1, m_input_pos-1);
-              AST_NodePtr t(new eval::Id_AST_Node(match, AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Id_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
             else {
               std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Id_AST_Node(match, AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Id_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -790,7 +791,7 @@ namespace chaiscript
           } while (Symbol("#"));
 
           std::string match(start, m_input_pos);
-          AST_NodePtr t(new eval::Annotation_AST_Node(match, AST_Node_Type::Annotation, m_filename, prev_line, prev_col, m_line, m_col));
+          AST_NodePtr t(new eval::Annotation_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
           m_match_stack.push_back(t);
           return true;
         }
@@ -804,10 +805,9 @@ namespace chaiscript
        */
       bool Quoted_String_() {
         bool retval = false;
-        char prev_char = 0;
         if (has_more_input() && (*m_input_pos == '\"')) {
           retval = true;
-          prev_char = *m_input_pos;
+          char prev_char = *m_input_pos;
           ++m_input_pos;
           ++m_col;
 
@@ -865,13 +865,13 @@ namespace chaiscript
                   if (is_interpolated) {
                     //If we've seen previous interpolation, add on instead of making a new one
 
-                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(t);
 
                     build_match(AST_NodePtr(new eval::Addition_AST_Node()), prev_stack_top);
                   }
                   else {
-                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(t);
                   }
 
@@ -891,17 +891,17 @@ namespace chaiscript
 
                     size_t tostr_stack_top = m_match_stack.size();
 
-                    AST_NodePtr tostr(new eval::Id_AST_Node("to_string", AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr tostr(new eval::Id_AST_Node("to_string", m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(tostr);
 
                     size_t ev_stack_top = m_match_stack.size();
 
-                    AST_NodePtr ev(new eval::Id_AST_Node("eval", AST_Node_Type::Id, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr ev(new eval::Id_AST_Node("eval", m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(ev);
 
                     size_t arg_stack_top = m_match_stack.size();
 
-                    AST_NodePtr t(new eval::Quoted_String_AST_Node(eval_match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+                    AST_NodePtr t(new eval::Quoted_String_AST_Node(eval_match, m_filename, prev_line, prev_col, m_line, m_col));
                     m_match_stack.push_back(t);
 
                     build_match(AST_NodePtr(new eval::Arg_List_AST_Node()), arg_stack_top);
@@ -959,13 +959,13 @@ namespace chaiscript
               }
             }
             if (is_interpolated) {
-              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
 
               build_match(AST_NodePtr(new eval::Addition_AST_Node()), prev_stack_top);
             }
             else {
-              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, AST_Node_Type::Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
             }
             return true;
@@ -981,10 +981,9 @@ namespace chaiscript
          */
         bool Single_Quoted_String_() {
           bool retval = false;
-          char prev_char = 0;
           if (has_more_input() && (*m_input_pos == '\'')) {
             retval = true;
-            prev_char = *m_input_pos;
+            char prev_char = *m_input_pos;
             ++m_input_pos;
             ++m_col;
 
@@ -1057,7 +1056,7 @@ namespace chaiscript
                   is_escaped = false;
                 }
               }
-              AST_NodePtr t(new eval::Single_Quoted_String_AST_Node(match, AST_Node_Type::Single_Quoted_String, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Single_Quoted_String_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -1096,7 +1095,7 @@ namespace chaiscript
             int prev_line = m_line;
             if (Char_(t_c)) {
               std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Char_AST_Node(match, AST_Node_Type::Char, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Char_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -1148,7 +1147,7 @@ namespace chaiscript
 
           if ( t_capture && retval ) {
             std::string match(start, m_input_pos);
-            AST_NodePtr t(new eval::Str_AST_Node(match, AST_Node_Type::Str, m_filename, prev_line, prev_col, m_line, m_col));
+            AST_NodePtr t(new eval::Str_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
             m_match_stack.push_back(t);
           }
           return retval;
@@ -1196,7 +1195,7 @@ namespace chaiscript
 
           if ( t_capture && retval ) {
             std::string match(start, m_input_pos);
-            AST_NodePtr t(new eval::Str_AST_Node(match, AST_Node_Type::Str, m_filename, prev_line, prev_col, m_line, m_col));
+            AST_NodePtr t(new eval::Str_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
             m_match_stack.push_back(t);
           }
 
@@ -1236,7 +1235,7 @@ namespace chaiscript
             int prev_line = m_line;
             if (Eol_()) {
               std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Eol_AST_Node(match, AST_Node_Type::Eol, m_filename, prev_line, prev_col, m_line, m_col));
+              AST_NodePtr t(new eval::Eol_AST_Node(match, m_filename, prev_line, prev_col, m_line, m_col));
               m_match_stack.push_back(t);
               return true;
             }
@@ -1350,7 +1349,6 @@ namespace chaiscript
         bool Def() {
           bool retval = false;
           bool is_annotated = false;
-          bool is_method = false;
           AST_NodePtr annotation;
 
           if (Annotation()) {
@@ -1369,6 +1367,8 @@ namespace chaiscript
               throw exception::eval_error("Missing function name in definition", File_Position(m_line, m_col), *m_filename);
             }
 
+            bool is_method = false;
+
             if (Symbol("::", false)) {
               //We're now a method
               is_method = true;
@@ -1506,7 +1506,7 @@ namespace chaiscript
               if (Keyword("else", true)) {
                 if (Keyword("if")) {
                   AST_NodePtr back(m_match_stack.back());
-                  m_match_stack.back() = AST_NodePtr(new eval::If_AST_Node("else if", back->identifier)); 
+                  m_match_stack.back() = AST_NodePtr(new eval::If_AST_Node("else if"));
                   m_match_stack.back()->start = back->start;
                   m_match_stack.back()->end = back->end;
                   m_match_stack.back()->children = back->children;
@@ -1574,18 +1574,40 @@ namespace chaiscript
           return retval;
         }
 
+
         /**
          * Reads the C-style for conditions from input
          */
         bool For_Guards() {
-          Equation();
+          if (!(Equation() && Eol()))
+          {
+            if (!Eol())
+            {
+              throw exception::eval_error("'for' loop initial statment missing", File_Position(m_line, m_col), *m_filename);          
+            } else {
+              AST_NodePtr t(new eval::Noop_AST_Node());
+              m_match_stack.push_back(t);
+            }
+          }
 
-          if (Char(';') && Operator() && Char(';') && Equation()) {
-            return true;
+          if (!(Equation() && Eol()))
+          {
+            if (!Eol())
+            {
+              throw exception::eval_error("'for' loop condition missing", File_Position(m_line, m_col), *m_filename);          
+            } else {
+              AST_NodePtr t(new eval::Noop_AST_Node());
+              m_match_stack.push_back(t);
+            }
           }
-          else {
-            throw exception::eval_error("Incomplete conditions in 'for' loop", File_Position(m_line, m_col), *m_filename);
+
+          if (!Equation())
+          {
+            AST_NodePtr t(new eval::Noop_AST_Node());
+            m_match_stack.push_back(t);
           }
+
+          return true; 
         }
 
         /**
@@ -1760,6 +1782,23 @@ namespace chaiscript
           return retval;
         }
 
+        /**
+         * Reads a continue statement from input
+         */
+        bool Continue() {
+          bool retval = false;
+
+          size_t prev_stack_top = m_match_stack.size();
+
+          if (Keyword("continue")) {
+            retval = true;
+
+            build_match(AST_NodePtr(new eval::Continue_AST_Node()), prev_stack_top);
+          }
+
+          return retval;
+        }
+
         /**
          * Reads a dot expression(member access), then proceeds to check if it's a function or array call
          */
@@ -2257,6 +2296,14 @@ namespace chaiscript
               retval = true;
               saw_eol = false;
             }
+            else if (Continue()) {
+              if (!saw_eol) {
+                throw exception::eval_error("Two expressions missing line separator", File_Position(prev_line, prev_col), *m_filename);
+              }
+              has_more = true;
+              retval = true;
+              saw_eol = false;
+            }
             else if (Equation()) {
               if (!saw_eol) {
                 throw exception::eval_error("Two expressions missing line separator", File_Position(prev_line, prev_col), *m_filename);

include/chaiscript/language/chaiscript_prelude.hpp

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

include/chaiscript/utility/utility.hpp

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

license.txt

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

readme.md

@@ -1,8 +1,11 @@
+[![Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=master)](https://travis-ci.org/ChaiScript/ChaiScript)
+
 ChaiScript
 
 http://www.chaiscript.com
 
-(c) 2009-2012 Jason Turner and Jonathan Turner
+(c) 2009-2012 Jonathan Turner
+(c) 2009-2014 Jason Turner
 
 Release under the BSD license, see "license.txt" for details.
 

releasenotes.txt

@@ -1,8 +1,35 @@
-Changes since 4.1.1
+Current Version: 4.3.1
+
+Note: this is scheduled to be the last release that requires boost, new releases after this will require a C++11 compiler.
+
+### Changes since 4.3.0
+* Add automatic conversion of arithmetic return types, following the same
+  rules as conversion of arithmetic types when passing parameters
+* Add automatic casting up the inheritence hierarchy when possible.
+* Enable travis.ci testing
+
+### Changes since 4.2.0
+* Enhanced unit tests
+* Add `continue` statement, fix various use cases for `for`  loops
+* Fix use of suffixed numbers in vector initialization
+* Code cleanups
+* Eliminate global data, which makes code more portable and thread safe
+* Fix issue #79
+* Merge pretty_print fixes from @mgee #82
+* Compiler warning fixes for latest compiler releases
+* Fix threading problems
+* Fix linking error on MacOS Mavericks #88
+* Allow non-const globals
+* Make sure user cannot name a variable with `::` in it #91
+* Fix various string / map / vector `size` and `count` calls for compilers which have weird overloads for them. #90 #93 #95
+* Make module search path relative to the currently running executable
+* Build and work with wstring windows builds
+
+### Changes since 4.1.1
 * Add support for automatic conversion of arithmetic types when possible
   and when no ambiguous method dispatch exists.
 
-Changes since 4.1.0
+### Changes since 4.1.0
 * Fix missed gcc build error in 4.1.0
 
 Changes since 4.0.0
@@ -29,7 +56,7 @@ Changes since 3.1.0
 * Increased unit tests to 161
 * Performance enhancements
 
-Changes since 3.0.0
+### Changes since 3.0.0
 * Numeric operations performance increased approximately 10x
 * Looping operations performance increased up to 2x
 * Engine start up time decreased
@@ -38,8 +65,7 @@ Changes since 3.0.0
   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
-
+### Changes since 2.3.3
 * Code simplifications
 * Fully integrate documentation with source code in doxygen style comments
 * Unit tests increased from 114 to 137

samples/example.cpp

@@ -9,7 +9,18 @@
 #include <chaiscript/chaiscript.hpp>
 #include <chaiscript/dispatchkit/function_call.hpp>
 #include <boost/function.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
 #include <boost/date_time/posix_time/posix_time.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #include <boost/regex.hpp>
 
 void log(const std::string &msg)
@@ -43,9 +54,9 @@ struct System
   std::map<std::string, boost::function<std::string (const std::string &) > > m_callbacks;
 
   void add_callback(const std::string &t_name, 
-      const chaiscript::Proxy_Function &t_func)
+      const boost::function<std::string (const std::string &)> &t_func)
   {
-    m_callbacks[t_name] = chaiscript::dispatch::functor<std::string (const std::string &)>(t_func);
+    m_callbacks[t_name] = t_func;
   }
 
 

samples/range.chai

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

src/main.cpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <iostream>
@@ -30,6 +30,86 @@ void add_history(const char*){}
 void using_history(){}
 #endif
 
+
+void *cast_module_symbol(std::string (*t_path)())
+{
+  union cast_union
+  {
+    std::string (*in_ptr)();
+    void *out_ptr;
+  };
+
+  cast_union c;
+  c.in_ptr = t_path;
+  return c.out_ptr;
+}
+
+std::string default_search_path()
+{
+#ifdef BOOST_WINDOWS  // force no unicode
+  CHAR path[4096];
+  int size = GetModuleFileNameA(0, path, sizeof(path)-1);
+
+  std::string exepath(path, size);
+
+  size_t secondtolastslash = exepath.rfind('\\', exepath.rfind('\\') - 1);
+  if (secondtolastslash != std::string::npos)
+  {
+    return exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\";
+  } else {
+    return "";
+  }
+
+#else
+
+  std::string exepath;
+
+  std::vector<char> buf(2048);
+  ssize_t size = -1;
+
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  {
+    exepath = std::string(&buf.front(), size);
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    Dl_info rInfo; 
+    memset( &rInfo, 0, sizeof(rInfo) ); 
+    if ( !dladdr(cast_module_symbol(&default_search_path), &rInfo)  || !rInfo.dli_fname ) { 
+      return "";
+    }
+
+    exepath = std::string(rInfo.dli_fname);
+  }
+
+  size_t secondtolastslash = exepath.rfind('/', exepath.rfind('/') - 1);
+  if (secondtolastslash != std::string::npos)
+  {
+    return exepath.substr(0, secondtolastslash) + "/lib/chaiscript/";
+  } else {
+    return "";
+  }
+#endif
+}
+
+
 void help(int n) {
   if ( n >= 0 ) {
     std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>." << std::endl;
@@ -167,6 +247,8 @@ int main(int argc, char *argv[])
     usepaths.push_back(usepath);
   }
 
+  std::string searchpath = default_search_path();
+  modulepaths.push_back(searchpath);
   modulepaths.push_back("");
   if (modulepath)
   {

src/reflection.cpp

@@ -1,3 +1,9 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
 
 #include <chaiscript/chaiscript.hpp>
 #include <chaiscript/utility/utility.hpp>
@@ -18,7 +24,12 @@ bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
     = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
   if (pf)
   {
-    return pf->get_parse_tree();
+    if (pf->get_parse_tree())
+    {
+      return true;
+    } else {
+      return false;
+    }
   } else {
     return false;
   }
@@ -42,6 +53,12 @@ chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t
 }
 
 
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
+
+
 CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflection()
 {
   chaiscript::ModulePtr m(new chaiscript::Module());
@@ -90,6 +107,11 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
   return m;
 }
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+
 
 #ifdef BOOST_MSVC
 #pragma warning(pop)

src/stl_extra.cpp

@@ -1,3 +1,8 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
 
 #include <chaiscript/chaiscript.hpp>
 #include <list>
@@ -10,11 +15,19 @@
 #pragma warning(disable : 4190)
 #endif
 
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
+
 CHAISCRIPT_MODULE_EXPORT chaiscript::ModulePtr create_chaiscript_module_stl_extra()
 {
   return chaiscript::bootstrap::standard_library::list_type<std::list<chaiscript::Boxed_Value> >("List");
 }
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
 
 #ifdef BOOST_MSVC
 #pragma warning(pop)

src/test_module.cpp

@@ -5,12 +5,21 @@
 class TestBaseType
 {
   public:
-    TestBaseType() {}
-    TestBaseType(int) {}
-    TestBaseType(int *) {}
+    TestBaseType() : val(10), const_val(15) { }
+    TestBaseType(int) : val(10), const_val(15) {}
+    TestBaseType(int *) : val(10), const_val(15) {}
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
 
+    int base_only_func() { return -9; }
+
+    const TestBaseType &constMe() const { return *this; }
+
+    int val;
+    const int const_val;
+
+  private:
+    TestBaseType &operator=(const TestBaseType &);
 };
 
 enum TestEnum
@@ -28,8 +37,28 @@ class TestDerivedType : public TestBaseType
   public:
     virtual ~TestDerivedType() {}
     virtual int func() { return 1; }
+    int derived_only_func() { return 19; }
+
+  private:
+    TestDerivedType &operator=(const TestDerivedType &);
 };
 
+class TestMoreDerivedType : public TestDerivedType
+{
+  public:
+    virtual ~TestMoreDerivedType() {}
+};
+
+boost::shared_ptr<TestBaseType> derived_type_factory()
+{
+  return boost::shared_ptr<TestBaseType>(new TestDerivedType());
+}
+
+boost::shared_ptr<TestBaseType> more_derived_type_factory()
+{
+  return boost::shared_ptr<TestBaseType>(new TestMoreDerivedType());
+}
+
 std::string hello_world()
 {
   return "Hello World";
@@ -47,6 +76,10 @@ int *get_new_int()
 #pragma warning(disable : 4190)
 #endif
 
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
 
 CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_module()
 {
@@ -56,6 +89,7 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
 
   m->add(chaiscript::user_type<TestBaseType>(), "TestBaseType");
   m->add(chaiscript::user_type<TestDerivedType>(), "TestDerivedType");
+  m->add(chaiscript::user_type<TestMoreDerivedType>(), "TestMoreDerivedType");
 
   m->add(chaiscript::constructor<TestBaseType ()>(), "TestBaseType");
 //  m->add(chaiscript::constructor<TestBaseType (int)>(), "TestBaseType");
@@ -65,23 +99,45 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::constructor<TestDerivedType ()>(), "TestDerivedType");
   m->add(chaiscript::constructor<TestDerivedType (const TestDerivedType &)>(), "TestDerivedType");
 
+  m->add(chaiscript::constructor<TestMoreDerivedType ()>(), "TestMoreDerivedType");
+  m->add(chaiscript::constructor<TestMoreDerivedType (const TestMoreDerivedType &)>(), "TestMoreDerivedType");
+
+  /// \todo automatic chaining of base classes?
   m->add(chaiscript::base_class<TestBaseType, TestDerivedType>());
+  m->add(chaiscript::base_class<TestBaseType, TestMoreDerivedType>());
+  m->add(chaiscript::base_class<TestDerivedType, TestMoreDerivedType>());
+
+  m->add(chaiscript::fun(&TestDerivedType::derived_only_func), "derived_only_func");
+
+  m->add(chaiscript::fun(&derived_type_factory), "derived_type_factory");
+  m->add(chaiscript::fun(&more_derived_type_factory), "more_derived_type_factory");
+
+  m->add(chaiscript::fun(&TestDerivedType::func), "func");
 
   m->add(chaiscript::fun(&TestBaseType::func), "func");
+  m->add(chaiscript::fun(&TestBaseType::val), "val");
+  m->add(chaiscript::fun(&TestBaseType::const_val), "const_val");
+  m->add(chaiscript::fun(&TestBaseType::base_only_func), "base_only_func");
 
   m->add(chaiscript::fun(&get_new_int), "get_new_int");
 
+
   m->add_global_const(chaiscript::const_var(TestValue1), "TestValue1");
 
   m->add(chaiscript::user_type<TestEnum>(), "TestEnum");
 
   m->add(chaiscript::fun(&to_int), "to_int");
+  m->add(chaiscript::fun(&TestBaseType::constMe), "constMe");
 
 
   return m;
 }
 
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif

unittests/arithmetic_conversions_test.cpp

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

unittests/break_for.chai

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

unittests/continue_for.chai

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

unittests/continue_while.chai

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

unittests/eval_catch_exception_test.cpp

@@ -9,7 +9,7 @@ int test_generic()
   try {
     chai.eval("throw(runtime_error(\"error\"));");
   } catch (const chaiscript::Boxed_Value &bv) {
-    const std::exception &e = chaiscript::boxed_cast<const std::exception &>(bv);
+    const std::exception &e = chai.boxed_cast<const std::exception &>(bv);
     if (e.what() == std::string("error"))
     {
       return EXIT_SUCCESS;

unittests/for.chai

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

unittests/inheritance.chai

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

unittests/integer_literal_test.cpp

@@ -1,5 +1,3 @@
-// Tests to make sure that the order in which function dispatches occur is correct
-
 #include <chaiscript/chaiscript.hpp>
 
 #define TEST_LITERAL(v) test_literal(v, #v)

unittests/load_module.chai

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

unittests/map_count.chai

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

unittests/member_variable_access.chai

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

unittests/multithreaded_test.cpp

@@ -1,9 +1,3 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
 #include <iostream>
 
 #include <list>
@@ -25,13 +19,17 @@ int expected_value(int num_iters)
 
 void do_work(chaiscript::ChaiScript &c, int id)
 {
-  std::stringstream ss;
-  ss << "MyVar" << rand();
-  c.add(chaiscript::var(5), ss.str());
-  ss.str("");
-  ss << id;
-  c.use("multithreaded_work.inc");
-  c("do_chai_work(4000, " + ss.str() + ");");
+  try{
+    std::stringstream ss;
+    ss << "MyVar" << rand();
+    c.add(chaiscript::var(5), ss.str());
+    ss.str("");
+    ss << id;
+    c.use("multithreaded_work.inc");
+    c("do_chai_work(4000, " + ss.str() + ");");
+  } catch (const std::exception &e) {
+    std::cout << "exception: " << e.what() << " thread:  " << id;
+  }
 }
 
 int main()
@@ -65,20 +63,17 @@ int main()
 
   chaiscript::ChaiScript chai(modulepaths,usepaths);
 
-  std::vector<boost::shared_ptr<boost::thread> > threads;
+  boost::thread_group threads;
 
   // Ensure at least two, but say only 7 on an 8 core processor
   int num_threads = std::max<unsigned int>(boost::thread::hardware_concurrency() - 1, 2u);
 
   for (int i = 0; i < num_threads; ++i)
   {
-    threads.push_back(boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(do_work, boost::ref(chai), i))));
+    threads.create_thread(boost::bind(&do_work, boost::ref(chai), i));
   }
 
-  for (int i = 0; i < num_threads; ++i)
-  {
-    threads[i]->join();
-  }
+  threads.join_all();
 
 
   for (int i = 0; i < num_threads; ++i)

unittests/string_size.chai

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

unittests/vector_of_suffixed_numbers.chai

@@ -0,0 +1,3 @@
+var x = [1, 2u, 3.0l]
+assert_equal(3.0l, x[2])
+assert_equal(2u, x[1])