Fix test for overload registration with add_class utility

The latest VisualStudio 2013 CTP2 sworks with this now. Be sure to install it to build chaiscript

.travis.yml

@@ -0,0 +1,17 @@
+language: cpp
+compiler:
+  - gcc
+before_install:
+    - sudo pip install cpp-coveralls --use-mirrors
+script: 
+  - cmake -D ENABLE_COVERAGE:BOOL=TRUE -D CMAKE_BUILD_TYPE:STRING=Debug -D USE_LIBCXX:BOOL=FALSE .
+  - make
+  - make test
+  - coveralls -x hpp
+notifications:
+  recipients:
+    - jason@emptycrate.com
+  email:
+    on_success: always
+    on_failure: always
+

CMakeLists.txt

@@ -2,7 +2,19 @@ cmake_minimum_required(VERSION 2.8)
 
 project(chaiscript)
 
-option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
+# MINGW does not yet support C++11's concurrency features
+if (MINGW)
+  option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" FALSE)
+else()
+  option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
+endif()
+
+if (CMAKE_COMPILER_IS_GNUCC)
+  option(ENABLE_COVERAGE "Enable Coverage Reporting in GCC" FALSE)
+endif()
+
+
+
 option(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
 option(BUILD_SAMPLES "Build Samples Folder" FALSE)
 
@@ -17,8 +29,9 @@ set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
 
 set(CPACK_PACKAGE_VERSION_MAJOR 5)
-set(CPACK_PACKAGE_VERSION_MINOR 1)
+set(CPACK_PACKAGE_VERSION_MINOR 3)
 set(CPACK_PACKAGE_VERSION_PATCH 0)
+
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
 set(CPACK_PACKAGE_CONTACT "contact@chaiscript.com")
@@ -39,7 +52,9 @@ include(CPack)
 
 include(cmake/CheckCXX11Features.cmake)
 
-find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+if(NOT MINGW)
+  find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+endif()
 
 if(HAS_CXX11_VARIADIC_TEMPLATES)
   message(STATUS "Variadic Template support detected")
@@ -61,31 +76,64 @@ else(READLINE_LIBRARY)
     set (READLINE_FLAG )
 endif(READLINE_LIBRARY)
 
+SET(EXTRA_LINKER_FLAGS "")
+
+if (CMAKE_COMPILER_IS_GNUCC)
+  execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+
+  if (GCC_VERSION VERSION_LESS 4.8)
+    SET(CPP11_FLAG "-std=c++0x")
+  else()
+    SET(CPP11_FLAG "-std=c++11")
+  endif()
+
+  if (ENABLE_COVERAGE)
+    add_definitions(-fprofile-arcs -ftest-coverage)
+    SET(EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} "-fprofile-arcs -ftest-coverage")
+    #    SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "-fprofile-arcs -ftest-coverage")
+  endif()
+   
+
+else()
+  SET(CPP11_FLAG "-std=c++11")
+endif()
+
 if(MSVC)
   add_definitions(/W4)
-  if(CMAKE_CL_64)
-    add_definitions(/bigobj)
-   endif()
+  add_definitions(/bigobj)
+  # Note on MSVC compiler flags.
+  # The code base selective disables warnings as necessary when the compiler is complaining too much
+  # about something that is perfectly valid, or there is simply no technical way around it
+  # This particular warning, C4503 is in regards to the decorated names that MSVC generates internally.
+  # The error did not come up until the move to C++11, but the compiler doesn't give enough information
+  # to determine where the error is coming from, and the internet provides no real information for
+  # how to workaround or fix the error. So I'm disabling it globally.
+  ADD_DEFINITIONS(/wd4503)
 else()
-  add_definitions(-Wall -Wextra -Wshadow -pedantic -std=c++0x)
-
+  add_definitions(-Wall -Wextra -Wshadow -Wnon-virtual-dtor -pedantic ${CPP11_FLAG})
+  
   if (APPLE)
     add_definitions(-Wno-sign-compare)
   endif()
 endif()
 
-if (CMAKE_CXX_COMPILER MATCHES ".*clang")
-
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
   option(USE_LIBCXX "Use clang's libcxx" TRUE)
 
   if (USE_LIBCXX)
     add_definitions(-stdlib=libc++)
-    set (EXTRA_LINKER_FLAGS -std=c++0x -stdlib=libc++)
+    set (EXTRA_LINKER_FLAGS  ${EXTRA_LINKER_FLAGS} ${CPP11_FLAG} -stdlib=libc++)
   else ()
-    set (EXTRA_LINKER_FLAGS -std=c++0x )
+    set (EXTRA_LINKER_FLAGS  ${EXTRA_LINKER_FLAGS} ${CPP11_FLAG})
   endif()
-else()
-  set (EXTRA_LINKER_FLAGS )
+elseif(CMAKE_COMPILER_IS_GNUCC)
+  set (EXTRA_LINKER_FLAGS  ${EXTRA_LINKER_FLAGS} ${CPP11_FLAG})
+endif()
+
+# limitations in MinGW require us to make an optimized build
+# for the sake of object sizes or something
+if (MINGW)
+  add_definitions(-O3)
 endif()
 
 include_directories(include)
@@ -101,24 +149,33 @@ else()
 endif()
 
 if (CMAKE_HOST_UNIX)
-  list(APPEND LIBS "dl")
+  if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+    list(APPEND LIBS "dl")
+  endif(NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
 
   if (MULTITHREAD_SUPPORT_ENABLED)
-    list(APPEND LIBS "pthread")
+    if (CMAKE_COMPILER_IS_GNUCC)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE GCC_FULL_VERSION)
+      if (GCC_FULL_VERSION MATCHES "4.8.1.*ubuntu")
+        set (EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} -Wl,--no-as-needed -pthread )
+      else()
+        set (EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} -pthread )
+      endif()
+    else()
+      set (EXTRA_LINKER_FLAGS ${EXTRA_LINKER_FLAGS} -pthread )
+    endif()
+
     add_definitions(-pthread)
   endif()
+
 endif(CMAKE_HOST_UNIX)
   
 list(APPEND LIBS ${READLINE_LIB})
 
 
-if (CMAKE_COMPILER_2005)
-  # vs2005 is a bit too loud about possible loss of data warnings
-#  ADD_DEFINITIONS(/wd4244)
-endif()
 
 add_library(chaiscript_stdlib MODULE src/chaiscript_stdlib.cpp)
-target_link_libraries(chaiscript_stdlib ${LIBS} ${EXTRA_LINKER_FLAGS})
+target_link_libraries(chaiscript_stdlib ${LIBS} ${EXTRA_LINKER_FLAGS} ${CMAKE_THREAD_LIBS_INIT})
 
 add_executable(chai src/main.cpp ${Chai_INCLUDES})
 target_link_libraries(chai ${LIBS} ${EXTRA_LINKER_FLAGS})
@@ -160,6 +217,7 @@ if(BUILD_TESTING)
   )
 
   if (NOT UNIT_TEST_LIGHT)
+    # commented out because uniform initializer syntax is not working properly in MSVC 2013
     add_executable(utility_test unittests/utility_test.cpp)
     target_link_libraries(utility_test ${LIBS} ${EXTRA_LINKER_FLAGS})
     add_test(NAME Utility_Test COMMAND utility_test)
@@ -205,28 +263,36 @@ if(BUILD_TESTING)
     add_test(NAME cpp_lambda_test COMMAND cpp_lambda_test)
 
     add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
-    target_link_libraries(expected_eval_errors_test ${LIBS})
+    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(heap_allocated_chaiscript_test unittests/heap_allocated_chaiscript_test.cpp)
+    target_link_libraries(heap_allocated_chaiscript_test ${LIBS} ${EXTRA_LINKER_FLAGS})
+    add_test(NAME Heap_Allocated_Chaiscript_Test COMMAND heap_allocated_chaiscript_test)
+
     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} ${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
@@ -249,7 +315,8 @@ if(BUILD_TESTING)
   endif()
 endif(BUILD_TESTING)
 
-install(TARGETS chai ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript )
+install(TARGETS chai chaiscript_stdlib ${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]);
+  }
+}

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_defines.hpp

@@ -9,7 +9,7 @@
 
 #ifdef _MSC_VER
 #define CHAISCRIPT_MSVC _MSC_VER
-#define CHAISCRIPT_HAS_DECLSPEc
+#define CHAISCRIPT_HAS_DECLSPEC
 #endif
 
 #ifdef _WIN32
@@ -23,6 +23,15 @@
 #define CHAISCRIPT_MODULE_EXPORT extern "C" 
 #endif
 
+#ifdef CHAISCRIPT_MSVC
+#define CHAISCRIPT_NOEXCEPT throw()
+#define CHAISCRIPT_CONSTEXPR 
+#else
+#define CHAISCRIPT_NOEXCEPT noexcept
+#define CHAISCRIPT_CONSTEXPR constexpr
+#endif
+
+
 
 #endif
 

include/chaiscript/chaiscript_stdlib.hpp

@@ -38,7 +38,5 @@ namespace chaiscript
   };
 }
 
-
-
 #endif
 

include/chaiscript/chaiscript_threading.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_THREADING_HPP_
@@ -122,6 +122,8 @@ namespace chaiscript
       {
         public:
           unique_lock(T &) {}
+          void lock() {}
+          void unlock() {}
       };
 
       template<typename T>
@@ -129,6 +131,7 @@ namespace chaiscript
       {
         public:
           shared_lock(T &) {}
+          void lock() {}
           void unlock() {}
       };
 

include/chaiscript/dispatchkit/any.hpp

@@ -19,15 +19,15 @@ namespace chaiscript {
       class bad_any_cast : public std::bad_cast
       {
         public:
-          bad_any_cast() noexcept
+          bad_any_cast() CHAISCRIPT_NOEXCEPT
             : m_what("bad any cast")
           {
           }
 
-          virtual ~bad_any_cast() noexcept {}
+          virtual ~bad_any_cast() CHAISCRIPT_NOEXCEPT {}
 
           /// \brief Description of what error occured
-          virtual const char * what() const noexcept
+          virtual const char * what() const CHAISCRIPT_NOEXCEPT
           {
             return m_what.c_str();
           }
@@ -42,6 +42,7 @@ namespace chaiscript {
       private:
         struct Data
         {
+          virtual ~Data() {}
           virtual void *data() = 0;
           virtual const std::type_info &type() const = 0;
           virtual std::shared_ptr<Data> clone() const = 0;
@@ -56,6 +57,8 @@ namespace chaiscript {
             {
             }
 
+            virtual ~Data_Impl() {}
+
             virtual void *data()
             {
               return &m_data;
@@ -71,6 +74,8 @@ namespace chaiscript {
               return std::shared_ptr<Data>(new Data_Impl<T>(m_data));
             }
 
+            Data_Impl &operator=(const Data_Impl&) = delete;
+              
             const std::type_info &m_type;
             T m_data;
           };
@@ -92,9 +97,9 @@ namespace chaiscript {
         }
 
         template<typename ValueType> 
-          Any(const ValueType &t_value)
+        Any(const ValueType &t_value)
+          : m_data(std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value)))
         {
-          m_data = std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value));
         }
 
         Any & operator=(const Any &t_any)

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_
@@ -22,25 +22,25 @@ namespace chaiscript
     {
       public:
         bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) noexcept
+            const std::string &t_what) CHAISCRIPT_NOEXCEPT
           : from(t_from), to(&t_to), m_what(t_what)
         {
         }
 
-        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) noexcept
+        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
           : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
         {
         }
 
-        bad_boxed_cast(const std::string &t_what) noexcept
+        bad_boxed_cast(const std::string &t_what) CHAISCRIPT_NOEXCEPT
           : to(0), m_what(t_what)
         {
         }
 
-        virtual ~bad_boxed_cast() noexcept {} 
+        virtual ~bad_boxed_cast() CHAISCRIPT_NOEXCEPT {} 
 
         /// \brief Description of what error occured
-        virtual const char * what() const noexcept
+        virtual const char * what() const CHAISCRIPT_NOEXCEPT
         {
           return m_what.c_str();
         }

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
 
 #ifndef CHAISCRIPT_BIND_FIRST_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_
@@ -269,28 +269,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)
       {
         auto pf = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
         if (pf)
         {
-          return bool(pf->get_guard());
+          if (pf->get_guard()) {
+            return true;
+          } else {
+            return false;
+          }
         } else {
           return false;
         }
@@ -379,7 +368,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==), "==");
 
         
@@ -472,9 +460,6 @@ namespace chaiscript
         m->add(fun(&ptr_assign<std::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
         m->add(fun(&ptr_assign<std::add_const<dispatch::Proxy_Function_Base>::type>), "=");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&call_exists, std::placeholders::_1))), 
-          "call_exists");
-
         m->add(fun(&Boxed_Value::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_
@@ -26,11 +23,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
         {
@@ -149,6 +145,12 @@ namespace chaiscript
 
       namespace detail {
 
+        template<typename T>
+        size_t count(const T &t_target, const typename T::key_type &t_key)
+        {
+          return t_target.count(t_key);
+        }
+
         template<typename T>
           void insert(T &t_target, const T &t_other)
           {
@@ -163,9 +165,7 @@ 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()))
           {
@@ -184,9 +184,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)
           {
@@ -202,9 +201,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)
           {
@@ -230,10 +228,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()))
         {
@@ -252,10 +249,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()))
         {
@@ -264,23 +260,21 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/Container.html
-       */
+
+      /// Add container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Container.html
       template<typename ContainerType>
         ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun( std::function<int (const ContainerType *)>( [](const ContainerType *a) { return a->size(); } ) ), "size");
+          m->add(fun( std::function<size_t (const ContainerType *)>( [](const ContainerType *a) { return a->size(); } ) ), "size");
           m->add(fun( std::function<bool (const ContainerType *)>( [](const ContainerType *a) { return a->empty(); } ) ), "empty");
           m->add(fun( std::function<void (ContainerType *)>( [](ContainerType *a) { a->clear(); } ) ), "clear");
           return m;
         }
 
-      /**
-       * 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()))
         {
@@ -290,10 +284,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()))
         {
@@ -311,10 +304,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()))
         {
@@ -337,10 +329,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()))
         {
@@ -363,10 +354,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()))
         {
@@ -386,10 +376,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()))
         {
@@ -398,18 +388,17 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add unique associative container concept to the given ContainerType
-       * http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
-       */
+
+      /// Add unique associative container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
       template<typename ContainerType>
         ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun<int (const ContainerType *, const typename ContainerType::key_type &)>(&ContainerType::count), "count");
+          m->add(fun(detail::count<ContainerType>), "count");
 
           typedef size_t (ContainerType::*erase_ptr)(const typename ContainerType::key_type &);
 
-          m->add(fun<int (ContainerType *, const typename ContainerType::key_type &)>(static_cast<erase_ptr>(&ContainerType::erase)), "erase");
+          m->add(fun(static_cast<erase_ptr>(&ContainerType::erase)), "erase");
 
           m->add(fun(&detail::insert<ContainerType>), "insert");
 
@@ -425,10 +414,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()))
         {
@@ -447,10 +435,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()))
         {
@@ -467,10 +454,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()))
         {
@@ -513,10 +499,8 @@ namespace chaiscript
           return m;
         }
 
-      /**
-       * Add a String container
-       * http://www.sgi.com/tech/stl/basic_string.html
-       */
+      /// 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()))
         {
@@ -527,7 +511,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);
 
@@ -541,15 +525,19 @@ namespace chaiscript
           }
           m->add(fun(&String::push_back), push_back_name);
 
-          typedef std::function<int (const String *, const String &, int)> find_func;
+          typedef std::function<size_t (const String *, const String &, size_t)> find_func;
 
 
-          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find(f, pos); } )), "find");
-          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->rfind(f, pos); } ) ), "rfind");
-          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_first_of(f, pos); } ) ), "find_first_of");
-          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_last_of(f, pos); } ) ), "find_last_of");
-          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_last_not_of(f, pos); } ) ), "find_last_not_of");
-          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_first_not_of(f, pos); } ) ), "find_first_not_of");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find(f, pos); } )), "find");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->rfind(f, pos); } ) ), "rfind");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_first_of(f, pos); } ) ), "find_first_of");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_last_of(f, pos); } ) ), "find_last_of");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_last_not_of(f, pos); } ) ), "find_last_not_of");
+          m->add(fun(find_func( [](const String *s, const String &f, size_t pos) { return s->find_first_not_of(f, pos); } ) ), "find_first_not_of");
+
+	        m->add(fun( std::function<void (String *)>( [](String *s) { return s->clear(); } ) ), "clear");
+	        m->add(fun( std::function<bool (const String *)>( [](const String *s) { return s->empty(); } ) ), "empty");
+	        m->add(fun( std::function<size_t (const String *)>( [](const String *s) { return s->size(); } ) ), "size");
 
           m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->c_str(); } ) ), "c_str");
           m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->data(); } ) ), "data");
@@ -563,3 +551,5 @@ namespace chaiscript
 
 
 #endif
+
+

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_
@@ -62,10 +62,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 = nullptr)
   {
     try {
-      return detail::Cast_Helper<Type>::cast(bv);
+      return detail::Cast_Helper<Type>::cast(bv, t_conversions);
     } catch (const chaiscript::detail::exception::bad_any_cast &) {
 
 
@@ -76,12 +76,12 @@ namespace chaiscript
 #pragma warning(disable : 4127)
 #endif
 
-      if (std::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value)
+      if (std::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value && t_conversions)
       {
         try {
           // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
           // either way, we are not responsible if it doesn't work
-          return detail::Cast_Helper<Type>::cast(detail::boxed_dynamic_cast<Type>(bv));
+          return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_cast<Type>(bv), t_conversions);
         } catch (const chaiscript::detail::exception::bad_any_cast &) {
           throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
         }

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_
@@ -13,6 +13,8 @@
 
 namespace chaiscript 
 {
+  class Dynamic_Cast_Conversions;
+
   namespace detail
   {
     // Cast_Helper_Inner helper classes
@@ -25,7 +27,7 @@ namespace chaiscript
       {
         typedef typename std::reference_wrapper<typename std::add_const<Result>::type > Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -67,7 +69,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())
           {
@@ -96,7 +98,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())
           {
@@ -115,7 +117,7 @@ namespace chaiscript
       {
         typedef Result& Result_Type;
 
-        static Result &cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -135,7 +137,7 @@ namespace chaiscript
       {
         typedef typename std::shared_ptr<Result> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           return ob.get().cast<std::shared_ptr<Result> >();
         }
@@ -149,7 +151,7 @@ namespace chaiscript
       {
         typedef typename std::shared_ptr<const Result> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
         {
           if (!ob.get_type_info().is_const())
           {
@@ -197,7 +199,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;    
         }
@@ -258,9 +260,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,11 +10,12 @@
 #include "boxed_value.hpp"
 #include "../language/chaiscript_algebraic.hpp"
 #include <sstream>
+#include <cstdint>
 
 namespace chaiscript 
 {
  
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4244 4018 4389 4146)
 #endif
@@ -49,7 +50,6 @@ namespace chaiscript
             default:
               throw chaiscript::detail::exception::bad_any_cast();        
           }
-          throw chaiscript::detail::exception::bad_any_cast();        
         }
       };
 
@@ -145,7 +145,6 @@ namespace chaiscript
             default:
               throw chaiscript::detail::exception::bad_any_cast();        
           }
-          throw chaiscript::detail::exception::bad_any_cast();        
         }
       };
 
@@ -171,7 +170,6 @@ namespace chaiscript
             default:
               throw chaiscript::detail::exception::bad_any_cast();        
           }
-          throw chaiscript::detail::exception::bad_any_cast();        
         }
       };
 
@@ -335,6 +333,46 @@ namespace chaiscript
         validate_boxed_number(bv);
       }
 
+      Boxed_Number get_as(const Type_Info &inp_) const
+      {
+        if (inp_.bare_equal_type_info(typeid(int))) {
+          return Boxed_Number(get_as<int>());
+        } else if (inp_.bare_equal_type_info(typeid(double))) {
+          return Boxed_Number(get_as<double>());
+        } else if (inp_.bare_equal_type_info(typeid(float))) {
+          return Boxed_Number(get_as<float>());
+        } else if (inp_.bare_equal_type_info(typeid(long double))) {
+          return Boxed_Number(get_as<long double>());
+        } else if (inp_.bare_equal_type_info(typeid(char))) {
+          return Boxed_Number(get_as<char>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned int))) {
+          return Boxed_Number(get_as<unsigned int>());
+        } else if (inp_.bare_equal_type_info(typeid(long))) {
+          return Boxed_Number(get_as<long>());
+        } else if (inp_.bare_equal_type_info(typeid(unsigned long))) {
+          return Boxed_Number(get_as<unsigned long>());
+        } else if (inp_.bare_equal_type_info(typeid(int8_t))) {
+          return Boxed_Number(get_as<int8_t>());
+        } else if (inp_.bare_equal_type_info(typeid(int16_t))) {
+          return Boxed_Number(get_as<int16_t>());
+        } else if (inp_.bare_equal_type_info(typeid(int32_t))) {
+          return Boxed_Number(get_as<int32_t>());
+        } else if (inp_.bare_equal_type_info(typeid(int64_t))) {
+          return Boxed_Number(get_as<int64_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint8_t))) {
+          return Boxed_Number(get_as<uint8_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint16_t))) {
+          return Boxed_Number(get_as<uint16_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint32_t))) {
+          return Boxed_Number(get_as<uint32_t>());
+        } else if (inp_.bare_equal_type_info(typeid(uint64_t))) {
+          return Boxed_Number(get_as<uint64_t>());
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+
+      }
+
       template<typename Target> Target get_as() const
       {
         const Type_Info &inp_ = bv.get_type_info();
@@ -783,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);
         }
@@ -806,7 +844,7 @@ namespace chaiscript
       };  
   }
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
 

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-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_

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_
@@ -39,12 +39,12 @@ namespace chaiscript
     class reserved_word_error : public std::runtime_error
     {
       public:
-        reserved_word_error(const std::string &t_word) noexcept
+        reserved_word_error(const std::string &t_word) CHAISCRIPT_NOEXCEPT
           : std::runtime_error("Reserved word not allowed in object name: " + t_word), m_word(t_word)
         {
         }
 
-        virtual ~reserved_word_error() noexcept {}
+        virtual ~reserved_word_error() CHAISCRIPT_NOEXCEPT {}
 
         std::string word() const
         {
@@ -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
      */
@@ -86,12 +108,12 @@ namespace chaiscript
     class global_non_const : public std::runtime_error
     {
       public:
-        global_non_const() noexcept
+        global_non_const() CHAISCRIPT_NOEXCEPT
           : std::runtime_error("a global object must be const")
         {
         }
 
-        virtual ~global_non_const() noexcept {}
+        virtual ~global_non_const() CHAISCRIPT_NOEXCEPT {}
     };
   }
 
@@ -156,7 +178,6 @@ namespace chaiscript
 
       ~Module()
       {
-        detail::Dynamic_Conversions::get().cleanup(m_conversions.begin(), m_conversions.end());
       }
 
     private:
@@ -227,9 +248,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
         {
@@ -279,7 +300,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;
 
@@ -288,7 +309,7 @@ namespace chaiscript
 
           while (begin != end)
           {
-            if ((*begin)->call_match(vals))
+            if ((*begin)->call_match(vals, t_conversions))
             {
               return true;
             } else {
@@ -305,9 +326,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:
@@ -396,16 +417,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);
         }
 
         /**
@@ -479,6 +505,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 chaiscript::exception::name_conflict_error(name);
+          } else {
+            m_state.m_global_objects.insert(std::make_pair(name, obj));
+          }
+        }
+
+
         /**
          * Adds a new scope to the stack
          */
@@ -778,11 +823,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
@@ -851,6 +901,22 @@ namespace chaiscript
           std::cout << ") " << std::endl;
         }
 
+        /**
+         * Returns true if a call can be made that consists of the first parameter
+         * (the function) with the remaining parameters as its arguments.
+         */
+        Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
+        {
+          if (params.size() < 1)
+          {
+            throw chaiscript::exception::arity_error(static_cast<int>(params.size()), 1);
+          }
+
+          Const_Proxy_Function f = this->boxed_cast<Const_Proxy_Function>(params[0]);
+
+          return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end()), m_conversions));
+        }
+
         /**
          * Dump all system info to stdout
          */
@@ -1077,6 +1143,10 @@ namespace chaiscript
          */
         void validate_object_name(const std::string &name) const
         {
+          if (name.find("::") != std::string::npos) {
+            throw chaiscript::exception::illegal_name_error(name);
+          }
+
           chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
 
           if (m_state.m_reserved_words.find(name) != m_state.m_reserved_words.end())
@@ -1116,6 +1186,14 @@ namespace chaiscript
             vec.push_back(t_f);
             std::stable_sort(vec.begin(), vec.end(), &function_less_than);
             func_objs[t_name] = Proxy_Function(new Dispatch_Function(vec));
+          } else if (t_f->has_arithmetic_param()) {
+            // if the function is the only function but it also contains
+            // arithmetic operators, we must wrap it in a dispatch function
+            // to allow for automatic arithmetic type conversions
+            std::vector<Proxy_Function> vec;
+            vec.push_back(t_f);
+            funcs.insert(std::make_pair(t_name, vec));
+            func_objs[t_name] = Proxy_Function(new Dispatch_Function(vec));
           } else {
             std::vector<Proxy_Function> vec;
             vec.push_back(t_f);
@@ -1145,7 +1223,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,12 +1,15 @@
 // 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_
 #define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
 
+#include <memory>
+#include <set>
+
 #include "type_info.hpp"
 #include "boxed_value.hpp"
 #include "boxed_cast_helper.hpp"
@@ -20,22 +23,22 @@ namespace chaiscript
     {
       public:
         bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) noexcept
+            const std::string &t_what) CHAISCRIPT_NOEXCEPT
           : bad_boxed_cast(t_from, t_to, t_what)
         {
         }
 
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) noexcept
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
           : bad_boxed_cast(t_from, t_to)
         {
         }
 
-        bad_boxed_dynamic_cast(const std::string &w) noexcept
+        bad_boxed_dynamic_cast(const std::string &w) CHAISCRIPT_NOEXCEPT
           : bad_boxed_cast(w)
         {
         }
 
-        virtual ~bad_boxed_dynamic_cast() noexcept {}
+        virtual ~bad_boxed_dynamic_cast() CHAISCRIPT_NOEXCEPT {}
     };
   }
 
@@ -44,7 +47,7 @@ namespace chaiscript
     class Dynamic_Conversion
     {
       public:
-        virtual Boxed_Value convert(const Boxed_Value &derived) = 0;
+        virtual Boxed_Value convert(const Boxed_Value &derived) const = 0;
 
         const Type_Info &base()
         {
@@ -70,7 +73,7 @@ namespace chaiscript
     };
 
     template<typename Base, typename Derived>
-    class Dynamic_Conversion_Impl : public Dynamic_Conversion
+      class Dynamic_Conversion_Impl : public Dynamic_Conversion
     {
       public:
         Dynamic_Conversion_Impl()
@@ -78,7 +81,7 @@ namespace chaiscript
         {
         }
 
-        virtual Boxed_Value convert(const Boxed_Value &t_derived)
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const
         {
           if (t_derived.get_type_info().bare_equal(user_type<Derived>()))
           {
@@ -88,7 +91,7 @@ namespace chaiscript
               if (t_derived.is_const())
               {
                 std::shared_ptr<const Base> data 
-                  = std::dynamic_pointer_cast<const Base>(detail::Cast_Helper<std::shared_ptr<const Derived> >::cast(t_derived));
+                  = std::dynamic_pointer_cast<const Base>(detail::Cast_Helper<std::shared_ptr<const Derived> >::cast(t_derived, nullptr));
                 if (!data)
                 {
                   throw std::bad_cast();
@@ -97,7 +100,7 @@ namespace chaiscript
                 return Boxed_Value(data);
               } else {
                 std::shared_ptr<Base> data 
-                  = std::dynamic_pointer_cast<Base>(detail::Cast_Helper<std::shared_ptr<Derived> >::cast(t_derived));
+                  = std::dynamic_pointer_cast<Base>(detail::Cast_Helper<std::shared_ptr<Derived> >::cast(t_derived, nullptr));
 
                 if (!data)
                 {
@@ -110,11 +113,11 @@ namespace chaiscript
               // 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 Derived &d = detail::Cast_Helper<const Derived &>::cast(t_derived, 0);
                 const Base &data = dynamic_cast<const Base &>(d);
                 return Boxed_Value(std::cref(data));
               } else {
-                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived);
+                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived, 0);
                 Base &data = dynamic_cast<Base &>(d);
                 return Boxed_Value(std::ref(data));
               }
@@ -124,101 +127,98 @@ namespace chaiscript
           }
         }
     };
-
-
-    class Dynamic_Conversions
-    {
-      public:
-        static inline Dynamic_Conversions &get()
-        {
-          static Dynamic_Conversions obj;
-          return obj;
-        }
-
-        template<typename Base, typename Derived>
-        static std::shared_ptr<Dynamic_Conversion> create()
-        {
-          std::shared_ptr<Dynamic_Conversion> conversion(new Dynamic_Conversion_Impl<Base, Derived>());
-
-          /// \todo this is a hack and a kludge. The idea is to make sure that
-          ///       the conversion is registered both in the module's notion of the static conversion object
-          ///       and in the global notion of the static conversion object
-          ///       someday this will almost certainly have to change. Maybe it is time for ChaiScript
-          ///       to become a library?
-          Dynamic_Conversions::get().add_conversion(conversion);
-          return conversion;
-        }
-
-        template<typename InItr>
-        void cleanup(InItr begin, const InItr &end)
-        {
-          chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-          while (begin != end)
-          {
-            if (begin->unique())
-            {
-              m_conversions.erase(begin->get());
-            }
-
-            ++begin;
-          }
-        }
-
-        void add_conversion(const std::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 std::shared_ptr<detail::Dynamic_Conversion> &conversion)
+      {
+        chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+        m_conversions.insert(conversion);
+      }
+
+      template<typename Base, typename Derived>
+        bool dynamic_cast_converts() const
+        {
+          return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
+        }
+
+      bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived) const
+      {
+        return has_conversion(base, derived);
+      }
+
+      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");
+          }
+        }
+
+      bool has_conversion(const Type_Info &base, const Type_Info &derived) const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+        return find(base, derived) != m_conversions.end();
+      }
+
+      std::shared_ptr<detail::Dynamic_Conversion> get_conversion(const Type_Info &base, const Type_Info &derived) const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        std::set<std::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<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
+          const Type_Info &base, const Type_Info &derived) const
+      {
+        for (std::set<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr = m_conversions.begin();
+            itr != m_conversions.end();
+            ++itr)
+        {
+          if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
+          {
+            return itr;
+          }
+        }
+
+        return m_conversions.end();
+      }
+
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> > get_conversions() const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        return m_conversions;
+      }
+
+      mutable chaiscript::detail::threading::shared_mutex m_mutex;
+      std::set<std::shared_ptr<detail::Dynamic_Conversion> > m_conversions;
+  };
+
   typedef std::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
 
   /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
@@ -253,34 +253,9 @@ namespace chaiscript
     static_assert(std::is_polymorphic<Base>::value, "Base class must be polymorphic");
     static_assert(std::is_polymorphic<Derived>::value, "Derived class must be polymorphic");
 
-    return detail::Dynamic_Conversions::create<Base, Derived>();
+    return std::shared_ptr<detail::Dynamic_Conversion>(new detail::Dynamic_Conversion_Impl<Base, Derived>());
   }
 
-  namespace detail
-  {
-    template<typename Base, typename Derived>
-      bool dynamic_cast_converts()
-      {
-        return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
-      }
-
-    static bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived)
-    {
-      return detail::Dynamic_Conversions::get().has_conversion(base, derived);
-    }
-
-    template<typename Base>
-      Boxed_Value boxed_dynamic_cast(const Boxed_Value &derived)
-      {
-        try {
-          return detail::Dynamic_Conversions::get().get_conversion(user_type<Base>(), derived.get_type_info())->convert(derived);
-        } catch (const std::out_of_range &) {
-          throw chaiscript::exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "No known conversion");
-        } catch (const std::bad_cast &) {
-          throw chaiscript::exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
-        }
-      }
-  }
 }
 
 

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,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_
@@ -66,7 +66,7 @@ namespace chaiscript
               const Proxy_Function &t_func,
               const Type_Info &t_ti)
             : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti)),
-            m_type_name(t_type_name), m_func(t_func), m_ti(new Type_Info(t_ti))
+              m_type_name(t_type_name), m_func(t_func), m_ti(new Type_Info(t_ti))
           {
             assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
                 && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
@@ -85,11 +85,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;
             }
@@ -113,19 +113,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:
@@ -141,13 +141,13 @@ namespace chaiscript
           }
 
           static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const std::shared_ptr<Type_Info> &ti)
+              const std::shared_ptr<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;
@@ -164,11 +164,11 @@ namespace chaiscript
           }
 
           static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const std::shared_ptr<Type_Info> &ti) 
+              const std::shared_ptr<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;
             }
@@ -194,7 +194,7 @@ 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)
+              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)");
@@ -226,13 +226,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);
           }    
 
 
@@ -248,14 +248,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 chaiscript::exception::bad_boxed_cast &) {}
+          try { T t = t_engine.boxed_cast<T>(bv); throw t; } catch (const chaiscript::exception::bad_boxed_cast &) {}
         }
     };
 
     template<typename T1>
       struct Exception_Handler_Impl1 : Exception_Handler_Base
       {
-        virtual 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_
@@ -29,10 +29,10 @@ namespace chaiscript
      */
     template<typename FunctionType>
       std::function<FunctionType>
-      functor(const std::vector<Const_Proxy_Function> &funcs)
+      functor(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
       {
         FunctionType *p=0;
-        return detail::build_function_caller_helper(p, funcs);
+        return detail::build_function_caller_helper(p, funcs, t_conversions);
       }
 
     /**
@@ -50,11 +50,11 @@ namespace chaiscript
      */
     template<typename FunctionType>
       std::function<FunctionType>
-      functor(Const_Proxy_Function func)
+      functor(Const_Proxy_Function func, const Dynamic_Cast_Conversions *t_conversions)
       {
         std::vector<Const_Proxy_Function> funcs;
         funcs.push_back(func);
-        return functor<FunctionType>(funcs);
+        return functor<FunctionType>(funcs, t_conversions);
       }
 
     /**
@@ -63,9 +63,9 @@ namespace chaiscript
      */
     template<typename FunctionType>
       std::function<FunctionType>
-      functor(const Boxed_Value &bv)
+      functor(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions)
       {
-        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv));
+        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
       }
   }
 
@@ -78,13 +78,13 @@ namespace chaiscript
       {
         typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const std::function<Signature> &>::cast(ob);
+            return Cast_Helper_Inner<const std::function<Signature> &>::cast(ob, t_conversions);
           }
         }
       };
@@ -97,13 +97,13 @@ namespace chaiscript
       {
         typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<std::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<std::function<Signature> >::cast(ob, t_conversions);
           }
         }
       };
@@ -116,13 +116,13 @@ namespace chaiscript
       {
         typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob)
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
-            return dispatch::functor<Signature>(ob);
+            return dispatch::functor<Signature>(ob, t_conversions);
           } else {
-            return Cast_Helper_Inner<const std::function<Signature> >::cast(ob);
+            return Cast_Helper_Inner<const std::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
 
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
@@ -26,9 +26,9 @@ namespace chaiscript
         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));
           }
         };
 
@@ -39,9 +39,9 @@ namespace chaiscript
         struct Function_Caller_Ret<void>
         {
           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);
           }
         };
 
@@ -51,8 +51,9 @@ namespace chaiscript
       template<typename Ret, typename ... Param>
         struct Build_Function_Caller_Helper
         {
-          Build_Function_Caller_Helper(const std::vector<Const_Proxy_Function> &t_funcs)
-            : m_funcs(t_funcs)
+          Build_Function_Caller_Helper(const std::vector<Const_Proxy_Function> &t_funcs, const Dynamic_Cast_Conversions &t_conversions)
+            : m_funcs(t_funcs),
+              m_conversions(t_conversions)
           {
           }
 
@@ -60,19 +61,20 @@ namespace chaiscript
           {
             return Function_Caller_Ret<Ret>::call(m_funcs, { 
 (std::is_reference<Param>::value&&!(std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<Param>::type>::type>::value))?Boxed_Value(std::ref(param)):Boxed_Value(param)... 
-          }
+          }, m_conversions
           
           );
 
           }
 
           std::vector<Const_Proxy_Function> m_funcs;
+          Dynamic_Cast_Conversions m_conversions;
         };
 
 
 
       template<typename Ret, typename ... Params>
-        std::function<Ret (Params...)> build_function_caller_helper(Ret (Params...), const std::vector<Const_Proxy_Function> &funcs)
+        std::function<Ret (Params...)> build_function_caller_helper(Ret (Params...), const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
         {
           if (funcs.size() == 1)
           {
@@ -88,7 +90,7 @@ namespace chaiscript
             // we cannot make any other guesses or assumptions really, so continuing
           }
 
-          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs));
+          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions?*t_conversions:Dynamic_Cast_Conversions()));
         }
     }
   }

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/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
 
 
@@ -39,9 +39,10 @@ namespace chaiscript
     {
       public:
         virtual ~Proxy_Function_Base() {}
-        Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+
+        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Dynamic_Cast_Conversions &t_conversions) const
         {
-          Boxed_Value bv = do_call(params);
+          Boxed_Value bv = do_call(params, t_conversions);
           return bv;
         }
 
@@ -52,17 +53,21 @@ namespace chaiscript
         const std::vector<Type_Info> &get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
-        virtual bool call_match(const std::vector<Boxed_Value> &vals) const = 0;
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
+
+        bool has_arithmetic_param() const 
+        {
+          return m_has_arithmetic_param;
+        }
 
         virtual std::vector<std::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
         {
           return std::vector<std::shared_ptr<const Proxy_Function_Base> >();
         }
 
-
         //! Return true if the function is a possible match
         //! to the passed in values
-        bool filter(const std::vector<Boxed_Value> &vals) const
+        bool filter(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           int arity = get_arity();
 
@@ -74,7 +79,7 @@ namespace chaiscript
             {
               return true;
             } else {
-              return compare_first_type(vals[0]);
+              return compare_first_type(vals[0], t_conversions);
             }
           } else {
             return false;
@@ -86,30 +91,15 @@ namespace chaiscript
 
         virtual std::string annotation() const = 0;
 
-      protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params) const = 0;
-
-        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
-          : m_types(t_types)
+        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions)
         {
-        }
-
-        virtual bool compare_first_type(const Boxed_Value &bv) const
-        {
-          const std::vector<Type_Info> &types = get_param_types();
-
-          if (types.size() < 2)
-          {
-            return true;
-          }
-          const Type_Info &ti = types[1];
           if (ti.is_undef() 
               || ti.bare_equal(user_type<Boxed_Value>())
               || (!bv.get_type_info().is_undef()
                 && (ti.bare_equal(user_type<Boxed_Number>())
                   || ti.bare_equal(bv.get_type_info())
-                  || chaiscript::detail::dynamic_cast_converts(ti, bv.get_type_info()) 
                   || bv.get_type_info().bare_equal(user_type<std::shared_ptr<const Proxy_Function_Base> >())
+                  || t_conversions.dynamic_cast_converts(ti, bv.get_type_info()) 
                   )
                 )
              )
@@ -119,8 +109,38 @@ namespace chaiscript
             return false;
           }
         }
+      protected:
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
 
-        bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs) const
+        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
+          : m_types(t_types), m_has_arithmetic_param(false)
+        {
+          for (size_t i = 1; i < m_types.size(); ++i)
+          {
+            if (m_types[i].is_arithmetic())
+            {
+              m_has_arithmetic_param = true;
+              return;
+            }
+          }
+
+        }
+
+        virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
+        {
+          const std::vector<Type_Info> &types = get_param_types();
+
+          if (types.size() < 2)
+          {
+            return true;
+          }
+
+          const Type_Info &ti = types[1];
+          return compare_type_to_param(ti, bv, t_conversions);
+
+        }
+
+        static bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs)
         {
           if (tis.size() - 1 != bvs.size())
           {
@@ -139,6 +159,8 @@ namespace chaiscript
         }
 
         std::vector<Type_Info> m_types;
+        bool m_has_arithmetic_param;
+
     };
   }
 
@@ -155,11 +177,11 @@ namespace chaiscript
     class guard_error : public std::runtime_error
     {
       public:
-        guard_error() noexcept
+        guard_error() CHAISCRIPT_NOEXCEPT
           : std::runtime_error("Guard evaluation failed")
         { }
 
-        virtual ~guard_error() noexcept
+        virtual ~guard_error() CHAISCRIPT_NOEXCEPT
         { }
     };
   }
@@ -184,6 +206,8 @@ namespace chaiscript
         {
         }
 
+        virtual ~Dynamic_Proxy_Function() {}
+
         virtual bool operator==(const Proxy_Function_Base &rhs) const
         {
           const Dynamic_Proxy_Function *prhs = dynamic_cast<const Dynamic_Proxy_Function *>(&rhs);
@@ -194,15 +218,12 @@ 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() {}
-
-
         virtual int get_arity() const
         {
           return m_arity;
@@ -224,12 +245,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 {
@@ -242,12 +263,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 &) {
@@ -303,7 +324,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()));
         }
@@ -315,14 +336,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
@@ -400,9 +416,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:
@@ -439,14 +455,14 @@ namespace chaiscript
           return static_cast<int>(m_types.size()) - 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 &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
@@ -460,9 +476,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 std::function<Func>::result_type>::go(m_f, params);
+          return detail::Do_Call<typename std::function<Func>::result_type>::go(m_f, params, t_conversions);
         }
 
       private:
@@ -503,7 +519,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)
           {
@@ -519,17 +535,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 std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
             } else {
-              Class *o = boxed_cast<Class *>(bv);
+              Class *o = boxed_cast<Class *>(bv, &t_conversions);
               return detail::Handle_Return<typename std::add_lvalue_reference<T>::type>::handle(o->*m_attr);
             }
           } else {
@@ -563,7 +579,7 @@ namespace chaiscript
         {
         }
 
-        virtual ~dispatch_error() noexcept {}
+        virtual ~dispatch_error() CHAISCRIPT_NOEXCEPT {}
 
         std::vector<Boxed_Value> parameters;
         std::vector<Const_Proxy_Function> functions;
@@ -572,6 +588,94 @@ namespace chaiscript
 
   namespace dispatch
   {
+    namespace detail 
+    {
+      template<typename FuncType>
+        bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          if (t_func->get_arity() != static_cast<int>(plist.size()))
+          {
+            return false;
+          }
+
+          const std::vector<Type_Info> &types = t_func->get_param_types();
+
+          assert(plist.size() == types.size() - 1);
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (Proxy_Function_Base::compare_type_to_param(types[i+1], plist[i], t_conversions)
+                || (types[i+1].is_arithmetic() && plist[i].get_type_info().is_arithmetic()))
+            {
+              // types continue to match
+            } else {
+              return false;
+            }
+          }
+
+          // all types match
+          return true;
+        }
+
+      template<typename InItr>
+        Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist, 
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          InItr orig(begin);
+
+          InItr matching_func(end);
+
+          while (begin != end)
+          {
+            if (types_match_except_for_arithmetic(*begin, plist, t_conversions))
+            {
+              if (matching_func == end)
+              {
+                matching_func = begin;
+              } else {
+                // More than one function matches, not attempting
+                throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+              }
+            }
+
+            ++begin;
+          }
+
+          if (matching_func == end)
+          {
+            // no appropriate function to attempt arithmetic type conversion on
+            throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+          }
+
+
+          std::vector<Boxed_Value> newplist;
+          const std::vector<Type_Info> &tis = (*matching_func)->get_param_types();
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (tis[i+1].is_arithmetic()
+                && plist[i].get_type_info().is_arithmetic()) {
+              newplist.push_back(Boxed_Number(plist[i]).get_as(tis[i+1]).bv);
+            } else {
+              newplist.push_back(plist[i]);
+            }
+          }
+
+          try {
+            return (*(*matching_func))(newplist, t_conversions);
+          } catch (const exception::bad_boxed_cast &) {
+            //parameter failed to cast
+          } catch (const exception::arity_error &) {
+            //invalid num params
+          } catch (const exception::guard_error &) {
+            //guard failed to allow the function to execute
+          }
+
+          throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+
+        }
+    }
 
     /**
      * Take a vector of functions and a vector of parameters. Attempt to execute
@@ -580,15 +684,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
@@ -601,7 +705,7 @@ namespace chaiscript
           ++begin;
         }
 
-        throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+        return detail::dispatch_with_conversions(orig, end, plist, t_conversions);
       }
 
     /**
@@ -611,9 +715,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,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_PROXY_FUNCTIONS_DETAIL_HPP_
@@ -32,7 +32,7 @@ namespace chaiscript
       {
       }
 
-      virtual ~arity_error() noexcept {}
+      virtual ~arity_error() CHAISCRIPT_NOEXCEPT {}
 
       int got;
       int expected;
@@ -43,6 +43,29 @@ namespace chaiscript
   {
     namespace detail
     {
+      template<typename ... Rest>
+      struct Build_Param_Type_List;
+
+      template<typename Param, typename ... Rest>
+      struct Build_Param_Type_List<Param, Rest...>
+      {
+        static void build(std::vector<Type_Info> &t_params)
+        {
+          t_params.push_back(chaiscript::detail::Get_Type_Info<Param>::get());
+          Build_Param_Type_List<Rest...>::build(t_params);
+        }
+      };
+
+      // 0th case
+      template<>
+      struct Build_Param_Type_List<>
+      {
+        static void build(std::vector<Type_Info> &)
+        {
+        }
+      };
+
+
       /**
        * Used by Proxy_Function_Impl to return a list of all param types
        * it contains.
@@ -50,8 +73,12 @@ namespace chaiscript
       template<typename Ret, typename ... Params>
         std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
         {
-          return std::vector<Type_Info> { chaiscript::detail::Get_Type_Info<Ret>::get(),
-              chaiscript::detail::Get_Type_Info<Params>::get()... };
+          /// \todo this code was previously using { chaiscript::detail::Get_Type_Info<Ret>::get()... }
+          ///       but this seems to indicate another bug with MSVC's uniform initializer lists
+          std::vector<Type_Info> params;
+          params.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
+          Build_Param_Type_List<Params...>::build(params);
+          return params;
         }
 
 
@@ -59,14 +86,13 @@ namespace chaiscript
       template<typename ... Rest> 
         struct Try_Cast; 
 
-      // implementation
       template<typename Param, typename ... Rest>
         struct Try_Cast<Param, Rest...>
         {
-          static void do_try(const std::vector<Boxed_Value> &params, int generation)
+          static void do_try(const std::vector<Boxed_Value> &params, int generation, const Dynamic_Cast_Conversions &t_conversions)
           {
-            boxed_cast<Param>(params[generation]);
-            Try_Cast<Rest...>::do_try(params, generation+1);
+            boxed_cast<Param>(params[generation], &t_conversions);
+            Try_Cast<Rest...>::do_try(params, generation+1, t_conversions);
           }
         };
 
@@ -74,13 +100,12 @@ namespace chaiscript
       template<>
         struct Try_Cast<>
         {
-          static void do_try(const std::vector<Boxed_Value> &, int)
+          static void do_try(const std::vector<Boxed_Value> &, int, const Dynamic_Cast_Conversions &)
           {
           }
         };
       
 
-
       /**
        * Used by Proxy_Function_Impl to determine if it is equivalent to another
        * Proxy_Function_Impl object. This function is primarly used to prevent
@@ -88,10 +113,10 @@ namespace chaiscript
        */
       template<typename Ret, typename ... Params>
         bool compare_types_cast(Ret (*)(Params...),
-             const std::vector<Boxed_Value> &params)
-        {
+             const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+       {
           try {
-            Try_Cast<Params...>::do_try(params, 0);
+            Try_Cast<Params...>::do_try(params, 0, t_conversions);
           } catch (const exception::bad_boxed_cast &) {
             return false;
           }
@@ -105,21 +130,28 @@ namespace chaiscript
 
           template<typename ... InnerParams>
           static Ret do_call(const std::function<Ret (Params...)> &f,
-              const std::vector<Boxed_Value> &params, InnerParams &&... innerparams)
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions, InnerParams &&... innerparams)
           {
-            return Call_Func<Ret, count - 1, Params...>::do_call(f, params, std::forward<InnerParams>(innerparams)..., params[sizeof...(Params) - count]);
+            return Call_Func<Ret, count - 1, Params...>::do_call(f, params, t_conversions, std::forward<InnerParams>(innerparams)..., params[sizeof...(Params) - count]);
           } 
         };
 
       template<typename Ret, typename ... Params>
         struct Call_Func<Ret, 0, Params...>
         {
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4100) /// Disable unreferenced formal parameter warning, which only shows up in MSVC I don't think there's any way around it \todo evaluate this
+#endif
           template<typename ... InnerParams>
             static Ret do_call(const std::function<Ret (Params...)> &f,
-                const std::vector<Boxed_Value> &, InnerParams &&... innerparams)
+                const std::vector<Boxed_Value> &, const Dynamic_Cast_Conversions &t_conversions, 	InnerParams &&... innerparams)
             {
-              return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams))...);
+              return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams), &t_conversions)...);
             }
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif
         };
 
       /**
@@ -130,11 +162,11 @@ namespace chaiscript
        */
       template<typename Ret, typename ... Params>
         Ret call_func(const std::function<Ret (Params...)> &f,
-            const std::vector<Boxed_Value> &params)
+            const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
         {
           if (params.size() == sizeof...(Params))
           {
-            return Call_Func<Ret, sizeof...(Params), Params...>::do_call(f, params);
+            return Call_Func<Ret, sizeof...(Params), Params...>::do_call(f, params, t_conversions);
           }
 
           throw exception::arity_error(static_cast<int>(params.size()), sizeof...(Params));
@@ -156,9 +188,9 @@ namespace chaiscript
       struct Do_Call
       {
         template<typename Fun>
-          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            return Handle_Return<Ret>::handle(call_func(fun, params));
+            return Handle_Return<Ret>::handle(call_func(fun, params, t_conversions));
           }
       };
 
@@ -166,9 +198,9 @@ namespace chaiscript
       struct Do_Call<void>
       {
         template<typename Fun>
-          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-            call_func(fun, params);
+            call_func(fun, params, t_conversions);
             return Handle_Return<void>::handle();
           }
       };

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,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_
@@ -36,13 +36,17 @@ namespace chaiscript
       template<typename Ret, typename Class, typename ... Args> 
         std::function<Ret (Class &, Args...) > to_function(Ret (Class::*func)(Args...))
         {
-          return std::function<Ret (Class &, Args...)>(func);
+          /// \todo this std::mem_fn wrap shouldn't be necessary but type conversions for 
+          ///       std::function for member function pointers seems to be broken in MSVC
+          return std::function<Ret(Class &, Args...)>(std::mem_fn(func));
         }
 
       template<typename Ret, typename Class, typename ... Args> 
         std::function<Ret (const Class &, Args...) > to_function(Ret (Class::*func)(Args...) const)
         {
-          return std::function<Ret (const Class &, Args...)>(func);
+          /// \todo this std::mem_fn wrap shouldn't be necessary but type conversions for 
+          ///       std::function for member function pointers seems to be broken in MSVC
+          return std::function<Ret (const Class &, Args...)>(std::mem_fn(func));
         }
 
       template<bool Object>
@@ -51,6 +55,7 @@ namespace chaiscript
           template<typename T>
             static Proxy_Function go(T t)
             {
+              /// \todo is it possible to reduce the number of templates generated here?
               return Proxy_Function(
                   new Proxy_Function_Impl<typename FunctionSignature<decltype(to_function(t)) >::Signature>(to_function(t)));
             }      
@@ -68,23 +73,6 @@ namespace chaiscript
     }
   }
 
-  /// \brief Creates a new Proxy_Function object from a std::function object
-  /// \param[in] f std::function to expose to ChaiScript
-  ///
-  /// \b Example:
-  /// \code
-  /// std::function<int (char, float, std::string)> f = get_some_function();
-  /// chaiscript::ChaiScript chai;
-  /// chai.add(fun(f), "some_function");
-  /// \endcode
-  /// 
-  /// \sa \ref addingfunctions
-  template<typename T>
-    Proxy_Function fun(const std::function<T> &f)
-    {
-      return Proxy_Function(new dispatch::Proxy_Function_Impl<T>(f));
-    }
-
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member
   /// \param[in] t Function / member to expose
   ///
@@ -111,6 +99,25 @@ namespace chaiscript
       return dispatch::detail::Fun_Helper<std::is_member_object_pointer<T>::value>::go(t);
     }
 
+
+  /// \brief Creates a new Proxy_Function object from a std::function object
+  /// \param[in] f std::function to expose to ChaiScript
+  ///
+  /// \b Example:
+  /// \code
+  /// std::function<int (char, float, std::string)> f = get_some_function();
+  /// chaiscript::ChaiScript chai;
+  /// chai.add(fun(f), "some_function");
+  /// \endcode
+  /// 
+  /// \sa \ref addingfunctions
+  template<typename T>
+    Proxy_Function fun(const std::function<T> &f)
+    {
+      return Proxy_Function(new dispatch::Proxy_Function_Impl<T>(f));
+    }
+
+  
   /// \brief Creates a new Proxy_Function object from a free function, member function or data member and binds the first parameter of it
   /// \param[in] t Function / member to expose
   /// \param[in] q Value to bind to first parameter

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_
@@ -28,7 +28,7 @@ namespace chaiscript
   class Type_Info
   {
     public:
-      Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
+      CHAISCRIPT_CONSTEXPR Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
           bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
         : m_type_info(t_ti), m_bare_type_info(t_bareti),
         m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
@@ -90,6 +90,12 @@ namespace chaiscript
           || (ti.m_bare_type_info && m_bare_type_info && *ti.m_bare_type_info == *m_bare_type_info);
       }
 
+      bool bare_equal_type_info(const std::type_info &ti) const
+      {
+        return m_bare_type_info != 0 
+          && (*m_bare_type_info) == ti;
+      }
+
       bool is_const() const { return m_is_const; }
       bool is_reference() const { return m_is_reference; }
       bool is_void() const { return m_is_void; }
@@ -138,7 +144,7 @@ namespace chaiscript
       {
         typedef T type;
 
-        constexpr static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
           return Type_Info(std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
@@ -153,7 +159,7 @@ namespace chaiscript
       {
         typedef T type;
 
-        constexpr static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
@@ -168,7 +174,7 @@ namespace chaiscript
       {
         typedef T type;
 
-        constexpr static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
@@ -183,7 +189,7 @@ namespace chaiscript
       {
         typedef T type;
 
-        constexpr static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
@@ -198,7 +204,7 @@ namespace chaiscript
       {
         typedef T type;
 
-        constexpr static Type_Info get()
+        CHAISCRIPT_CONSTEXPR static Type_Info get()
         {
           return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
               std::is_void<T>::value,
@@ -225,7 +231,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type(i);
   /// \endcode
   template<typename T>
-  constexpr Type_Info user_type(const T &/*t*/)
+  CHAISCRIPT_CONSTEXPR Type_Info user_type(const T &/*t*/)
   {
     return detail::Get_Type_Info<T>::get();
   }
@@ -240,7 +246,7 @@ namespace chaiscript
   /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
   /// \endcode
   template<typename T>
-  constexpr Type_Info user_type()
+  CHAISCRIPT_CONSTEXPR Type_Info user_type()
   {
     return detail::Get_Type_Info<T>::get();
   }

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, Reference, Switch, Case, Default, Ternary_Cond
+                Logical_And, Logical_Or, Reference, 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", "Reference", "Switch", "Case", "Default", "Ternary Condition"};
+                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
 
       return ast_node_types[ast_node_type];
     }
@@ -61,9 +60,8 @@ namespace chaiscript
   /// \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;
@@ -75,7 +73,7 @@ namespace chaiscript
       eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
           bool t_dot_notation,
-          const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
+          const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_NOEXCEPT :
         std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_dot_notation, t_ss)),
         reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss)) 
       {}
@@ -83,18 +81,18 @@ namespace chaiscript
       eval_error(const std::string &t_why, 
            const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
            bool t_dot_notation,
-           const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
+           const chaiscript::detail::Dispatch_Engine &t_ss) CHAISCRIPT_NOEXCEPT :
         std::runtime_error(format(t_why, t_parameters, t_dot_notation, t_ss)),
         reason(t_why), detail(format_detail(t_functions, t_dot_notation, t_ss))
       {}
 
 
-      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) noexcept :
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) CHAISCRIPT_NOEXCEPT :
         std::runtime_error(format(t_why, t_where, t_fname)),
         reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
       {}
 
-      eval_error(const std::string &t_why) noexcept
+      eval_error(const std::string &t_why) CHAISCRIPT_NOEXCEPT
         : std::runtime_error("Error: \"" + t_why + "\" "),
         reason(t_why) 
       {}
@@ -121,7 +119,7 @@ namespace chaiscript
         return ss.str();
       }
 
-      virtual ~eval_error() noexcept {}
+      virtual ~eval_error() CHAISCRIPT_NOEXCEPT {}
 
     private:
 
@@ -377,15 +375,14 @@ 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) noexcept
+      file_not_found_error(const std::string &t_filename) CHAISCRIPT_NOEXCEPT
         : std::runtime_error("File Not Found: " + t_filename)
       { }
 
-      virtual ~file_not_found_error() noexcept {}
+      virtual ~file_not_found_error() CHAISCRIPT_NOEXCEPT {}
     };
 
   }
@@ -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;
 
@@ -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_
@@ -39,12 +39,12 @@ namespace chaiscript
     /// \brief Thrown if an error occurs while attempting to load a binary module
     struct load_module_error : std::runtime_error
     {
-      load_module_error(const std::string &t_reason) noexcept
+      load_module_error(const std::string &t_reason) CHAISCRIPT_NOEXCEPT
         : std::runtime_error(t_reason)
       {
       }
 
-      virtual ~load_module_error() noexcept
+      virtual ~load_module_error() CHAISCRIPT_NOEXCEPT
       {
       }
     };
@@ -157,9 +157,9 @@ namespace chaiscript
         typedef LPSTR StringType;
         std::string retval = "Unknown Error";
 #endif
-        StringType lpMsgBuf = 0;
+        StringType lpMsgBuf = nullptr;
 
-        FormatMessage(
+        if (FormatMessage(
             FORMAT_MESSAGE_ALLOCATE_BUFFER | 
             FORMAT_MESSAGE_FROM_SYSTEM |
             FORMAT_MESSAGE_IGNORE_INSERTS,
@@ -167,14 +167,12 @@ namespace chaiscript
             t_err,
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
             (StringType)&lpMsgBuf,
-            0, NULL );        
-
-        if (lpMsgBuf)
+            0, NULL ) != 0 && lpMsgBuf)
         {
           retval = lpMsgBuf;
+          LocalFree(lpMsgBuf);
         }
 
-        LocalFree(lpMsgBuf);
         return tostring(retval);
       }
 
@@ -256,9 +254,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 {
@@ -287,9 +284,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);
@@ -298,16 +294,12 @@ 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(const ModulePtr &t_lib) {
       m_engine.add_reserved_word("def");
       m_engine.add_reserved_word("fun");
@@ -338,10 +330,14 @@ namespace chaiscript
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_function_objects, std::ref(m_engine)), "get_functions");
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_scripting_objects, std::ref(m_engine)), "get_objects");
 
+      m_engine.add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&chaiscript::detail::Dispatch_Engine::call_exists, std::ref(m_engine), std::placeholders::_1))), 
+          "call_exists");
+      m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base *, const std::vector<Boxed_Value> &)>(std::bind(&chaiscript::dispatch::Proxy_Function_Base::operator(), std::placeholders::_1, std::placeholders::_2, std::ref(m_engine.conversions()))), "call");
+
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::ref(m_engine)), "name");
 
 
-      typedef void (ChaiScript::*load_mod_1)(const std::string&);
+      typedef std::string (ChaiScript::*load_mod_1)(const std::string&);
       typedef void (ChaiScript::*load_mod_2)(const std::string&, const std::string&);
 
       m_engine.add(fun(static_cast<load_mod_1>(&ChaiScript::load_module), this), "load_module");
@@ -351,12 +347,11 @@ namespace chaiscript
       m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
       m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
 
-      do_eval(ChaiScript_Prelude::chaiscript_prelude, "standard prelude");
+      do_eval(ChaiScript_Prelude::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 );
 
@@ -454,7 +449,7 @@ namespace chaiscript
           dllpath = std::string(&buf.front(), pathlen);
         }
 
-        m_modulepaths.push_back(dllpath+"/");
+        m_modulepaths.insert(m_modulepaths.begin(), dllpath+"/");
       } 
 #endif    
 
@@ -479,19 +474,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);
           }
@@ -512,6 +508,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
@@ -645,7 +652,7 @@ namespace chaiscript
     /// (the symbol mentioned above), an exception is thrown.
     ///
     /// \throw chaiscript::exception::load_module_error In the event that no matching module can be found.
-    void load_module(const std::string &t_module_name)
+    std::string load_module(const std::string &t_module_name)
     {
       std::vector<exception::load_module_error> errors;
 
@@ -658,23 +665,25 @@ namespace chaiscript
       postfixes.push_back(".so");
       postfixes.push_back("");
 
-      for (size_t i = 0; i < m_modulepaths.size(); ++i)
+      for (size_t i = 0; i < m_modulepaths.size(); ++i) 
+      {
+        for (size_t j = 0; j < prefixes.size(); ++j)
         {
-          for (size_t j = 0; j < prefixes.size(); ++j)
-            {
-              for (size_t k = 0; k < postfixes.size(); ++k)
-                {
-                  try {
-                    std::string name = m_modulepaths[i] + prefixes[j] + t_module_name + postfixes[k];
-                    load_module(t_module_name, name);
-                    return;
-                  } catch (const chaiscript::exception::load_module_error &e) {
-                    errors.push_back(e);
-                    // Try next set
-                  }
-                }
+          for (size_t k = 0; k < postfixes.size(); ++k)
+          {
+            try {
+              std::string name = m_modulepaths[i] + prefixes[j] + t_module_name + postfixes[k];
+              // std::cerr << "trying location: " << name << std::endl;
+              load_module(t_module_name, name);
+              return name;
+            } catch (const chaiscript::exception::load_module_error &e) {
+              // std::cerr << "error: " << e.what() << std::endl;
+              errors.push_back(e);
+              // Try next set
             }
+          }
         }
+      }
 
       std::string errstring;
 
@@ -731,7 +740,7 @@ 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;
       }
@@ -754,15 +763,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;
       }
     }
 
+    /// \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
@@ -779,7 +796,7 @@ 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;
       }
@@ -795,7 +812,7 @@ 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;
       }
@@ -812,10 +829,10 @@ 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;
       }

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_
@@ -39,7 +39,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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)
       { }
 
@@ -93,19 +93,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 &){
@@ -119,11 +119,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 &){
@@ -137,8 +137,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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))
       { }
 
@@ -181,22 +181,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 
@@ -207,8 +207,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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);
@@ -226,7 +226,7 @@ namespace chaiscript
           Boxed_Value fn = this->children[0]->eval(t_ss);
           try {
             chaiscript::eval::detail::Stack_Push_Pop spp(t_ss);
-            const Boxed_Value &retval = (*boxed_cast<const Const_Proxy_Function &>(fn))(params);
+            const Boxed_Value &retval = (*t_ss.boxed_cast<const Const_Proxy_Function &>(fn))(params, t_ss.conversions());
             return retval;
           }
           catch(const exception::dispatch_error &e){
@@ -234,7 +234,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);
@@ -276,8 +276,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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){
           std::vector<Boxed_Value> params;
@@ -294,11 +294,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)(params);
+            return (*fn)(params, 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);
@@ -341,8 +341,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 
@@ -363,15 +363,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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() {}
@@ -440,8 +440,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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){
           if (this->children[0]->identifier == AST_Node_Type::Reference)
@@ -472,17 +472,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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));
@@ -491,10 +491,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 std::shared_ptr<std::string> &t_fname=std::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));
@@ -503,10 +503,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 std::shared_ptr<std::string> &t_fname=std::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));
@@ -515,10 +515,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 std::shared_ptr<std::string> &t_fname=std::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));
@@ -527,10 +527,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 std::shared_ptr<std::string> &t_fname=std::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));
@@ -539,8 +539,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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);
@@ -587,8 +587,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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);
@@ -654,8 +654,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 &) {
@@ -674,8 +674,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 &){
@@ -721,8 +721,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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();
@@ -750,8 +750,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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;
@@ -806,35 +806,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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();
         }
 
@@ -842,8 +835,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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;
@@ -851,7 +844,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) {
@@ -865,8 +858,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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;
@@ -910,49 +903,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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();
         }
 
@@ -960,8 +942,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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;
@@ -1003,8 +985,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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);
@@ -1017,8 +999,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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);
@@ -1032,8 +1014,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 {
@@ -1052,19 +1034,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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);
@@ -1078,8 +1064,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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) {
@@ -1094,8 +1080,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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(); 
@@ -1130,8 +1116,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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() {}
@@ -1141,6 +1127,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);
@@ -1160,32 +1147,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 {
@@ -1202,15 +1216,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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;        
@@ -1338,22 +1352,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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){
 
@@ -1435,8 +1449,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 {
@@ -1464,43 +1478,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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);
@@ -1533,8 +1547,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 std::shared_ptr<std::string> &t_fname=std::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 std::shared_ptr<std::string> &t_fname=std::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_
@@ -317,13 +317,21 @@ namespace chaiscript
 
       /**
        * Skips ChaiScript whitespace, which means space and tab, but not cr/lf
+       * jespada: Modified SkipWS to skip optionally CR ('\n')
        */
-      bool SkipWS() {
+      bool SkipWS(bool skip_cr=false) {
         bool retval = false;
         while (has_more_input()) {
-          if ( char_in_alphabet(*m_input_pos,detail::white_alphabet) ) {
+          if ( char_in_alphabet(*m_input_pos,detail::white_alphabet) || (skip_cr && (*m_input_pos == '\n'))) {
+            if(*m_input_pos == '\n') {
+              m_col = 1;
+              ++m_line;
+            }
+            else {
+              ++m_col;
+            }
             ++m_input_pos;
-            ++m_col;
+
             retval = true;
           }
           else if (SkipComment()) {
@@ -626,7 +634,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;
             }
@@ -651,14 +659,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;
             }
@@ -667,12 +675,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;
@@ -742,13 +750,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;
             }
@@ -781,7 +789,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;
         }
@@ -856,13 +864,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);
                   }
 
@@ -882,17 +890,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);
@@ -950,13 +958,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;
@@ -1048,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;
             }
@@ -1087,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;
             }
@@ -1139,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;
@@ -1187,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);
           }
 
@@ -1227,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;
             }
@@ -1241,6 +1249,8 @@ namespace chaiscript
          * Reads a comma-separated list of values from input
          */
         bool Arg_List() {
+
+          SkipWS(true);
           bool retval = false;
 
           size_t prev_stack_top = m_match_stack.size();
@@ -1259,6 +1269,8 @@ namespace chaiscript
             build_match(AST_NodePtr(new eval::Arg_List_AST_Node()), prev_stack_top);
           }
 
+          SkipWS(true);
+
           return retval;
         }
 
@@ -1267,6 +1279,7 @@ namespace chaiscript
          */
         bool Container_Arg_List() {
           bool retval = false;
+          SkipWS(true);
 
           size_t prev_stack_top = m_match_stack.size();
 
@@ -1301,6 +1314,8 @@ namespace chaiscript
             build_match(AST_NodePtr(new eval::Arg_List_AST_Node()), prev_stack_top);
           }
 
+          SkipWS(true);
+
           return retval;
 
         }
@@ -1497,7 +1512,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;
@@ -1565,18 +1580,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; 
         }
 
         /**
@@ -1751,6 +1788,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
          */
@@ -1878,6 +1932,7 @@ namespace chaiscript
           if (Char('[')) {
             retval = true;
             Container_Arg_List();
+
             if (!Char(']')) {
               throw exception::eval_error("Missing closing square bracket ']' in container initializer", File_Position(m_line, m_col), *m_filename);
             }
@@ -2189,6 +2244,7 @@ namespace chaiscript
                 Symbol("-=", true, true) || Symbol("*=", true, true) || Symbol("/=", true, true) ||
                 Symbol("%=", true, true) || Symbol("<<=", true, true) || Symbol(">>=", true, true) ||
                 Symbol("&=", true, true) || Symbol("^=", true, true) || Symbol("|=", true, true)) {
+              SkipWS(true);
               if (!Equation()) {
                 throw exception::eval_error("Incomplete equation", File_Position(m_line, m_col), *m_filename);
               }
@@ -2276,6 +2332,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 (Block()) {
               has_more = true;
               retval = true;

include/chaiscript/language/chaiscript_prelude.chai

@@ -9,7 +9,7 @@
 
 namespace chaiscript {
 struct ChaiScript_Prelude { 
-  constexpr static const char *chaiscript_prelude=R""(
+  static std::string chaiscript_prelude() {  return R""(
 
 def lt(l, r) { 
   if (call_exists(`<`, l, r)) { 
@@ -455,37 +455,37 @@ def zip(x, y) {
 
 # Returns the position of the second value string in the first value string
 def string::find(substr) : is_type(substr, "string") { 
-  int(find(this, substr, 0)); 
+  find(this, substr, size_t(0)); 
 }
 
 
 # Returns the position of last match of the second value string in the first value string
 def string::rfind(substr) : is_type(substr, "string") { 
-  int(rfind(this, substr, -1)); 
+  rfind(this, substr, size_t(-1)); 
 }
 
 
 # Returns the position of the first match of elements in the second value string in the first value string
 def string::find_first_of(list) : is_type(list, "string") { 
-  int(find_first_of(this, list, 0)); 
+  find_first_of(this, list, size_t(0)); 
 } 
 
 
 # Returns the position of the last match of elements in the second value string in the first value string
 def string::find_last_of(list) : is_type(list, "string") { 
-  int(find_last_of(this, list, -1)); 
+  find_last_of(this, list, size_t(-1)); 
 } 
 
 
 # Returns the position of the first non-matching element in the second value string in the first value string
 def string::find_first_not_of(list) : is_type(list, "string") { 
-  int(find_first_not_of(this, list, 0)); 
+  find_first_not_of(this, list, size_t(0)); 
 } 
 
 
 # Returns the position of the last non-matching element in the second value string in the first value string
 def string::find_last_not_of(list) : is_type(list, "string") { 
-  int(find_last_not_of(this, list, -1)); 
+  find_last_not_of(this, list, size_t(-1)); 
 } 
 
 
@@ -523,6 +523,7 @@ def find(container, value) {
 
 
 )"";
+}
 
 };
 }

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_
@@ -16,6 +16,8 @@ namespace chaiscript
   namespace utility
   {
 
+    /// \todo Use of this utility, and uniform initializer lists, is causing memory errors in MSVC
+    
     template<typename Class, typename ModuleType>
       void add_class(ModuleType &t_module,
           const std::string &t_classname,
@@ -35,6 +37,7 @@ namespace chaiscript
         }
         
       }
+      
   }
 }
 

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,12 @@
+[![Build Status](https://travis-ci.org/ChaiScript/ChaiScript.png?branch=ChaiScript_5_0_CPP_11)](https://travis-ci.org/ChaiScript/ChaiScript)
+[![Coverage Status](https://coveralls.io/repos/ChaiScript/ChaiScript/badge.png?branch=ChaiScript_5_0_CPP_11)](https://coveralls.io/r/ChaiScript/ChaiScript?branch=ChaiScript_5_0_CPP_11)
+
 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,13 +1,42 @@
-Changes since 5.0.0
+Notes:
+
+ * There was overlap during the 5.x and 4.x development cycle, so some of the notes appear twice as the new features were developed for 4.x (which required boost) then ported to 5.x (which requires C++11).
+ * This is the last release of 5.x, all future development will be on the final merged 6.x line.
+
+
+### Changes since 5.2.0
+* Official support for MSVC with C++11. All major platforms and compilers are now support for C++11 release
+* Enhanced unit tests
+* Add `continue` statement, fix various use cases for `for`  loops
+* Fix use of suffixed numbers in vector initialization
+* Code cleanups
+* Eliminate global data, which makes code more portable and thread safe
+* Fix issue #79
+* Merge pretty_print fixes from @mgee #82
+* Compiler warning fixes for latest compiler releases
+* Fix threading problems
+* Fix linking error on MacOS Mavericks #88
+* Allow non-const globals
+* Make sure user cannot name a variable with `::` in it #91
+* Fix various string / map / vector `size` and `count` calls for compilers which have weird overloads for them. #90 #93 #95
+* Make module search path relative to the currently running executable
+* Build and work with wstring windows builds
+* fix for some new line cases in the middle of a vector initialization from jespada
+
+### Changes since 5.1.0
+* Add support for automatic conversion of arithmetic types when possible
+  and when no ambiguous method dispatch exists.
+
+### Changes since 5.0.0
 * Fix sizing of numeric constants to match that of the C++ standard
 * Add support for u,ll,l,f suffixes for numeric constants
 * Siginificant improvement in error reporting
 
-Changes since 4.0.0
+### Changes since 4.0.0
 * Dropped boost in favor of C++11
 * Separated out stdlib to make more options for compile time improvements
 
-Changes since 3.1.0
+### Changes since 3.1.0
 * svenstaro: Unused variables and CMake consistency fixes
 * Added support for returning pointers from functions (#13)
 * Compile with -pedantic (#9)
@@ -26,7 +55,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
@@ -35,8 +64,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

@@ -5,6 +5,7 @@
 // http://www.chaiscript.com
 
 #include <iostream>
+#include <ctime>
 
 #include <chaiscript/chaiscript.hpp>
 #include <chaiscript/dispatchkit/bootstrap_stl.hpp>
@@ -41,9 +42,9 @@ struct System
   std::map<std::string, std::function<std::string (const std::string &) > > m_callbacks;
 
   void add_callback(const std::string &t_name, 
-      const chaiscript::Proxy_Function &t_func)
+      const std::function<std::string (const std::string &)> &t_func)
   {
-    m_callbacks[t_name] = chaiscript::dispatch::functor<std::string (const std::string &)>(t_func);
+    m_callbacks[t_name] = t_func;
   }
 
 

samples/range.chai

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

src/chaiscript_stdlib.cpp

@@ -9,6 +9,11 @@
 #pragma warning(disable : 4190)
 #endif
 
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
+
 
 CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_chaiscript_stdlib()
 {
@@ -16,6 +21,10 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_chaiscr
 }
 
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

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>
@@ -15,21 +15,124 @@
 #include <readline/readline.h>
 #include <readline/history.h>
 #else
+
+char *mystrdup (const char *s) {
+  size_t len = strlen(s) + 1; // Space for length plus nul
+  char *d = static_cast<char*>(malloc (len));   
+  if (d == nullptr) return nullptr;          // No memory
+#ifdef CHAISCRIPT_MSVC
+  strcpy_s(d, len, s);                        // Copy the characters
+#else
+  strcpy(d,s);                        // Copy the characters
+#endif
+  return d;                            // Return the new string
+}
+
 char* readline(const char* p)
 {
   std::string retval;
   std::cout << p ;
   std::getline(std::cin, retval);
-#ifdef CHAISCRIPT_MSVC
-  return std::cin.eof() ? NULL : _strdup(retval.c_str());
-#else
-  return std::cin.eof() ? NULL : strdup(retval.c_str());
-#endif
+  return std::cin.eof() ? NULL : mystrdup(retval.c_str());
 }
+
+
 void add_history(const char*){}
 void using_history(){}
 #endif
 
+
+
+void *cast_module_symbol(std::vector<std::string> (*t_path)())
+{
+  union cast_union
+  {
+    std::vector<std::string> (*in_ptr)();
+    void *out_ptr;
+  };
+
+  cast_union c;
+  c.in_ptr = t_path;
+  return c.out_ptr;
+}
+
+std::vector<std::string> default_search_paths()
+{
+  std::vector<std::string> paths;
+
+#ifdef CHAISCRIPT_WINDOWS  // force no unicode
+  CHAR path[4096];
+  int size = GetModuleFileNameA(0, path, sizeof(path)-1);
+
+  std::string exepath(path, size);
+
+  size_t lastslash = exepath.rfind('\\');
+  size_t secondtolastslash = exepath.rfind('\\', lastslash - 1);
+  if (lastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, lastslash));
+  }
+
+  if (secondtolastslash != std::string::npos)
+  {
+    return {exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\"};
+  }
+#else
+
+  std::string exepath;
+
+  std::vector<char> buf(2048);
+  ssize_t size = -1;
+
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  {
+    exepath = std::string(&buf.front(), size);
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    Dl_info rInfo;
+    memset( &rInfo, 0, sizeof(rInfo) ); 
+    if ( !dladdr(cast_module_symbol(&default_search_paths), &rInfo)  || !rInfo.dli_fname ) { 
+      return paths;
+    }
+
+    exepath = std::string(rInfo.dli_fname);
+  }
+
+  size_t lastslash = exepath.rfind('/');
+
+  size_t secondtolastslash = exepath.rfind('/', lastslash - 1);
+  if (lastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, lastslash));
+  }
+
+  if (secondtolastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, secondtolastslash) + "/lib/chaiscript/");
+  }
+#endif
+
+  return paths;
+}
+
 void help(int n) {
   if ( n >= 0 ) {
     std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>." << std::endl;
@@ -148,8 +251,6 @@ void interactive(chaiscript::ChaiScript& chai)
 
 int main(int argc, char *argv[])
 {
-  std::vector<std::string> usepaths;
-  std::vector<std::string> modulepaths;
 
   // Disable deprecation warning for getenv call.
 #ifdef CHAISCRIPT_MSVC
@@ -164,12 +265,16 @@ int main(int argc, char *argv[])
 #pragma warning(pop)
 #endif
 
+  std::vector<std::string> usepaths;
   usepaths.push_back("");
   if (usepath)
   {
     usepaths.push_back(usepath);
   }
 
+  std::vector<std::string> modulepaths;
+  std::vector<std::string> searchpaths = default_search_paths();
+  modulepaths.insert(modulepaths.end(), searchpaths.begin(), searchpaths.end());
   modulepaths.push_back("");
   if (modulepath)
   {

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/dispatchkit/bootstrap.hpp>
@@ -20,7 +26,12 @@ bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
     = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
   if (pf)
   {
-    return bool(pf->get_parse_tree());
+    if (pf->get_parse_tree())
+    {
+      return true;
+    } else {
+      return false;
+    }
   } else {
     return false;
   }
@@ -44,6 +55,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());
@@ -56,14 +73,15 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
   chaiscript::bootstrap::standard_library::vector_type<std::vector<std::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
 
   using namespace chaiscript;
-
+  
   chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
       "eval_error",
       { },
       { {fun(&chaiscript::exception::eval_error::reason), "reason"},
         {fun(&chaiscript::exception::eval_error::call_stack), "call_stack"} }
       );
-
+      
+  
   chaiscript::utility::add_class<chaiscript::File_Position>(*m,
       "File_Position",
       { constructor<File_Position()>(),
@@ -71,33 +89,40 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflect
       { {fun(&File_Position::line), "line"},
         {fun(&File_Position::column), "column"} }
       );
-
-  chaiscript::utility::add_class<AST_Node>(*m,
-      "AST_Node",
-      {  },
-      { {fun(&AST_Node::text), "text"},
-        {fun(&AST_Node::identifier), "identifier"},
-        {fun(&AST_Node::filename), "filename"},
-        {fun(&AST_Node::start), "start"},
-        {fun(&AST_Node::end), "end"},
-        {fun(&AST_Node::internal_to_string), "internal_to_string"},
-        {fun(&AST_Node::children), "children"},
-        {fun(&AST_Node::replace_child), "replace_child"}
-      }
-    );
-
+      
+  
+  chaiscript::utility::add_class<AST_Node>(*m, 
+  "AST_Node",
+  {  },
+  { {fun(&AST_Node::text), "text"},
+    {fun(&AST_Node::identifier), "identifier"},
+    {fun(&AST_Node::filename), "filename"},
+    {fun(&AST_Node::start), "start"},
+    {fun(&AST_Node::end), "end"},
+    {fun(&AST_Node::internal_to_string), "internal_to_string"},
+    {fun(&AST_Node::children), "children"},
+    {fun(&AST_Node::replace_child), "replace_child"}
+  }
+  );
+  
+  
   chaiscript::utility::add_class<parser::ChaiScript_Parser>(*m,
       "ChaiScript_Parser",
       { constructor<parser::ChaiScript_Parser ()>() },
       { {fun(&parser::ChaiScript_Parser::parse), "parse"},
         {fun(&parser::ChaiScript_Parser::ast), "ast"} }
       );
-
+      
 
 
   return m;
 }
 
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+
 
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)

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 <chaiscript/dispatchkit/bootstrap_stl.hpp>
@@ -11,11 +16,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 CHAISCRIPT_MSVC
 #pragma warning(pop)

src/test_module.cpp

@@ -5,12 +5,19 @@
 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; }
 
+    const TestBaseType &constMe() const { return *this; }
+
+    int val;
+    const int const_val;
+
+  private:
+    TestBaseType &operator=(const TestBaseType &);
 };
 
 enum TestEnum
@@ -28,6 +35,9 @@ class TestDerivedType : public TestBaseType
   public:
     virtual ~TestDerivedType() {}
     virtual int func() { return 1; }
+
+  private:
+    TestDerivedType &operator=(const TestDerivedType &);
 };
 
 std::string hello_world()
@@ -47,6 +57,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()
 {
@@ -68,6 +82,8 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::base_class<TestBaseType, TestDerivedType>());
 
   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(&get_new_int), "get_new_int");
 
@@ -76,12 +92,17 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   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 CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

unittests/arithmetic_conversions_test.cpp

@@ -0,0 +1,58 @@
+// Tests to make sure that type conversions happen only when they should
+
+#include <chaiscript/chaiscript.hpp>
+
+void f1(int)
+{
+}
+
+void f4(std::string)
+{
+}
+
+void f2(int)
+{
+}
+
+void f3(double)
+{
+}
+
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+
+  chai.add(chaiscript::fun(&f1), "f1");
+  chai.add(chaiscript::fun(&f2), "f2");
+  chai.add(chaiscript::fun(&f3), "f2");
+  chai.add(chaiscript::fun(&f1), "f3");
+  chai.add(chaiscript::fun(&f4), "f3");
+
+  // no overloads
+  chai.eval("f1(0)");
+  chai.eval("f1(0l)");
+  chai.eval("f1(0ul)");
+  chai.eval("f1(0ll)");
+  chai.eval("f1(0ull)");
+  chai.eval("f1(0.0)");
+  chai.eval("f1(0.0f)");
+  chai.eval("f1(0.0l)");
+
+  // expected overloads
+  chai.eval("f2(1)");
+  chai.eval("f2(1.0)");
+
+  // 1 non-arithmetic overload
+  chai.eval("f2(1.0)");
+
+  // this is the one call we expect to fail
+  try {
+    chai.eval("f2(1.0l)");
+  } catch (const std::exception &) {
+    return EXIT_SUCCESS;
+  }
+
+  // if the last one did not throw, we failed
+  return EXIT_FAILURE;
+}

unittests/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 (auto 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/heap_allocated_chaiscript_test.cpp

@@ -0,0 +1,10 @@
+#include <chaiscript/chaiscript.hpp>
+
+
+int main()
+{
+  chaiscript::ChaiScript *chai = new chaiscript::ChaiScript();
+  delete chai;
+
+  return EXIT_SUCCESS;
+}

unittests/inheritance.chai

@@ -6,3 +6,12 @@ auto 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)
+

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>
@@ -24,19 +18,26 @@ 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()
 {
   // Disable deprecation warning for getenv call.
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
+#ifdef max // Why microsoft? why?
+#undef max
+#endif
 #pragma warning(push)
 #pragma warning(disable : 4996)
 #endif
@@ -44,7 +45,7 @@ int main()
   const char *usepath = getenv("CHAI_USE_PATH");
   const char *modulepath = getenv("CHAI_MODULE_PATH");
 
-#ifdef BOOST_MSVC
+#ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif
 
@@ -80,6 +81,7 @@ int main()
   }
 
 
+
   for (int i = 0; i < num_threads; ++i)
   {
     std::stringstream ss;

unittests/object_lifetime_test.cpp

@@ -29,12 +29,19 @@ int main()
 {
   chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
 
+  /*
   chaiscript::utility::add_class<Test>(*m,
       "Test",
       { chaiscript::constructor<Test ()>(),
         chaiscript::constructor<Test (const Test &)>() },
       { {chaiscript::fun(&Test::count), "count"} }
       );
+      */
+
+  m->add(chaiscript::user_type<Test>(), "Test");
+  m->add(chaiscript::constructor<Test()>(), "Test");
+  m->add(chaiscript::constructor<Test(const Test &)>(), "Test");
+  m->add(chaiscript::fun(&Test::count), "count");
 
   chaiscript::ChaiScript chai;
   chai.add(m);

unittests/string_size.chai

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

unittests/type_info_test.cpp

@@ -1,6 +1,8 @@
 // Tests to make sure that the order in which function dispatches occur is correct
 
+#include <chaiscript/chaiscript_defines.hpp>
 #include <chaiscript/dispatchkit/type_info.hpp>
+#include <cstdlib>
 
 void test_type(const chaiscript::Type_Info &ti, bool t_is_const, bool t_is_pointer, bool t_is_reference, bool t_is_void,
     bool t_is_undef)

unittests/utility_test.cpp

@@ -1,5 +1,7 @@
+#include <chaiscript/chaiscript.hpp>
 #include <chaiscript/chaiscript_stdlib.hpp>
 #include <chaiscript/utility/utility.hpp>
+#include <functional>
 
 class Test
 {
@@ -18,6 +20,7 @@ int main()
 
   using namespace chaiscript;
 
+  /// \todo fix overload resolution for fun<>
   chaiscript::utility::add_class<Test>(*m,
       "Test",
       { constructor<Test ()>(),
@@ -25,9 +28,9 @@ int main()
       { {fun(&Test::function), "function"},
         {fun(&Test::function2), "function2"},
         {fun(&Test::function3), "function3"},
-        {fun<std::string (Test::*)(double)>(&Test::functionOverload), "functionOverload"},
-        {fun<std::string (Test::*)(int)>(&Test::functionOverload), "functionOverload"},
-        {fun<Test & (Test::*)(const Test &)>(&Test::operator=), "="}
+        {fun(static_cast<std::string(Test::*)(double)>(&Test::functionOverload)), "functionOverload" },
+        {fun(static_cast<std::string(Test::*)(int)>(&Test::functionOverload)), "functionOverload" },
+        {fun(static_cast<Test & (Test::*)(const Test &)>(&Test::operator=)), "=" }
  
         }
       );

unittests/vector_inplace_init.chai

@@ -3,6 +3,7 @@ assert_equal(3, x.size())
 
 
 
+
 // Make sure vector elements are copied into place for consistency with
 // map inplace construction
 var i = 1;
@@ -12,3 +13,9 @@ assert_equal(1, y[0]);
 i = 3;
 assert_equal(3, i);
 assert_equal(1, y[0]);
+
+
+// make sure initialization with a break in the middle works as expected
+var a = [0.0,0.0,
+  1.0,1.0]
+ 

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])