Update version to 4.3.0

Interestingly, VS2013 with Boost 1.55 exhibited the issues complained
about in issue #92, so I was able to provide an appropriate fix. It would
appear to be bugs in both compilers, which seems very odd.

CMakeLists.txt

@@ -1,45 +1,266 @@
-cmake_minimum_required(VERSION 2.6)
+cmake_minimum_required(VERSION 2.8)
 
 project(chaiscript)
 
-FIND_LIBRARY(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+option(MULTITHREAD_SUPPORT_ENABLED "Multithreaded Support Enabled" TRUE)
+option(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
+option(BUILD_SAMPLES "Build Samples Folder" FALSE)
 
-MESSAGE(STATUS "Detecting readline support")
+list(APPEND CPACK_SOURCE_IGNORE_FILES "${CMAKE_CURRENT_BINARY_DIR}")
+list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.svn")
+list(APPEND CPACK_SOURCE_IGNORE_FILES "\\\\.git")
+list(APPEND CPACK_SOURCE_IGNORE_FILES ".swp")
+list(APPEND CPACK_SOURCE_IGNORE_FILES ".*~")
+
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
+
+set(CPACK_PACKAGE_VERSION_MAJOR 4)
+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")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "An embedded scripting language for C++")
+
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "libboost-dev (>=1.36.0)")
+set(CPACK_DEBIAN_PACKAGE_SECTION "devel")
+set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+
+set(CPACK_RPM_PACKAGE_LICENSE "BSD")
+set(CPACK_RPM_PACKAGE_GROUP "Programming")
+set(CPACK_RPM_PACKAGE_REQUIRES "boost-devel >= 1.36.0, boost-thread >= 1.36.0")
+
+set(CHAI_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
+
+configure_file(Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile)
+
+include(CTest)
+include(CPack)
+
+find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
+
+enable_testing()
+
+
+message(STATUS "Detecting readline support")
 if (READLINE_LIBRARY)
-    MESSAGE(STATUS "Found: ${READLINE_LIBRARY}")
-    SET (READLINE_LIB readline)
-    SET (READLINE_FLAG " -DREADLINE_AVAILABLE")
+    message(STATUS "Found: ${READLINE_LIBRARY}")
+    set (READLINE_LIB readline)
+    add_definitions(/DREADLINE_AVAILABLE)
 else(READLINE_LIBRARY)
-    MESSAGE(STATUS "Not Found")
-    SET (READLINE_LIB )
-    SET (READLINE_FLAG )
+    message(STATUS "Not Found")
+    set (READLINE_LIB )
+    set (READLINE_FLAG )
 endif(READLINE_LIBRARY)
 
-SET (CMAKE_C_FLAGS_REL " -Wall -O3 ${READLINE_FLAG}")
-SET (CMAKE_CXX_FLAGS_REL " -Wall -O3 ${READLINE_FLAG}")
+if(MSVC)
+  add_definitions(/W4)
+  if(CMAKE_CL_64)
+    add_definitions(/bigobj)
+   endif()
+else()
+  add_definitions(-Wall -Wextra -Wshadow -pedantic)
 
-SET (CMAKE_C_FLAGS " -Wall -ggdb ${READLINE_FLAG}")
-SET (CMAKE_CXX_FLAGS " -Wall -ggdb ${READLINE_FLAG}")
+  if (APPLE)
+    # -Wno-missing-field-initializers is for boost on macos
+    add_definitions(-Wno-missing-field-initializers -Wno-sign-compare)
+  endif()
+endif()
 
 include_directories(include)
 
-find_package(Boost 1.36.0 COMPONENTS thread)
+set(Boost_ADDITIONAL_VERSIONS "1.44" "1.44.0" "1.43" "1.43.0" "1.42" "1.42.0" "1.41")
+set(Boost_USE_MULTITHREADED ON)
+
+set (Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.hpp include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
+
+set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
+
+if (MULTITHREAD_SUPPORT_ENABLED)
+  find_package(Boost 1.36.0 COMPONENTS thread system)
 
   if (Boost_FOUND)
-	include_directories(${Boost_INCLUDE_DIRS})
-	add_executable(chaiscript_eval src/main.cpp)
-	#add_executable(dispatchkit_test contrib/test/dispatchkit_test.cpp)
-	target_link_libraries(chaiscript_eval dl ${Boost_LIBRARIES} ${READLINE_LIB})
-
-        add_library(test MODULE src/test_module.cpp)
-	target_link_libraries(test ${Boost_LIBRARIES})
-
-        add_library(stl_extra MODULE src/stl_extra.cpp)
-	target_link_libraries(stl_extra ${Boost_LIBRARIES})
-
-	install(TARGETS chaiscript_eval DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/bin)
-        
-else(Boost_FOUND)
+    link_directories( ${Boost_LIBRARY_DIRS} )
+  else()
     message(FATAL_ERROR "Can not find Boost")
   endif(Boost_FOUND)
 
+  if (CMAKE_HOST_UNIX)
+    add_definitions(-pthread)
+    list(APPEND LIBS "pthread")
+  endif()
+else()
+  add_definitions(-DCHAISCRIPT_NO_THREADS)
+endif()
+
+if (CMAKE_HOST_UNIX AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+  list(APPEND LIBS "dl")
+endif()
+  
+list(APPEND LIBS ${READLINE_LIB})
+
+if (NOT MSVC)
+  # Boost on MSVC does automatic linking
+  list(APPEND LIBS ${Boost_LIBRARIES})
+endif()
+
+if (CMAKE_COMPILER_2005)
+  # vs2005 is a bit too loud about possible loss of data warnings
+#  ADD_DEFINITIONS(/wd4244)
+endif()
+
+include_directories(${Boost_INCLUDE_DIRS})
+include_directories(${Boost_INCLUDE_DIR})
+add_executable(chai src/main.cpp ${Chai_INCLUDES})
+target_link_libraries(chai ${LIBS})
+
+if (BUILD_SAMPLES)
+  add_executable(example samples/example.cpp)
+  target_link_libraries(example ${LIBS})
+  add_executable(memory_leak_test samples/memory_leak_test.cpp)
+  target_link_libraries(memory_leak_test ${LIBS})
+endif()
+
+
+if (BUILD_MODULES)
+  add_library(stl_extra MODULE src/stl_extra.cpp)
+  target_link_libraries(stl_extra ${LIBS})
+
+  add_library(reflection MODULE src/reflection.cpp)
+  target_link_libraries(reflection ${LIBS})
+  set(MODULES stl_extra reflection)
+endif()
+
+file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai)
+
+list(SORT UNIT_TESTS)
+
+if(BUILD_TESTING)
+  option(UNIT_TEST_LIGHT "Unit tests light (expect module loading failures)" FALSE)
+
+  foreach(filename ${UNIT_TESTS})
+    message(STATUS "Adding test ${filename}")
+    add_test(${filename} chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/unit_test.inc ${CMAKE_CURRENT_SOURCE_DIR}/unittests/${filename})
+  endforeach(filename)
+
+  set_property(TEST ${UNIT_TESTS}
+   PROPERTY ENVIRONMENT
+    "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
+    "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+  )
+
+  if (NOT UNIT_TEST_LIGHT)
+    add_executable(utility_test unittests/utility_test.cpp)
+    target_link_libraries(utility_test ${LIBS})
+    add_test(NAME Utility_Test COMMAND utility_test)
+
+    add_executable(dynamic_object_test unittests/dynamic_object_test.cpp)
+    target_link_libraries(dynamic_object_test ${LIBS})
+    add_test(NAME Dynamic_Object_Test COMMAND dynamic_object_test)
+
+    add_executable(functor_creation_test unittests/functor_creation_test.cpp)
+    target_link_libraries(functor_creation_test ${LIBS})
+    add_test(NAME Functor_Creation_Test COMMAND functor_creation_test)
+
+    add_executable(functor_cast_test unittests/functor_cast_test.cpp)
+    target_link_libraries(functor_cast_test ${LIBS})
+    add_test(NAME Functor_Cast_Test COMMAND functor_cast_test)
+
+    add_executable(boxed_cast_test unittests/boxed_cast_test.cpp)
+    target_link_libraries(boxed_cast_test ${LIBS})
+    add_test(NAME Boxed_Cast_Test COMMAND boxed_cast_test)
+
+    add_executable(object_lifetime_test unittests/object_lifetime_test.cpp)
+    target_link_libraries(object_lifetime_test ${LIBS})
+    add_test(NAME Object_Lifetime_Test COMMAND object_lifetime_test)
+
+    add_executable(function_ordering_test unittests/function_ordering_test.cpp)
+    target_link_libraries(function_ordering_test ${LIBS})
+    add_test(NAME Function_Ordering_Test COMMAND function_ordering_test)
+
+    add_executable(type_info_test unittests/type_info_test.cpp)
+    target_link_libraries(type_info_test ${LIBS})
+    add_test(NAME Type_Info_Test COMMAND type_info_test)
+
+    add_executable(eval_catch_exception_test unittests/eval_catch_exception_test.cpp)
+    target_link_libraries(eval_catch_exception_test ${LIBS})
+    add_test(NAME Eval_Catch_Exception_Test COMMAND eval_catch_exception_test)
+
+    add_executable(short_comparison_test unittests/short_comparison_test.cpp)
+    target_link_libraries(short_comparison_test ${LIBS})
+    add_test(NAME Short_Comparison_Test COMMAND short_comparison_test)
+
+    add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
+    target_link_libraries(expected_eval_errors_test ${LIBS})
+    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})
+    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})
+    add_test(NAME Simultaneous_Chaiscript_Test COMMAND simultaneous_chaiscript_test)
+
+    add_executable(c_linkage_test unittests/c_linkage_test.cpp)
+    target_link_libraries(c_linkage_test ${LIBS})
+    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})
+    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})
+    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})
+      add_test(NAME Multithreaded_Test COMMAND multithreaded_test)
+      set_property(TEST Multithreaded_Test
+        PROPERTY ENVIRONMENT
+        "CHAI_USE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/unittests/"
+        "CHAI_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR}/"
+        )
+
+    endif()
+
+
+    add_executable(multifile_test unittests/multifile_test_main.cpp unittests/multifile_test_chai.cpp
+      unittests/multifile_test_module.cpp)
+    target_link_libraries(multifile_test ${LIBS})
+    add_test(NAME MultiFile_Test COMMAND multifile_test)
+
+    add_library(test_module MODULE src/test_module.cpp)
+    target_link_libraries(test_module ${LIBS})
+
+    install(TARGETS test_module RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript)
+  endif()
+endif(BUILD_TESTING)
+
+install(TARGETS chai ${MODULES} RUNTIME DESTINATION bin LIBRARY DESTINATION lib/chaiscript )
+
+install(DIRECTORY include/chaiscript DESTINATION include
+   PATTERN "*.hpp"
+   PATTERN "*/.svn*" EXCLUDE
+   PATTERN "*/.git*" EXCLUDE
+   PATTERN "*~" EXCLUDE)
+install(DIRECTORY unittests DESTINATION share/chaiscript
+   PATTERN "*.chai" 
+   PATTERN "*.inc"
+   PATTERN "*/.svn*" EXCLUDE
+   PATTERN "*/.git*" EXCLUDE
+   PATTERN "*~" EXCLUDE)
+install(DIRECTORY samples DESTINATION share/chaiscript
+   PATTERN "*.chai"
+   PATTERN "*/.svn*" EXCLUDE
+   PATTERN "*/.git*" EXCLUDE
+   PATTERN "*~" EXCLUDE)
+
+configure_file(contrib/pkgconfig/chaiscript.pc.in lib/pkgconfig/chaiscript.pc @ONLY)
+install(FILES "${chaiscript_BINARY_DIR}/lib/pkgconfig/chaiscript.pc"
+        DESTINATION lib/pkgconfig)
+

bin/placeholder.txt

@@ -1 +0,0 @@
-This is a placeholder

build_package.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo .
-make install
-
-INCLUDED_FILES="include/chaiscript/*.hpp include/chaiscript/dispatchkit/*.hpp include/chaiscript/language/*.hpp bin/chaiscript_eval"
-
-zip -r chaiscript-1.0.zip $INCLUDED_FILES

contrib/codeanalysis/heterogenous_array_loop.chai

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

contrib/codeanalysis/is_prime.chai

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

contrib/codeanalysis/profile_math.chai

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

contrib/geshi/chaiscript.php

@@ -0,0 +1,136 @@
+<?php
+/*************************************************************************************
+ * chaiscript.php
+ * --------------
+ * Author: Jason Turner & Jonathan Turner (based on JavaScript by Ben Keen (ben.keen@gmail.com))
+ * Copyright: (c) 2010 Jason Turner (jason@emptycrate.com) (c) 2009 Jonathan Turner 
+ *            (c) 2004 Ben Keen (ben.keen@gmail.com), Nigel McNie (http://qbnz.com/highlighter)
+ * Release Version: 1.0
+ * Date Started: 2009/07/03
+ *
+ * ChaiScript language file for GeSHi.
+ *
+ * CHANGES
+ * -------
+ * 2009/07/03 (1.0.0)
+ *  -  First Release
+ * 2010/03/30 (1.1.0)
+ *  -  Updated to include more language features and remove left over pieces from JavaScript
+ *
+ *************************************************************************************
+ *
+ *     This file is part of GeSHi.
+ *
+ *   GeSHi is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   GeSHi is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with GeSHi; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ ************************************************************************************/
+
+$language_data = array (
+    'LANG_NAME' => 'Chaiscript',
+    'COMMENT_SINGLE' => array(1 => '//'),
+    'COMMENT_MULTI' => array('/*' => '*/'),
+    //Regular Expressions
+    'COMMENT_REGEXP' => array(2 => "/(?<=[\\s^])s\\/(?:\\\\.|(?!\n)[^\\/\\\\])+\\/(?:\\\\.|(?!\n)[^\\/\\\\])+\\/[gimsu]*(?=[\\s$\\.\\;])|(?<=[\\s^(=])m?\\/(?:\\\\.|(?!\n)[^\\/\\\\])+\\/[gimsu]*(?=[\\s$\\.\\,\\;\\)])/iU"),
+    'CASE_KEYWORDS' => GESHI_CAPS_NO_CHANGE,
+    'QUOTEMARKS' => array("'", '"'),
+    'ESCAPE_CHAR' => '\\',
+    'KEYWORDS' => array(
+        1 => array(
+            'break', 'else', 'else if', 'eval', 'for', 'if', 'return', 'while', 'try', 'catch', 'finally', 'case', 'switch', 'default',
+            ),
+        2 => array(
+            'def', 'false', 'fun', 'true', 'var', 'attr',
+            ),
+        3 => array(
+            // built in functions
+            'throw', 
+            )
+        ),
+    'SYMBOLS' => array(
+        '(', ')', '[', ']', '{', '}',
+        '+', '-', '*', '/', '%',
+        '!', '@', '&', '|', '^',
+        '<', '>', '=',
+        ',', ';', '?', ':'
+        ),
+    'CASE_SENSITIVE' => array(
+        GESHI_COMMENTS => false,
+        1 => false,
+        2 => false,
+        3 => false
+        ),
+    'STYLES' => array(
+        'KEYWORDS' => array(
+            1 => 'color: #000066; font-weight: bold;',
+            2 => 'color: #003366; font-weight: bold;',
+            3 => 'color: #000066;'
+            ),
+        'COMMENTS' => array(
+            1 => 'color: #006600; font-style: italic;',
+            2 => 'color: #009966; font-style: italic;',
+            'MULTI' => 'color: #006600; font-style: italic;'
+            ),
+        'ESCAPE_CHAR' => array(
+            0 => 'color: #000099; font-weight: bold;'
+            ),
+        'BRACKETS' => array(
+            0 => 'color: #009900;'
+            ),
+        'STRINGS' => array(
+            0 => 'color: #3366CC;'
+            ),
+        'NUMBERS' => array(
+            0 => 'color: #CC0000;'
+            ),
+        'METHODS' => array(
+            1 => 'color: #660066;'
+            ),
+        'SYMBOLS' => array(
+            0 => 'color: #339933;'
+            ),
+        'REGEXPS' => array(
+            ),
+        'SCRIPT' => array(
+            0 => '',
+            1 => '',
+            2 => '',
+            3 => ''
+            )
+        ),
+    'URLS' => array(
+        1 => '',
+        2 => '',
+        3 => ''
+        ),
+    'OOLANG' => true,
+    'OBJECT_SPLITTERS' => array(
+        1 => '.'
+        ),
+    'REGEXPS' => array(
+        ),
+    'STRICT_MODE_APPLIES' => GESHI_MAYBE,
+    'SCRIPT_DELIMITERS' => array(
+        0 => array(
+            ),
+        1 => array(
+            )
+        ),
+    'HIGHLIGHT_STRICT_BLOCK' => array(
+        0 => true,
+        1 => true
+        )
+);
+
+?>

contrib/pkgconfig/chaiscript.pc.in

@@ -0,0 +1,12 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: chaiscript
+Description: ChaiScript is a scripting language that easily embeds into your existing C++ applications. It's built to be flexible and dynamic, yet still maintain the type-safety you expect as a C++ user. It can natively use classes, methods, and attributes, even if the class inherits functionality from a parent class. 
+Version: @CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@
+Requires:
+Conflicts:
+Libs: 
+Cflags: -I${includedir}

contrib/test/callbacktest.cpp

@@ -1,69 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
-// http://www.chaiscript.com
-
-#include <iostream>
-
-#include "function_call.hpp"
-#include "chaiscript.hpp"
-#include <boost/function.hpp>
-
-struct Callback_Handler
-{
-  typedef std::vector<std::pair<boost::function<std::string ()>,
-                        boost::function<double (int)> > > Callbacks;
-  
-  Callbacks m_callbacks;
-
-  void add_callbacks(boost::shared_ptr<dispatchkit::Proxy_Function> t_name,
-      boost::shared_ptr<dispatchkit::Proxy_Function> t_value)
-  {
-    m_callbacks.push_back(
-        std::make_pair(dispatchkit::build_function_caller<std::string ()>(t_name),
-                       dispatchkit::build_function_caller<double (int)>(t_value)
-          )
-        );
-  }
-
-  void do_callbacks()
-  {
-    int i=1;
-    for (Callbacks::iterator itr = m_callbacks.begin();
-         itr != m_callbacks.end();
-         ++itr)
-    {
-      std::cout << "Name: " << itr->first() << "  =  " << itr->second(i) << std::endl;
-      ++i;
-    }
-  }
-};
-
-int main(int argc, char *argv[]) {
-
-    chaiscript::ChaiScript_Engine chai;
-
-    Callback_Handler cb_handler;
-    chai.get_eval_engine().add_object("cb_handler", boost::ref(cb_handler));
-    dispatchkit::register_function(chai.get_eval_engine(), &Callback_Handler::add_callbacks, "add_callbacks");
-
-    for (int i = 1; i < argc; ++i) {
-      try {
-        dispatchkit::Boxed_Value val = chai.evaluate_file(argv[i]);
-      }
-      catch (std::exception &e) {
-        std::cerr << "Could not open: " << argv[i] << std::endl;
-        exit(1);
-      }
-    }
-
-    cb_handler.do_callbacks();
-
-    boost::function<std::string (const std::string&, const std::string &)> f = 
-      dispatchkit::build_functor<std::string (const std::string &, const std::string &)>
-        (chai, "function(x, y) { return x + y }");
-
-    std::cout << "Functor call: " << f("Hello", " World") << std::endl;
-}
-

contrib/test/dispatchkit_test.cpp

@@ -1,212 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
-// http://www.chaiscript.com
-
-#include <iostream>
-#include <string>
-#include <vector>
-#include <boost/shared_ptr.hpp>
-#include <boost/function.hpp>
-
-#include <chaiscript/dispatchkit/dispatchkit.hpp>
-#include <chaiscript/dispatchkit/bootstrap.hpp>
-#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
-#include <chaiscript/dispatchkit/function_call.hpp>
-
-using namespace dispatchkit;
-
-struct Test
-{
-  Test(const std::string &s)
-    : number(-25), message(s)
-  {
-    std::cout << "Test class constructed with value: " << s << std::endl;
-  }
-
-  void show_message()
-  {
-    std::cout << "Constructed Message: " << message << std::endl;
-  }
-
-  std::string &get_message()
-  {
-    return message;
-  }
-
-  int number;
-
-  std::string message;
-};
-
-
-
-Boxed_Value named_func_call(Dispatch_Engine &ss,
-    const std::string &nametocall, const std::vector<Boxed_Value> &params)
-{
-  if (params.size() == 2)
-  {
-    return dispatch(ss.get_function(nametocall), params);
-  } else {
-    throw std::runtime_error("Invalid num params");
-  }
-}
-
-// A function that takes a dynamic list of params
-// and calls a bunch of conversion functions on them and 
-// returns the result as a boxed_value
-Boxed_Value dynamic_function(Dispatch_Engine &ss, const std::string &name, 
-    const std::vector<Boxed_Value> &params)
-{
-  if (name == "concat_string")
-  {
-    Boxed_Value result;
-
-    //Return a void if there is nothing in the array
-    if (params.size() == 0)
-    {
-      return result;
-    } else {
-      //else, prepopulate the result with a string conversion of the first
-      //param
-      result = 
-        dispatch(ss.get_function("to_string"), Param_List_Builder() << params[0]);
-    }
-
-    //Then, loop over all remaining params, converting them to strings and adding
-    //them to the result. This example maybe bette served with a string += operator
-    //implementation, but it works.
-    for (size_t i = 1; i < params.size(); ++i)
-    {
-      result = 
-        dispatch(ss.get_function("+"), Param_List_Builder() << result << 
-            dispatch(ss.get_function("to_string"), Param_List_Builder() << params[i]));
-    }
-
-    return result;
-  } else {
-    throw std::runtime_error("Unknown function call");
-  }
-}
-
-void test(const std::string &p)
-{
-  std::cout << "Test: " << p << std::endl;
-}
-
-//Test main
-int main()
-{
-  Dispatch_Engine ss;
-  Bootstrap::bootstrap(ss);
-  bootstrap_vector<std::vector<int> >(ss, "VectorInt");
-  dump_system(ss);
-
-  //Calling a function by name and allowing the built in dispatch mechanism to
-  //choose the most appropriate version of the function
-  Boxed_Value addresult = dispatch(ss.get_function("+"), Param_List_Builder() << double(5.1) << double(10.3));
-
-  //Using the cast to unbox the resultant value and output it
-  std::cout << boxed_cast<double>(addresult) << std::endl;
-
-  //Using the Boxed_Value as input to another function, again with automatic dispatch.
-  //This time we will not bother saving the result and will instead send it straight out
-  std::cout << boxed_cast<double>(
-      dispatch(ss.get_function("*"), Param_List_Builder() << 2 << addresult)
-      ) << std::endl;
-
-  //Register a new function, this one with typing for us, so we don't have to ubox anything
-  //right here
-
-  //Now we have a print method, let's try to print out the earlier example:
-  //so, we dispatch the to_string and pass its result as a param to "print"
-  //In this example we don't bother with temporaries and we don't have to know
-  //anything about types
-  dispatch(ss.get_function("print_string"),
-      Param_List_Builder() << dispatch(ss.get_function("to_string"), Param_List_Builder() << addresult));
-
-  // Now we are going to register a new dynamic function,
-  // when this function is called the objects are not unboxed, but passed
-  // in in their boxed state
-  ss.register_function(boost::shared_ptr<Proxy_Function>(new Dynamic_Proxy_Function(boost::bind(&dynamic_function, boost::ref(ss), "concat_string", _1))), "concat_string");
-
-
-  // Call our newly defined dynamic function with 10 parameters, then send
-  // its output to the "print" function
-  dispatch(ss.get_function("print_string"),
-      Param_List_Builder() << dispatch(ss.get_function("concat_string"),
-        Param_List_Builder() << std::string("\n\t") << std::string("The Value Was: ") 
-                             << double(42.5) << std::string(".")
-                             << '\n'
-                             << '\t' << std::string("The old value was: ")
-                             << addresult << '.' << '\n' ));
-
-
-
-
-  //Register some local methods of the "Test" class
-  ss.register_function(build_constructor<Test, const std::string &>(), "Test");
-
-  register_function(ss, &Test::get_message, "get_message");
-  register_function(ss, &Test::show_message, "show_message");
-  register_member(ss, &Test::number, "number");
-
-  //Create a new object using the "Test" constructor, passing the param "Yo".
-  //Then, add the new object to the system with the name "testobj2"
-  ss.add_object("testobj2", 
-      dispatch(ss.get_function("Test"), Param_List_Builder() << std::string("Yo")));
-
-  // Look up and store a reference to our new object
-  std::vector<Boxed_Value> sos;
-  sos.push_back(ss.get_object("testobj2"));
-
-  //Build a bound function proxy for calling the script handled function
-  boost::function<void (Test &)> show_message = 
-    build_function_caller<void (Test &)>(ss.get_function("show_message"));
-
-  Test &t = boxed_cast<Test &>(ss.get_object("testobj2"));
-
-  //Print the message the object was created with
-  show_message(t);
-
-  //Now, get a reference to the object's stored message
-  Boxed_Value stringref = dispatch(ss.get_function("get_message"), sos);
-
-  //Unbox it using boxed_cast
-  std::string &sr = boxed_cast<std::string &>(stringref);
-
-  //Update the value of the reference
-  sr = "Bob Updated The message";
-
-  //Now, get a reference to the object's stored number
-  Boxed_Value numberref= dispatch(ss.get_function("number"), sos);
-
-  //Unbox it using boxed_cast
-  int &ir = boxed_cast<int &>(numberref);
-
-  std::cout << "Number: " << ir << std::endl;
-
-  //Now, prove that the reference was successfully acquired
-  //and we are able to peek into the boxed types
-  show_message(t);
-
-
-  // Finally, we are going to register some named function aliases, for 
-  // the fun of it
-  ss.register_function(boost::shared_ptr<Proxy_Function>(
-        new Dynamic_Proxy_Function(boost::bind(&named_func_call, boost::ref(ss), "+", _1))), "add");
-
-  //Call our newly named "add" function (which in turn dispatches +)
-  
-  std::cout << "Result of add function: " << 
-    boxed_cast<int>(dispatch(ss.get_function("add"), Param_List_Builder() << 5 << 2))
-    << std::endl; 
-
-
-  ss.set_object("myfunc", boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<boost::function<void (const std::string &)> >(&test)));
-
-  dispatch(ss.get_function("myfunc"), Param_List_Builder() << std::string("hello function variable"));
-
-}
-

contrib/test/dispatchkit_unittest.cpp

@@ -1,23 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
-// http://www.chaiscript.com
-
-#include "dispatchkit.hpp"
-#include "bootstrap.hpp"
-
-#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE boxedcpp_unittests
-#include <boost/test/unit_test.hpp>
-
-BOOST_AUTO_TEST_CASE( add_operators )
-{
-  using namespace dispatchkit;
-
-  Dispatch_Engine ss;
-  Bootstrap::bootstrap(ss);
-  dump_system(ss);
-
-  BOOST_CHECK_EQUAL(boxed_cast<int>(dispatch(ss.get_function("+"), Param_List_Builder() << double(5.1) << double(10.3))), 15.4);
-}

contrib/test/sensors.cpp

@@ -1,148 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
-// http://www.chaiscript.com
-
-#include <iostream>
-
-#include "chaiscript.hpp"
-#include "function_call.hpp"
-#include <boost/function.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/regex.hpp>
-
-
-std::string load_text_file(const std::string &filename)
-{
-  std::ifstream infile(filename.c_str());
-
-  std::string str;
-
-  std::string result;
-
-  while (std::getline(infile, str))
-  {
-    result += str + "\n";
-  }
-
-  return result;
-}
-
-std::vector<dispatchkit::Boxed_Value> regex_search(const std::string &str, const std::string &regex)
-{
-  boost::smatch matches;
-  boost::regex_search(str, matches, boost::regex(regex));
-
-  std::vector<dispatchkit::Boxed_Value> results;
-
-  for (unsigned int i = 0; i < matches.size(); ++i)
-  {
-    results.push_back(dispatchkit::Boxed_Value(std::string(matches.str(i))));
-  }
-
-  return results;
-}
-
-struct Sensor_Manager
-{
-  struct Sensor
-  {
-    int milliseconds;
-    dispatchkit::Boxed_Value state_object;
-    boost::function<double (dispatchkit::Boxed_Value)> sensor;
-    boost::posix_time::ptime next_run;
-
-    Sensor(int t_milliseconds, dispatchkit::Boxed_Value t_state_object, 
-        boost::function<double (dispatchkit::Boxed_Value)> t_sensor)
-      : milliseconds(t_milliseconds), state_object(t_state_object), sensor(t_sensor),
-        next_run(boost::posix_time::microsec_clock::universal_time() 
-            + boost::posix_time::milliseconds(milliseconds))
-    {
-    }
-
-    std::pair<boost::posix_time::ptime, double> get_value()
-    {
-      next_run = boost::posix_time::microsec_clock::universal_time() 
-            + boost::posix_time::milliseconds(milliseconds);
-
-      return std::make_pair(boost::posix_time::microsec_clock::universal_time(),
-          sensor(state_object));
-    }
-  };
-
-  std::map<std::string, Sensor> m_sensors;
-
-  //sensor_manager.add_sensor("CPU", 1000, global_state, function(state) { update_state(state); state["CPU"]; } )
-  void add_sensor(const std::string &t_name, int t_milliseconds, dispatchkit::Boxed_Value t_state_object,
-      boost::shared_ptr<dispatchkit::Proxy_Function> t_func)
-  {
-    m_sensors.insert(
-        std::make_pair(t_name, 
-          Sensor(t_milliseconds, t_state_object, 
-            dispatchkit::build_function_caller<double (dispatchkit::Boxed_Value)>(t_func)
-            )
-          )
-        );
-  }
-
-
-  std::vector<std::pair<std::string, double> > run_sensors()
-  {
-    std::vector<std::pair<std::string, double> > results;
-
-    boost::posix_time::ptime t(boost::posix_time::microsec_clock::universal_time());
-
-    for (std::map<std::string, Sensor>::iterator itr = m_sensors.begin();
-         itr != m_sensors.end();
-         ++itr)
-    {
-      if (itr->second.next_run <= t)
-      {
-        results.push_back(std::make_pair(itr->first, itr->second.get_value().second));
-      }
-    }
-
-    return results;
-  }
-
-};
-
-
-int main(int argc, char *argv[]) {
-
-  chaiscript::ChaiScript_Engine chai;
-
-  Sensor_Manager sensor_manager;
-  chai.get_eval_engine().add_object("sensor_manager", boost::ref(sensor_manager));
-
-  dispatchkit::register_function(chai.get_eval_engine(), &Sensor_Manager::add_sensor, "add_sensor");
-  dispatchkit::register_function(chai.get_eval_engine(), &regex_search, "regex_search");
-  dispatchkit::register_function(chai.get_eval_engine(), &load_text_file, "load_text_file");
-
-
-
-  for (int i = 1; i < argc; ++i) {
-    try {
-      chai.evaluate_file(argv[i]);
-    }
-    catch (std::exception &e) {
-      std::cerr << "Could not open: " << argv[i] << std::endl;
-      exit(1);
-    }
-  }
-
-  while (true)
-  {
-    usleep(1000);
-    std::vector<std::pair<std::string, double> > sensor_data = sensor_manager.run_sensors();
-
-    for (std::vector<std::pair<std::string, double> >::iterator itr = sensor_data.begin();
-         itr != sensor_data.end();
-         ++itr)
-    {
-      std::cout << "Sensor: " << itr->first << " value: " << itr->second << std::endl;
-    }
-  }
-}
-

contrib/vim/README.txt

@@ -0,0 +1,7 @@
+Install ftdetect, indent and syntax subdirectories to:
+
+~/.vim/
+
+See the vim documentation on this:
+
+http://vimdoc.sourceforge.net/htmldoc/syntax.html#mysyntaxfile

contrib/vim/ftdetect/chaiscript.vim

@@ -0,0 +1,2 @@
+au BufRead,BufNewFile *.chai            set filetype=chaiscript
+

contrib/vim/indent/chaiscript.vim

@@ -0,0 +1,50 @@
+" Vim indent file
+" Language:     ChaiScript
+" Maintainer:	Jason Turner <lefticus 'at' gmail com>
+
+" Only load this indent file when no other was loaded.
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetChaiScriptIndent()
+setlocal autoindent
+
+" Only define the function once.
+if exists("*GetChaiScriptIndent")
+  finish
+endif
+
+function! GetChaiScriptIndent()
+  " Find a non-blank line above the current line.
+  let lnum = prevnonblank(v:lnum - 1)
+
+  " Hit the start of the file, use zero indent.
+  if lnum == 0
+    return 0
+  endif
+
+  " Add a 'shiftwidth' after lines that start a block:
+  " lines containing a {
+  let ind = indent(lnum)
+  let flag = 0
+  let prevline = getline(lnum)
+  if prevline =~ '^.*{.*'
+    let ind = ind + &shiftwidth
+    let flag = 1
+  endif
+
+  " Subtract a 'shiftwidth' after lines containing a { followed by a }
+  " to keep it balanced
+  if flag == 1 && prevline =~ '.*{.*}.*'
+    let ind = ind - &shiftwidth
+  endif
+
+  " Subtract a 'shiftwidth' on lines ending with }
+  if getline(v:lnum) =~ '^\s*\%(}\)'
+    let ind = ind - &shiftwidth
+  endif
+
+  return ind
+endfunction

contrib/vim/syntax/chaiscript.vim

@@ -0,0 +1,99 @@
+" Vim syntax file
+" Language:	ChaiScript
+" Maintainer:	Jason Turner <lefticus 'at' gmail com>
+
+" Quit when a (custom) syntax file was already loaded
+if exists("b:current_syntax")
+  finish
+end
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+syn case match
+
+" syncing method
+syn sync fromstart
+
+" Strings
+syn region chaiscriptString        start=+"+ end=+"+ skip=+\\\\\|\\"+ contains=chaiscriptSpecial,chaiscriptEval,@Spell
+
+" Escape characters
+syn match  chaiscriptSpecial       contained "\\[\\abfnrtv\'\"]\|\\\d\{,3}"
+
+" String evals
+syn region chaiscriptEval          contained start="${" end="}"
+
+" integer number
+syn match  chaiscriptNumber        "\<\d\+\>"
+
+" floating point number, with dot, optional exponent
+syn match  chaiscriptFloat         "\<\d\+\.\d*\%(e[-+]\=\d\+\)\=\>"
+
+" floating point number, starting with a dot, optional exponent
+syn match  chaiscriptFloat         "\.\d\+\%(e[-+]\=\d\+\)\=\>"
+
+" floating point number, without dot, with exponent
+syn match  chaiscriptFloat         "\<\d\+e[-+]\=\d\+\>"
+
+" Hex strings
+syn match  chaiscriptNumber        "\<0x\x\+\>"
+
+" Binary strings
+syn match  chaiscriptNumber        "\<0b[01]\+\>"
+
+" Various language features
+syn keyword chaiscriptCond         if else
+syn keyword chaiscriptRepeat       while for do
+syn keyword chaiscriptStatement    break continue return switch case default
+syn keyword chaiscriptExceptions   try catch throw
+
+"Keyword
+syn keyword chaiscriptKeyword      def true false attr
+
+"Built in types
+syn keyword chaiscriptType         fun var
+
+"Built in funcs, keep it simple
+syn keyword chaiscriptFunc         eval throw
+
+"Let's treat all backtick operator function lookups as built in too
+syn region  chaiscriptFunc         matchgroup=chaiscriptFunc start="`" end="`"
+
+" Account for the "[1..10]" syntax, treating it as an operator
+" Intentionally leaving out all of the normal, well known operators
+syn match   chaiscriptOperator     "\.\."
+
+" Guard seperator as an operator
+syn match   chaiscriptOperator     ":"
+
+" Comments
+syn match   chaiscriptComment      "//.*$" contains=@Spell
+syn region  chaiscriptComment      matchgroup=chaiscriptComment start="/\*" end="\*/" contains=@Spell
+
+
+
+hi def link chaiscriptExceptions	Exception
+hi def link chaiscriptKeyword		Keyword
+hi def link chaiscriptStatement		Statement
+hi def link chaiscriptRepeat		Repeat
+hi def link chaiscriptString		String
+hi def link chaiscriptNumber		Number
+hi def link chaiscriptFloat		Float
+hi def link chaiscriptOperator		Operator
+hi def link chaiscriptConstant		Constant
+hi def link chaiscriptCond		Conditional
+hi def link chaiscriptFunction		Function
+hi def link chaiscriptComment		Comment
+hi def link chaiscriptTodo		Todo
+hi def link chaiscriptError		Error
+hi def link chaiscriptSpecial		SpecialChar
+hi def link chaiscriptFunc		Identifier
+hi def link chaiscriptType		Type
+hi def link chaiscriptEval	        Special
+
+let b:current_syntax = "chaiscript"
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+" vim: nowrap sw=2 sts=2 ts=8 noet

description.txt

@@ -0,0 +1 @@
+ChaiScript is a header-only C++ embedded scripting language loosely based on ECMA script. It is designed for ease of use and tight integration with C++. See http://www.chaiscript.com for more details.

include/chaiscript/chaiscript.hpp

@@ -1,27 +1,757 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HPP_
 #define CHAISCRIPT_HPP_
 
-#include <boost/bind.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/function.hpp>
 
-#include <stdexcept>
-#include <iostream>
-#include <map>
-#include <fstream>
-#include <boost/shared_ptr.hpp>
+
+/// \mainpage
+/// <a href="http://www.chaiscript.com">ChaiScript</a> is a scripting language designed specifically for integration with C++. It provides
+/// seamless integration with C++ on all levels, including shared_ptr objects, functors and exceptions.
+/// 
+/// The parts of the ChaiScript API that the average user will be concerned with are contained in the 
+/// chaiscript namespace and the chaiscript::ChaiScript class.
+///
+/// The end user parts of the API are extremely simple both in size and ease of use.
+///
+/// Currently, all source control and project management aspects of ChaiScript occur on <a href="http://www.github.com/ChaiScript/ChaiScript">github</a>.
+///
+/// <hr>
+/// 
+/// \sa chaiscript
+/// \sa chaiscript::ChaiScript
+/// \sa ChaiScript_Language for Built in Functions
+/// \sa \ref LangGettingStarted
+/// \sa \ref LangKeywordRef
+/// \sa \ref LangInPlaceRef
+/// \sa \ref LangObjectSystemRef
+/// \sa http://www.chaiscript.com
+/// \sa http://www.github.com/ChaiScript/ChaiScript
+///
+/// <hr>
+///
+/// \section gettingstarted API Getting Started
+///
+/// \li \ref basics
+/// \li \ref compiling
+/// \li \ref eval
+/// \li \ref addingitems
+/// \li \ref operatoroverloading
+/// \li \ref helpermacro
+/// \li \ref pointerconversions
+/// \li \ref baseclasses
+/// \li \ref functionobjects
+/// \li \ref threading
+/// \li \ref exceptions
+/// 
+/// 
+/// \subsection basics Basics
+/// 
+/// Basic simple example:
+///
+/// \code
+/// //main.cpp
+/// #include <chaiscript/chaiscript.hpp>
+/// 
+/// double function(int i, double j)
+/// {
+///   return i * j;
+/// }
+///
+/// int main()
+/// {
+///   chaiscript::ChaiScript chai;
+///   chai.add(&function, "function");
+///
+///   double d = chai.eval<double>("function(3, 4.75);");
+/// } 
+/// \endcode
+///
+/// <hr>
+/// \subsection compiling Compiling ChaiScript Applications
+///
+/// ChaiScript is a header only library with only two dependecies. boost::threads (optional) and the
+/// operating system provided dynamic library loader, which has to be specified on some platforms.
+/// 
+/// \subsubsection compilinggcc Compiling with GCC
+/// 
+/// To compile the above application on a Unix like operating system (MacOS, Linux) with GCC you need to link
+/// both boost::threads and the dynamic loader. For example:
+///
+/// \code
+/// gcc main.cpp -I/path/to/chaiscript/headers -ldl -lboost_threads
+/// \endcode
+///
+/// Alternatively, you may compile without threading support.
+///
+/// \code
+/// gcc main.cpp -I/path/to/chaiscript/headers -ldl -DCHAISCRIPT_NO_THREADS
+/// \endcode
+/// 
+/// <hr>
+/// \subsection eval Evaluating Scripts
+///
+/// Scripts can be evaluated with the () operator, eval method or eval_file method.
+///
+/// \subsubsection parenoperator () Operator
+///
+/// operator() can be used as a handy shortcut for evaluating ChaiScript snippets.
+/// \code
+/// chaiscript::ChaiScript chai;
+/// chai("print(\"hello world\")");
+/// \endcode
+/// 
+/// \sa chaiscript::ChaiScript::operator()(const std::string &)
+///
+/// \subsubsection evalmethod Method 'eval'
+/// 
+/// The eval method is somewhat more verbose and can be used to get typesafely return values
+/// from the script.
+///
+/// \code
+/// chaiscript::ChaiScript chai;
+/// chai.eval("callsomefunc()");
+/// int result = chai.eval<int>("1 + 3");
+/// // result now equals 4
+/// \endcode
+///
+/// \sa chaiscript::ChaiScript::eval
+///
+/// \subsubsection evalfilemethod Method 'eval_file'
+/// 
+/// The 'eval_file' method loads a file from disk and executes the script in it
+/// 
+/// \code
+/// chaiscript::ChaiScript chai;
+/// chai.eval_file("myfile.chai");
+/// std::string result = chai.eval_file<std::string>("myfile.chai") // extract the last value returned from the file
+/// \endcode
+/// 
+/// \sa chaiscript::ChaiScript::eval_file
+///
+/// <hr>
+/// \subsection addingitems Adding Items to ChaiScript
+///
+/// ChaiScript supports 4 basic things that can be added: objects, functions, type infos and Modules
+///
+/// \subsubsection addingobjects Adding Objects
+///
+/// Named objects can be created with the chaiscript::var function. Note: adding a object
+/// adds it to the current thread scope, not to a global scope. If you have multiple 
+/// threads that need to access the same variables you will need to add them
+/// separately for each thread, from the thread itself.
+/// 
+/// \code
+/// using namespace chaiscript;
+/// ChaiScript chai;
+/// int i = 5;
+/// chai.add(var(i), "i");
+/// chai("print(i)");
+/// \endcode
+///
+/// Immutable objects can be created with the chaiscript::const_var function.
+///
+/// \code
+/// chai.add(const_var(i), "i");
+/// chai("i = 5"); // exception throw, cannot assign const var
+/// \endcode
+/// 
+/// Named variables can only be accessed from the context they are created in.
+/// If you want a global variable, it must be const, and created with the 
+/// chaiscript::ChaiScript::add_global_const function.
+///
+/// \code
+/// chai.add_global_const(const_var(i), "i");
+/// chai("def somefun() { print(i); }; sumfun();");
+/// \endcode
+/// 
+/// \subsubsection addingfunctions Adding Functions
+/// 
+/// Functions, methods and members are all added using the same function: chaiscript::fun.
+///
+/// \code
+/// using namespace chaiscript;
+/// 
+/// class MyClass {
+///   public:
+///     int memberdata;
+///     void method();
+///     void method2(int);
+///     static void staticmethod();
+///     void overloadedmethod();
+///     void overloadedmethod(const std::string &);
+/// };
+/// 
+/// ChaiScript chai;
+/// chai.add(fun(&MyClass::memberdata), "memberdata");
+/// chai.add(fun(&MyClass::method), "method");
+/// chai.add(fun(&MyClass::staticmethod), "staticmethod");
+/// \endcode
+///
+/// Overloaded methods will need some help, to hint the compiler as to which overload you want:
+///
+/// \code
+/// chai.add(fun<void (MyClass::*)()>(&MyClass::overloadedmethod), "overloadedmethod");
+/// chai.add(fun<void (MyClass::*)(const std::string &)>(&MyClass::overloadedmethod), "overloadedmethod");
+/// \endcode
+///
+/// There are also shortcuts built into chaiscript::fun for binding up to the first two parameters of the function.
+/// 
+/// \code
+/// MyClass obj;
+/// chai.add(fun(&MyClass::method, &obj), "method");
+/// chai("method()"); // equiv to obj.method()
+/// chai.add(fun(&MyClass::method2, &obj, 3), "method2");
+/// chai("method2()"); // equiv to obj.method2(3)
+/// \endcode
+///
+/// \subsubsection addingtypeinfo Adding Type Info
+///
+/// ChaiScript will automatically support any type implicitly provided to it in the form
+/// of objects and function parameters / return types. However, it can be nice to let ChaiScript 
+/// know more details about the types you are giving it. For instance, the "clone" functionality
+/// cannot work unless there is a copy constructor registered and the name of the type is known
+/// (so that ChaiScript can look up the copy constructor).
+///
+/// Continuing with the example "MyClass" from above:
+///
+/// \code
+/// chai.add(user_type<MyClass>(), "MyClass");
+/// \endcode
+///
+/// \subsubsection addingmodules Adding Modules
+/// 
+/// Modules are holders for collections of ChaiScript registrations.
+///
+/// \code
+/// ModulePtr module = get_sum_module();
+/// chai.add(module);
+/// \endcode
+/// 
+/// \sa chaiscript::Module
+///
+/// <hr>
+/// \subsection operatoroverloading Operator Overloading
+/// 
+/// Operators are just like any other function in ChaiScript, to overload an operator, simply register it.
+/// 
+/// \code 
+/// class MyClass {
+///   MyClass operator+(const MyClass &) const;
+/// };
+///
+/// chai.add(fun(&MyClass::operator+), "+");
+///
+/// std::string append_string_int(const std::string &t_lhs, int t_rhs)
+/// {
+///   return t_lhs + boost::lexical_cast<std::string>(t_rhs);
+/// }
+///
+/// chai.add(fun(append_string_int), "+");
+/// \endcode
+///
+/// \sa \ref addingfunctions
+///
+/// <hr>
+/// \subsection helpermacro Class Helper Macro
+/// 
+/// Much of the work of adding new classes to ChaiScript can be reduced with the help
+/// of the CHAISCRIPT_CLASS helper macro.
+///
+/// \code
+/// class Test
+/// {
+///   public:
+///     void function() {}
+///     std::string function2() { return "Function2"; }
+///     void function3() {}
+///     std::string functionOverload(double) { return "double"; }
+///     std::string functionOverload(int) { return "int"; }
+/// };
+///
+/// int main()
+/// {
+///
+///   chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
+///
+///   CHAISCRIPT_CLASS( m, 
+///       Test,
+///       (Test ())
+///       (Test (const Test &)),
+///       ((function))
+///       ((function2))
+///       ((function3))
+///       ((functionOverload)(std::string (Test::*)(double)))
+///       ((functionOverload)(std::string (Test::*)(int)))
+///       ((operator=))
+///     );
+/// 
+///   chaiscript::ChaiScript chai;
+///   chai.add(m);
+/// }
+/// \endcode
+/// 
+/// \sa \ref addingmodules
+///
+/// <hr>
+/// \subsection pointerconversions Pointer / Object Conversions
+///
+/// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, boost::shared_ptr<T>,
+/// boost::shared_ptr<const T>, boost::reference_wrapper<T>, boost::reference_wrapper<const T> and value types automatically.
+///
+/// If a chaiscript::var object was created in C++ from a pointer, it cannot be convered to a shared_ptr (this would add invalid reference counting).
+/// Const may be added, but never removed. 
+///
+/// The take away is that you can pretty much expect function calls to Just Work when you need them to.
+///
+/// \code
+/// void fun1(const int *);
+/// void fun2(int *);
+/// void fun3(int);
+/// void fun4(int &);
+/// void fun5(const int &);
+/// void fun5(boost::shared_ptr<int>);
+/// void fun6(boost::shared_ptr<const int>);
+/// void fun7(const boost::shared_ptr<int> &);
+/// void fun8(const boost::shared_ptr<const int> &);
+/// void fun9(boost::reference_wrapper<int>);
+/// void fun10(boost::reference_wrapper<const int>);
+///
+/// int main()
+/// {
+///   using namespace chaiscript
+///   chaiscript::ChaiScript chai;
+///   chai.add(fun(fun1), "fun1");
+///   chai.add(fun(fun2), "fun2");
+///   chai.add(fun(fun3), "fun3");
+///   chai.add(fun(fun4), "fun4");
+///   chai.add(fun(fun5), "fun5");
+///   chai.add(fun(fun6), "fun6");
+///   chai.add(fun(fun7), "fun7");
+///   chai.add(fun(fun8), "fun8");
+///   chai.add(fun(fun9), "fun9");
+///   chai.add(fun(fun10), "fun10");
+///
+///   chai("var i = 10;");
+///   chai("fun1(i)");
+///   chai("fun2(i)");
+///   chai("fun3(i)");
+///   chai("fun4(i)");
+///   chai("fun5(i)");
+///   chai("fun6(i)");
+///   chai("fun7(i)");
+///   chai("fun8(i)");
+///   chai("fun9(i)");
+///   chai("fun10(i)");
+/// }  
+/// \endcode
+///
+/// See the unit test unittests/boxed_cast_test.cpp for a complete breakdown of the automatic casts that 
+/// available and tested.
+/// 
+/// <hr>
+/// \subsection baseclasses Base Classes
+/// 
+/// ChaiScript supports handling of passing a derived class object to a function expecting a base class object.
+/// For the process to work, the base/derived relationship must be registered with the engine.
+///
+/// \code
+/// class Base {};
+/// class Derived : public Base {};
+/// void myfunction(Base *b);
+///
+/// int main()
+/// {
+///   chaiscript::ChaiScript chai;
+///   chai.add(chaiscript::base_class<Base, Derived>());
+///   Derived d;
+///   chai.add(chaiscript::var(&d), "d");
+///   chai.add(chaiscript::fun(&myfunction), "myfunction");
+///   chai("myfunction(d)");
+/// }
+/// \endcode
+/// 
+/// <hr>
+///
+/// \subsection functionobjects Function Objects
+///
+/// Functions are first class objects in Chaiscript and ChaiScript supports automatic conversion
+/// between ChaiScript functions and boost::function objects.
+///
+/// \code
+/// void callafunc(const boost::function<void (const std::string &)> &t_func)
+/// {
+///   t_func("bob");
+/// }
+/// 
+/// int main()
+/// {
+///   chaiscript::ChaiScript chai;
+///   chai.add(chaiscript::fun(&callafunc), "callafunc");
+///   chai("callafunc(fun(x) { print(x); })"); // pass a lambda function to the registered function
+///                                            // which expects a typed boost::function
+///
+///   boost::function<void ()> f = chai.eval<boost::function<void ()> >("dump_system");
+///   f(); // call the ChaiScript function dump_system, from C++
+/// }
+/// \endcode
+/// 
+/// <hr>
+///
+/// \subsection threading Threading
+/// 
+/// Thread safety is automatically handled within the ChaiScript system. Objects can be added
+/// and scripts executed from multiple threads. For each thread that executes scripts, a new
+/// context is created and managed by the engine.
+/// 
+/// Thread safety can be disabled by defining CHAISCRIPT_NO_THREADS when using the library.
+///
+/// Disabling thread safety increases performance and removes the requirement for boost_threads.
+///
+/// <hr>
+///
+/// \subsection exceptions Exception Handling
+/// 
+/// \subsubsection exceptionsbasics Exception Handling Basics
+///
+/// Exceptions can be thrown in ChaiScript and caught in C++ or thrown in C++ and caught in 
+/// ChaiScript.
+///
+/// \code
+/// void throwexception()
+/// {
+///   throw std::runtime_error("err");
+/// }
+/// 
+/// int main()
+/// {
+///   // Throw in C++, catch in ChaiScript
+///   chaiscript::ChaiScript chai;
+///   chai.add(chaiscript::fun(&throwexception), "throwexception");
+///   chai("try { throwexception(); } catch (e) { print(e.what()); }"); // prints "err"
+/// 
+///   // Throw in ChaiScript, catch in C++
+///   try {
+///     chai("throw(1)");
+///   } catch (chaiscript::Boxed_Value bv) {
+///     int i = chaiscript::boxed_cast<int>(bv);
+///     // i == 1
+///   }
+/// }
+/// \endcode
+/// 
+/// \subsubsection exceptionsautomatic Exception Handling Automatic Unboxing
+///
+/// As an alternative to the manual unboxing of exceptions shown above, exception specifications allow the user to tell 
+/// ChaiScript what possible exceptions are expected from the script being executed. 
+///
+/// Example:
+/// \code
+/// chaiscript::ChaiScript chai;
+///
+/// try {
+///   chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
+/// } catch (const double e) {
+/// } catch (int) {
+/// } catch (float) {
+/// } catch (const std::string &) {
+/// } catch (const std::exception &e) {
+///   // This is the one what will be called in the specific throw() above
+/// }
+/// \endcode
+///
+/// \sa chaiscript::Exception_Handler for details on automatic exception unboxing 
+/// \sa chaiscript::exception_specification
+
+
+
+/// \page LangObjectSystemRef ChaiScript Language Object Model Reference
+///
+///
+/// ChaiScript has an object system built in, for types defined within the ChaiScript system.
+///
+/// \code
+/// attr Rectangle::height
+/// attr Rectangle::width
+/// def Rectangle::Rectangle() { this.height = 10; this.width = 20 }
+/// def Rectangle::area() { this.height * this.width }
+/// 
+/// var rect = Rectangle()
+/// rect.height = 30
+/// print(rect.area())
+/// \endcode
+///
+/// \sa \ref keywordattr
+/// \sa \ref keyworddef
+
+/// \page LangInPlaceRef ChaiScript Language In-Place Creation Reference
+/// \section inplacevector Vector
+/// 
+/// \code
+/// In-place Vector ::= "[" [expression ("," expression)*]  "]"
+/// \endcode
+///
+/// \section inplacerangedvector Ranged Vector
+///
+/// \code
+/// In-place Ranged Vector ::= "[" value ".." value "]"
+/// \endcode
+///
+/// Creates a vector over a range (eg. 1..10)
+///
+/// \section inplacemap Map
+///
+/// \code
+/// In-place Map ::= "[" (string ":" expression)+ "]"
+/// \endcode
+
+/// \page LangGettingStarted ChaiScript Language Getting Started
+/// 
+/// ChaiScript is a simple language that should feel familiar to anyone who knows
+/// C++ or ECMAScript (JavaScript). 
+///
+/// <hr>
+/// \section chaiscriptloops Loops
+///
+/// Common looping constructs exist in ChaiScript
+///
+/// \code
+/// var i = 0;
+/// while (i < 10)
+/// {
+///   // do something
+///   ++i;
+/// }
+/// \endcode
+///
+/// \code
+/// for (var i = 0; i < 10; ++i)
+/// {
+///   // do something
+/// }
+/// \endcode
+///
+/// \sa \ref keywordfor
+/// \sa \ref keywordwhile
+///
+/// <hr>
+/// \section chaiscriptifs Conditionals
+///
+/// If statements work as expected
+/// 
+/// \code
+/// var b = true;
+/// 
+/// if (b) {
+///   // do something
+/// } else if (c < 10) {
+///   // do something else
+/// } else {
+///   // or do this
+/// }
+/// \endcode
+///
+/// \sa \ref keywordif
+///
+/// <hr>
+/// \section chaiscriptfunctions Functions
+/// 
+/// Functions are defined with the def keyword
+/// 
+/// \code
+/// def myfun(x) { print(x); }
+///
+/// myfun(10);
+/// \endcode
+///
+/// Functions may have "guards" which determine if which is called.
+///
+/// \code
+/// eval> def myfun2(x) : x < 10 { print("less than 10"); }
+/// eval> def myfun2(x) : x >= 10 { print("10 or greater"); }
+/// eval> myfun2(5)
+/// less than 10
+/// eval> myfun2(12)
+/// 10 or greater
+/// \endcode
+/// 
+/// \sa \ref keyworddef
+/// \sa \ref keywordattr
+/// \sa \ref LangObjectSystemRef
+///
+/// <hr>
+/// \section chaiscriptfunctionobjects Function Objects
+/// 
+/// Functions are first class types in ChaiScript and can be used as variables.
+///
+/// \code
+/// eval> var p = print;
+/// eval> p(1);
+/// 1
+/// \endcode
+/// 
+/// They can also be passed to functions. 
+///
+/// \code
+/// eval> def callfunc(f, lhs, rhs) { return f(lhs, rhs); }
+/// eval> def dosomething(lhs, rhs) { print("lhs: ${lhs}, rhs: ${rhs}"); }
+/// eval> callfunc(dosomething, 1, 2);
+/// lhs: 1, rhs: 2
+/// \endcode
+///
+/// Operators can also be treated as functions by using the back tick operator. Building on the above example:
+/// 
+/// \code
+/// eval> callfunc(`+`, 1, 4);
+/// 5
+/// eval> callfunc(`*`, 3, 2);
+/// 6
+/// \endcode
+///
+/// <hr>
+/// \sa \ref LangKeywordRef
+/// \sa ChaiScript_Language for Built in Functions
+
+
+/// \page LangKeywordRef ChaiScript Language Keyword Reference
+///
+///
+/// <hr>
+/// \section keywordattr attr
+/// Defines a ChaiScript object attribute
+/// 
+/// \code 
+/// Attribute Definition ::= "attr" class_name "::" attribute_name
+/// \endcode
+///
+/// \sa \ref LangObjectSystemRef
+///
+/// <hr>
+/// \section keywordbreak break
+/// Stops execution of a looping block.
+///
+/// \code
+/// Break Statement ::= "break"
+/// \endcode
+///
+/// \sa \ref keywordfor
+/// \sa \ref keywordwhile 
+///
+///
+/// <hr>
+/// \section keyworddef def
+/// Begins a function or method definition
+///
+/// \code
+/// Function Definition ::= [annotation + CR/LF] "def" identifier "(" [arg ("," arg)*] ")" [":" guard] block
+/// Method Definition ::= [annotation + CR/LF] "def" class_name "::" method_name "(" [arg ("," arg)*] ")" [":" guard] block
+/// \endcode
+/// 
+/// annotation: meta-annotation on function, currently used as documentation. Optional.
+/// identifier: name of function. Required.
+/// args: comma-delimited list of parameter names. Optional.
+/// guards: guarding statement that act as a prerequisite for the function. Optional.
+/// { }: scoped block as function body. Required.
+///
+/// Functions return values in one of two ways:
+///
+/// By using an explicit return call, optionally passing the value to be returned.
+/// By implicitly returning the value of the last expression (if it is not a while or for loop).
+///
+/// Method definitions for known types extend those types with new methods. This includes C++ and ChaiScript defined types.
+/// Method definitions for unknown types implicitly define the named type.
+///
+/// \sa \ref LangObjectSystemRef
+///
+///
+/// <hr>
+/// \section keywordelse else
+/// \sa \ref keywordif 
+///
+///
+/// <hr>
+/// \section keywordfor for
+/// \code
+/// For Block ::= "for" "(" [initial] ";" stop_condition ";" loop_expression ")" block
+/// \endcode
+/// This loop can be broken using the \ref keywordbreak command.
+///
+///
+/// <hr>
+/// \section keywordfun fun
+/// Begins an anonymous function declaration (sometimes called a lambda).
+///
+/// \code
+/// Lambda ::= "fun" "(" [variable] ("," variable)*  ")" block
+/// \endcode
+///
+/// \b Examples:
+///
+/// \code
+/// // Generate an anonymous function object that adds 2 to its parameter
+/// var f = fun(x) { x + 2; }
+/// \endcode
+///
+/// \sa \ref keyworddef for more details on ChaiScript functions
+///
+///
+/// <hr>
+/// \section keywordif if
+/// Begins a conditional block of code that only executes if the condition evaluates as true.
+/// \code
+/// If Block ::= "if" "(" condition ")" block
+/// Else If Block ::= "else if" "(" condition ")" block
+/// Else Block ::= "else" block
+/// \endcode
+/// \b Example:
+/// \code
+/// if (true) {
+///   // do something
+/// } else if (false) {
+///   // do something else
+/// } else {
+///   // otherwise do this
+/// }
+/// \endcode
+///
+///
+/// <hr>
+/// \section keywordtry try
+/// \code
+/// Try Block ::= "try" block 
+///  ("catch" ["(" variable ")"] [":" guards] block)+ 
+///    ["finally" block]
+/// \endcode
+///
+/// \sa ChaiScript_Language::throw
+///
+/// <hr>
+/// \section keywordwhile while
+/// 
+/// Begins a conditional block of code that loops 0 or more times, as long as the condition is true
+///
+/// \code
+/// While Block ::= "while" "(" condition ")" block
+/// \endcode
+/// This loop can be broken using the \ref keywordbreak command.
+
+
+/// \namespace chaiscript
+/// \brief Namespace chaiscript contains every API call that the average user will be concerned with.
+
+/// \namespace chaiscript::detail
+/// \brief Classes and functions reserved for internal use. Items in this namespace are not supported.
 
 #include "dispatchkit/dispatchkit.hpp"
 #include "dispatchkit/bootstrap.hpp"
 #include "dispatchkit/bootstrap_stl.hpp"
 #include "dispatchkit/function_call.hpp"
 #include "dispatchkit/dynamic_object.hpp"
+#include "dispatchkit/boxed_number.hpp"
 
 #ifdef  BOOST_HAS_DECLSPEC
 #define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)

include/chaiscript/chaiscript_threading.hpp

@@ -1,19 +1,55 @@
-#ifndef __chaiscript_threading_hpp__
-#define __chaiscript_threading_hpp__
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_THREADING_HPP_
+#define CHAISCRIPT_THREADING_HPP_
 
 #ifndef CHAISCRIPT_NO_THREADS
-#include <boost/thread.hpp>
-#else
-#warning "ChaiScript is compiling without thread safety."
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#pragma clang diagnostic ignored "-Wshadow"
 #endif
+#include <boost/thread.hpp>
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+#else
+#pragma message ("ChaiScript is compiling without thread safety.")
+#endif
+
+/// \file
+///
+/// This file contains code necessary for thread support in ChaiScript.
+/// If the compiler definition CHAISCRIPT_NO_THREADS is defined then thread safety
+/// is disabled in ChaiScript. This has the result that some code is faster, because mutex locks are not required.
+/// It also has the side effect that the chaiscript::ChaiScript object may not be accessed from more than
+/// one thread simultaneously.
 
 namespace chaiscript
 {
+  namespace detail
+  {
+    /// If threading is enabled, then this namespace contains boost::thread classes.
+    /// If threading is not enabled, then stubbed in wrappers that do nothing are provided.
+    /// This allows us to avoid \#ifdef code in the sections that need thread safety.
     namespace threading
     {
 
 #ifndef CHAISCRIPT_NO_THREADS
+      using boost::unique_lock; 
+      using boost::shared_lock;
+      using boost::lock_guard;
+      using boost::shared_mutex;
+      using boost::recursive_mutex;
 
+
+      /// Typesafe thread specific storage. If threading is enabled, this class uses boost::thread_specific_ptr<T>. If
+      /// threading is not enabled, the class always returns the same data, regardless of which thread it is called from.
       template<typename T>
         class Thread_Storage
         {
@@ -43,6 +79,35 @@ namespace chaiscript
         };
 
 #else
+      template<typename T>
+      class unique_lock 
+      {
+        public:
+          unique_lock(T &) {}
+          void lock() {}
+          void unlock() {}
+      };
+
+      template<typename T>
+      class shared_lock 
+      {
+        public:
+          shared_lock(T &) {}
+          void lock() {}
+          void unlock() {}
+      };
+
+      template<typename T>
+      class lock_guard 
+      {
+        public:
+          lock_guard(T &) {}
+      };
+
+      class shared_mutex { };
+
+      class recursive_mutex {};
+
 
       template<typename T>
         class Thread_Storage
@@ -63,7 +128,7 @@ namespace chaiscript
         };
 
 #endif
-
+    }
   }
 }
 

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -0,0 +1,60 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
+#define CHAISCRIPT_BAD_BOXED_CAST_HPP_
+
+#include "type_info.hpp"
+
+namespace chaiscript 
+{
+  namespace exception
+  {
+    /// \brief Thrown in the event that a Boxed_Value cannot be cast to the desired type
+    ///
+    /// It is used internally during function dispatch and may be used by the end user.
+    ///
+    /// \sa chaiscript::boxed_cast
+    class bad_boxed_cast : public std::bad_cast
+    {
+      public:
+        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to,
+            const std::string &t_what) throw()
+          : from(t_from), to(&t_to), m_what(t_what)
+        {
+        }
+
+        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
+          : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
+        {
+        }
+
+        bad_boxed_cast(const std::string &t_what) throw()
+          : to(0), m_what(t_what)
+        {
+        }
+
+        virtual ~bad_boxed_cast() throw() {}
+
+        /// \brief Description of what error occured
+        virtual const char * what() const throw()
+        {
+          return m_what.c_str();
+        }
+
+        Type_Info from; ///< Type_Info contained in the Boxed_Value
+        const std::type_info *to; ///< std::type_info of the desired (but failed) result type
+
+      private:
+        std::string m_what;
+    };
+  }
+}
+
+
+
+#endif
+

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, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <boost/preprocessor.hpp>
@@ -10,8 +10,8 @@
 #define param(z,n,text) BOOST_PP_CAT(text, BOOST_PP_INC(n)) 
 
 #ifndef  BOOST_PP_IS_ITERATING
-#ifndef __bind_first_hpp__
-#define __bind_first_hpp__
+#ifndef CHAISCRIPT_BIND_FIRST_HPP_
+#define CHAISCRIPT_BIND_FIRST_HPP_
 
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
@@ -30,21 +30,40 @@
 
 namespace chaiscript
 {
- 
+  namespace detail
+  { 
+    /// \brief Helper function for binding the first parameter of a class method pointer. Used in chaiscript::fun overloads
+    ///        that take 1 or 2 parameters to pre-bind to the function.
+    ///
+    /// \param[in] f method pointer to bind
+    /// \param[in] o object to bind as first parameter 
+    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
     template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
       boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
       bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const O &o)
       {
-        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return boost::bind(boost::mem_fn(f), o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
       }
 
+    /// \brief Helper function for binding the first parameter of a const class method pointer. Used in chaiscript::fun overloads
+    ///        that take 1 or 2 parameters to pre-bind to the function.
+    ///
+    /// \param[in] f method pointer to bind
+    /// \param[in] o object to bind as first parameter 
+    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
     template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
       boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
       bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)) const, const O &o)
       {
-        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+        return boost::bind(boost::mem_fn(f), o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
       }
 
+    /// \brief Helper function for binding the first parameter of a function pointer. Used in chaiscript::fun overloads
+    ///        that take 1 or 2 parameters to pre-bind to the function.
+    ///
+    /// \param[in] f method pointer to bind
+    /// \param[in] o object to bind as first parameter 
+    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
     template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
       boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
       bind_first(Ret (*f)(BOOST_PP_ENUM_PARAMS(m, Param)), const O &o)
@@ -52,6 +71,12 @@ namespace chaiscript
         return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
       }
 
+    /// \brief Helper function for binding the first parameter of a boost::function object. Used in chaiscript::fun overloads
+    ///        that take 1 or 2 parameters to pre-bind to the function.
+    ///
+    /// \param[in] f method pointer to bind
+    /// \param[in] o object to bind as first parameter 
+    /// \returns a new boost::function object with one fewer parameters than the function passed in. 
     template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
       boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
       bind_first(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(m, Param))> &f, const O &o)
@@ -59,7 +84,11 @@ namespace chaiscript
         return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
       }
 
-
+  }
 }
 
+#undef n
+#undef m
+#undef param
+
 #endif

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,442 +1,46 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __bootstrap_hpp
-#define __bootstrap_hpp__
+#ifndef CHAISCRIPT_BOOTSTRAP_HPP_
+#define CHAISCRIPT_BOOTSTRAP_HPP_
 
 #include "dispatchkit.hpp"
 #include "dynamic_object.hpp"
 #include "register_function.hpp"
+#include "operators.hpp"
+#include "boxed_number.hpp"
+#include <boost/function_types/result_type.hpp>
+#include <sstream>
 
 namespace chaiscript 
 {
+  /// \brief Classes and functions useful for bootstrapping of ChaiScript and adding of new types
   namespace bootstrap
   {
     namespace detail
     {
-      /**
-      * Set of helper functions for common operators
-      */
-      template<typename Ret, typename P1, typename P2>
-      Ret add(P1 p1, P2 p2)
-      {
-        return p1 + p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret subtract(P1 p1, P2 p2)
-      {
-        return p1 - p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret divide(P1 p1, P2 p2)
-      {
-        return p1 / p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret multiply(P1 p1, P2 p2)
-      {
-        return p1 * p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret modulus(P1 p1, P2 p2)
-      {
-        return p1 % p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret shift_left(P1 p1, P2 p2)
-      {
-        return p1 << p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret shift_right(P1 p1, P2 p2)
-      {
-        return p1 >> p2;
-      }
-
-      template<typename P1, typename P2>
-      P1 &assign(P1 &p1, const P2 &p2)
-      {
-        return (p1 = p2);
-      }
-
-      template<typename P1, typename P2>
-      bool equals(P1 p1, P2 p2)
-      {
-        return p1 == p2;
-      }
-
-      template<typename P1, typename P2>
-      bool not_equals(P1 p1, P2 p2)
-      {
-        return p1 != p2;
-      }
-
-
-      template<typename P1, typename P2>
-      bool less_than(P1 p1, P2 p2)
-      {
-        return p1 < p2;
-      }
-
-      template<typename P1, typename P2>
-      bool greater_than(P1 p1, P2 p2)
-      {
-        return p1 > p2;
-      }
-
-      template<typename P1, typename P2>
-      bool less_than_equals(P1 p1, P2 p2)
-      {
-        return p1 <= p2;
-      }
-
-      template<typename P1, typename P2>
-      bool greater_than_equals(P1 p1, P2 p2)
-      {
-        return p1 >= p2;
-      }
-
-      template<typename P1, typename P2>
-      P1 &timesequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 *= p2);
-      }
-
-      template<typename P1, typename P2>
-      P1 &dividesequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 /= p2);
-      }
-
-      template<typename P1, typename P2>
-      P1 &addsequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 += p2);
-      }
-
-      template<typename P1, typename P2>
-      P1 &subtractsequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 -= p2);
-      }
-
+      /// \brief Constructs a new POD value object from a Boxed_Number
+      /// \param[in] v Boxed_Number to copy into the new object
+      /// \returns The newly created object.
       template<typename P1>
-      P1 &prefixincrement(P1 &p1)
+      boost::shared_ptr<P1> construct_pod(Boxed_Number v)
       {
-        return (++p1);
-      }
-
-      template<typename P1>
-      P1 &prefixdecrement(P1 &p1)
-      {
-        return (--p1);
-      }
-
-      template<typename P1>
-      P1 &prefixnegate(P1 &p1)
-      {
-        return (p1);
-      }
-
-      template<typename P1>
-      P1 &prefixnot(P1 &p1)
-      {
-        return (p1);
-      }
-
-      /* Special helpers for generating generic "POD" type operators
-      * The POD operators are needed for general support of C++ POD
-      * types without iterating out all possible combinations of operators
-      * (<, >, +, +=, *=, \=, -, <=, >=, ==) and types
-      * (char, uint8_t, int8_t, uint16_t, int16_t...)
-      */
-      template<typename P1>
-      P1 &assign_pod(P1 &p1, Boxed_POD_Value v)
-      {
-        if (v.m_isfloat)
-        {
-          return (p1 = P1(v.d));
-        } else {
-          return (p1 = P1(v.i));
+        boost::shared_ptr<P1> p(new P1());
+        Boxed_Value bv(p);
+        Boxed_Number nb(bv);
+        nb = v;
+        return p;
       }
     }
 
-      template<typename P1>
-      P1 construct_pod(Boxed_POD_Value v)
-      {
-        if (v.m_isfloat)
-        {
-          return P1(v.d);
-        } else {
-          return P1(v.i);
-        }    
-      }
-
-      template<typename P1>
-      P1 &timesequal_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.m_isfloat)
-        {
-          return p1 *= P1(r.d);
-        } else {
-          return p1 *= P1(r.i);
-        }
-      }
-
-      template<typename P1>
-      P1 &dividesequal_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.m_isfloat)
-        {
-          return p1 /= P1(r.d);
-        } else {
-          return p1 /= P1(r.i);
-        }
-      }
-
-      template<typename P1>
-      P1 &addsequal_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.m_isfloat)
-        {
-          return p1 += P1(r.d);
-        } else {
-          return p1 += P1(r.i);
-        }
-      }
-
-      template<typename P1>
-      P1 &subtractsequal_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.m_isfloat)
-        {
-          return p1 -= P1(r.d);
-        } else {
-          return p1 -= P1(r.i);
-        }
-      }
-    }
-
-    /**
-    * Add canonical form of "=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::equals<const T&, const T&>), "=");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "+" for type T
-    */
-    template<typename T>
-    ModulePtr oper_add(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::add<T, const T&, const T&>), "+");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "+=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_add_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::addsequal<T, T>), "+=");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "-" for type T
-    */
-    template<typename T>
-    ModulePtr oper_subtract(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::subtract<T, const T&, const T&>), "-");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "/" for type T
-    */
-    template<typename T>
-    ModulePtr oper_divide(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::divide<T, const T&, const T&>), "/");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "*" for type T
-    */
-    template<typename T>
-    ModulePtr oper_multiply(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::multiply<T, const T&, const T&>), "*");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "!=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_not_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::not_equals<const T&, const T&>), "!=");
-      return m;
-    }
-
-    /**
-    * Add user defined assignment operator for T = U
-    */
-    template<typename T, typename U>
-    ModulePtr oper_assign_overload(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::assign<T,U>), "=");
-      return m;
-    }
-
-
-    /**
-    * Add canonical form of "=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_assign(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::assign<T,T>), "=");
-      return m;
-    }
-
-
-    /**
-    * Add assignment operator for T = POD.
-    */
-    template<typename T>
-    ModulePtr oper_assign_pod(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::assign_pod<T>), "=");
-      return m;
-    }
-
-
-    /**
-    * Add canonical form of "<" for type T
-    */
-    template<typename T>
-    ModulePtr oper_less_than(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::less_than<const T&, const T&>), "<");
-      return m;
-    }
-
-    /**
-    * Add canonical form of ">" for type T
-    */
-    template<typename T>
-    ModulePtr oper_greater_than(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::greater_than<const T&, const T&>), ">");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "<=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_less_than_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::less_than_equals<const T&, const T&>), "<=");
-      return m;
-    }
-
-    /**
-    * Add canonical form of ">=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_greater_than_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::greater_than_equals<const T&, const T&>), ">=");
-      return m;
-    }
-
-    /**
-    * Add user defined comparison operators for T and R.
-    * Examples: T < R, T == R, etc.
-    */
-    template<typename T, typename R>
-    ModulePtr opers_comparison_overload(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::equals<const T&, const R&>), "==");
-      m->add(fun(&detail::not_equals<const T&, const R&>), "!=");
-      m->add(fun(&detail::less_than<const T&, const R&>), "<");
-      m->add(fun(&detail::greater_than<const T&, const R&>), ">");
-      m->add(fun(&detail::less_than_equals<const T&, const R&>), "<=");
-      m->add(fun(&detail::greater_than_equals<const T&, const R&>), ">=");
-      return m;
-    }
-
-    /**
-    * Add canonical forms of all comparison operators for type T
-    */
-    template<typename T>
-    ModulePtr opers_comparison(ModulePtr m = ModulePtr(new Module()))
-    {
-      opers_comparison_overload<T, T>(m);
-      return m;
-    }
-
-    /**
-    * Add all arithmetic operators that return a type of Ret, taking
-    * a lhs of T and a rhs of R, when possible.
-    * examples: Ret = T + R;
-    * ++T
-    * T *= R;
-    */
-    template<typename Ret, typename T, typename R>
-    ModulePtr opers_arithmetic_overload(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::add<Ret, T, R>), "+");
-      m->add(fun(&detail::subtract<Ret, T, R>), "-");
-      m->add(fun(&detail::divide<Ret, T, R>), "/");
-      m->add(fun(&detail::multiply<Ret, T, R>), "*");
-      m->add(fun(&detail::timesequal<T, R>), "*=");
-      m->add(fun(&detail::dividesequal<T, R>), "/=");
-      m->add(fun(&detail::subtractsequal<T, R>), "-=");
-      m->add(fun(&detail::addsequal<T, R>), "+=");
-      m->add(fun(&detail::prefixincrement<T>), "++");
-      m->add(fun(&detail::prefixdecrement<T>), "--");
-      m->add(fun(&detail::prefixnegate<T>), "-");
-      m->add(fun(&detail::prefixnot<T>), "!");
-      return m;
-    }
-
-    /**
-    * Add arithmetic assign operators for POD types:
-    * example: POD *= T, POD /= T
-    */
-    template<typename T>
-    ModulePtr opers_arithmetic_modify_pod(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::timesequal_pod<T>), "*=");
-      m->add(fun(&detail::dividesequal_pod<T>), "/=");
-      m->add(fun(&detail::subtractsequal_pod<T>), "-=");
-      m->add(fun(&detail::addsequal_pod<T>), "+=");
-      return m;
-    }
-
-    /**
-    * Add a copy constructor for type T
-    */
+    /// \brief Adds a copy constructor for the given type to the given Model
+    /// \param[in] type The name of the type. The copy constructor will be named "type".
+    /// \param[in,out] m The Module to add the copy constructor to
+    /// \tparam T The type to add a copy constructor for
+    /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
     template<typename T>
     ModulePtr copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
@@ -444,9 +48,31 @@ namespace chaiscript
       return m;
     }
 
-    /**
-    * Add default and copy constructors for type T
-    */
+    /// \brief Add all comparison operators for the templated type. Used during bootstrap, also available to users.
+    /// \tparam T Type to create comparison operators for
+    /// \param[in,out] m module to add comparison operators to
+    /// \returns the passed in ModulePtr or the newly constructed one if the default params are used.
+    template<typename T>
+    ModulePtr opers_comparison(ModulePtr m = ModulePtr(new Module()))
+    {
+      operators::equal<T>(m);
+      operators::greater_than<T>(m);
+      operators::greater_than_equal<T>(m);
+      operators::less_than<T>(m);
+      operators::less_than_equal<T>(m);
+      operators::not_equal<T>(m);
+      return m;
+    }
+
+
+
+    /// \brief Adds default and copy constructors for the given type
+    /// \param[in] type The name of the type to add the constructors for.
+    /// \param[in,out] m The Module to add the basic constructors to
+    /// \tparam T Type to generate basic constructors for
+    /// \returns The passed in ModulePtr, or the newly constructed one if the default param is used
+    /// \sa copy_constructor
+    /// \sa constructor
     template<typename T>
     ModulePtr basic_constructors(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
@@ -455,9 +81,10 @@ namespace chaiscript
       return m;
     }
 
-    /**
-    * Add POD type constructor for type T. ie: T = type(POD)
-    */
+    /// \brief Adds a constructor for a POD type 
+    /// \tparam T The type to add the constructor for
+    /// \param[in] type The name of the type
+    /// \param[in,out] m The Module to add the constructor to
     template<typename T>
     ModulePtr construct_pod(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
@@ -465,26 +92,6 @@ namespace chaiscript
       return m;
     }
 
-    /**
-    * add user defined single parameter constructor for type T.
-    * T = type(const U &)
-    */
-    template<typename T, typename U>
-    ModulePtr constructor_overload(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(constructor<T (const U &)>(), type);
-      return m;
-    }
-
-    /**
-    * Add canonical forms of all arithmetic operators for type T
-    */
-    template<typename T>
-    ModulePtr opers_arithmetic(ModulePtr m = ModulePtr(new Module()))
-    {
-      opers_arithmetic_overload<T, T, T>(m);
-      return m;
-    }
 
     /**
      * to_string function for internal use. Uses ostream operator<<
@@ -492,10 +99,11 @@ namespace chaiscript
     template<typename Input>
       std::string to_string(Input i)
       {
-      return boost::lexical_cast<std::string>(i);
+        std::stringstream ss;
+        ss << i;
+        return ss.str();
       }
 
-
     /**
      * Internal function for converting from a string to a value
      * uses ostream operator >> to perform the conversion
@@ -503,9 +111,17 @@ namespace chaiscript
     template<typename Input>
       Input parse_string(const std::string &i)
       {
-      return boost::lexical_cast<Input>(i);
+        std::stringstream ss(i);
+        Input t;
+        ss >> t;
+        return t;
       }
 
+
+
+     
+      
+            
     /**
     * Add all common functions for a POD type. All operators, and
     * common conversions
@@ -514,17 +130,15 @@ namespace chaiscript
     ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
     {
       m->add(user_type<T>(), name);
-      basic_constructors<T>(name, m);
-      oper_assign<T>(m);
-      oper_assign_pod<T>(m);
+      m->add(constructor<T ()>(), name);
       construct_pod<T>(name, m);
-      opers_arithmetic<T>(m);
-      opers_arithmetic_modify_pod<T>(m);
+
       m->add(fun(&to_string<T>), "to_string");
       m->add(fun(&parse_string<T>), "to_" + name);
       return m;
     }
 
+
     /**
     * "clone" function for a shared_ptr type. This is used in the case
     * where you do not want to make a deep copy of an object during cloning
@@ -556,15 +170,15 @@ namespace chaiscript
     * Similar to shared_ptr_clone. Used for Proxy_Function.
     */
     template<typename Type>
-    Boxed_Value ptr_assign(Boxed_Value lhs, const boost::shared_ptr<typename boost::add_const<Type>::type> &rhs)
+    Boxed_Value ptr_assign(Boxed_Value lhs, const boost::shared_ptr<Type> &rhs)
     {
-      if (lhs.is_unknown() 
+      if (lhs.is_undef() 
           || (!lhs.get_type_info().is_const() && lhs.get_type_info().bare_equal(chaiscript::detail::Get_Type_Info<Type>::get())))
       {
         lhs.assign(Boxed_Value(rhs));
         return lhs;
       } else {
-        throw bad_boxed_cast("type mismatch in pointer assignment");
+        throw exception::bad_boxed_cast("type mismatch in pointer assignment");
       }
     }
 
@@ -580,11 +194,11 @@ namespace chaiscript
       */
       static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs)
       {
-        if (lhs.is_unknown())
+        if (lhs.is_undef())
         {
           return (lhs.assign(rhs));
         } else {
-          throw bad_boxed_cast("boxed_value has a set type already");
+          throw exception::bad_boxed_cast("boxed_value has a set type already");
         }
       }
 
@@ -598,28 +212,47 @@ namespace chaiscript
         std::cout << s << std::endl;
       }
 
-      /**
-      * Add all comparison operators for POD types
-      */
-      static void opers_comparison_pod(ModulePtr m = ModulePtr(new Module()))
-      {
-        m->add(fun(&detail::equals<Boxed_POD_Value, Boxed_POD_Value>), "==");
-        m->add(fun(&detail::not_equals<Boxed_POD_Value, Boxed_POD_Value>), "!=");
-        m->add(fun(&detail::less_than<Boxed_POD_Value, Boxed_POD_Value>), "<");
-        m->add(fun(&detail::greater_than<Boxed_POD_Value, Boxed_POD_Value>), ">");
-        m->add(fun(&detail::less_than_equals<Boxed_POD_Value, Boxed_POD_Value>), "<=");
-        m->add(fun(&detail::greater_than_equals<Boxed_POD_Value, Boxed_POD_Value>), ">=");
-      }
 
       /**
       * Add all arithmetic operators for PODs
       */
       static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
       {
-        m->add(fun(&detail::add<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "+");
-        m->add(fun(&detail::subtract<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "-");
-        m->add(fun(&detail::divide<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "/");
-        m->add(fun(&detail::multiply<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "*");
+        m->add(fun(&Boxed_Number::equals), "==");
+        m->add(fun(&Boxed_Number::less_than), "<");
+        m->add(fun(&Boxed_Number::greater_than), ">");
+        m->add(fun(&Boxed_Number::greater_than_equal), ">=");
+        m->add(fun(&Boxed_Number::less_than_equal), "<=");
+        m->add(fun(&Boxed_Number::not_equal), "!=");
+
+        m->add(fun(&Boxed_Number::pre_decrement), "--");
+        m->add(fun(&Boxed_Number::pre_increment), "++");
+        m->add(fun(&Boxed_Number::sum), "+");
+        m->add(fun(&Boxed_Number::unary_plus), "+");
+        m->add(fun(&Boxed_Number::unary_minus), "-");
+        m->add(fun(&Boxed_Number::difference), "-");
+        m->add(fun(&Boxed_Number::assign_bitwise_and), "&=");
+        m->add(fun(&Boxed_Number::assign), "=");
+        m->add(fun(&Boxed_Number::assign_bitwise_or), "|=");
+        m->add(fun(&Boxed_Number::assign_bitwise_xor), "^=");
+        m->add(fun(&Boxed_Number::assign_remainder), "%=");
+        m->add(fun(&Boxed_Number::assign_shift_left), "<<=");
+        m->add(fun(&Boxed_Number::assign_shift_right), ">>=");
+        m->add(fun(&Boxed_Number::bitwise_and), "&");
+        m->add(fun(&Boxed_Number::bitwise_complement), "~");
+        m->add(fun(&Boxed_Number::bitwise_xor), "^");
+        m->add(fun(&Boxed_Number::bitwise_or), "|");
+        m->add(fun(&Boxed_Number::assign_product), "*=");
+        m->add(fun(&Boxed_Number::assign_quotient), "/=");
+        m->add(fun(&Boxed_Number::assign_sum), "+=");
+        m->add(fun(&Boxed_Number::assign_difference), "-=");
+        m->add(fun(&Boxed_Number::quotient), "/");
+        m->add(fun(&Boxed_Number::shift_left), "<<");
+        m->add(fun(&Boxed_Number::product), "*");
+        m->add(fun(&Boxed_Number::remainder), "%");
+        m->add(fun(&Boxed_Number::shift_right), ">>");
+
+
      }
 
       /**
@@ -631,36 +264,52 @@ namespace chaiscript
       {
         if (params.size() < 2)
         {
-          throw arity_error(params.size(), 2);
+          throw exception::arity_error(static_cast<int>(params.size()), 2);
         }
 
         Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
 
-        return Boxed_Value(Const_Proxy_Function(new Bound_Function(f,
+        return Boxed_Value(Const_Proxy_Function(new dispatch::Bound_Function(f,
           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)
+
+      static bool has_guard(const Const_Proxy_Function &t_pf)
       {
-        if (params.size() < 1)
+        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        if (pf)
         {
-          throw arity_error(params.size(), 1);
+          if (pf->get_guard()) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
       }
 
-        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 Const_Proxy_Function get_guard(const Const_Proxy_Function &t_pf)
+      {
+        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> pf = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_pf);
+        if (pf)
+        {
+          if (pf->get_guard())
+          {
+            return pf->get_guard();
+          } else {
+            throw std::runtime_error("Function does not have a guard");
+          }
+        } else {
+          throw std::runtime_error("Function does not have a guard");
+        }
       }
 
       static void throw_exception(const Boxed_Value &bv) {
         throw bv;
       }
       
-      static boost::shared_ptr<Dispatch_Engine> bootstrap2(boost::shared_ptr<Dispatch_Engine> e = boost::shared_ptr<Dispatch_Engine> (new Dispatch_Engine()))
+      static boost::shared_ptr<chaiscript::detail::Dispatch_Engine> bootstrap2(boost::shared_ptr<chaiscript::detail::Dispatch_Engine> e = boost::shared_ptr<chaiscript::detail::Dispatch_Engine> (new chaiscript::detail::Dispatch_Engine()))
       {
         e->add(user_type<void>(), "void");
         return e;
@@ -684,34 +333,97 @@ namespace chaiscript
         }
       }
 
+      template<typename FunctionType>
+        static std::vector<Boxed_Value> do_return_boxed_value_vector(FunctionType f,
+            const dispatch::Proxy_Function_Base *b)
+        {
+          typedef typename boost::function_types::result_type<FunctionType>::type Vector;
+          Vector v = (b->*f)();
+ 
+          std::vector<Boxed_Value> vbv;
+          for (typename Vector::const_iterator itr = v.begin();
+               itr != v.end();
+               ++itr)
+          {
+            vbv.push_back(const_var(*itr));
+          }
+
+          return vbv;
+        }
+
+      template<typename Function>
+      static boost::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
+      {
+        return boost::bind(&do_return_boxed_value_vector<Function>, f, _1);
+      }
+
     public:
-      /**
-      * perform all common bootstrap functions for std::string, void and POD types
-      */
+      /// \brief perform all common bootstrap functions for std::string, void and POD types
+      /// \param[in,out] m Module to add bootstrapped functions to
+      /// \returns passed in ModulePtr, or newly created one if default argument is used
       static ModulePtr bootstrap(ModulePtr m = ModulePtr(new Module()))
       {
         m->add(user_type<void>(), "void");
         m->add(user_type<bool>(), "bool");
         m->add(user_type<Boxed_Value>(), "Object");
-        m->add(user_type<Boxed_POD_Value>(), "PODObject");
-        m->add(user_type<Proxy_Function>(), "function");
+        m->add(user_type<Boxed_Number>(), "Number");
+        m->add(user_type<Proxy_Function>(), "Function");
         m->add(user_type<std::exception>(), "exception");
 
+        m->add(fun(&dispatch::Proxy_Function_Base::get_arity), "get_arity");
+        m->add(fun(&dispatch::Proxy_Function_Base::annotation), "get_annotation");
+        m->add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
+
+        
+        m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_param_types)), "get_param_types");
+        m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_contained_functions)), "get_contained_functions");
+
+
         m->add(user_type<std::runtime_error>(), "runtime_error");
+        m->add(chaiscript::base_class<std::exception, std::runtime_error>());
+ 
+
         m->add(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
         m->add(fun(boost::function<std::string (const std::runtime_error &)>(&what)), "what");     
 
-        m->add(user_type<Dynamic_Object>(), "Dynamic_Object");
-        m->add(constructor<Dynamic_Object (const std::string &)>(), "Dynamic_Object");
-        m->add(fun(&Dynamic_Object::get_type_name), "get_type_name");
-        m->add(fun(&Dynamic_Object::get_attrs), "get_attrs");
-        m->add(fun(&Dynamic_Object::get_attr), "get_attr");
+        m->add(user_type<dispatch::Dynamic_Object>(), "Dynamic_Object");
+        m->add(constructor<dispatch::Dynamic_Object (const std::string &)>(), "Dynamic_Object");
+        m->add(fun(&dispatch::Dynamic_Object::get_type_name), "get_type_name");
+        m->add(fun(&dispatch::Dynamic_Object::get_attrs), "get_attrs");
+        m->add(fun(&dispatch::Dynamic_Object::get_attr), "get_attr");
+
         m->eval("def Dynamic_Object::clone() { var new_o := Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
 
+        m->add(fun(&has_guard), "has_guard");
+        m->add(fun(&get_guard), "get_guard");
+
+        m->add(fun(&Boxed_Value::is_undef), "is_var_undef");
+        m->add(fun(&Boxed_Value::is_null), "is_var_null");
+        m->add(fun(&Boxed_Value::is_const), "is_var_const");
+        m->add(fun(&Boxed_Value::is_ref), "is_var_reference");
+        m->add(fun(&Boxed_Value::is_pointer), "is_var_pointer");
+        m->add(fun(&Boxed_Value::is_type), "is_type");
+
+        m->add(fun(&Boxed_Value::get_type_info), "get_type_info");
+        m->add(user_type<Type_Info>(), "Type_Info");
+
+
+        operators::equal<Type_Info>(m);
+
+        m->add(fun(&Type_Info::is_const), "is_type_const");
+        m->add(fun(&Type_Info::is_reference), "is_type_reference");
+        m->add(fun(&Type_Info::is_void), "is_type_void");
+        m->add(fun(&Type_Info::is_undef), "is_type_undef");
+        m->add(fun(&Type_Info::is_pointer), "is_type_pointer");
+        m->add(fun(&Type_Info::is_arithmetic), "is_type_arithmetic");
+        m->add(fun(&Type_Info::name), "cpp_name");
+        m->add(fun(&Type_Info::bare_name), "cpp_bare_name");
+        m->add(fun(&Type_Info::bare_equal), "bare_equal");
+
 
         basic_constructors<bool>("bool", m);
-        oper_assign<std::string>(m);
-        oper_assign<bool>(m);
+        operators::assign<bool>(m);
+        operators::equal<bool>(m);
 
         m->add(fun(&to_string<const std::string &>), "internal_to_string");
         m->add(fun(&Bootstrap::bool_to_string), "internal_to_string");
@@ -720,29 +432,37 @@ namespace chaiscript
         m->add(fun(&what), "what");
 
         bootstrap_pod_type<double>("double", m);
+        bootstrap_pod_type<long double>("long_double", m);
+        bootstrap_pod_type<float>("float", m);
         bootstrap_pod_type<int>("int", m);
+        bootstrap_pod_type<long>("long", m);
+        bootstrap_pod_type<unsigned int>("unsigned_int", m);
+        bootstrap_pod_type<unsigned long>("unsigned_long", m);
         bootstrap_pod_type<size_t>("size_t", m);
         bootstrap_pod_type<char>("char", m);
+        bootstrap_pod_type<boost::int8_t>("int8_t", m);
+        bootstrap_pod_type<boost::int16_t>("int16_t", m);
+        bootstrap_pod_type<boost::int32_t>("int32_t", m);
         bootstrap_pod_type<boost::int64_t>("int64_t", m);
+        bootstrap_pod_type<boost::uint8_t>("uint8_t", m);
+        bootstrap_pod_type<boost::uint16_t>("uint16_t", m);
+        bootstrap_pod_type<boost::uint32_t>("uint32_t", m);
+        bootstrap_pod_type<boost::uint64_t>("uint64_t", m);
+
+        operators::logical_compliment<bool>(m);
 
-        opers_comparison_pod(m);
         opers_arithmetic_pod(m);
 
-        m->add(fun(&detail::modulus<int, int, int>), "%");
-        m->add(fun(&detail::shift_left<int, int, int>), "<<");
-        m->add(fun(&detail::shift_right<int, int, int>), ">>");
 
         m->add(fun(&print), "print_string");
         m->add(fun(&println), "println_string");
 
-        m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&bind_function, _1))), 
+        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(boost::bind(&bind_function, _1))), 
           "bind");
 
-        m->add(fun(&shared_ptr_unconst_clone<Proxy_Function_Base>), "clone");
-        m->add(fun(&ptr_assign<Proxy_Function_Base>), "=");
-
-        m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), 
-          "call_exists");
+        m->add(fun(&shared_ptr_unconst_clone<dispatch::Proxy_Function_Base>), "clone");
+        m->add(fun(&ptr_assign<boost::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
+        m->add(fun(&ptr_assign<boost::add_const<dispatch::Proxy_Function_Base>::type>), "=");
 
         m->add(fun(&type_match), "type_match");
 

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -1,34 +1,35 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-/**
-* 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 __bootstrap_stl_hpp__
-#define __bootstrap_stl_hpp__
+
+#ifndef CHAISCRIPT_BOOTSTRAP_STL_HPP_
+#define CHAISCRIPT_BOOTSTRAP_STL_HPP_
 
 #include "dispatchkit.hpp"
 #include "register_function.hpp"
 
-
 namespace chaiscript 
 {
   namespace bootstrap
   {
-    /**
-    * 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
-    */
+    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
       template<typename Container>
         struct Bidir_Range
         {
+          typedef Container container_type;
           typedef typename std::iterator_traits<typename Container::iterator>::reference reference_type;
 
           Bidir_Range(Container &c)
@@ -83,128 +84,185 @@ namespace chaiscript
           typename Container::iterator m_end;
         };
 
-    template<typename Range>
-    struct Retro
+      template<typename Container>
+        struct Const_Bidir_Range
         {
-      Retro(const Range &r)
-        : m_r(r)
-      {}
+          typedef const Container container_type;
+          typedef typename std::iterator_traits<typename Container::const_iterator>::reference const_reference_type;
 
-      bool empty() { return m_r.empty(); }
-      void pop_front() { m_r.pop_back(); }
-      void pop_back() { m_r.pop_front(); }
-      typename Range::reference_type front() { return m_r.back(); }
-      typename Range::reference_type back() { return m_r.front(); }
+          Const_Bidir_Range(const Container &c)
+            : m_begin(c.begin()), m_end(c.end())
+          {
+          }
 
-    private:
-      Range m_r;
+          bool empty() const
+          {
+            return m_begin == m_end;
+          }
+
+          void pop_front()
+          {
+            if (empty())
+            {
+              throw std::range_error("Range empty");
+            }
+            ++m_begin;
+          }
+
+          void pop_back()
+          {
+            if (empty())
+            {
+              throw std::range_error("Range empty");
+            }
+            --m_end;
+          }
+
+          const_reference_type front() const
+          {
+            if (empty())
+            {
+              throw std::range_error("Range empty");
+            }
+            return *m_begin;
+          }
+
+          const_reference_type back() const
+          {
+            if (empty())
+            {
+              throw std::range_error("Range empty");
+            }
+            typename Container::const_iterator pos = m_end;
+            --pos;
+            return *(pos);
+          }
+
+          typename Container::const_iterator m_begin;
+          typename Container::const_iterator m_end;
         };
 
-
-    /**
-    * Add Bidir_Range support for the given ContainerType
-    */
-    template<typename ContainerType>
-    ModulePtr input_range_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+      namespace detail {
+        template<typename T>
+          int return_int_impl(const boost::function<typename T::size_type (const T *)> &t_func, const T *t_obj)
           {
-      m->add(user_type<Bidir_Range<ContainerType> >(), type + "_Range");
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
 
-      copy_constructor<Bidir_Range<ContainerType> >(type + "_Range", m);
+        template<typename T>
+        boost::function<int (const T *)> return_int(size_t (T::*t_func)() const)
+          {
+            return boost::bind(&return_int_impl<T>, boost::function<size_t (const T *)>(boost::mem_fn(t_func)), _1);
+          }
 
-      m->add(constructor<Bidir_Range<ContainerType> (ContainerType &)>(), "range");
+        template<typename T, typename P1>
+          int return_int_impl(const boost::function<typename T::size_type (const T *, P1)> &t_func, const T *t_obj, P1 p1)
+          {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj, p1);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
 
-      m->add(fun(&Bidir_Range<ContainerType>::empty), "empty");
-      m->add(fun(&Bidir_Range<ContainerType>::pop_front), "pop_front");
-      m->add(fun(&Bidir_Range<ContainerType>::front), "front");
-      m->add(fun(&Bidir_Range<ContainerType>::pop_back), "pop_back");
-      m->add(fun(&Bidir_Range<ContainerType>::back), "back");
+        template<typename T, typename P1>
+          int return_int_impl_non_const(const boost::function<typename T::size_type (T *, P1)> &t_func, T *t_obj, P1 p1)
+          {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj, p1);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
+
+        template<typename T, typename P1>
+        boost::function<int (const T *, P1)> return_int(size_t (T::*t_func)(P1) const)
+          {
+            return boost::bind(&return_int_impl<T, P1>, boost::function<size_t (const T *, P1)>(boost::mem_fn(t_func)), _1, _2);
+          }
+
+        template<typename T, typename P1>
+        boost::function<int (T *, P1)> return_int(size_t (T::*t_func)(P1) )
+          {
+            return boost::bind(&return_int_impl_non_const<T, P1>, boost::function<size_t (T*, P1)>(boost::mem_fn(t_func)), _1, _2);
+          }
+
+
+        template<typename T, typename P1, typename P2>
+          int return_int_impl(const boost::function<typename T::size_type (const T *, P1, P2)> &t_func, const T *t_obj, P1 p1, P2 p2)
+          {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4267)
+#endif
+            return t_func(t_obj, p1, p2);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+          }
+
+        template<typename StringType, StringType (StringType::*Func)(typename StringType::size_type, typename StringType::size_type) const >
+        StringType substr_helper(const StringType &str, int begin, int end)
+        {
+          return (str.*Func)(begin, end);
+        }
+
+        template<typename T, typename P1, typename P2>
+        boost::function<int (const T *, P1, P2)> return_int(size_t (T::*t_func)(P1, P2) const)
+          {
+            return boost::bind(&return_int_impl<T, P1, P2>, boost::function<size_t (const T *, P1, P2)>(boost::mem_fn(t_func)), _1, _2, _3);
+          }
+
+        template<typename T>
+          void insert(T &t_target, const T &t_other)
+          {
+            t_target.insert(t_other.begin(), t_other.end());
+          }
+
+        template<typename T>
+          void insert_ref(T &t_target, const typename T::value_type &t_val)
+          {
+            t_target.insert(t_val);
+          }
+
+
+
+
+
+        /// Add Bidir_Range support for the given ContainerType
+        template<typename Bidir_Type>
+          ModulePtr input_range_type_impl(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+          {
+            m->add(user_type<Bidir_Type>(), type + "_Range");
+
+            copy_constructor<Bidir_Type>(type + "_Range", m);
+
+            m->add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range");
+
+            m->add(fun(&Bidir_Type::empty), "empty");
+            m->add(fun(&Bidir_Type::pop_front), "pop_front");
+            m->add(fun(&Bidir_Type::front), "front");
+            m->add(fun(&Bidir_Type::pop_back), "pop_back");
+            m->add(fun(&Bidir_Type::back), "back");
 
             return m;
           } 
 
-    /**
-    * Add reversible_container concept to the given ContainerType
-    * http://www.sgi.com/tech/stl/ReversibleContainer.html
-    */
-    template<typename ContainerType>
-    ModulePtr reversible_container_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
-    {
-      return m;
-    }
 
-    /**
-    * 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()))
-    {
-      reversible_container_type<ContainerType>(type, m);
-      typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
-
-      //In the interest of runtime safety for the m, we prefer the at() method for [] access,
-      //to throw an exception in an out of bounds condition.
-      m->add(
-        fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(static_cast<indexoper>(&ContainerType::at))), "[]");
-
-      return m;
-    }
-
-    /**
-    * 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()))
-    {
-      basic_constructors<ContainerType>(type, m);
-      oper_assign<ContainerType>(m);
-      return m;
-    }
-
-    /**
-    * 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()))
-    {
-      assignable_type<ContainerType>(type, m);
-
-      m->add(fun<size_t (ContainerType::*)() const>(&ContainerType::size), "size");
-      m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
-      m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
-
-      return m;
-    }
-
-    /**
-    * Add forward container concept to the given ContainerType
-    * http://www.sgi.com/tech/stl/ForwardContainer.html
-    */
-    template<typename ContainerType>
-    ModulePtr forward_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      input_range_type<ContainerType>(type, m);
-      container_type<ContainerType>(type, m);
-
-      return m;
-    }
-
-    /**
-    * 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()))
-    {
-      m->add(constructor<Type ()>(), type);
-      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)
           {
@@ -220,9 +278,8 @@ namespace chaiscript
             container.insert(itr, v);
           }
 
-    /**
-    * Algorithm for erasing a specific position from a container
-    */
+
+        /// Algorithm for erasing a specific position from a container
         template<typename Type>
           void erase_at(Type &container, int pos)
           {
@@ -238,16 +295,79 @@ namespace chaiscript
             container.erase(itr);
           }      
         
-    /**
-    * 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()))
-    {
-      forward_container_type<ContainerType>(type, m);
-      default_constructible_type<ContainerType>(type, m);
+      }
 
+      template<typename ContainerType>
+        ModulePtr input_range_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        {
+          detail::input_range_type_impl<Bidir_Range<ContainerType> >(type,m);
+          detail::input_range_type_impl<Const_Bidir_Range<ContainerType> >("Const_" + type, m);
+          return m;
+        }
+
+
+      /// 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()))
+        {
+          typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
+          typedef typename ContainerType::const_reference(ContainerType::*constindexoper)(size_t) const;
+
+          //In the interest of runtime safety for the m, we prefer the at() method for [] access,
+          //to throw an exception in an out of bounds condition.
+          m->add(
+              fun(boost::function<typename ContainerType::reference (ContainerType *, int)>
+                (boost::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
+          m->add(
+              fun(boost::function<typename ContainerType::const_reference (const ContainerType *, int)>
+                (boost::mem_fn(static_cast<constindexoper>(&ContainerType::at)))), "[]");
+
+          return m;
+        }
+
+
+      /// 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()))
+        {
+          basic_constructors<ContainerType>(type, m);
+          operators::assign<ContainerType>(m);
+          return m;
+        }
+
+
+      /// Add container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/Container.html
+      template<typename ContainerType>
+        ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
+        {
+          boost::function<int (const ContainerType *)> f = detail::return_int(&ContainerType::size);
+          m->add(fun(f), "size");
+          m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
+          m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
+          return m;
+        }
+
+
+      /// Add default constructable concept to the given Type
+      /// http://www.sgi.com/tech/stl/DefaultConstructible.html
+      template<typename Type>
+        ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(constructor<Type ()>(), type);
+          return m;
+        }
+
+
+
+
+      /// 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()))
+        {
           std::string insert_name;
           if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
           {
@@ -256,22 +376,18 @@ namespace chaiscript
             insert_name = "insert_at";
           }
 
-      m->add(fun(&insert_at<ContainerType>), insert_name);
-      m->add(fun(&erase_at<ContainerType>), "erase_at");
+          m->add(fun(&detail::insert_at<ContainerType>), insert_name);
+          m->add(fun(&detail::erase_at<ContainerType>), "erase_at");
 
           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()))
+        ModulePtr back_insertion_sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-      sequence_type<ContainerType>(type, m);
-
-
           typedef typename ContainerType::reference (ContainerType::*backptr)();
 
           m->add(fun(static_cast<backptr>(&ContainerType::back)), "back");
@@ -284,22 +400,22 @@ namespace chaiscript
             push_back_name = "push_back";
           }
 
-      m->add(fun(&ContainerType::push_back), push_back_name);
+          typedef void (ContainerType::*pushback)(const typename ContainerType::value_type &);
+          m->add(fun(static_cast<pushback>(&ContainerType::push_back)), push_back_name);
           m->add(fun(&ContainerType::pop_back), "pop_back");
           return m;
         }
 
 
-    /**
-     *Front insertion sequence
-     *http://www.sgi.com/tech/stl/FrontInsertionSequence.html
-     */
-    template<typename ContainerType>
-    ModulePtr front_insertion_sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      sequence_type<ContainerType>(type, m);
 
+      /// 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()))
+        {
           typedef typename ContainerType::reference (ContainerType::*frontptr)();
+          typedef void (ContainerType::*pushptr)(typename ContainerType::const_reference);
+          typedef void (ContainerType::*popptr)();
 
           m->add(fun(static_cast<frontptr>(&ContainerType::front)), "front");
 
@@ -310,60 +426,26 @@ namespace chaiscript
           } else {
             push_front_name = "push_front";
           }
-      m->add(fun(&ContainerType::push_front), push_front_name);
-      m->add(fun(&ContainerType::pop_front), "pop_front");
+
+          m->add(fun(static_cast<pushptr>(&ContainerType::push_front)), push_front_name);
+          m->add(fun(static_cast<popptr>(&ContainerType::pop_front)), "pop_front");
           return m;
         }
 
-    /**
-     * 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()))
-    {
-      m->add(user_type<ListType>(), type);
-      front_insertion_sequence_type<ListType>(type, m);
-      back_insertion_sequence_type<ListType>(type, m);
-      return m;
-    }
 
-    /**
-    * 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()))
-    {
-      m->add(user_type<VectorType>(), type);
-      random_access_container_type<VectorType>(type, m);
-      back_insertion_sequence_type<VectorType>(type, m);
-      return m;
-    }
-
-    /**
-    * Create a vector type with associated concepts
-    * http://www.sgi.com/tech/stl/Vector.html
-    */
-    template<typename ContainerType>
-    ModulePtr associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      forward_container_type<ContainerType>(type, m);
-      default_constructible_type<ContainerType>(type, m);
-      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()))
         {
           m->add(user_type<PairType>(), type);
 
-      m->add(fun(&PairType::first), "first");
-      m->add(fun(&PairType::second), "second");
+
+          typename PairType::first_type PairType::* f = &PairType::first;
+          typename PairType::second_type PairType::* s = &PairType::second;
+
+          m->add(fun(f), "first");
+          m->add(fun(s), "second");
 
           basic_constructors<PairType>(type, m);
           m->add(constructor<PairType (const typename PairType::first_type &, const typename PairType::second_type &)>(), type);
@@ -372,89 +454,172 @@ 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()))
         {
-      associative_container_type<ContainerType>(type, m);
           pair_type<typename ContainerType::value_type>(type + "_Pair", m);
 
           return m;
         }
 
-    /**
-    * 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()))
-    {
-      associative_container_type<ContainerType>(type, m);
-      m->add(fun<size_t (ContainerType::*)(const typename ContainerType::key_type &) const>(&ContainerType::count), "count");
 
+      /// Add unique associative container concept to the given ContainerType
+      /// http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
+      template<typename ContainerType>
+        ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(boost::function<int (const ContainerType *, const typename ContainerType::key_type &)>(detail::return_int(&ContainerType::count))), "count");
+
+
+          typedef size_t (ContainerType::*erase)(const typename ContainerType::key_type &);
+          erase eraseptr(&ContainerType::erase);
+
+          m->add(fun(boost::function<int (ContainerType *, const typename ContainerType::key_type &)>(detail::return_int(eraseptr))), "erase");
+
+          m->add(fun(&detail::insert<ContainerType>), "insert");
+
+          std::string insert_name;
+          if (typeid(typename ContainerType::mapped_type) == typeid(Boxed_Value))
+          {
+            insert_name = "insert_ref";
+          } else {
+            insert_name = "insert";
+          }
+
+          m->add(fun(&detail::insert_ref<ContainerType>), insert_name);
           return m;
         }
 
-    /**
-    * Add sorted associative container concept to the given ContainerType
-    * http://www.sgi.com/tech/stl/SortedAssociativeContainer.html
-    */
-    template<typename ContainerType>
-    ModulePtr sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator> 
-        (ContainerType::*eq_range)(const typename ContainerType::key_type &);
 
-      reversible_container_type<ContainerType>(type, m);
-      associative_container_type<ContainerType>(type, m);
-
-      return m;
-    }
-
-    /**
-    * Add unique sorted associative container concept to the given ContainerType
-    * http://www.sgi.com/tech/stl/UniqueSortedAssociativeContainer.html
-    */
-    template<typename ContainerType>
-    ModulePtr unique_sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
-    {
-      sorted_associative_container_type<ContainerType>(type, m);
-      unique_associative_container_type<ContainerType>(type, m);
-
-      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()))
         {
           m->add(user_type<MapType>(), type);
-      m->add(fun(&MapType::operator[]), "[]");
-      unique_sorted_associative_container_type<MapType>(type, m);
+
+          typedef typename MapType::mapped_type &(MapType::*elemaccess)(const typename MapType::key_type &);
+
+          m->add(fun(static_cast<elemaccess>(&MapType::operator[])), "[]");
+
+          container_type<MapType>(type, m);
+          assignable_type<MapType>(type, m);
+          unique_associative_container_type<MapType>(type, m);
           pair_associative_container_type<MapType>(type, m);
+          input_range_type<MapType>(type, m);
 
           return m;
         }
 
-    /**
-    * Add a String container
-    * http://www.sgi.com/tech/stl/basic_string.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()))
+        {
+          m->add(user_type<ListType>(), type);
+
+          front_insertion_sequence_type<ListType>(type, m);
+          back_insertion_sequence_type<ListType>(type, m);
+          sequence_type<ListType>(type, m);
+          container_type<ListType>(type, m);
+          default_constructible_type<ListType>(type, m);
+          assignable_type<ListType>(type, m);
+          input_range_type<ListType>(type, m);
+
+          return m;
+        }
+
+
+      /// 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()))
+        {
+          m->add(user_type<VectorType>(), type);
+
+          typedef typename VectorType::reference (VectorType::*frontptr)();
+          m->add(fun(static_cast<frontptr>(&VectorType::front)), "front");
+
+
+          back_insertion_sequence_type<VectorType>(type, m);
+          sequence_type<VectorType>(type, m);
+          random_access_container_type<VectorType>(type, m);
+          container_type<VectorType>(type, m);
+          default_constructible_type<VectorType>(type, m);
+          assignable_type<VectorType>(type, m);
+          input_range_type<VectorType>(type, m);
+
+          if (typeid(VectorType) == typeid(std::vector<Boxed_Value>))
+          {
+            m->eval("def Vector::`==`(rhs) : type_match(rhs, this) { \
+                       if ( rhs.size() != this.size() ) {    \
+                         return false;  \
+                       } else {  \
+                         var r1 = range(this); \
+                         var r2 = range(rhs);  \
+                         while (!r1.empty()) \
+                         {  \
+                           if (!eq(r1.front(), r2.front())) \
+                           {  \
+                             return false; \
+                           } \
+                           r1.pop_front(); \
+                           r2.pop_front(); \
+                         } \
+                       return true; \
+                     } \
+                   }");
+          } 
+
+          return m;
+        }
+
+        namespace detail {
+          template<typename String>
+          struct apple_string_workarounds
+          {
+            /// The latest version of MacOS has a broken std::string implementation which will not allow
+            /// us to take pointers to the members. Code compiles, but does not link
+            /// \todo re-evaluate at some point
+
+            static size_t find(const String *s, const String &w, int pos) { return s->find(w, pos); }
+            static size_t rfind(const String *s, const String &w, size_t pos) { return s->rfind(w, pos); }
+            static size_t find_first_of(const String *s, const String &w, size_t pos) { return s->find_first_of(w, pos); }
+            static size_t find_last_of(const String *s, const String &w, size_t pos) { return s->find_last_of(w, pos); }
+            static size_t find_first_not_of(const String *s, const String &w, size_t pos) { return s->find_first_not_of(w, pos); }
+            static size_t find_last_not_of(const String *s, const String &w, size_t pos) { return s->find_last_not_of(w, pos); }
+
+            static void clear(String *s) { s->clear(); }
+            static bool empty(const String *s) { return s->empty(); }
+            static size_t size(const String *s) { return s->size(); }
+ 
+            static std::string substr(const String *s, size_t pos, size_t len) { return s->substr(pos,len); }
+            static const char *c_str(const String *s) {  return s->c_str(); }
+            static const char *data(const String *s) { return s->data(); }
+          };
+        }
+
+
+      /// Add a String container
+      /// http://www.sgi.com/tech/stl/basic_string.html
       template<typename String>
         ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
         {
           m->add(user_type<String>(), type);
-      oper_add<String>(m);
-      oper_add_equals<String>(m);
+          operators::addition<String>(m);
+          operators::assign_sum<String>(m);
           opers_comparison<String>(m);
           random_access_container_type<String>(type, m);
           sequence_type<String>(type, m);
+          default_constructible_type<String>(type, m);
+          // container_type<String>(type, m);
+          assignable_type<String>(type, m);
+          input_range_type<String>(type, m);
 
           //Special case: add push_back to string (which doesn't support other back_insertion operations
           std::string push_back_name;
@@ -466,17 +631,26 @@ namespace chaiscript
           }
           m->add(fun(&String::push_back), push_back_name);
 
-      typedef typename String::size_type (String::*find_func)(const String &, typename String::size_type) const;
-      m->add(fun(static_cast<find_func>(&String::find)), "find");
-      m->add(fun(static_cast<find_func>(&String::rfind)), "rfind");
-      m->add(fun(static_cast<find_func>(&String::find_first_of)), "find_first_of");
-      m->add(fun(static_cast<find_func>(&String::find_last_of)), "find_last_of");
-      m->add(fun(static_cast<find_func>(&String::find_first_not_of)), "find_first_not_of");
-      m->add(fun(static_cast<find_func>(&String::find_last_not_of)), "find_last_not_of");
+            
+          m->add(fun(&detail::apple_string_workarounds<String>::find), "find");
+          m->add(fun(&detail::apple_string_workarounds<String>::rfind), "rfind");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_first_of), "find_first_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_last_of), "find_last_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_first_not_of), "find_first_not_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::find_last_not_of), "find_last_not_of");
+          m->add(fun(&detail::apple_string_workarounds<String>::clear), "clear");
+          m->add(fun(&detail::apple_string_workarounds<String>::size), "size");
+          m->add(fun(&detail::apple_string_workarounds<String>::empty), "empty");
+          m->add(fun(&detail::apple_string_workarounds<String>::substr), "substr");
+          m->add(fun(&detail::apple_string_workarounds<String>::c_str), "c_str");
+          m->add(fun(&detail::apple_string_workarounds<String>::data), "data");
+
 
           return m;
         }
     }
   }
+}
+
 
 #endif

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -0,0 +1,112 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_BOXED_CAST_HPP_
+#define CHAISCRIPT_BOXED_CAST_HPP_
+
+#include "type_info.hpp"
+#include "boxed_value.hpp"
+#include "boxed_cast_helper.hpp"
+#include "dynamic_cast_conversion.hpp"
+
+#include "../chaiscript_threading.hpp"
+#include <boost/shared_ptr.hpp>
+#include <boost/any.hpp>
+#include <boost/function.hpp>
+#include <boost/ref.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/integer_traits.hpp>
+
+namespace chaiscript 
+{
+ 
+  /// \brief Function for extracting a value stored in a Boxed_Value object
+  /// \tparam Type The type to extract from the Boxed_Value
+  /// \param[in] bv The Boxed_Value to extract a typed value from
+  /// \returns Type equivalent to the requested type 
+  /// \throws exception::bad_boxed_cast If the requested conversion is not possible
+  /// 
+  /// boxed_cast will attempt to make conversions between value, &, *, boost::shared_ptr, boost::reference_wrapper,
+  /// and boost::function (const and non-const) where possible. boxed_cast is used internally during function
+  /// dispatch. This means that all of these conversions will be attempted automatically for you during
+  /// ChaiScript function calls.
+  ///
+  /// \li non-const values can be extracted as const or non-const
+  /// \li const values can be extracted only as const
+  /// \li Boxed_Value constructed from pointer or boost::reference_wrapper can be extracted as reference,
+  ///     pointer or value types
+  /// \li Boxed_Value constructed from boost::shared_ptr or value types can be extracted as reference,
+  ///     pointer, value, or boost::shared_ptr types
+  ///
+  /// Conversions to boost::function objects are attempted as well
+  ///
+  /// Example:
+  /// \code
+  /// // All of the following should succeed
+  /// chaiscript::Boxed_Value bv(1);
+  /// boost::shared_ptr<int> spi = chaiscript::boxed_cast<boost::shared_ptr<int> >(bv);
+  /// int i = chaiscript::boxed_cast<int>(bv);
+  /// int *ip = chaiscript::boxed_cast<int *>(bv);
+  /// int &ir = chaiscript::boxed_cast<int &>(bv);
+  /// boost::shared_ptr<const int> cspi = chaiscript::boxed_cast<boost::shared_ptr<const int> >(bv);
+  /// const int ci = chaiscript::boxed_cast<const int>(bv);
+  /// const int *cip = chaiscript::boxed_cast<const int *>(bv);
+  /// const int &cir = chaiscript::boxed_cast<const int &>(bv);
+  /// \endcode
+  ///
+  /// boost::function conversion example
+  /// \code
+  /// chaiscript::ChaiScript chai;
+  /// Boxed_Value bv = chai.eval("`+`"); // Get the functor for the + operator which is built in 
+  /// boost::function<int (int, int)> f = chaiscript::boxed_cast<boost::function<int (int, int)> >(bv);
+  /// int i = f(2,3);
+  /// assert(i == 5);
+  /// \endcode
+  template<typename Type>
+  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions = 0)
+  {
+    try {
+      return detail::Cast_Helper<Type>::cast(bv, t_conversions);
+    } catch (const boost::bad_any_cast &) {
+
+#ifdef BOOST_MSVC
+      //Thank you MSVC, yes we know that a constant value is being used in the if
+      // statment in THIS VERSION of the template instantiation
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+      if (boost::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value && 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(t_conversions->boxed_dynamic_cast<Type>(bv), t_conversions);
+        } catch (const boost::bad_any_cast &) {
+          throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+        }
+      } else {
+        // If it's not polymorphic, just throw the error, don't waste the time on the 
+        // attempted dynamic_cast
+        throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
+      }
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+
+    } 
+  }
+
+}
+
+
+
+#endif
+

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -0,0 +1,275 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
+#define CHAISCRIPT_BOXED_CAST_HELPER_HPP_
+
+#include "type_info.hpp"
+#include "boxed_value.hpp"
+
+#include <boost/shared_ptr.hpp>
+#include <boost/any.hpp>
+#include <boost/ref.hpp>
+#include <boost/type_traits/add_const.hpp>
+
+namespace chaiscript 
+{
+  class Dynamic_Cast_Conversions;
+
+  namespace detail
+  {
+    // Cast_Helper_Inner helper classes
+
+    /**
+     * Generic Cast_Helper_Inner, for casting to any type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner
+      {
+        typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          if (ob.is_ref())
+          {
+            if (!ob.get_type_info().is_const())
+            {
+              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
+            } else {
+              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
+            }
+          } else {
+            if (!ob.get_type_info().is_const())
+            {
+              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
+            } else {
+              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
+            }
+          }
+        }
+      };
+
+	template<typename Result>
+	  struct Cast_Helper_Inner<const Result> : Cast_Helper_Inner<Result>
+	  {
+	  };
+
+    /**
+     * Cast_Helper_Inner for casting to a const & type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<const Result &> : Cast_Helper_Inner<Result>
+      {
+      };
+
+    /**
+     * Cast_Helper_Inner for casting to a const * type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<const Result *>
+      {
+        typedef const Result * Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          if (ob.is_ref())
+          {
+            if (!ob.get_type_info().is_const())
+            {
+              return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+            } else {
+              return (boost::any_cast<boost::reference_wrapper<const Result> >(ob.get())).get_pointer();
+            }
+          } else {
+            if (!ob.get_type_info().is_const())
+            {
+              return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+            } else {
+              return (boost::any_cast<boost::shared_ptr<const Result> >(ob.get())).get();
+            }
+          }
+        }
+      };
+
+    /**
+     * Cast_Helper_Inner for casting to a * type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<Result *>
+      {
+        typedef Result * Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          if (ob.is_ref())
+          {
+            return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+          } else {
+            return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+          }
+        }
+      };
+
+    /**
+     * Cast_Helper_Inner for casting to a & type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<Result &>
+      {
+        typedef typename boost::reference_wrapper<Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          if (ob.is_ref())
+          {
+            return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
+          } else {
+            return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
+          }
+        }
+      };
+
+    /**
+     * Cast_Helper_Inner for casting to a boost::shared_ptr<> type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<typename boost::shared_ptr<Result> >
+      {
+        typedef typename boost::shared_ptr<Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
+        }
+      };
+
+    /**
+     * Cast_Helper_Inner for casting to a boost::shared_ptr<const> type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<typename boost::shared_ptr<const Result> >
+      {
+        typedef typename boost::shared_ptr<const Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          if (!ob.get_type_info().is_const())
+          {
+            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
+          } else {
+            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
+          }
+        }
+      };
+
+    /**
+     * Cast_Helper_Inner for casting to a const boost::shared_ptr<> & type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::shared_ptr<Result> > : Cast_Helper_Inner<boost::shared_ptr<Result> >
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::shared_ptr<Result> &> : Cast_Helper_Inner<boost::shared_ptr<Result> >
+      {
+      };
+
+
+    /**
+     * Cast_Helper_Inner for casting to a const boost::shared_ptr<const> & type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::shared_ptr<const Result> > : Cast_Helper_Inner<boost::shared_ptr<const Result> >
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::shared_ptr<const Result> &> : Cast_Helper_Inner<boost::shared_ptr<const Result> >
+      {
+      };
+
+
+
+    /**
+     * Cast_Helper_Inner for casting to a Boxed_Value type
+     */
+    template<>
+      struct Cast_Helper_Inner<Boxed_Value>
+      {
+        typedef const Boxed_Value & Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        {
+          return ob;    
+        }
+      };
+
+    /**
+     * Cast_Helper_Inner for casting to a const Boxed_Value & type
+     */
+    template<>
+      struct Cast_Helper_Inner<const Boxed_Value> : Cast_Helper_Inner<Boxed_Value>
+      {
+      };
+
+    template<>
+      struct Cast_Helper_Inner<const Boxed_Value &> : Cast_Helper_Inner<Boxed_Value>
+      {
+      };
+    
+
+	/**
+     * Cast_Helper_Inner for casting to a boost::reference_wrapper type
+     */
+    template<typename Result>
+      struct Cast_Helper_Inner<boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::reference_wrapper<Result> &> : Cast_Helper_Inner<Result &>
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> > : Cast_Helper_Inner<const Result &>
+      {
+      };
+
+    template<typename Result>
+      struct Cast_Helper_Inner<const boost::reference_wrapper<const Result> & > : Cast_Helper_Inner<const Result &>
+      {
+      };
+
+    /**
+     * The exposed Cast_Helper object that by default just calls the Cast_Helper_Inner
+     */
+    template<typename T>
+      struct Cast_Helper
+      {
+        typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
+        
+        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
+        {
+          return Cast_Helper_Inner<T>::cast(ob, t_conversions);
+        }
+      };
+  }
+  
+}
+
+#endif

include/chaiscript/dispatchkit/boxed_number.hpp

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

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,31 +1,44 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __boxed_value_hpp__
-#define __boxed_value_hpp__
+#ifndef CHAISCRIPT_BOXED_VALUE_HPP_
+#define CHAISCRIPT_BOXED_VALUE_HPP_
 
 #include "type_info.hpp"
+
 #include "../chaiscript_threading.hpp"
+
 #include <map>
 #include <boost/shared_ptr.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
+#include <boost/make_shared.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #include <boost/any.hpp>
 #include <boost/function.hpp>
 #include <boost/ref.hpp>
 #include <boost/bind.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/type_traits/add_const.hpp>
+#include <boost/integer_traits.hpp>
 
 namespace chaiscript 
 {
-  /**
-   * Boxed_Value is the main tool of the dispatchkit. It allows
-   * for boxed / untyped containment of any C++ object. It uses
-   * boost::any internally but also provides user access the underlying
-   * stored type information
-   */
+
+  /// \brief A wrapper for holding any valid C++ type. All types in ChaiScript are Boxed_Value objects
+  /// \sa chaiscript::boxed_cast
   class Boxed_Value
   {
     public:
@@ -42,49 +55,12 @@ namespace chaiscript
        */
       struct Data
       {
-        /** 
-         * used to provide type-erased access to the internal boost::shared_ptr
-         * reference count information 
-         */
-        struct Shared_Ptr_Proxy
-        {
-          virtual ~Shared_Ptr_Proxy()
-          {
-          }
-
-          virtual bool unique(boost::any *) = 0;
-          virtual long use_count(boost::any *) = 0;
-        };
-
-        /** 
-         * Typed implementation of the Shared_Ptr_Proxy
-         */
-        template<typename T>
-          struct Shared_Ptr_Proxy_Impl : Shared_Ptr_Proxy
-        {
-          virtual ~Shared_Ptr_Proxy_Impl()
-          {
-          }
-
-          virtual bool unique(boost::any *a)
-          {
-            boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a);
-            return ptr->unique();
-          }
-
-          virtual long use_count(boost::any *a)
-          {
-            boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a);
-            return ptr->use_count();
-          }
-        };
-
         Data(const Type_Info &ti,
             const boost::any &to,
             bool tr,
-            const boost::shared_ptr<Shared_Ptr_Proxy> &t_proxy = boost::shared_ptr<Shared_Ptr_Proxy>())
-          : m_type_info(ti), m_obj(to), 
-          m_is_ref(tr), m_ptr_proxy(t_proxy)
+            const void *t_void_ptr)
+          : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?0:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
+            m_is_ref(tr)
         {
         }
 
@@ -93,162 +69,86 @@ namespace chaiscript
           m_type_info = rhs.m_type_info;
           m_obj = rhs.m_obj;
           m_is_ref = rhs.m_is_ref;
-          m_ptr_proxy = rhs.m_ptr_proxy;
+          m_data_ptr = rhs.m_data_ptr;
+          m_const_data_ptr = rhs.m_const_data_ptr;
 
           return *this;
         }
 
-        Type_Info m_type_info;
-        boost::any m_obj;
-        bool m_is_ref;
-        boost::shared_ptr<Shared_Ptr_Proxy> m_ptr_proxy;
-      };
-
-      /**
-       * Cache of all created objects in the dispatch kit. Used to return the 
-       * same shared_ptr if the same object is created more than once.
-       * Also used for acquiring a shared_ptr of a reference object, if the 
-       * value of the shared_ptr is known
-       */
-      struct Object_Cache
-      {
-        Object_Cache()
-          : m_cullcount(0)
+        ~Data()
         {
         }
 
-        boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
+        Type_Info m_type_info;
+        boost::any m_obj;
+        void *m_data_ptr;
+        const void *m_const_data_ptr;
+        bool m_is_ref;
+      };
+
+      struct Object_Data
       {
-          return boost::shared_ptr<Data> (new Data(
+        static boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
+        {
+          return boost::make_shared<Data>(
                 detail::Get_Type_Info<void>::get(),
                 boost::any(), 
-                false)
-              );
+                false,
+                static_cast<void *>(0));
         }
 
         template<typename T>
-          boost::shared_ptr<Data> get(const boost::shared_ptr<T> *obj)
+          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> *obj)
           {
             return get(*obj);
           }
 
         template<typename T>
-          boost::shared_ptr<Data> get(const boost::shared_ptr<T> &obj)
+          static boost::shared_ptr<Data> get(const boost::shared_ptr<T> &obj)
           {
-            bool b_const = boost::is_const<T>::value; 
-
-            boost::shared_ptr<Data> data(new Data(
+            return boost::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
                   boost::any(obj), 
                   false,
-                  boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
-                );
-
-            std::map<std::pair<const void *, bool>, Data>::iterator itr
-              = m_ptrs.find(std::make_pair(obj.get(), b_const));
-
-            if (itr != m_ptrs.end())
-            {
-              (*data) = (itr->second);
-            } else {
-              m_ptrs.insert(std::make_pair(std::make_pair(obj.get(), b_const), *data));
-            }
-
-            return data;
+                  obj.get());
           }
 
         template<typename T>
-          boost::shared_ptr<Data> get(T *t)
+          static boost::shared_ptr<Data> get(T *t)
           {
             return get(boost::ref(*t));
           }
 
         template<typename T>
-          boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
+          static boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
           {
-            bool b_const = boost::is_const<T>::value; 
-
-            boost::shared_ptr<Data> data(new Data(
+            return boost::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
                   boost::any(obj),
-                  true)
-                );
-
-            std::map<std::pair<const void *, bool>, Data >::iterator itr
-              = m_ptrs.find(std::make_pair(obj.get_pointer(), b_const) );
-
-            // If the ptr is found in the cache and it is the correct type,
-            // return it. It may be the incorrect type when two variables share the
-            // same memory location. Example:
-            // struct test { int x; };
-            // test t;
-            // Both t and t.x share the same memory location, but do not represent
-            // objects of the same type.
-            if (itr != m_ptrs.end() 
-                && itr->second.m_type_info.bare_equal(data->m_type_info))
-            {
-              (*data) = (itr->second);
-            } 
-
-            return data;
+                  true,
+                  obj.get_pointer());
           }
 
         template<typename T>
-          boost::shared_ptr<Data> get(const T& t)
+          static boost::shared_ptr<Data> get(const T& t)
           {
-            boost::shared_ptr<Data> data(new Data(
+            boost::shared_ptr<T> p(new T(t));
+            return boost::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  boost::any(boost::shared_ptr<T>(new T(t))), 
+                  boost::any(p), 
                   false,
-                  boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
-                );
-
-            boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(&data->m_obj);
-
-            m_ptrs.insert(std::make_pair(std::make_pair(ptr->get(), false), *data));
-            return data;
+                  p.get());
           }
 
-        boost::shared_ptr<Data> get()
+        static boost::shared_ptr<Data> get()
         {
-          return boost::shared_ptr<Data> (new Data(
+          return boost::make_shared<Data>(
                 Type_Info(),
                 boost::any(),
-                false)
-              );
+                false,
+                static_cast<void *>(0));
         }
 
-        /**
-         * Drop objects from the cache where there is only one (ie, our)
-         * reference to it, so it may be destructed
-         */
-        void cull(bool force = false)
-        {
-          
-          ++m_cullcount;
-          if (force || m_cullcount % 10 != 0)
-          {
-            return;
-          }
-
-
-          std::map<std::pair<const void *, bool>, Data>::iterator itr = m_ptrs.begin();
-
-          while (itr != m_ptrs.end())
-          {
-            if (itr->second.m_ptr_proxy->unique(&itr->second.m_obj) == 1)
-            {
-              std::map<std::pair<const void *, bool>, Data >::iterator todel = itr;
-              ++itr;
-              m_ptrs.erase(todel);
-            } else {
-              ++itr;
-            }
-          }
-        }
-
-        std::map<std::pair<const void *, bool>, Data > m_ptrs;
-        int m_cullcount;
       };
 
     public:
@@ -257,9 +157,8 @@ namespace chaiscript
        */
       template<typename T>
         explicit Boxed_Value(T t)
-        : m_data(get_object_cache().get(t))
+        : m_data(Object_Data::get(t))
         {
-          get_object_cache().cull();
         }
 
       /**
@@ -274,7 +173,7 @@ namespace chaiscript
        * Unknown-type constructor
        */
       Boxed_Value()
-        : m_data(get_object_cache().get())    
+        : m_data(Object_Data::get())    
       {
       }
 
@@ -282,18 +181,9 @@ namespace chaiscript
       {
       }
 
-      /**
-       * Return a reference to the static global Object_Cache
-       */
-      static Object_Cache &get_object_cache()
+      void swap(Boxed_Value &rhs)
       {
-        static chaiscript::threading::Thread_Storage<Object_Cache> oc;
-        return *oc;
-      }   
-
-      static void clear_cache()
-      {
-        get_object_cache().m_ptrs.clear();
+        std::swap(m_data, rhs.m_data);
       }
 
       /**
@@ -311,7 +201,8 @@ namespace chaiscript
        */
       Boxed_Value &operator=(const Boxed_Value &rhs)
       {
-        m_data = rhs.m_data;
+        Boxed_Value temp(rhs);
+        swap(temp);
         return *this;
       }
 
@@ -323,12 +214,27 @@ namespace chaiscript
       /**
        * return true if the object is uninitialized
        */
-      bool is_unknown() const
+      bool is_undef() const
       {
-        return m_data->m_type_info.is_unknown();
+        return m_data->m_type_info.is_undef();
       }
 
-      boost::any get() const
+      bool is_const() const
+      {
+        return m_data->m_type_info.is_const();
+      }
+
+      bool is_type(const Type_Info &ti) const
+      {
+        return m_data->m_type_info.bare_equal(ti);
+      }
+
+      bool is_null() const
+      {
+        return (m_data->m_data_ptr == 0 && m_data->m_const_data_ptr == 0);
+      }
+
+      const boost::any & get() const
       {
         return m_data->m_obj;
       }
@@ -338,468 +244,124 @@ namespace chaiscript
         return m_data->m_is_ref;
       }
 
+      bool is_pointer() const
+      {
+        return !is_ref();
+      }
+
+      void *get_ptr() const
+      {
+        return m_data->m_data_ptr;
+      }
+
+      const void *get_const_ptr() const
+      {
+        return m_data->m_const_data_ptr;
+      }
+
     private:
       boost::shared_ptr<Data> m_data;
   };
 
-
-  namespace detail
-  {
-    // Cast_Helper helper classes
-
-    /**
-     * Generic Cast_Helper, for casting to any type
-     */
-    template<typename Result>
-      struct Cast_Helper
-      {
-        typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          if (ob.is_ref())
-          {
-            if (!ob.get_type_info().is_const())
-            {
-              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
-            } else {
-              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
-            }
-          } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
-            } else {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
-            }
-          }
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a const & type
-     */
-    template<typename Result>
-      struct Cast_Helper<const Result &>
-      {
-        typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          if (ob.is_ref())
-          {
-            if (!ob.get_type_info().is_const())
-            {
-              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
-            } else {
-              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
-            }
-          } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
-            } else {
-              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
-            }
-          }
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a const * type
-     */
-    template<typename Result>
-      struct Cast_Helper<const Result *>
-      {
-        typedef const Result * Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          if (ob.is_ref())
-          {
-            if (!ob.get_type_info().is_const())
-            {
-              return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
-            } else {
-              return (boost::any_cast<boost::reference_wrapper<const Result> >(ob.get())).get_pointer();
-            }
-          } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
-            } else {
-              return (boost::any_cast<boost::shared_ptr<const Result> >(ob.get())).get();
-            }
-          }
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a * type
-     */
-    template<typename Result>
-      struct Cast_Helper<Result *>
-      {
-        typedef Result * Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          if (ob.is_ref())
-          {
-            return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
-          } else {
-            return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
-          }
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a & type
-     */
-    template<typename Result>
-      struct Cast_Helper<Result &>
-      {
-        typedef typename boost::reference_wrapper<Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          if (ob.is_ref())
-          {
-            return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
-          } else {
-            return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
-          }
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a boost::shared_ptr<> type
-     */
-    template<typename Result>
-      struct Cast_Helper<typename boost::shared_ptr<Result> >
-      {
-        typedef typename boost::shared_ptr<Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a boost::shared_ptr<const> type
-     */
-    template<typename Result>
-      struct Cast_Helper<typename boost::shared_ptr<const Result> >
-      {
-        typedef typename boost::shared_ptr<const Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          if (!ob.get_type_info().is_const())
-          {
-            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
-          } else {
-            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
-          }
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a const boost::shared_ptr<> & type
-     */
-    template<typename Result>
-      struct Cast_Helper<const boost::shared_ptr<Result> &>
-      {
-        typedef typename boost::shared_ptr<Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a const boost::shared_ptr<const> & type
-     */
-    template<typename Result>
-      struct Cast_Helper<const boost::shared_ptr<const Result> &>
-      {
-        typedef typename boost::shared_ptr<const Result> Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          if (!ob.get_type_info().is_const())
-          {
-            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
-          } else {
-            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
-          }
-        }
-      };
-
-
-
-    /**
-     * Cast_Helper for casting to a Boxed_Value type
-     */
-    template<>
-      struct Cast_Helper<Boxed_Value>
-      {
-        typedef const Boxed_Value & Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          return ob;    
-        }
-      };
-
-    /**
-     * Cast_Helper for casting to a const Boxed_Value & type
-     */
-    template<>
-      struct Cast_Helper<const Boxed_Value &>
-      {
-        typedef const Boxed_Value & Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          return ob;    
-        }
-      };
-  }
-
-  /**
-   * class that is thrown in the event of a bad_boxed_cast. That is,
-   * in the case that a Boxed_Value cannot be cast to the desired type
-   */
-  class bad_boxed_cast : public std::bad_cast
-  {
-    public:
-      bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
-        : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
-      {
-      }
-
-      bad_boxed_cast(const std::string &w) throw()
-        : m_what(w)
-      {
-      }
-
-      virtual ~bad_boxed_cast() throw() {}
-
-      virtual const char * what () throw()
-      {
-        return m_what.c_str();
-      }
-
-      Type_Info from;
-      const std::type_info *to;
-
-    private:
-      std::string m_what;
-  };
-
-  /**
-   * boxed_cast function for casting a Boxed_Value into a given type
-   * example:
-   * int &i = boxed_cast<int &>(boxedvalue);
-   */
-  template<typename Type>
-  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv)
-  {
-    try {
-      return detail::Cast_Helper<Type>::cast(bv);
-    } catch (const boost::bad_any_cast &) {
-      throw bad_boxed_cast(bv.get_type_info(), typeid(Type));
-    }
-  }
-
-  /**
-   * Object which attempts to convert a Boxed_Value into a generic
-   * POD type and provide generic POD type operations
-   */
-  struct Boxed_POD_Value
-  {
-    Boxed_POD_Value(const Boxed_Value &v)
-      : d(0), i(0), m_isfloat(false)
-    {
-      if (v.get_type_info().is_unknown())
-      {
-        throw boost::bad_any_cast();
-      }
-
-      const Type_Info &inp_ = v.get_type_info();
-
-      if (inp_ == typeid(double))
-      {
-        d = boxed_cast<double>(v);
-        m_isfloat = true;
-      } else if (inp_ == typeid(float)) {
-        d = boxed_cast<float>(v);
-        m_isfloat = true;
-      } else if (inp_ == typeid(bool)) {
-        i = boxed_cast<bool>(v);
-      } else if (inp_ == typeid(char)) {
-        i = boxed_cast<char>(v);
-      } else if (inp_ == typeid(int)) {
-        i = boxed_cast<int>(v);
-      } else if (inp_ == typeid(unsigned int)) {
-        i = boxed_cast<unsigned int>(v);
-      } else if (inp_ == typeid(long)) {
-        i = boxed_cast<long>(v);
-      } else if (inp_ == typeid(unsigned long)) {
-        i = boxed_cast<unsigned long>(v);
-      } else if (inp_ == typeid(boost::int8_t)) {
-        i = boxed_cast<boost::int8_t>(v);
-      } else if (inp_ == typeid(boost::int16_t)) {
-        i = boxed_cast<boost::int16_t>(v);
-      } else if (inp_ == typeid(boost::int32_t)) {
-        i = boxed_cast<boost::int32_t>(v);
-      } else if (inp_ == typeid(boost::int64_t)) {
-        i = boxed_cast<boost::int64_t>(v);
-      } else if (inp_ == typeid(boost::uint8_t)) {
-        i = boxed_cast<boost::uint8_t>(v);
-      } else if (inp_ == typeid(boost::uint16_t)) {
-        i = boxed_cast<boost::uint16_t>(v);
-      } else if (inp_ == typeid(boost::uint32_t)) {
-        i = boxed_cast<boost::uint32_t>(v);
-      } else {
-        throw boost::bad_any_cast();
-      }
-    }
-
-    bool operator==(const Boxed_POD_Value &r) const
-    {
-      return ((m_isfloat)?d:i) == ((r.m_isfloat)?r.d:r.i);
-    }
-
-    bool operator<(const Boxed_POD_Value &r) const
-    {
-      return ((m_isfloat)?d:i) < ((r.m_isfloat)?r.d:r.i);
-    }
-
-    bool operator>(const Boxed_POD_Value &r) const
-    {
-      return ((m_isfloat)?d:i) > ((r.m_isfloat)?r.d:r.i);
-    }
-
-    bool operator>=(const Boxed_POD_Value &r) const
-    {
-      return ((m_isfloat)?d:i) >= ((r.m_isfloat)?r.d:r.i);
-    }
-
-    bool operator<=(const Boxed_POD_Value &r) const
-    {
-      return ((m_isfloat)?d:i) <= ((r.m_isfloat)?r.d:r.i);
-    }
-
-    bool operator!=(const Boxed_POD_Value &r) const
-    {
-      return ((m_isfloat)?d:i) != ((r.m_isfloat)?r.d:r.i);
-    }
-
-    Boxed_Value operator+(const Boxed_POD_Value &r) const
-    {
-      if (!m_isfloat && !r.m_isfloat)
-      {
-        return Boxed_Value(i + r.i);
-      }
-
-      return Boxed_Value(((m_isfloat)?d:i) + ((r.m_isfloat)?r.d:r.i));
-    }
-
-    Boxed_Value operator*(const Boxed_POD_Value &r) const
-    {
-      if (!m_isfloat && !r.m_isfloat)
-      {
-        return Boxed_Value(i * r.i);
-      }
-
-      return Boxed_Value(((m_isfloat)?d:i) * ((r.m_isfloat)?r.d:r.i));
-    }
-
-    Boxed_Value operator/(const Boxed_POD_Value &r) const
-    {
-      if (!m_isfloat && !r.m_isfloat)
-      {
-        return Boxed_Value(i / r.i);
-      }
-
-      return Boxed_Value(((m_isfloat)?d:i) / ((r.m_isfloat)?r.d:r.i));
-    }
-
-    Boxed_Value operator-(const Boxed_POD_Value &r) const
-    {
-      if (!m_isfloat && !r.m_isfloat)
-      {
-        return Boxed_Value(i - r.i);
-      }
-
-      return Boxed_Value(((m_isfloat)?d:i) - ((r.m_isfloat)?r.d:r.i));
-    }
-
-    double d;
-    boost::int64_t i;
-
-    bool m_isfloat;
-  };
-
-  namespace detail
-  {
-    /**
-     * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
-     */
-    template<>
-      struct Cast_Helper<Boxed_POD_Value>
-      {
-        typedef Boxed_POD_Value Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob)
-        {
-          return Boxed_POD_Value(ob);
-        }
-      };
-  }
-
+  /// \brief Creates a Boxed_Value. If the object passed in is a value type, it is copied. If it is a pointer, boost::shared_ptr, or boost::reference_type
+  ///        a copy is not made.
+  /// \param t The value to box
+  /// 
+  /// Example:
+  /// \code
+  /// int i;
+  /// chaiscript::ChaiScript chai;
+  /// chai.add(chaiscript::var(i), "i");
+  /// chai.add(chaiscript::var(&i), "ip");
+  /// \endcode
+  /// 
+  /// \sa \ref addingobjects
   template<typename T>
     Boxed_Value var(T t)
     {
       return Boxed_Value(t);
     }
 
+  namespace detail {
+    /// \brief Takes a value, copies it and returns a Boxed_Value object that is immutable
+    /// \param[in] t Value to copy and make const
+    /// \returns Immutable Boxed_Value 
+    /// \sa Boxed_Value::is_const
     template<typename T>
-    Boxed_Value const_var(T *t)
-    {
-      return Boxed_Value( const_cast<typename boost::add_const<T>::type>(t) );
-    }
-
-  template<typename T>
-    Boxed_Value const_var(const boost::shared_ptr<T> &t)
-    {
-      return Boxed_Value( boost::const_pointer_cast<typename boost::add_const<T>::type>(t) );
-    }
-
-  template<typename T>
-    Boxed_Value const_var(const boost::reference_wrapper<T> &t)
-    {
-      return Boxed_Value( boost::cref(t.get()) );
-    }
-
-  template<typename T>
-    Boxed_Value const_var(const T &t)
+      Boxed_Value const_var_impl(const T &t)
       {
         return Boxed_Value(boost::shared_ptr<typename boost::add_const<T>::type >(new T(t)));
       }
 
-  /**
-   * Return true if the two Boxed_Values share the same internal type
-   */
+    /// \brief Takes a pointer to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
+    ///        Does not copy the pointed to value.
+    /// \param[in] t Pointer to make immutable
+    /// \returns Immutable Boxed_Value
+    /// \sa Boxed_Value::is_const
+    template<typename T>
+      Boxed_Value const_var_impl(T *t)
+      {
+        return Boxed_Value( const_cast<typename boost::add_const<T>::type *>(t) );
+      }
+
+    /// \brief Takes a boost::shared_ptr to a value, adds const to the pointed to type and returns an immutable Boxed_Value.
+    ///        Does not copy the pointed to value.
+    /// \param[in] t Pointer to make immutable
+    /// \returns Immutable Boxed_Value
+    /// \sa Boxed_Value::is_const
+    template<typename T>
+      Boxed_Value const_var_impl(const boost::shared_ptr<T> &t)
+      {
+        return Boxed_Value( boost::const_pointer_cast<typename boost::add_const<T>::type>(t) );
+      }
+
+    /// \brief Takes a boost::reference_wrapper value, adds const to the referenced type and returns an immutable Boxed_Value.
+    ///        Does not copy the referenced value.
+    /// \param[in] t Reference object to make immutable
+    /// \returns Immutable Boxed_Value
+    /// \sa Boxed_Value::is_const
+    template<typename T>
+      Boxed_Value const_var_impl(const boost::reference_wrapper<T> &t)
+      {
+        return Boxed_Value( boost::cref(t.get()) );
+      }
+  }
+
+  /// \brief Takes an object and returns an immutable Boxed_Value. If the object is a boost::reference or pointer type
+  ///        the value is not copied. If it is an object type, it is copied.
+  /// \param[in] t Object to make immutable
+  /// \returns Immutable Boxed_Value
+  /// \sa chaiscript::Boxed_Value::is_const
+  /// \sa chaiscript::var
+  ///
+  /// Example:
+  /// \code
+  /// enum Colors
+  /// {
+  ///   Blue,
+  ///   Green,
+  ///   Red
+  /// };
+  /// chaiscript::ChaiScript chai
+  /// chai.add(chaiscript::const_var(Blue), "Blue"); // add immutable constant
+  /// chai.add(chaiscript::const_var(Red), "Red");
+  /// chai.add(chaiscript::const_var(Green), "Green");
+  /// \endcode
+  /// 
+  /// \sa \ref addingobjects
+  template<typename T>
+    Boxed_Value const_var(const T &t)
+    {
+      return detail::const_var_impl(t);
+    }
+
+
+
+  /// \returns true if the two Boxed_Values share the same internal type
   static bool type_match(Boxed_Value l, Boxed_Value r)
   {
     return l.get_type_info() == r.get_type_info();
   }
-
 }
 
 #endif

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

@@ -0,0 +1,262 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
+#define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
+
+#include "type_info.hpp"
+#include "boxed_value.hpp"
+#include "boxed_cast_helper.hpp"
+#include "bad_boxed_cast.hpp"
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+namespace chaiscript
+{
+  namespace exception
+  {
+    class bad_boxed_dynamic_cast : public bad_boxed_cast
+    {
+      public:
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
+            const std::string &t_what) throw()
+          : bad_boxed_cast(t_from, t_to, t_what)
+        {
+        }
+
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
+          : bad_boxed_cast(t_from, t_to)
+        {
+        }
+
+        bad_boxed_dynamic_cast(const std::string &w) throw()
+          : bad_boxed_cast(w)
+        {
+        }
+
+        virtual ~bad_boxed_dynamic_cast() throw() {}
+    };
+  }
+
+  namespace detail
+  {
+    class Dynamic_Conversion
+    {
+      public:
+        virtual Boxed_Value convert(const Boxed_Value &derived) const = 0;
+
+        const Type_Info &base()
+        {
+          return m_base;
+        }
+        const Type_Info &derived()
+        {
+          return m_derived;
+        }
+
+      protected:
+        Dynamic_Conversion(const Type_Info &t_base, const Type_Info &t_derived)
+          : m_base(t_base), m_derived(t_derived)
+        {
+        }
+
+        virtual ~Dynamic_Conversion() {} 
+
+      private:
+        Type_Info m_base;
+        Type_Info m_derived;
+
+    };
+
+    template<typename Base, typename Derived>
+      class Dynamic_Conversion_Impl : public Dynamic_Conversion
+    {
+      public:
+        Dynamic_Conversion_Impl()
+          : Dynamic_Conversion(user_type<Base>(), user_type<Derived>())
+        {
+        }
+
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const
+        {
+          if (t_derived.get_type_info().bare_equal(user_type<Derived>()))
+          {
+            if (t_derived.is_pointer())
+            {
+              // Dynamic cast out the contained boxed value, which we know is the type we want
+              if (t_derived.is_const())
+              {
+                boost::shared_ptr<const Base> data 
+                  = boost::dynamic_pointer_cast<const Base>(detail::Cast_Helper<boost::shared_ptr<const Derived> >::cast(t_derived, 0));
+                if (!data)
+                {
+                  throw std::bad_cast();
+                }
+
+                return Boxed_Value(data);
+              } else {
+                boost::shared_ptr<Base> data 
+                  = boost::dynamic_pointer_cast<Base>(detail::Cast_Helper<boost::shared_ptr<Derived> >::cast(t_derived, 0));
+
+                if (!data)
+                {
+                  throw std::bad_cast();
+                }
+
+                return Boxed_Value(data);
+              }
+            } else {
+              // Pull the reference out of the contained boxed value, which we know is the type we want
+              if (t_derived.is_const())
+              {
+                const Derived &d = detail::Cast_Helper<const Derived &>::cast(t_derived, 0);
+                const Base &data = dynamic_cast<const Base &>(d);
+                return Boxed_Value(boost::cref(data));
+              } else {
+                Derived &d = detail::Cast_Helper<Derived &>::cast(t_derived, 0);
+                Base &data = dynamic_cast<Base &>(d);
+                return Boxed_Value(boost::ref(data));
+              }
+            }
+          } else {
+            throw exception::bad_boxed_dynamic_cast(t_derived.get_type_info(), typeid(Base), "Unknown dynamic_cast_conversion");
+          }
+        }
+    };
+  }
+
+  class Dynamic_Cast_Conversions
+  {
+    public:
+      Dynamic_Cast_Conversions()
+      {
+      }
+
+      Dynamic_Cast_Conversions(const Dynamic_Cast_Conversions &t_other)
+        : m_conversions(t_other.get_conversions())
+      {
+      }
+
+      void add_conversion(const boost::shared_ptr<detail::Dynamic_Conversion> &conversion)
+      {
+        chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+        m_conversions.insert(conversion);
+      }
+
+      template<typename Base, typename Derived>
+        bool dynamic_cast_converts() const
+        {
+          return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
+        }
+
+      bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived) const
+      {
+        return has_conversion(base, derived);
+      }
+
+      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();
+      }
+
+      boost::shared_ptr<detail::Dynamic_Conversion> get_conversion(const Type_Info &base, const Type_Info &derived) const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr =
+          find(base, derived);
+
+        if (itr != m_conversions.end())
+        {
+          return *itr;
+        } else {
+          throw std::out_of_range("No such conversion exists from " + derived.bare_name() + " to " + base.bare_name());
+        }
+      }
+
+    private:
+      std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
+          const Type_Info &base, const Type_Info &derived) const
+      {
+        for (std::set<boost::shared_ptr<detail::Dynamic_Conversion> >::const_iterator itr = m_conversions.begin();
+            itr != m_conversions.end();
+            ++itr)
+        {
+          if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
+          {
+            return itr;
+          }
+        }
+
+        return m_conversions.end();
+      }
+
+      std::set<boost::shared_ptr<detail::Dynamic_Conversion> > get_conversions() const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        return m_conversions;
+      }
+
+      mutable chaiscript::detail::threading::shared_mutex m_mutex;
+      std::set<boost::shared_ptr<detail::Dynamic_Conversion> > m_conversions;
+  };
+
+  typedef boost::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
+
+  /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
+  ///        want automatic conversions up your inheritance hierarchy.
+  ///
+  /// Create a new base class registration for applying to a module or to the chaiscript engine
+  /// Currently, due to limitations in module loading on Windows, and for the sake of portability,
+  /// if you have a type that is introduced in a loadable module and is used by multiple modules
+  /// (through a tertiary dll that is shared between the modules, static linking the new type
+  /// into both loadable modules would not be portable), you need to register the base type
+  /// relationship in all modules that use the newly added type in a polymorphic way.
+  ///
+  /// Example:
+  /// \code
+  /// class Base
+  /// {};
+  /// class Derived : public Base
+  /// {};
+  ///
+  /// chaiscript::ChaiScript chai;
+  /// chai.add(chaiscript::base_class<Base, Derived>());
+  /// \endcode
+  /// 
+  /// \todo Move share static type registration code into a mechanism that allows it to be properly
+  ///       shared by all modules
+  template<typename Base, typename Derived>
+    Dynamic_Cast_Conversion base_class()
+    {
+      //Can only be used with related polymorphic types
+      //may be expanded some day to support conversions other than child -> parent
+      BOOST_STATIC_ASSERT((boost::is_base_of<Base,Derived>::value));
+      BOOST_STATIC_ASSERT(boost::is_polymorphic<Base>::value);
+      BOOST_STATIC_ASSERT(boost::is_polymorphic<Derived>::value);
+
+      return boost::shared_ptr<detail::Dynamic_Conversion>(new detail::Dynamic_Conversion_Impl<Base, Derived>());
+    }
+
+}
+
+
+#endif

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,9 +1,17 @@
-#ifndef __DYNAMIC_OBJECT_HPP__
-#define __DYNAMIC_OBJECT_HPP__
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
+#define CHAISCRIPT_DYNAMIC_OBJECT_HPP_
 
 #include <boost/optional.hpp>
 
 namespace chaiscript
+{
+  namespace dispatch
   {
     class Dynamic_Object
     {
@@ -34,20 +42,8 @@ namespace chaiscript
         std::map<std::string, Boxed_Value> m_attrs;
     };
 
-  struct Dynamic_Object_Attribute
+    namespace detail
     {
-    static Boxed_Value func(const std::string &t_type_name, const std::string &t_attr_name,
-        Dynamic_Object &t_do)
-    {
-      if (t_do.get_type_name() != t_type_name) 
-      {
-        throw bad_boxed_cast("Dynamic object type mismatch");
-      }
-
-      return t_do.get_attr(t_attr_name);
-    }
-  };
-
       /**
        * A Proxy_Function implementation designed for calling a function
        * that is automatically guarded based on the first param based on the
@@ -60,7 +56,7 @@ namespace chaiscript
               const std::string &t_type_name,
               const Proxy_Function &t_func,
               const boost::optional<Type_Info> &t_ti = boost::optional<Type_Info>())
-        : Proxy_Function_Base(t_func->get_param_types()),
+            : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti)),
               m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
           {
             assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
@@ -71,35 +67,33 @@ namespace chaiscript
 
           virtual bool operator==(const Proxy_Function_Base &f) const
           {
-        try
+            const Dynamic_Object_Function *df = dynamic_cast<const Dynamic_Object_Function *>(&f);
+            if (df)
             {
-          const Dynamic_Object_Function &df = dynamic_cast<const Dynamic_Object_Function &>(f);
-          return df.m_type_name == m_type_name && (*df.m_func) == (*m_func);
-        } catch (const std::bad_cast &) {
-          return false;
-        }
-      }
-
-      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
-      {
-        if (dynamic_object_typename_match(vals, m_type_name, m_ti))
-        {
-          return m_func->call_match(vals);
+              return df->m_type_name == m_type_name && (*df->m_func) == (*m_func);
             } else {
               return false;
             }
           }
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
           {
-        if (dynamic_object_typename_match(params, m_type_name, m_ti))
+            if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
             {
-          return (*m_func)(params);
+              return m_func->call_match(vals, t_conversions);
             } else {
-          throw guard_error();
+              return false;
             }
           }    
 
+          virtual std::vector<Const_Proxy_Function> get_contained_functions() const
+          {
+            std::vector<Const_Proxy_Function> fs;
+            fs.push_back(m_func);
+            return fs;
+          }
+
+
           virtual int get_arity() const
           {
             return m_func->get_arity();
@@ -110,23 +104,69 @@ namespace chaiscript
             return m_func->annotation();
           }
 
-    private:
-      static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-          const boost::optional<Type_Info> &ti) 
+
+        protected:
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
           {
-        if (bvs.size() > 0)
+            if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
+            {
+              return (*m_func)(params, t_conversions);
+            } else {
+              throw exception::guard_error();
+            } 
+          }
+
+          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, t_conversions);
+          }
+
+        private:
+          static std::vector<Type_Info> build_param_types(
+              const std::vector<Type_Info> &t_inner_types, boost::optional<Type_Info> t_objectti)
+          {
+            if (t_objectti)
+            {
+              std::vector<Type_Info> types(t_inner_types);
+
+              assert(types.size() > 1);
+              assert(types[1].bare_equal(user_type<Boxed_Value>()));
+              types[1] = *t_objectti;
+              return types;
+            } else {
+              return t_inner_types;
+            }
+          }
+
+          static bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
+              const boost::optional<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions)
+          {
+            static Type_Info doti = user_type<Dynamic_Object>();
+            if (bv.get_type_info().bare_equal(doti))
             {
               try {
-            const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bvs[0]);
+                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;
+              } 
+            } else {
               if (ti)
               {
-              return bvs[0].get_type_info().bare_equal(*ti);
+                return bv.get_type_info().bare_equal(*ti);
               } else {
                 return false;
               }
             }
+
+          }
+
+          static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+              const boost::optional<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) 
+          {
+            if (bvs.size() > 0)
+            {
+              return dynamic_object_typename_match(bvs[0], name, ti, t_conversions);
             } else {
               return false;
             }
@@ -175,35 +215,24 @@ namespace chaiscript
 
           virtual bool operator==(const Proxy_Function_Base &f) const
           {
-        try
+            const Dynamic_Object_Constructor *dc = dynamic_cast<const Dynamic_Object_Constructor*>(&f);
+            if (dc)
             {
-          const Dynamic_Object_Constructor &dc = dynamic_cast<const Dynamic_Object_Constructor&>(f);
-          return dc.m_type_name == m_type_name && (*dc.m_func) == (*m_func);
-        } catch (const std::bad_cast &) {
+              return dc->m_type_name == m_type_name && (*dc->m_func) == (*m_func);
+            } else {
               return false;
             }
           }
 
-      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);
           }    
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) 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);
-
-        return bv;
-      }
 
           virtual int get_arity() const
           {
@@ -216,11 +245,26 @@ namespace chaiscript
             return m_func->annotation();
           }
 
+        protected:
+          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, t_conversions);
+
+            return bv;
+          }
+
         private:
           std::string m_type_name;
           Proxy_Function m_func;
 
       };
     }
+  }
+}
 #endif
 

include/chaiscript/dispatchkit/exception_specification.hpp

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

include/chaiscript/dispatchkit/function_call.hpp

@@ -1,11 +1,11 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __function_call_hpp__
-#define __function_call_hpp__
+#ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
+#define CHAISCRIPT_FUNCTION_CALL_HPP_
 
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
@@ -15,7 +15,12 @@
 #include "proxy_functions.hpp"
 #include "function_call_detail.hpp"
 
+
+#include <iostream>
+
 namespace chaiscript
+{
+  namespace dispatch
   {
     /**
      * Build a function caller that knows how to dispatch on a set of functions
@@ -27,10 +32,10 @@ namespace chaiscript
      */
     template<typename FunctionType>
       boost::function<FunctionType>
-      functor(const std::vector<std::pair<std::string, 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);
       }
 
     /**
@@ -48,11 +53,11 @@ namespace chaiscript
      */
     template<typename FunctionType>
       boost::function<FunctionType>
-      functor(Proxy_Function func)
+      functor(Const_Proxy_Function func, const Dynamic_Cast_Conversions *t_conversions)
       {
-        std::vector<std::pair<std::string, Proxy_Function > > funcs;
-        funcs.push_back(std::make_pair(std::string(), func));
-        return functor<FunctionType>(funcs);
+        std::vector<Const_Proxy_Function> funcs;
+        funcs.push_back(func);
+        return functor<FunctionType>(funcs, t_conversions);
       }
 
     /**
@@ -61,11 +66,70 @@ namespace chaiscript
      */
     template<typename FunctionType>
       boost::function<FunctionType>
-      functor(const Boxed_Value &bv)
+      functor(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions)
       {
-        return functor<FunctionType>(boxed_cast<Proxy_Function >(bv));
+        return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
+      }
   }
 
+  namespace detail{
+    /**
+     * Cast helper to handle automatic casting to const boost::function &
+     */
+    template<typename Signature>
+      struct Cast_Helper<const boost::function<Signature> &>
+      {
+        typedef boost::function<Signature> Result_Type;
+
+        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, t_conversions);
+          } else {
+            return Cast_Helper_Inner<const boost::function<Signature> &>::cast(ob, t_conversions);
+          }
+        }
+      };
+
+    /**
+     * Cast helper to handle automatic casting to boost::function
+     */
+    template<typename Signature>
+      struct Cast_Helper<boost::function<Signature> >
+      {
+        typedef boost::function<Signature> Result_Type;
+
+        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, t_conversions);
+          } else {
+            return Cast_Helper_Inner<boost::function<Signature> >::cast(ob, t_conversions);
+          }
+        }
+      };
+
+    /**
+     * Cast helper to handle automatic casting to const boost::function
+     */
+    template<typename Signature>
+      struct Cast_Helper<const boost::function<Signature> >
+      {
+        typedef boost::function<Signature> Result_Type;
+
+        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, t_conversions);
+          } else {
+            return Cast_Helper_Inner<const boost::function<Signature> >::cast(ob, t_conversions);
+          }
+        }
+      };
+  }
 }
 
 #endif

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,18 +1,18 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <boost/preprocessor.hpp>
 
-#define addparam(z,n,text)  params.push_back(boost::is_reference<Param ## n>::value?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
+#define addparam(z,n,text)  params.push_back((boost::is_reference<Param ## n>::value&&!(boost::is_same<chaiscript::Boxed_Value, typename boost::remove_const<typename boost::remove_reference<Param ## n>::type>::type>::value))?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
 #define curry(z,n,text)  BOOST_PP_CAT(_, BOOST_PP_INC(n))
 
 
 #ifndef  BOOST_PP_IS_ITERATING
-#ifndef __function_call_detail_hpp__
-#define __function_call_detail_hpp__
+#ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
+#define CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
 
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
@@ -22,9 +22,12 @@
 #include "proxy_functions.hpp"
 
 namespace chaiscript
+{
+  namespace dispatch
   {
     namespace detail
     {
+
       /**
        * Internal helper class for handling the return
        * value of a build_function_caller
@@ -32,10 +35,10 @@ namespace chaiscript
       template<typename Ret>
         struct Function_Caller_Ret
         {
-        static Ret call(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs, 
-            const std::vector<Boxed_Value> &params)
+          static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-          return boxed_cast<Ret>(dispatch(t_funcs, params));
+            return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, t_conversions));
           }
         };
 
@@ -45,14 +48,15 @@ namespace chaiscript
       template<>
         struct Function_Caller_Ret<void>
         {
-        static void call(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs, 
-            const std::vector<Boxed_Value> &params)
+          static void call(const std::vector<Const_Proxy_Function> &t_funcs, 
+              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
           {
-          dispatch(t_funcs, params);
+            dispatch::dispatch(t_funcs, params, t_conversions);
           }
         };
     }
   }
+}
 
 #define BOOST_PP_ITERATION_LIMITS ( 0, 9 )
 #define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/function_call_detail.hpp>
@@ -63,6 +67,8 @@ namespace chaiscript
 # define n BOOST_PP_ITERATION()
 
 namespace chaiscript
+{
+  namespace dispatch
   {
     namespace detail
     {
@@ -70,14 +76,14 @@ namespace chaiscript
        * used internally for unwrapping a function call's types
        */
       template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-      Ret function_caller(const std::vector<std::pair<std::string, Proxy_Function > > &funcs 
+        Ret function_caller(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions &t_conversions 
             BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
         {
           std::vector<Boxed_Value> params;
 
-        BOOST_PP_REPEAT(n, addparam, ~)
+          BOOST_PP_REPEAT(n, addparam, ~);
 
-          return Function_Caller_Ret<Ret>::call(funcs, params);
+          return Function_Caller_Ret<Ret>::call(funcs, params, t_conversions);
         }
 
       /**
@@ -85,14 +91,32 @@ namespace chaiscript
        */
       template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
         boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
-      build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<std::pair<std::string, Proxy_Function> > &funcs)
+        build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<Const_Proxy_Function> &funcs, 
+            const Dynamic_Cast_Conversions *t_conversions)
         {
-        return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs
-            BOOST_PP_ENUM_TRAILING(n, curry, ~));
+          if (funcs.size() == 1)
+          {
+            boost::shared_ptr<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> > pfi = 
+              boost::dynamic_pointer_cast<const Proxy_Function_Impl<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> >
+              (funcs[0]);
+
+            if (pfi)
+            {
+              return pfi->internal_function();
+            } 
+            // looks like this either wasn't a Proxy_Function_Impl or the types didn't match
+            // we cannot make any other guesses or assumptions really, so continuing
           }
 
+          return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs, (t_conversions?*t_conversions:Dynamic_Cast_Conversions())
+              BOOST_PP_ENUM_TRAILING(n, curry, ~));
         }
     }
+  }
+}
+#undef n
+#undef addparam
+#undef curry 
 
 #endif
 

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,13 +1,14 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __handle_return_hpp__
-#define __handle_return_hpp__
+#ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
+#define CHAISCRIPT_HANDLE_RETURN_HPP_
 
 #include "boxed_value.hpp"
+#include "boxed_number.hpp"
 #include "type_info.hpp"
 #include <string>
 #include <boost/function.hpp>
@@ -16,6 +17,10 @@
 #include <vector>
 
 namespace chaiscript
+{
+  namespace dispatch
+  {
+    namespace detail
     {
       /**
        * Used internally for handling a return value from a Proxy_Function call
@@ -25,7 +30,16 @@ namespace chaiscript
         {
           static Boxed_Value handle(const Ret &r)
           {
-        return Boxed_Value(r);
+            return const_var(r);
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<Ret *>
+        {
+          static Boxed_Value handle(Ret *p)
+          {
+            return Boxed_Value(p);
           }
         };
 
@@ -38,6 +52,15 @@ namespace chaiscript
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<boost::shared_ptr<Ret> >
+        {
+          static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+          {
+            return Boxed_Value(r);
+          }
+        };
+
       template<typename Ret>
         struct Handle_Return<const boost::shared_ptr<Ret> &>
         {
@@ -47,6 +70,16 @@ namespace chaiscript
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<const Ret &>
+        {
+          static Boxed_Value handle(const Ret &r)
+          {
+            return Boxed_Value(boost::cref(r));
+          }
+        };
+
+
       /**
        * Used internally for handling a return value from a Proxy_Function call
        */
@@ -57,6 +90,11 @@ namespace chaiscript
           {
             return Boxed_Value(boost::ref(r));
           }
+
+          static Boxed_Value handle(const Ret &r)
+          {
+            return Boxed_Value(boost::cref(r));
+          }
         };
 
       /**
@@ -71,6 +109,18 @@ namespace chaiscript
           }
         };
 
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<const Boxed_Value>
+        {
+          static Boxed_Value handle(const Boxed_Value &r)
+          {
+            return r;
+          }
+        };
+
       /**
        * Used internally for handling a return value from a Proxy_Function call
        */
@@ -83,6 +133,43 @@ namespace chaiscript
           }
         };
 
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<const Boxed_Value &>
+        {
+          static Boxed_Value handle(const Boxed_Value &r)
+          {
+            return r;
+          }
+        };
+
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<Boxed_Number>
+        {
+          static Boxed_Value handle(const Boxed_Number &r)
+          {
+            return r.bv;
+          }
+        };
+
+      /**
+       * Used internally for handling a return value from a Proxy_Function call
+       */
+      template<>
+        struct Handle_Return<const Boxed_Number>
+        {
+          static Boxed_Value handle(const Boxed_Number &r)
+          {
+            return r.bv;
+          }
+        };
+
+
       /**
        * Used internally for handling a return value from a Proxy_Function call
        */
@@ -95,5 +182,7 @@ namespace chaiscript
           }
         };
     }
+  }
+}
 
 #endif

include/chaiscript/dispatchkit/operators.hpp

@@ -0,0 +1,458 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_OPERATORS_HPP_
+#define CHAISCRIPT_OPERATORS_HPP_
+
+namespace chaiscript 
+{
+  namespace bootstrap
+  {
+    namespace operators
+    {
+      template<typename Ret, typename L, typename R>
+        Ret assign(L l, R r)
+        {
+          return (l = r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_bitwise_and(L l, R r)
+        {
+          return (l &= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_xor(L l, R r)
+        {
+          return (l ^= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_bitwise_or(L l, R r)
+        {
+          return (l |= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_difference(L l, R r)
+        {
+          return (l -= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_left_shift(L l, R r)
+        {
+          return (l <<= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_product(L l, R r)
+        {
+          return (l *= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_quotient(L l, R r)
+        {
+          return (l /= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_remainder(L l, R r)
+        {
+          return (l %= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_right_shift(L l, R r)
+        {
+          return (l >>= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret assign_sum(L l, R r)
+        {
+          return (l += r);
+        }
+
+      template<typename Ret, typename L>
+        Ret prefix_decrement(L l)
+        {
+          return (--l);
+        }
+
+      template<typename Ret, typename L>
+        Ret prefix_increment(L l)
+        {
+          return (++l);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret equal(L l, R r)
+        {
+          return (l == r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret greater_than(L l, R r)
+        {
+          return (l > r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret greater_than_equal(L l, R r)
+        {
+          return (l >= r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret less_than(L l, R r)
+        {
+          return (l < r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret less_than_equal(L l, R r)
+        {
+          return (l <= r);
+        }
+
+      template<typename Ret, typename L>
+        Ret logical_compliment(L l)
+        {
+          return (!l);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret not_equal(L l, R r)
+        {
+          return (l != r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret addition(L l, R r)
+        {
+          return (l + r);
+        }
+
+      template<typename Ret, typename L>
+        Ret unary_plus(L l)
+        {
+          return (+l);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret subtraction(L l, R r)
+        {
+          return (l - r);
+        }
+
+      template<typename Ret, typename L>
+        Ret unary_minus(L l)
+        {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4146)
+          return (-l);
+#pragma warning(pop)
+#else
+          return (-l);
+#endif
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret bitwise_and(L l, R r)
+        {
+          return (l & r);
+        }
+
+      template<typename Ret, typename L>
+        Ret bitwise_compliment(L l)
+        {
+          return (~l);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret bitwise_xor(L l, R r)
+        {
+          return (l ^ r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret bitwise_or(L l, R r)
+        {
+          return (l | r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret division(L l, R r)
+        {
+          return (l / r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret left_shift(L l, R r)
+        {
+          return l << r;
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret multiplication(L l, R r)
+        {
+          return l * r;
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret remainder(L l, R r)
+        {
+          return (l % r);
+        }
+
+      template<typename Ret, typename L, typename R>
+        Ret right_shift(L l, R r)
+        {
+          return (l >> r);
+        }
+
+
+
+
+      template<typename T>
+        ModulePtr assign(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign<T &, T &, const T&>), "=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_bitwise_and(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_bitwise_and<T &, T &, const T&>), "&=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_xor(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_xor<T &, T &, const T&>), "^=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_bitwise_or(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_bitwise_or<T &, T &, const T&>), "|=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_difference(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_difference<T &, T &, const T&>), "-=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_left_shift(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_left_shift<T &, T &, const T&>), "<<=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_product(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_product<T &, T &, const T&>), "*=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_quotient(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_quotient<T &, T &, const T&>), "/=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_remainder(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_remainder<T &, T &, const T&>), "%=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_right_shift(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_right_shift<T &, T &, const T&>), ">>=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr assign_sum(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&assign_sum<T &, T &, const T&>), "+=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr prefix_decrement(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&prefix_decrement<T &, T &>), "--");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr prefix_increment(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&prefix_increment<T &, T &>), "++");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr equal(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&equal<bool, const T&, const T&>), "==");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr greater_than(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&greater_than<bool, const T&, const T&>), ">");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr greater_than_equal(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&greater_than_equal<bool, const T&, const T&>), ">=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr less_than(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&less_than<bool, const T&, const T&>), "<");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr less_than_equal(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&less_than_equal<bool, const T&, const T&>), "<=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr logical_compliment(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&logical_compliment<bool, const T &>), "!");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr not_equal(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&not_equal<bool, const T &, const T &>), "!=");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr addition(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&addition<T, const T &, const T &>), "+");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr unary_plus(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&unary_plus<T, const T &>), "+");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr subtraction(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&subtraction<T, const T &, const T &>), "-");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr unary_minus(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&unary_minus<T, const T &>), "-");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr bitwise_and(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&bitwise_and<T, const T &, const T &>), "&");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr bitwise_compliment(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&bitwise_compliment<T, const T &>), "~");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr bitwise_xor(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&bitwise_xor<T, const T &, const T &>), "^");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr bitwise_or(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&bitwise_or<T, const T &, const T &>), "|");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr division(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&division<T, const T &, const T &>), "/");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr left_shift(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&left_shift<T, const T &, const T &>), "<<");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr multiplication(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&multiplication<T, const T &, const T &>), "*");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr remainder(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&remainder<T, const T &, const T &>), "%");
+          return m;
+        }
+
+      template<typename T>
+        ModulePtr right_shift(ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(fun(&right_shift<T, const T &, const T &>), ">>");
+          return m;
+        }
+    }
+  }
+}
+
+#endif

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -1,14 +1,14 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <boost/preprocessor.hpp>
 
 #ifndef  BOOST_PP_IS_ITERATING
-#ifndef __proxy_constructors_hpp__
-#define __proxy_constructors_hpp__
+#ifndef CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
+#define CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
@@ -22,11 +22,22 @@
 
 namespace chaiscript
 {
+  /// \brief Generates a constructor function for use with ChaiScript
+  /// 
+  /// \tparam T The signature of the constructor to generate. In the form of: ClassType (ParamType1, ParamType2, ...)
+  /// 
+  /// Example:
+  /// \code
+  ///    chaiscript::ChaiScript chai;
+  ///    // Create a new function that creates a MyClass object using the (int, float) constructor
+  ///    // and call that function "MyClass" so that it appears as a normal constructor to the user.
+  ///    chai.add(constructor<MyClass (int, float)>(), "MyClass");
+  /// \endcode
   template<typename T>
     Proxy_Function constructor()
     {
       T *f = 0;
-      return (detail::build_constructor_(f));
+      return (dispatch::detail::build_constructor_(f));
     }
 }
 
@@ -34,6 +45,8 @@ namespace chaiscript
 # define n BOOST_PP_ITERATION()
 
 namespace chaiscript
+{
+  namespace dispatch
   {
     namespace detail
     {
@@ -61,6 +74,8 @@ namespace chaiscript
         }
     }
   }
+}
+#undef n
 
 #endif
 

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -1,23 +1,31 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 
-#ifndef __proxy_functions_hpp__
-#define __proxy_functions_hpp__
+#ifndef CHAISCRIPT_PROXY_FUNCTIONS_HPP_
+#define CHAISCRIPT_PROXY_FUNCTIONS_HPP_
 
 
 #include "boxed_value.hpp"
 #include "type_info.hpp"
 #include <string>
 #include <boost/function.hpp>
+#include <boost/type_traits/add_reference.hpp>
 #include <stdexcept>
 #include <vector>
 #include "proxy_functions_detail.hpp"
 
 namespace chaiscript
+{
+  class Boxed_Number;
+  struct AST_Node;
+
+  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
+
+  namespace dispatch
   {
     /**
      * Helper for building a list of parameters for calling a Proxy_Function
@@ -62,16 +70,35 @@ namespace chaiscript
     {
       public:
         virtual ~Proxy_Function_Base() {}
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const = 0;
+        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Dynamic_Cast_Conversions &t_conversions) const
+        {
+          Boxed_Value bv = do_call(params, t_conversions);
+          return bv;
+        }
 
+        /// Returns a vector containing all of the types of the parameters the function returns/takes
+        /// if the function is variadic or takes no arguments (arity of 0 or -1), the returned
+        /// value containes exactly 1 Type_Info object: the return type
+        /// \returns the types of all parameters. 
         std::vector<Type_Info> get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
-      virtual bool call_match(const std::vector<Boxed_Value> &vals) const = 0;
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
+
+        bool has_arithmetic_param() const 
+        {
+          return m_has_arithmetic_param;
+        }
+
+        virtual std::vector<boost::shared_ptr<const Proxy_Function_Base> > get_contained_functions() const
+        {
+          return std::vector<boost::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();
 
@@ -83,6 +110,55 @@ namespace chaiscript
             {
               return true;
             } else {
+              return compare_first_type(vals[0], t_conversions);
+            }
+          } else {
+            return false;
+          }
+        }
+
+        /// \returns the number of arguments the function takes or -1 if it is variadic
+        virtual int get_arity() const = 0;
+
+        virtual std::string annotation() const = 0;
+
+        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions)
+        {
+          if (ti.is_undef() 
+              || ti.bare_equal(user_type<Boxed_Value>())
+              || (!bv.get_type_info().is_undef()
+                && (ti.bare_equal(user_type<Boxed_Number>())
+                  || ti.bare_equal(bv.get_type_info())
+                  || bv.get_type_info().bare_equal(user_type<boost::shared_ptr<const Proxy_Function_Base> >())
+                  || t_conversions.dynamic_cast_converts(ti, bv.get_type_info()) 
+                  )
+                )
+             )
+          {
+            return true;
+          } else {
+            return false;
+          }
+        }
+      protected:
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
+
+        Proxy_Function_Base(const std::vector<Type_Info> &t_types)
+          : m_types(t_types), m_has_arithmetic_param(false)
+        {
+          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)
@@ -91,40 +167,18 @@ namespace chaiscript
           }
 
           const Type_Info &ti = types[1];
+          return compare_type_to_param(ti, bv, t_conversions);
 
-            if (ti.is_unknown() || vals[0].get_type_info().is_unknown()
-                || ti.bare_equal(user_type<Boxed_Value>())
-                || ti.bare_equal(user_type<Boxed_POD_Value>())
-                || ti.bare_equal(vals[0].get_type_info()))
-            {
-              return true;
-            } else {
-              return false;
-            }
-          }
-        } else {
-          return false;
-        }
         }
 
-      virtual int get_arity() const = 0;
-
-      virtual std::string annotation() const = 0;
-
-    protected:
-      Proxy_Function_Base(const std::vector<Type_Info> &t_types)
-        : m_types(t_types)
-      {
-      }
-
-      bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs) const
+        static bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs)
         {
           if (tis.size() - 1 != bvs.size())
           {
             return false;
           } else {
-          const int size = bvs.size();
-          for (int i = 0; i < size; ++i)
+            size_t size = bvs.size();
+            for (size_t i = 0; i < size; ++i)
             {
               if (!(tis[i+1].bare_equal(bvs[i].get_type_info()) && tis[i+1].is_const() >= bvs[i].get_type_info().is_const() ))
               {
@@ -136,14 +190,21 @@ namespace chaiscript
         }
 
         std::vector<Type_Info> m_types;
+        bool m_has_arithmetic_param;
+
     };
+  }
 
-  typedef boost::shared_ptr<Proxy_Function_Base> Proxy_Function;
-  typedef boost::shared_ptr<const Proxy_Function_Base> Const_Proxy_Function;
+  /// \brief Common typedef used for passing of any registered function in ChaiScript
+  typedef boost::shared_ptr<dispatch::Proxy_Function_Base> Proxy_Function;
 
-  /**
-   * Exception thrown if a function's guard fails to execute
-   */
+  /// \brief Const version of Proxy_Function chaiscript. Points to a const Proxy_Function. This is how most registered functions
+  ///        are handled internally.
+  typedef boost::shared_ptr<const dispatch::Proxy_Function_Base> Const_Proxy_Function;
+
+  namespace exception
+  {
+    /// \brief  Exception thrown if a function's guard fails
     class guard_error : public std::runtime_error
     {
       public:
@@ -154,7 +215,10 @@ namespace chaiscript
         virtual ~guard_error() throw()
         { }
     };
+  }
 
+  namespace dispatch
+  {
     /**
      * A Proxy_Function implementation that is not type safe, the called function
      * is expecting a vector<Boxed_Value> that it works with how it chooses.
@@ -165,63 +229,81 @@ namespace chaiscript
         Dynamic_Proxy_Function(
             const boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, 
             int t_arity=-1,
+            const AST_NodePtr &t_parsenode = AST_NodePtr(),
             const std::string &t_description = "",
             const Proxy_Function &t_guard = Proxy_Function())
           : Proxy_Function_Base(build_param_type_list(t_arity)),
-          m_f(t_f), m_arity(t_arity), m_description(t_description), m_guard(t_guard)
+            m_f(t_f), m_arity(t_arity), m_description(t_description), m_guard(t_guard), m_parsenode(t_parsenode)
         {
         }
 
-      virtual bool operator==(const Proxy_Function_Base &) const
+        virtual bool operator==(const Proxy_Function_Base &rhs) const
         {
-        return false;
+          const Dynamic_Proxy_Function *prhs = dynamic_cast<const Dynamic_Proxy_Function *>(&rhs);
+
+          return this == &rhs
+            || (prhs
+                && this->m_arity == prhs->m_arity
+                && !this->m_guard && !prhs->m_guard);
         }
 
-      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
         {
           return (m_arity < 0 || vals.size() == size_t(m_arity))
-            && test_guard(vals);
+            && test_guard(vals, t_conversions);
         }    
 
         virtual ~Dynamic_Proxy_Function() {}
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
-      {
-        if (m_arity < 0 || params.size() == size_t(m_arity))
-        {
-
-          if (test_guard(params))
-          {
-            return m_f(params);
-          } else {
-            throw guard_error();
-          }
-
-        } else {
-          throw arity_error(params.size(), m_arity);
-        } 
-      }
 
         virtual int get_arity() const
         {
           return m_arity;
         }
 
+        Proxy_Function get_guard() const
+        {
+          return m_guard;
+        }
+
+        AST_NodePtr get_parse_tree() const
+        {
+          return m_parsenode;
+        }
+
         virtual std::string annotation() const
         {
           return m_description;
         }
 
+      protected:
+        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, t_conversions))
+            {
+              return m_f(params);
+            } else {
+              throw exception::guard_error();
+            }
+
+          } else {
+            throw exception::arity_error(static_cast<int>(params.size()), m_arity);
+          } 
+        }
+
       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));
-          } catch (const arity_error &) {
+              return boxed_cast<bool>((*m_guard)(params, t_conversions));
+            } catch (const exception::arity_error &) {
               return false;
-          } catch (const bad_boxed_cast &) {
+            } catch (const exception::bad_boxed_cast &) {
               return false;
             }
           } else {
@@ -233,16 +315,15 @@ namespace chaiscript
         {
           std::vector<Type_Info> types;
 
-        types.push_back(detail::Get_Type_Info<Boxed_Value>::get());
+          // For the return type
+          types.push_back(chaiscript::detail::Get_Type_Info<Boxed_Value>::get());
 
           if (arity >= 0)
           {
             for (int i = 0; i < arity; ++i)
             {
-            types.push_back(detail::Get_Type_Info<Boxed_Value>::get());
+              types.push_back(chaiscript::detail::Get_Type_Info<Boxed_Value>::get());
             }
-        } else {
-          types.push_back(detail::Get_Type_Info<std::vector<Boxed_Value> >::get());
           }
 
           return types;
@@ -252,6 +333,7 @@ namespace chaiscript
         int m_arity;
         std::string m_description;
         Proxy_Function m_guard;
+        AST_NodePtr m_parsenode;
     };
 
     /**
@@ -273,28 +355,32 @@ namespace chaiscript
       public:
         Bound_Function(const Const_Proxy_Function &t_f, 
             const std::vector<Boxed_Value> &t_args)
-        : Proxy_Function_Base(std::vector<Type_Info>()),
-          m_f(t_f), m_args(t_args), m_arity(m_f->get_arity()<0?-1:(m_f->get_arity() - m_args.size()))
+          : 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)
         {
+          assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
         }
 
-      virtual bool operator==(const Proxy_Function_Base &) const
+        virtual bool operator==(const Proxy_Function_Base &t_f) const
         {
-        return false;
+          return &t_f == this;
         }
 
         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));
+          return m_f->call_match(build_param_list(vals), t_conversions);
         }
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+        virtual std::vector<Const_Proxy_Function> get_contained_functions() const
         {
-        return (*m_f)(build_param_list(params));
+          std::vector<Const_Proxy_Function> fs;
+          fs.push_back(m_f);
+          return fs;
         }
 
+
         std::vector<Boxed_Value> build_param_list(const std::vector<Boxed_Value> &params) const
         {
           typedef std::vector<Boxed_Value>::const_iterator pitr;
@@ -304,10 +390,10 @@ namespace chaiscript
 
           std::vector<Boxed_Value> args;
 
-        while (true)
+          while (!(parg == params.end() && barg == m_args.end()))
           {
             while (barg != m_args.end() 
-                 && !(barg->get_type_info() == detail::Get_Type_Info<Placeholder_Object>::get()))
+                && !(barg->get_type_info() == chaiscript::detail::Get_Type_Info<Placeholder_Object>::get()))
             {
               args.push_back(*barg);
               ++barg;
@@ -320,15 +406,10 @@ namespace chaiscript
             }
 
             if (barg != m_args.end() 
-              && barg->get_type_info() == detail::Get_Type_Info<Placeholder_Object>::get())
+                && barg->get_type_info() == chaiscript::detail::Get_Type_Info<Placeholder_Object>::get())
             {
               ++barg;
             } 
-
-          if (parg == params.end() && barg == m_args.end())
-          {
-            break;
-          }
           }
           return args;
         }
@@ -340,7 +421,35 @@ namespace chaiscript
 
         virtual std::string annotation() const
         {
-        return "";
+          return "Bound: " + m_f->annotation();
+        }
+
+      protected:
+        static std::vector<Type_Info> build_param_type_info(const Const_Proxy_Function &t_f, 
+            const std::vector<Boxed_Value> &t_args)
+        {
+          assert(t_f->get_arity() < 0 || t_f->get_arity() == static_cast<int>(t_args.size()));
+          if (t_f->get_arity() < 0) { return std::vector<Type_Info>(); }
+
+          std::vector<Type_Info> types = t_f->get_param_types();
+          assert(types.size() == t_args.size() + 1);
+
+          std::vector<Type_Info> retval;
+          retval.push_back(types[0]);
+          for (size_t i = 0; i < types.size()-1; ++i)
+          {
+            if (t_args[i].get_type_info() == chaiscript::detail::Get_Type_Info<Placeholder_Object>::get())
+            {
+              retval.push_back(types[i+1]);
+            }
+          }
+
+          return retval;
+        }
+
+        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), t_conversions);
         }
 
       private:
@@ -359,7 +468,7 @@ namespace chaiscript
     {
       public:
         Proxy_Function_Impl(const boost::function<Func> &f)
-        : Proxy_Function_Base(build_param_type_list(static_cast<Func *>(0))),
+          : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(0))),
           m_f(f), m_dummy_func(0)
         {
         }
@@ -368,33 +477,25 @@ namespace chaiscript
 
         virtual bool operator==(const Proxy_Function_Base &t_func) const
         {
-        try {
-          dynamic_cast<const Proxy_Function_Impl<Func> &>(t_func);
-          return true; 
-        } catch (const std::bad_cast &) {
-          return false;
-        }
+          const Proxy_Function_Impl *pimpl = dynamic_cast<const Proxy_Function_Impl<Func> *>(&t_func);
+          return pimpl != 0;
         }
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
-      {
-        return Do_Call<typename boost::function<Func>::result_type>::go(m_f, params);
-      }
 
         virtual int get_arity() const
         {
-        return m_types.size() - 1;
+          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) || 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
@@ -402,26 +503,213 @@ namespace chaiscript
           return "";
         }
 
+        boost::function<Func> internal_function() const
+        {
+          return m_f;
+        }
+
+      protected:
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        {
+          return detail::Do_Call<typename boost::function<Func>::result_type>::go(m_f, params, t_conversions);
+        }
+
       private:
         boost::function<Func> m_f;
         Func *m_dummy_func;
     };
 
     /**
-   * Exception thrown in the case that a multi method dispatch fails
-   * because no matching function was found
-   * at runtime due to either an arity_error, a guard_error or a bad_boxed_cast
-   * exception
+     * Attribute getter Proxy_Function implementation
      */
-  struct dispatch_error : std::runtime_error
+    template<typename T, typename Class>
+      class Attribute_Access : public Proxy_Function_Base
     {
-    dispatch_error() throw()
-      : std::runtime_error("No matching function to dispatch to")
+      public:
+        Attribute_Access(T Class::* t_attr)
+          : Proxy_Function_Base(param_types()),
+          m_attr(t_attr)
+        {
+        }
+
+        virtual ~Attribute_Access() {}
+
+        virtual bool operator==(const Proxy_Function_Base &t_func) const
+        {
+          const Attribute_Access<T, Class> * aa 
+            = dynamic_cast<const Attribute_Access<T, Class> *>(&t_func);
+          if (aa) {
+            return m_attr == aa->m_attr;
+          } else {
+            return false;
+          }
+        }
+
+
+        virtual int get_arity() const
+        {
+          return 1;
+        }
+
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const
+        {
+          if (vals.size() != 1)
+          {
+            return false;
+          }
+
+          return vals[0].get_type_info().bare_equal(user_type<Class>());
+        }
+
+        virtual std::string annotation() const
+        {
+          return "";
+        }
+
+      protected:
+        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, &t_conversions);
+              return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
+            } else {
+              Class *o = boxed_cast<Class *>(bv, &t_conversions);
+              return detail::Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
+            }
+          } else {
+            throw exception::arity_error(static_cast<int>(params.size()), 1);
+          }       
+        }
+
+      private:
+        static std::vector<Type_Info> param_types()
+        {
+          std::vector<Type_Info> v;
+          v.push_back(user_type<T>());
+          v.push_back(user_type<Class>());
+          return v;
+        }
+        T Class::* m_attr;
+    };
+  }
+
+  namespace exception
+  {
+     /// \brief Exception thrown in the case that a method dispatch fails
+     ///        because no matching function was found
+     /// 
+     /// May be thrown due to an arity_error, a guard_error or a bad_boxed_cast
+     /// exception
+    class dispatch_error : public std::runtime_error
+    {
+      public:
+        dispatch_error(const std::vector<Boxed_Value> &t_parameters, 
+            const std::vector<Const_Proxy_Function> &t_functions)
+          : std::runtime_error("Error with function dispatch"), parameters(t_parameters), functions(t_functions)
         {
         }
 
         virtual ~dispatch_error() throw() {}
+
+        std::vector<Boxed_Value> parameters;
+        std::vector<Const_Proxy_Function> functions;
     };
+  } 
+
+  namespace dispatch
+  {
+    namespace detail 
+    {
+      template<typename FuncType>
+        bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          if (t_func->get_arity() != static_cast<int>(plist.size()))
+          {
+            return false;
+          }
+
+          const std::vector<Type_Info> &types = t_func->get_param_types();
+
+          assert(plist.size() == types.size() - 1);
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (Proxy_Function_Base::compare_type_to_param(types[i+1], plist[i], t_conversions)
+                || (types[i+1].is_arithmetic() && plist[i].get_type_info().is_arithmetic()))
+            {
+              // types continue to match
+            } else {
+              return false;
+            }
+          }
+
+          // all types match
+          return true;
+        }
+
+      template<typename InItr>
+        Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist, 
+            const Dynamic_Cast_Conversions &t_conversions)
+        {
+          InItr orig(begin);
+
+          InItr matching_func(end);
+
+          while (begin != end)
+          {
+            if (types_match_except_for_arithmetic(*begin, plist, t_conversions))
+            {
+              if (matching_func == end)
+              {
+                matching_func = begin;
+              } else {
+                // More than one function matches, not attempting
+                throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+              }
+            }
+
+            ++begin;
+          }
+
+          if (matching_func == end)
+          {
+            // no appropriate function to attempt arithmetic type conversion on
+            throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+          }
+
+
+          std::vector<Boxed_Value> newplist;
+          const std::vector<Type_Info> &tis = (*matching_func)->get_param_types();
+
+          for (size_t i = 0; i < plist.size(); ++i)
+          {
+            if (tis[i+1].is_arithmetic()
+                && plist[i].get_type_info().is_arithmetic()) {
+              newplist.push_back(Boxed_Number(plist[i]).get_as(tis[i+1]).bv);
+            } else {
+              newplist.push_back(plist[i]);
+            }
+          }
+
+          try {
+            return (*(*matching_func))(newplist, t_conversions);
+          } catch (const exception::bad_boxed_cast &) {
+            //parameter failed to cast
+          } catch (const exception::arity_error &) {
+            //invalid num params
+          } catch (const exception::guard_error &) {
+            //guard failed to allow the function to execute
+          }
+
+          throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
+
+        }
+    }
 
     /**
      * Take a vector of functions and a vector of parameters. Attempt to execute
@@ -429,28 +717,29 @@ namespace chaiscript
      * function is found or throw dispatch_error if no matching function is found
      */
     template<typename InItr>
-  Boxed_Value dispatch(InItr begin, InItr end,
-      const std::vector<Boxed_Value> &plist)
+      Boxed_Value dispatch(InItr begin, const InItr &end,
+          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
       {
+        InItr orig(begin);
         while (begin != end)
         {
           try {
-        if (begin->second->filter(plist))
+            if ((*begin)->filter(plist, t_conversions))
             {
-          return (*begin->second)(plist);
+              return (*(*begin))(plist, t_conversions);
             }
-      } catch (const bad_boxed_cast &) {
+          } catch (const exception::bad_boxed_cast &) {
             //parameter failed to cast, try again
-      } catch (const arity_error &) {
+          } catch (const exception::arity_error &) {
             //invalid num params, try again
-      } catch (const guard_error &) {
+          } catch (const exception::guard_error &) {
             //guard failed to allow the function to execute,
             //try again
           }
           ++begin;
         }
 
-    throw dispatch_error();
+        return detail::dispatch_with_conversions(orig, end, plist, t_conversions);
       }
 
     /**
@@ -460,9 +749,10 @@ 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(funcs.begin(), funcs.end(), plist);
+        return dispatch::dispatch(funcs.begin(), funcs.end(), plist, t_conversions);
+      }
   }
 }
 

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -1,31 +1,33 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <boost/preprocessor.hpp>
 
-#define gettypeinfo(z,n,text)  ti.push_back(detail::Get_Type_Info<Param ## n>::get());
-#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n])
-#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n]);
+#define gettypeinfo(z,n,text)  ti.push_back(chaiscript::detail::Get_Type_Info<Param ## n>::get());
+#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n], &t_conversions)
+#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n], &t_conversions);
 
 #ifndef  BOOST_PP_IS_ITERATING
-#ifndef __proxy_functions_detail_hpp__
-#define __proxy_functions_detail_hpp__
+#ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
+#define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
 
 #include "boxed_value.hpp"
+#include "boxed_cast.hpp"
 #include "type_info.hpp"
 #include "handle_return.hpp"
 #include <string>
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
 
 #include <stdexcept>
 #include <vector>
 
 namespace chaiscript
+{
+  namespace exception
   {
     /**
      * Exception thrown when there is a mismatch in number of
@@ -40,30 +42,12 @@ namespace chaiscript
       }
 
       virtual ~arity_error() throw() {}
+
       int got;
       int expected;
     };
-
-  template<typename Ret>
-    struct Do_Call
-    {
-      template<typename Fun>
-      static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
-      {
-        return Handle_Return<Ret>::handle(call_func(fun, params));
   }
-    };
 
-  template<>
-    struct Do_Call<void>
-    {
-      template<typename Fun>
-      static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
-      {
-        call_func(fun, params);
-        return Handle_Return<void>::handle();
-      };
-    };
 }
 
 #define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
@@ -76,6 +60,10 @@ namespace chaiscript
 # define n BOOST_PP_ITERATION()
 
 namespace chaiscript
+{
+  namespace dispatch
+  {
+    namespace detail
     {
       /**
        * Used by Proxy_Function_Impl to return a list of all param types
@@ -85,7 +73,7 @@ namespace chaiscript
         std::vector<Type_Info> build_param_type_list(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
         {
           std::vector<Type_Info> ti;
-      ti.push_back(detail::Get_Type_Info<Ret>::get());
+          ti.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
 
           BOOST_PP_REPEAT(n, gettypeinfo, ~) 
 
@@ -98,36 +86,118 @@ namespace chaiscript
        * if any unboxing fails the execution of the function fails and
        * the bad_boxed_cast is passed up to the caller.
        */
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
       template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
         Ret call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
-        const std::vector<Boxed_Value> &params)
+            const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions & BOOST_PP_IF(n, t_conversions, BOOST_PP_EMPTY))
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
         {
           if (params.size() != n)
           {
-        throw arity_error(params.size(), n);
+            throw exception::arity_error(static_cast<int>(params.size()), n);
           } else {
             return f(BOOST_PP_REPEAT(n, casthelper, ~));
           }
         }
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
       /**
        * Used by Proxy_Function_Impl to determine if it is equivalent to another
        * Proxy_Function_Impl object. This function is primarly used to prevent
        * registration of two functions with the exact same signatures
        */
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
        template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
         bool compare_types_cast(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)),
-        const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, ))
+            const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, BOOST_PP_EMPTY), const Dynamic_Cast_Conversions &t_conversions)
+
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
         {
           try {
+            (void)t_conversions;
             BOOST_PP_REPEAT(n, trycast, ~);
-      } catch (const bad_boxed_cast &) {
+          } catch (const exception::bad_boxed_cast &) {
             return false;
           }
 
           return true;
         }
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+    }
+  }
+}
+
+#undef n
+#undef gettypeinfo
+#undef casthelper
+#undef trycast
+
+
+#endif
+
+
+#ifndef BOOST_PP_IS_ITERATING
+
+namespace chaiscript
+{
+  namespace dispatch
+  {
+    namespace detail
+    {
+    template<typename Ret>
+      struct Do_Call
+      {
+        template<typename Fun>
+          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          {
+            return Handle_Return<Ret>::handle(call_func(fun, params, t_conversions));
+          }
+      };
+
+    template<>
+      struct Do_Call<void>
+      {
+        template<typename Fun>
+          static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          {
+            call_func(fun, params, t_conversions);
+            return Handle_Return<void>::handle();
+          }
+      };
+    }
+  }
 }
 
 #endif

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,11 +1,11 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __register_function_hpp__
-#define __register_function_hpp__
+#ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_
+#define CHAISCRIPT_REGISTER_FUNCTION_HPP_
 
 #include "dispatchkit.hpp"
 #include "bind_first.hpp"
@@ -13,74 +13,149 @@
 #include <boost/bind.hpp>
 #include <boost/function_types/components.hpp>
 #include <boost/function_types/function_type.hpp>
+#include <boost/function_types/is_member_object_pointer.hpp>
+#include <boost/function_types/is_member_function_pointer.hpp>
 
 namespace chaiscript
+{
+  namespace dispatch
   {
     namespace detail
     {
-    /**
-     * Helper function for register_member function
-     */
-    template<typename T, typename Class>
-      T &get_member(T Class::* m, Class *obj)
+      template<bool Object, bool MemFn>
+        struct Fun_Helper
         {
-        return (obj->*m);
-      }
-
           template<typename T>
-    boost::function<T> mk_boost_fun(const boost::function<T> &f)
+            static Proxy_Function go(T t)
             {
-      return f;
-    }
-
-    template<typename T>
+              return Proxy_Function(
+                  new Proxy_Function_Impl<
+                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
                     boost::function< 
                     typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-          >  mk_boost_fun(T t)
+                    >(t)));
+            }      
+        };
+
+      template<>
+        struct Fun_Helper<false, true>
         {
-      return 
+          template<typename T>
+            static Proxy_Function go(T t)
+            {
+              return Proxy_Function(
+                  new Proxy_Function_Impl<
+                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
                     boost::function< 
                     typename boost::function_types::function_type<boost::function_types::components<T> >::type 
-          >(t);
+                    >(boost::mem_fn(t))));
             }      
+        };
 
+
+      template<>
+        struct Fun_Helper<true, false>
+        {
           template<typename T, typename Class>
-      Proxy_Function fun_helper(T Class::* m)
+            static Proxy_Function go(T Class::* m)
             {
-        return fun_helper(boost::function<T& (Class *)>(boost::bind(&detail::get_member<T, Class>, m, _1)));
+              return Proxy_Function(new Attribute_Access<T, Class>(m));
             }
-
-
-    template<typename T>
-      Proxy_Function fun_helper(const boost::function<T> &f)
-      {
-        return Proxy_Function(new Proxy_Function_Impl<T>(f));
+        };
     }
   }
 
+  /// \brief Creates a new Proxy_Function object from a boost::function object
+  /// \param[in] f boost::function to expose to ChaiScript
+  ///
+  /// \b Example:
+  /// \code
+  /// boost::function<int (char, float, std::string)> f = get_some_function();
+  /// chaiscript::ChaiScript chai;
+  /// chai.add(fun(f), "some_function");
+  /// \endcode
+  /// 
+  /// \sa \ref addingfunctions
   template<typename T>
     Proxy_Function fun(const boost::function<T> &f)
     {
-      return detail::fun_helper(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
+  ///
+  /// \b Example:
+  /// \code
+  /// int myfunction(const std::string &);
+  /// class MyClass
+  /// {
+  ///   public:
+  ///     void memberfunction();
+  ///     int memberdata;
+  /// };
+  /// 
+  /// chaiscript::ChaiScript chai;
+  /// chai.add(fun(&myfunction), "myfunction");
+  /// chai.add(fun(&MyClass::memberfunction), "memberfunction");
+  /// chai.add(fun(&MyClass::memberdata), "memberdata");
+  /// \endcode
+  /// 
+  /// \sa \ref addingfunctions
   template<typename T>
     Proxy_Function fun(T t)
     {
-      return detail::fun_helper(detail::mk_boost_fun(t));
+      return dispatch::detail::Fun_Helper<boost::function_types::is_member_object_pointer<T>::value, boost::function_types::is_member_function_pointer<T>::value>::go(t);
     }
 
-
+  /// \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
+  ///
+  /// \b Example:
+  /// \code
+  /// struct MyClass
+  /// {
+  ///   void memberfunction(int);
+  /// };
+  /// 
+  /// MyClass obj;
+  /// chaiscript::ChaiScript chai;
+  /// // Add function taking only one argument, an int, and permanently bound to "obj"
+  /// chai.add(fun(&MyClass::memberfunction, boost::ref(obj)), "memberfunction"); 
+  /// \endcode
+  /// 
+  /// \sa \ref addingfunctions
   template<typename T, typename Q>
     Proxy_Function fun(T t, const Q &q)
     {
-      return detail::fun_helper(bind_first(t, q));
+      return fun(detail::bind_first(t, q));
     }
 
+  /// \brief Creates a new Proxy_Function object from a free function or member function and binds the first and second parameters of it
+  /// \param[in] t Function / member to expose
+  /// \param[in] q Value to bind to first parameter
+  /// \param[in] r Value to bind to second parameter
+  ///
+  /// \b Example:
+  /// \code
+  /// struct MyClass
+  /// {
+  ///   void memberfunction(int);
+  /// };
+  /// 
+  /// MyClass obj;
+  /// chaiscript::ChaiScript chai;
+  /// // Add function taking only no arguments, and permanently bound to "obj" and "1"
+  /// // memberfunction() will be equivalent to obj.memberfunction(1)
+  /// chai.add(fun(&MyClass::memberfunction, boost::ref(obj), 1), "memberfunction"); 
+  /// \endcode
+  /// 
+  /// \sa \ref addingfunctions
   template<typename T, typename Q, typename R>
     Proxy_Function fun(T t, const Q &q, const R &r)
     {
-      return detail::fun_helper(bind_first(bind_first(t, q), r));
+      return fun(detail::bind_first(detail::bind_first(t, q), r));
     }
    
 }

include/chaiscript/dispatchkit/type_info.hpp

@@ -1,16 +1,21 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef __type_info_hpp__
-#define __type_info_hpp__
+#ifndef CHAISCRIPT_TYPE_INFO_HPP_
+#define CHAISCRIPT_TYPE_INFO_HPP_
 
+#include <string>
+#include <typeinfo>
+#include <boost/shared_ptr.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_reference.hpp>
 #include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/remove_pointer.hpp>
@@ -18,46 +23,57 @@
 
 namespace chaiscript
 {
-  /**
-   * compile time deduced information about a type
-   */
+
+  namespace detail
+  {
+    template<typename T>
+      struct Bare_Type
+      {
+        typedef typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type type;
+      };
+  }
+
+  /// \brief Compile time deduced information about a type
   class Type_Info
   {
     public:
       Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
-          const std::type_info *t_ti, const std::type_info *t_bareti)
-        : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
-        m_is_void(t_is_void),
-        m_type_info(t_ti), m_bare_type_info(t_bareti),
-        m_is_unknown(false)
+          bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bareti)
+        : m_type_info(t_ti), m_bare_type_info(t_bareti),
+        m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
+        m_is_void(t_is_void), m_is_arithmetic(t_is_arithmetic),
+        m_is_undef(false)
       {
       }
 
       Type_Info()
-        : m_is_const(false), m_is_reference(false), m_is_pointer(false),
-        m_is_void(false), m_type_info(0), m_bare_type_info(0),
-        m_is_unknown(true)
+        : m_type_info(0), m_bare_type_info(0),
+        m_is_const(false), m_is_reference(false), m_is_pointer(false),
+        m_is_void(false), m_is_arithmetic(false), 
+        m_is_undef(true)
       {
       }
 
       Type_Info(const Type_Info &ti)
-        : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
-        m_is_pointer(ti.m_is_pointer),
-        m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
+        : m_type_info(ti.m_type_info), 
         m_bare_type_info(ti.m_bare_type_info),
-        m_is_unknown(ti.m_is_unknown)
+        m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
+        m_is_pointer(ti.m_is_pointer),
+        m_is_void(ti.m_is_void), m_is_arithmetic(ti.m_is_arithmetic),
+        m_is_undef(ti.m_is_undef)
       {
       }
 
       Type_Info &operator=(const Type_Info &ti)
       {
+        m_type_info = ti.m_type_info;
+        m_bare_type_info = ti.m_bare_type_info;
         m_is_const = ti.m_is_const;
         m_is_reference = ti.m_is_reference;
         m_is_pointer = ti.m_is_pointer;
         m_is_void = ti.m_is_void;
-        m_type_info = ti.m_type_info;
-        m_bare_type_info = ti.m_bare_type_info;
-        m_is_unknown = ti.m_is_unknown;
+        m_is_arithmetic = ti.m_is_arithmetic;
+        m_is_undef = ti.m_is_undef;
         return *this;
       }
 
@@ -83,10 +99,28 @@ namespace chaiscript
           || (ti.m_bare_type_info && m_bare_type_info && *ti.m_bare_type_info == *m_bare_type_info);
       }
 
+      bool bare_equal_type_info(const std::type_info &ti) const
+      {
+        return m_bare_type_info != 0 
+          && (*m_bare_type_info) == ti;
+      }
+
       bool is_const() const { return m_is_const; }
       bool is_reference() const { return m_is_reference; }
       bool is_void() const { return m_is_void; }
-      bool is_unknown() const { return m_is_unknown || m_bare_type_info == 0; }
+      bool is_arithmetic() const { return m_is_arithmetic; }
+      bool is_undef() const { return m_is_undef || m_bare_type_info == 0; }
+      bool is_pointer() const { return m_is_pointer; }
+
+      std::string name() const
+      {
+        if (m_type_info)
+        {
+          return m_type_info->name();
+        } else {
+          return "";
+        }
+      }
 
       std::string bare_name() const
       {
@@ -99,13 +133,14 @@ namespace chaiscript
       }
 
     private:
+      const std::type_info *m_type_info;
+      const std::type_info *m_bare_type_info;
       bool m_is_const;
       bool m_is_reference;
       bool m_is_pointer;
       bool m_is_void;
-      const std::type_info *m_type_info;
-      const std::type_info *m_bare_type_info;
-      bool m_is_unknown;
+      bool m_is_arithmetic;
+      bool m_is_undef;
   };
 
   namespace detail
@@ -116,59 +151,109 @@ namespace chaiscript
     template<typename T>
       struct Get_Type_Info
       {
+        typedef T type;
+
         static Type_Info get()
         {
-          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+          return Type_Info(boost::is_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(T), 
-              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+              &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
       struct Get_Type_Info<boost::shared_ptr<T> >
       {
+        typedef T type;
+
         static Type_Info get()
         {
           return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(boost::shared_ptr<T> ), 
-              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+              &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
       struct Get_Type_Info<const boost::shared_ptr<T> &>
       {
+        typedef T type;
+
         static Type_Info get()
         {
           return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(const boost::shared_ptr<T> &), 
-              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+              &typeid(typename Bare_Type<T>::type));
         }
       };
 
     template<typename T>
       struct Get_Type_Info<boost::reference_wrapper<T> >
       {
+        typedef T type;
+
         static Type_Info get()
         {
           return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
               boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
               &typeid(boost::reference_wrapper<T> ), 
-              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+              &typeid(typename Bare_Type<T>::type));
         }
       };
+
+    template<typename T>
+      struct Get_Type_Info<const boost::reference_wrapper<T> &>
+      {
+        typedef T type;
+
+        static Type_Info get()
+        {
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              boost::is_arithmetic<T>::value && !boost::is_same<typename boost::remove_const<T>::type, bool>::value,
+              &typeid(const boost::reference_wrapper<T> &), 
+              &typeid(typename Bare_Type<T>::type));
+        }
+      };
+
+    template<typename T>
+      struct Stripped_Type
+      {
+        typedef typename Bare_Type<typename detail::Get_Type_Info<T>::type>::type type;
+      };
   }
 
+  /// \brief Creates a Type_Info object representing the type passed in
+  /// \tparam T Type of object to get a Type_Info for, derived from the passed in parameter
+  /// \return Type_Info for T
+  /// 
+  /// \b Example:
+  /// \code
+  /// int i;
+  /// chaiscript::Type_Info ti = chaiscript::user_type(i);
+  /// \endcode
   template<typename T>
-  Type_Info user_type(T)
+  Type_Info user_type(const T &/*t*/)
   {
     return detail::Get_Type_Info<T>::get();
   }
 
 
+  /// \brief Creates a Type_Info object representing the templated type
+  /// \tparam T Type of object to get a Type_Info for
+  /// \return Type_Info for T
+  /// 
+  /// \b Example:
+  /// \code
+  /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
+  /// \endcode
   template<typename T>
   Type_Info user_type()
   {

include/chaiscript/language/chaiscript_algebraic.hpp

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

include/chaiscript/language/chaiscript_common.hpp

@@ -1,134 +1,575 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
-#ifndef _CHAISCRIPT_COMMON_HPP
-#define	_CHAISCRIPT_COMMON_HPP
+#ifndef CHAISCRIPT_COMMON_HPP_
+#define	CHAISCRIPT_COMMON_HPP_
 
-
-#ifdef  BOOST_HAS_DECLSPEC
-#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
-#else
-#define CHAISCRIPT_MODULE_EXPORT extern "C"
-#endif
+#include <chaiscript/dispatchkit/dispatchkit.hpp>
+#include <boost/enable_shared_from_this.hpp>
 
 namespace chaiscript
 {
+  /// Signature of module entry point that all binary loadable modules must implement.
   typedef ModulePtr (*Create_Module_Func)();
 
-    /**
-     * Types of AST nodes available to the parser and eval
-     */
-    class Token_Type { public: enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
-        Expression, Comparison, Additive, Multiplicative, Negate, Not, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
-        Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
-        Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl, Shift }; };
+
+  /// Types of AST nodes available to the parser and eval
+  class AST_Node_Type {
+  public:
+    enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
+                Comparison, Addition, Subtraction, Multiplication, Division, Modulus, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
+                Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Continue, Map_Pair, Value_Range,
+                Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl, Shift, Equality, Bitwise_And, Bitwise_Xor, Bitwise_Or, 
+                Logical_And, Logical_Or, Switch, Case, Default, Ternary_Cond, Noop
+    };
+  };
 
   namespace
   {
-      /**
-       * Helper lookup to get the name of each node type
-       */
-      const char *token_type_to_string(int tokentype) {
-        const char *token_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Inplace_Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
-          "Expression", "Comparison", "Additive", "Multiplicative", "Negate", "Not", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
-          "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
-          "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Shift"};
 
-        return token_types[tokentype];
+    /// 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", "Continue", "Map_Pair", "Value_Range",
+                                    "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Shift", "Equality", "Bitwise_And", "Bitwise_Xor", "Bitwise_Or", 
+                                    "Logical_And", "Logical_Or", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
+
+      return ast_node_types[ast_node_type];
     }
   }
 
-    /**
-     * Convenience type for file positions
-     */
+  /// \brief Convenience type for file positions
   struct File_Position {
     int line;
     int column;
 
-        File_Position(int file_line, int file_column)
-            : line(file_line), column(file_column) { }
+    File_Position(int t_file_line, int t_file_column)
+      : line(t_file_line), column(t_file_column) { }
 
     File_Position() : line(0), column(0) { }
   };
 
-    typedef boost::shared_ptr<struct Token> TokenPtr;
+  /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
+  typedef boost::shared_ptr<struct AST_Node> AST_NodePtr;
 
-    /**
-     * The struct that doubles as both a parser token and an AST node
-     */
-    struct Token {
-        std::string text;
-        int identifier;
-        const char *filename;
-        File_Position start, end;
-        bool is_cached;
-        Boxed_Value cached_value;
 
-        std::vector<TokenPtr> children;
-        TokenPtr annotation;
+  /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
+  namespace exception
+  {
 
-        Token(const std::string &token_text, int id, const char *fname) :
-            text(token_text), identifier(id), filename(fname), is_cached(false) { }
-
-        Token(const std::string &token_text, int id, const char *fname, int start_line, int start_col, int end_line, int end_col) :
-            text(token_text), identifier(id), filename(fname), is_cached(false) {
-
-            start.line = start_line;
-            start.column = start_col;
-            end.line = end_line;
-            end.column = end_col;
-        }
-    };
-
-    /**
-     * Errors generated during parsing or evaluation
-     */
-    struct Eval_Error : public std::runtime_error {
+    /// Errors generated during parsing or evaluation
+    struct eval_error : public std::runtime_error {
       std::string reason;
       File_Position start_position;
       File_Position end_position;
-        const char *filename;
+      std::string filename;
+      std::string detail;
+      std::vector<AST_NodePtr> call_stack;
 
-        Eval_Error(const std::string &why, const File_Position &where, const char *fname) :
-            std::runtime_error("Error: \"" + why + "\" " +
-                (std::string(fname) != "__EVAL__" ? ("in '" + std::string(fname) + "' ") : "during evaluation ") +
-                + "at (" + boost::lexical_cast<std::string>(where.line) + ", " +
-                boost::lexical_cast<std::string>(where.column) + ")"),
-            reason(why), start_position(where), end_position(where), filename(fname)
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
+          const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)  :
+        std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_dot_notation, t_ss)),
+        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss))
       {}
 
-        Eval_Error(const std::string &why, const TokenPtr &where)
-            : std::runtime_error("Error: \"" + why + "\" " +
-                (std::string(where->filename) != "__EVAL__" ? ("in '" + std::string(where->filename) + "' ") : "during evaluation ") +
-                "at (" + boost::lexical_cast<std::string>(where->start.line) + ", " +
-                boost::lexical_cast<std::string>(where->start.column) + ")"),
-              reason(why), start_position(where->start), end_position(where->end), filename(where->filename) {
+      eval_error(const std::string &t_why, 
+           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+           bool t_dot_notation,
+           const chaiscript::detail::Dispatch_Engine &t_ss) :
+        std::runtime_error(format(t_why, t_parameters, t_dot_notation, t_ss)),
+        reason(t_why), detail(format_detail(t_functions, t_dot_notation, t_ss))
+      {}
+
+
+      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname) :
+        std::runtime_error(format(t_why, t_where, t_fname)),
+        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
+      {}
+
+      eval_error(const std::string &t_why) throw()
+        : std::runtime_error("Error: \"" + t_why + "\" "),
+        reason(t_why) 
+      {}
+
+      std::string pretty_print() const
+      {
+        std::ostringstream ss;
+
+        ss << what();
+        if (call_stack.size() > 0) {
+          ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")" << std::endl;
+          ss << std::endl << detail << std::endl;
+          ss << "  " << fname(call_stack[0]) << " (" << startpos(call_stack[0]) << ") '" << pretty(call_stack[0]) << "'";
+          for (size_t j = 1; j < call_stack.size(); ++j) {
+            if (id(call_stack[j]) != chaiscript::AST_Node_Type::Block
+                && id(call_stack[j]) != chaiscript::AST_Node_Type::File)
+            {
+              ss << std::endl;
+              ss << "  from " << fname(call_stack[j]) << " (" << startpos(call_stack[j]) << ") '" << pretty(call_stack[j]) << "'";
+            }
+          }
+        }
+        ss << std::endl;
+        return ss.str();
       }
 
-        virtual ~Eval_Error() throw() {}
+      virtual ~eval_error() throw() {}
+
+    private:
+
+      template<typename T>
+        static int id(const T& t)
+        {
+          return t->identifier;
+        }
+
+      template<typename T>
+        static std::string pretty(const T& t)
+        {
+          return t->pretty_print();
+        }
+
+      template<typename T>
+        static std::string fname(const T& t)
+        {
+          return *t->filename;
+        }
+
+      template<typename T>
+        static std::string startpos(const T& t)
+        {
+          std::ostringstream oss;
+          oss << t->start.line << ", " << t->start.column;
+          return oss.str();
+        }
+
+      static std::string format_why(const std::string &t_why)
+      {
+        return "Error: \"" + t_why + "\"";
+      }
+
+      static std::string format_types(const Const_Proxy_Function &t_func,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        int arity = t_func->get_arity();
+        std::vector<Type_Info> types = t_func->get_param_types();
+
+        std::string retval;
+        if (arity == -1)
+        {
+          retval = "(...)";
+          if (t_dot_notation)
+          {
+            retval = "(Object)." + retval;
+          }
+        } else if (types.size() <= 1) {
+          retval = "()";
+        } else {
+          std::stringstream ss;
+          ss << "(";
+
+          std::string paramstr;
+
+          for (size_t index = 1;
+               index != types.size();
+               ++index)
+          {
+            paramstr += (types[index].is_const()?"const ":"");
+            paramstr += t_ss.get_type_name(types[index]);
+
+            if (index == 1 && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (types.size() == 2)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+
+          ss << ")";
+          retval = ss.str();
+        }
+
+
+        boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfun 
+          = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_func);
+
+        if (dynfun)
+        {
+          Proxy_Function f = dynfun->get_guard();
+
+          if (f)
+          {
+            boost::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfunguard 
+              = boost::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(f);
+            if (dynfunguard)
+            {
+              retval += " : " + format_guard(dynfunguard->get_parse_tree());
+            }
+          }
+
+          retval += "\n          Defined at " + format_location(dynfun->get_parse_tree());        
+        }
+
+        return retval;
+      }
+
+      template<typename T>
+        static std::string format_guard(const T &t)
+        {
+          return t->pretty_print();
+        }
+
+      template<typename T>
+        static std::string format_location(const T &t)
+        {
+          std::ostringstream oss;
+          oss << "(" << *t->filename << " " << t->start.line << ", " << t->start.column << ")"; 
+
+          return oss.str();
+
+        }
+
+      static std::string format_detail(const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        if (t_functions.size() == 1)
+        {
+          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << std::endl;
+        } else {
+          ss << "  " << t_functions.size() << " overloads available:" << std::endl;
+
+          for (std::vector<chaiscript::Const_Proxy_Function>::const_iterator itr = t_functions.begin();
+               itr != t_functions.end();
+               ++itr)
+          {
+            ss << "      " << format_types((*itr), t_dot_notation, t_ss) << std::endl;
+          }
+
+        }
+
+        return ss.str();
+
+      }
+
+      static std::string format_parameters(const std::vector<Boxed_Value> &t_parameters,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+        ss << "(";
+
+        if (!t_parameters.empty())
+        {
+          std::string paramstr;
+
+          for (std::vector<Boxed_Value>::const_iterator itr = t_parameters.begin();
+               itr != t_parameters.end();
+               ++itr)
+          {
+            paramstr += (itr->is_const()?"const ":"");
+            paramstr += t_ss.type_name(*itr);
+
+            if (itr == t_parameters.begin() && t_dot_notation)
+            {
+              paramstr += ").(";
+              if (t_parameters.size() == 1)
+              {
+                paramstr += ", ";
+              }
+            } else {
+              paramstr += ", ";
+            }
+          }
+
+          ss << paramstr.substr(0, paramstr.size() - 2);
+        }
+        ss << ")";
+
+        return ss.str();
+      }
+
+      static std::string format_filename(const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        if (t_fname != "__EVAL__")
+        {
+          ss << "in '" << t_fname << "' ";
+        } else {
+          ss << "during evaluation ";
+        }
+
+        return ss.str();
+      }
+
+      static std::string format_location(const File_Position &t_where)
+      {
+        std::stringstream ss;
+        ss << "at (" << t_where.line << ", " << t_where.column << ")";
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
+          const std::vector<Boxed_Value> &t_parameters, bool t_dot_notation, const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, 
+          const std::vector<Boxed_Value> &t_parameters, 
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
+        ss << " ";
+
+        return ss.str();
+      }
+
+      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname)
+      {
+        std::stringstream ss;
+
+        ss << format_why(t_why);
+        ss << " ";
+
+        ss << format_filename(t_fname);
+        ss << " ";
+
+        ss << format_location(t_where);
+
+        return ss.str();
+      }
     };
 
-    /**
-     * Special type for returned values
-     */
+
+    /// Errors generated when loading a file
+    struct file_not_found_error : public std::runtime_error {
+      file_not_found_error(const std::string &t_filename) throw()
+        : std::runtime_error("File Not Found: " + t_filename)
+      { }
+
+      virtual ~file_not_found_error() throw() {}
+    };
+
+  }
+
+ 
+  /// \brief Struct that doubles as both a parser ast_node and an AST node.
+  struct AST_Node : boost::enable_shared_from_this<AST_Node> {
+    public:
+      const std::string text;
+      const int identifier;
+      boost::shared_ptr<const std::string> filename;
+      File_Position start, end;
+      std::vector<AST_NodePtr> children;
+      AST_NodePtr annotation;
+
+      virtual std::string pretty_print() const
+      {
+        std::ostringstream oss;
+
+        oss << text;
+
+        for (unsigned int j = 0; j < this->children.size(); ++j) {
+          oss << this->children[j]->pretty_print();
+        }
+
+        return oss.str();
+      }
+
+
+      /// Prints the contents of an AST node, including its children, recursively
+      std::string to_string(std::string t_prepend = "") {
+        std::ostringstream oss;
+
+        oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
+            << this->text << " : " << this->start.line << ", " << this->start.column << std::endl;
+        
+        for (unsigned int j = 0; j < this->children.size(); ++j) {
+          oss << this->children[j]->to_string(t_prepend + "  ");
+        }
+        return oss.str();
+      }
+
+      std::string internal_to_string() {
+        return to_string();
+      }
+
+      Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) 
+      {
+        try {
+          return eval_internal(t_e);
+        } catch (exception::eval_error &ee) {
+          ee.call_stack.push_back(shared_from_this());
+          throw ee;
+        }
+      }
+
+
+      void replace_child(const AST_NodePtr &t_child, const AST_NodePtr &t_new_child)
+      {
+        std::replace(children.begin(), children.end(), t_child, t_new_child);
+      }
+
+    protected:
+      AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname, 
+          int t_start_line, int t_start_col, int t_end_line, int t_end_col) :
+        text(t_ast_node_text), identifier(t_id), filename(t_fname),
+        start(t_start_line, t_start_col), end(t_end_line, t_end_col)
+      {
+      }
+
+      AST_Node(const std::string &t_ast_node_text, int t_id, const boost::shared_ptr<std::string> &t_fname) :
+        text(t_ast_node_text), identifier(t_id), filename(t_fname) {}
+
+      virtual ~AST_Node() {}
+
+      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &)
+      {
+        throw std::runtime_error("Undispatched ast_node (internal error)");
+      }
+
+    private:
+      // Copy and assignment explicitly unimplemented
+      AST_Node(const AST_Node &);
+      AST_Node& operator=(const AST_Node &);
+  };
+
+
+  namespace eval
+  {
+    namespace detail
+    {
+
+      /// Special type for returned values
       struct Return_Value {
         Boxed_Value retval;
-        TokenPtr location;
 
-        Return_Value(const Boxed_Value &return_value, const TokenPtr where) : retval(return_value), location(where) { }
+        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 {
-        TokenPtr location;
-
-        Break_Loop(const TokenPtr where) : location(where) { }
+        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
+      {
+        Scope_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_scope();
+        }
+
+        ~Scope_Push_Pop()
+        {
+          m_de.pop_scope();
+        }
+
+
+        private:
+        // explicitly unimplemented copy and assignment
+        Scope_Push_Pop(const Scope_Push_Pop &);
+        Scope_Push_Pop& operator=(const Scope_Push_Pop &);
+
+        chaiscript::detail::Dispatch_Engine &m_de;
+      };
+
+      /// Creates a new functon call and pops it on destruction
+      struct Function_Push_Pop
+      {
+        Function_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_function_call();
+        }
+
+        ~Function_Push_Pop()
+        {
+          m_de.pop_function_call();
+        }
+
+        void save_params(const std::vector<Boxed_Value> &t_params)
+        {
+          m_de.save_function_params(t_params);
+        }
+
+
+        private:
+        // explicitly unimplemented copy and assignment
+        Function_Push_Pop(const Function_Push_Pop &);
+        Function_Push_Pop& operator=(const Function_Push_Pop &);
+
+        chaiscript::detail::Dispatch_Engine &m_de;
+      };
+
+      /// Creates a new scope then pops it on destruction
+      struct Stack_Push_Pop
+      {
+        Stack_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_stack();
+        }
+
+        ~Stack_Push_Pop()
+        {
+          m_de.pop_stack();
+        }
+
+
+        private:
+        // explicitly unimplemented copy and assignment
+        Stack_Push_Pop(const Stack_Push_Pop &);
+        Stack_Push_Pop& operator=(const Stack_Push_Pop &);
+
+        chaiscript::detail::Dispatch_Engine &m_de;
+      };
+    }
+  }
 }
 
 #endif	/* _CHAISCRIPT_COMMON_HPP */

include/chaiscript/language/chaiscript_prelude.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_PRELUDE_HPP_
@@ -131,11 +131,11 @@ def product(container) { foldl(container, `*`, 1.0) } \n\
 # Returns a new container with the elements of the first value concatenated with the elements of the second value\n\
 def concat(x, y) : call_exists(clone, x) { \n\
   var retval = x; \n\
-  var len = y.size(); \n\
-  var i = 0; \n\
-  while (i < len) { \n\
-    retval.push_back(y[i]); \n\
-    ++i; \n\
+  var inserter = back_inserter(retval); \n\
+  var range = range(y); \n\
+  while (!range.empty()) { \n\
+    inserter(range.front()); \n\
+    range.pop_front(); \n\
   } \n\
   retval; \n\
 } \n\
@@ -282,38 +282,38 @@ def zip(x, y) { \n\
 }\n\
 # Returns the position of the second value string in the first value string\n\
 def string::find(substr) : is_type(substr, "string") { \n\
-  int(find(this, substr, size_t(0))); \n\
+  int(find(this, substr, 0)); \n\
 } \n\
 # Returns the position of last match of the second value string in the first value string\n\
 def string::rfind(substr) : is_type(substr, "string") { \n\
-  int(rfind(this, substr, size_t(-1))); \n\
+  int(rfind(this, substr, -1)); \n\
 } \n\
 # Returns the position of the first match of elements in the second value string in the first value string\n\
 def string::find_first_of(list) : is_type(list, "string") { \n\
-  int(find_first_of(this, list, size_t(0))); \n\
+  int(find_first_of(this, list, 0)); \n\
 } \n\
 # Returns the position of the last match of elements in the second value string in the first value string\n\
 def string::find_last_of(list) : is_type(list, "string") { \n\
-  int(find_last_of(this, list, size_t(-1))); \n\
+  int(find_last_of(this, list, -1)); \n\
 } \n\
 # Returns the position of the first non-matching element in the second value string in the first value string\n\
 def string::find_first_not_of(list) : is_type(list, "string") { \n\
-  int(find_first_not_of(this, list, size_t(0))); \n\
+  int(find_first_not_of(this, list, 0)); \n\
 } \n\
 # Returns the position of the last non-matching element in the second value string in the first value string\n\
 def string::find_last_not_of(list) : is_type(list, "string") { \n\
-  int(find_last_not_of(this, list, size_t(-1))); \n\
+  int(find_last_not_of(this, list, -1)); \n\
 } \n\
 def string::ltrim() { \n\
-  drop_while(this, fun(x) { x == ' ' || x == '\t' }); \n\
+  drop_while(this, fun(x) { x == ' ' || x == '\t' || x == '\r' || x == '\n'}); \n\
 } \n\
 def string::rtrim() { \n\
-  reverse(drop_while(reverse(this), fun(x) { x == ' ' || x == '\t' })); \n\
+  reverse(drop_while(reverse(this), fun(x) { x == ' ' || x == '\t' || x == '\r' || x == '\n'})); \n\
 } \n\
 def string::trim() { \n\
   ltrim(rtrim(this)); \n\
 } \n\
-def find(container, value, compare_func) : call_exists(range, container) && is_type(compare_func, "function") { \n\
+def find(container, value, compare_func) : call_exists(range, container) && is_type(compare_func, "Function") { \n\
   var range = range(container); \n\
   while (!range.empty()) { \n\
     if (compare_func(range.front(), value)) { \n\

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -0,0 +1,830 @@
+/// This file is not technically part of the ChaiScript API. It is used solely for generating Doxygen docs
+/// regarding the ChaiScript standard runtime library.
+
+/// \brief Items in this namespace exist in the ChaiScript language runtime. They are not part of the C++ API
+namespace ChaiScript_Language
+{
+
+/// \page LangStandardLibraryRef ChaiScript Language Standard Libary Reference
+///
+/// ChaiScript, at its core, has some very functional programming-inspired habits. Few places show this off as clearly 
+/// as the prelude, itself a name taken as a nod to the popular functional language Haskell. This prelude is available 
+/// to all standard ChaiScript applications, and provides a simple foundation for using numbers, strings, and ranges 
+/// (the general category of Range cs and their iteration).
+///
+
+
+/// \brief Generic concept of a value in ChaiScript. 
+///
+/// The Object type exists merely as a concept. All objects in ChaiScript support this concept 
+/// and have the following methods available to them. All objects are stored internally as chaiscript::Boxed_Value types.
+///
+/// \sa chaiscript::Boxed_Value
+class Object
+{
+  public:
+    /// \brief Returns the Type_Info value for this Object
+    Type_Info get_type_info() const;
+
+    /// \brief Returns true if the Object is of the named type
+    bool is_type(string) const;
+
+    /// \brief Returns true if the Object is of the Type_Info passed in
+    bool is_type(Type_Info) const;
+
+    /// \brief Returns true if the Object is immutable
+    bool is_var_const() const;
+
+    /// \brief Returns true if the Object is a pointer and the pointer is null
+    bool is_var_null() const;
+
+    /// \brief Returns true if the Object is stored as a pointer
+    bool is_var_pointer() const;
+
+    /// \brief Returns true if the Object is stored as a reference    
+    bool is_var_reference() const;
+
+    /// \brief Returns true if the Object does not contain a value is is undefined.
+    bool is_var_undef() const;
+
+    /// \brief Returns the registered name of the type of the object. 
+    ///
+    /// \sa Type_Info::name();
+    string type_name() const;
+};
+
+/// \brief Item returned from a Range object from a Map
+class Map_Pair
+{
+  public:
+    /// \brief Returns the key of the Map entry
+    const string first();
+
+    /// \brief Returns the value Object of the Map entry 
+    Object second();
+};
+
+
+/// \brief Maps strings to Objects
+///
+/// ChaiScript has a built in shortcut for generating Map objects:
+/// 
+/// Example:
+/// \code
+/// eval> var m = ["a":1, "b":2];
+/// [<a,1>, <b,2>]
+/// eval> m.count("a");
+/// 1
+/// eval> m.count("c");
+/// 0
+/// eval> m.size();
+/// 2
+/// \endcode
+///
+/// Implemented as std::map<Boxed_Value>
+///
+/// \sa Map_Pair
+/// \sa chaiscript::bootstrap::standard_library::map_type
+class Map
+{
+  public:
+    /// \brief Returns an object that implements the Range concept for the Map_Pair's in this Map
+    Range range();
+
+    /// \brief Returns an object that implements the Const_Range concept for the Map_Pair's in this Map
+    Const_Range range() const;
+
+    /// \brief Returns the number of elements in the Map
+    int size() const;
+
+    /// \brief Returns the item at the given key, creating an undefined Object if the key does not yet exist in the map
+    Object operator[](string);
+
+    /// \brief Clears the map of all items
+    void clear();
+
+    /// \brief Returns the number of items in the Map with the given key. Returns 0 or 1 since this is not an std::multimap.
+    int count(string) const;
+
+    /// \brief Returns true if the map contains no items
+    bool empty() const;
+
+};
+
+
+/// \brief A concept implemented by string, Vector and Map. It is convertable to Range, default constructable and back_insertable
+class Container
+{
+  public:
+    void push_back(Object);
+    Range range();
+    Const_Range range() const;
+};
+
+
+/// \brief Converts o into a string.
+///
+/// \code
+/// eval> to_string(3).is_type("string") <br>
+/// true<br>
+/// \endcode
+string to_string(Object o);
+
+
+/// \brief Prints o to the terminal, without a trailing carriage return. Applies conversions to string automatically.
+/// \code
+/// eval> puts("hi, "); puts("there")
+/// hi, thereeval>
+/// \endcode
+/// \sa to_string
+/// \sa print
+void puts(Object o);
+
+
+/// \brief Prints o to the terminal, with a trailing carriage return. Applies conversions to string automatically
+/// \code
+/// eval> print("hello")
+/// hello
+/// eval>
+/// \endcode
+/// \sa to_string
+/// \sa puts
+void print(Object o);
+
+/// \brief ChaiScript representation of std::string. It is an std::string but only some member are exposed to ChaiScript.
+/// 
+/// Because the ChaiScript string object is an std::string, it is directly convertable to and from std::string
+/// using the chaiscript::boxed_cast and chaiscript::var functions.
+///
+/// With the exception of string::trim, string::rtrim, string::ltrim, all members are direct passthroughs to the
+/// std::string of the same name. 
+///
+/// \note Object and function notations are equivalent in ChaiScript. This means that
+///       \c "bob".find("b") and \c find("bob", "b") are exactly the same. Most examples below follow the
+///       second formation of the function calls.
+/// \sa \ref keyworddef for extending existing C++ classes in ChaiScript
+/// \sa chaiscript::bootstrap::standard_library::string_type
+class string
+{
+  public:
+    /// \brief Finds the first instance of substr.
+    /// \code
+    /// eval> find("abab", "ab")
+    /// 0
+    /// \endcode
+    int find(string s) const;
+
+
+    /// \brief Finds the last instance of substr.
+    /// \code
+    /// eval> rfind("abab", "ab")
+    /// 2
+    /// \endcode
+    int rfind(string s) const;
+
+    /// \brief Finds the first of characters in list in the string.
+    ///
+    /// \code
+    /// eval> find_first_of("abab", "bec")
+    /// 1
+    /// \endcode
+    int find_first_of(string list) const;
+
+    /// \brief Finds the last of characters in list in the string.
+    ///
+    /// \code
+    /// eval> find_last_of("abab", "bec")
+    /// 3
+    /// \endcode
+    int find_last_of(string list) const;
+
+    /// \brief Finds the first non-matching character to list in the str string.
+    ///
+    /// \code
+    /// eval> find_first_not_of("abcd", "fec")
+    /// 0
+    /// \endcode
+    int find_first_not_of(string list) const;
+
+    /// \brief Finds the last non-matching character to list in the list string.
+    ///
+    /// \code
+    /// eval> find_last_not_of("abcd", "fec")
+    /// 3
+    /// \endcode 
+    int find_last_not_of(string list) const;
+
+    /// \brief Removes whitespace from the front of the string, returning a new string
+    ///
+    /// \note This function is implemented as a ChaiScript function using the def member function notation.
+    ///
+    /// \code
+    /// eval> ltrim("  bob")
+    /// bob
+    /// \endcode
+    ///
+    /// \sa \ref keyworddef
+    string lstrim() const;
+
+    /// \brief Removes whitespace from the back of the string, returning a new string
+    ///
+    /// \note This function is implemented as a ChaiScript function using the def member function notation.
+    ///
+    /// \code
+    /// eval> rtrim("bob  ") + "|"
+    /// bob|
+    /// \endcode
+    ///
+    /// \sa \ref keyworddef
+    string rtrim() const;
+
+    /// \brief Removes whitespace from the front and back of the string, returning a new string
+    ///
+    /// \note This function is implemented as a ChaiScript function using the def member function notation.
+    ///
+    /// \code
+    /// eval> trim("  bob  ") + "|"
+    /// bob|
+    /// \endcode
+    /// 
+    /// Equivalent to rtrim(ltrim("  bob  "));
+    ///
+    /// \sa \ref keyworddef
+    string trim() const;
+
+    /// \brief Returns the character at the given index in the string, const version
+    const char &operator[](int t_index) const;
+
+    /// \brief Returns the character at the given index in the string
+    char &operator[](int t_index);
+
+    /// \brief Returns underlying const char * for C api compatibility
+    const char *c_str() const;
+
+    /// \brief Returns a pointer to the raw data in the string
+    const char *data() const;
+
+    /// \brief Resets the string to empty
+    void clear();
+
+    /// \brief Returns true if the string is empty
+    bool empty() const;
+
+    /// \brief Returns the size of the string in bytes.
+    ///
+    /// This function normally returns size_t in C++. In ChaiScript the return value is cast to int
+    /// for ease of use.
+    int size() const;
+
+    /// \brief Returns an object that implements the Range concept for the characters of this string
+    Range range();
+
+    /// \brief Returns an object that implements the Const_Range concept for the characters of this string
+    Const_Range range() const;
+};
+
+/// \brief A concept in ChaiScript that is implemented by \ref string, Vector and Map. It provides
+///        easy iteration over the elements in a container.
+///
+/// Implemented by the template chaiscript::bootstrap::standard_library::Bidir_Range
+///
+/// \sa Const_Range
+class Range
+{
+  public:
+    /// \brief Returns the last item of the range
+    Object back();
+
+    /// \brief Returns true if the front and back pointers have passed each other, if no items
+    ///        are left in the Range
+    bool empty() const;
+
+    /// \brief Returns the first item of the range
+    Object front();
+
+    /// \brief Moves the back pointer back one.
+    /// 
+    /// \post back() returns the element at back() - 1;
+    void pop_back();
+
+    /// \brief Moves the front pointer forward one
+    /// 
+    /// \post front() returne the element at front() + 1;
+    void pop_front();
+
+};
+
+/// \brief A concept in ChaiScript that is implemented by \ref string, Vector and Map. It provides
+///        easy iteration over the elements in a container. Contained values are const.
+///
+/// Implemented by the template chaiscript::bootstrap::standard_library::Const_Bidir_Range
+///
+/// \sa Range
+class Const_Range
+{
+  public:
+    /// \brief Returns the last item of the range
+    const Object back();
+
+    /// \brief Returns true if the front and back pointers have passed each other, if no items
+    ///        are left in the Range
+    bool empty() const;
+
+    /// \brief Returns the first item of the range
+    const Object front();
+
+    /// \brief Moves the back pointer back one.
+    /// 
+    /// \post back() returns the element at back() - 1;
+    void pop_back();
+
+    /// \brief Moves the front pointer forward one
+    /// 
+    /// \post front() returne the element at front() + 1;
+    void pop_front();
+
+};
+
+/// \brief A vector of Objects
+///
+/// ChaiScript includes a shortcut for creating a Vector of Objects
+/// 
+/// Example:
+/// \code
+/// eval> var v = [1,2,3,4]
+/// [1, 2, 3, 4]
+/// eval> v[0];
+/// 1
+/// eval> v.size();
+/// 4
+/// \endcode 
+///
+/// Implemented with std::vector<chaiscript::Boxed_Value>
+/// 
+/// \sa chaiscript::bootstrap::standard_library::vector_type
+class Vector
+{
+  public:
+    /// \brief returns the Object at the given index. Throws an exception if the index does not exist
+    Object operator[](int t_index);
+
+    /// \brief returns a const Object at the given index. Throws an exception if the index does not exist.
+    const Object operator[](int t_index) const;
+
+    /// \brief returns the last item in the Vector
+    Object back();
+
+    /// \brief Clears the Vector of all items
+    void clear();
+
+    /// \brief Returns true if the Vector is contains 0 items
+    bool empty();
+
+    /// \brief Erases the element at the given index
+    void erase_at(int t_index);
+
+    /// \brief Returns the first item in the Vector
+    Object front();
+
+    /// \brief Inserts a new item in the Vector at the given index. The item is not cloned on insert
+    /// 
+    /// \sa insert_ref
+    void insert_ref_at(int, Object);
+
+    /// \brief Inserts a new item in the Vector at the given index. The item is cloned on insert
+    /// 
+    /// \sa insert_ref
+    void insert_at(int, Object);
+   
+    /// \brief Removes the last item from the Vector
+    void pop_back();
+
+    /// \brief Adds an item to the end of the Vector. The item is not cloned.
+    ///
+    /// \sa push_back
+    void push_back_ref(Object);
+
+    /// \brief Adds an item to the end of the Vector. The item is cloned.
+    ///
+    /// \sa push_back_ref
+    void push_back(Object);
+
+    /// \brief Returns a Range object for the entire vector
+    Range range();
+
+    /// \brief Returns a Const_Range object for the entire vector
+    Const_Range range() const;
+
+    /// \brief Returns the number of elements in the Vector
+    int size() const;
+
+};
+
+class Type_Info
+{
+  public:
+    /// \brief Compares this Type_Info object with another one and returns true if the two types are the same
+    ///        after const, pointer, reference are removed.
+    bool bare_equal(Type_Info t_ti) const;
+
+    /// \brief Returns the mangled C++ name for the type given by the compiler after const, pointer, reference is removed.
+    string cpp_bare_name() const;
+
+    /// \brief Returns the mangled C++ name for the type given by the compiler.
+    string cpp_name() const;
+
+    /// \brief Returns true if the type is const
+    bool is_type_const() const;
+
+    /// \brief Returns true if the type is a pointer
+    bool is_type_pointer() const;
+
+    /// \brief Returns true if the type is a reference 
+    bool is_type_reference() const;
+
+    /// \brief Returns true if the type is undefined 
+    bool is_type_undef() const;
+
+    /// \brief Returns true if the type is "void"
+    bool is_type_void() const;
+
+    /// \brief Returns the ChaiScript registered name for the type if one exists.
+    string name() const;
+
+};
+
+
+/// \brief Represents a function object in ChaiScript
+///
+/// A function object may be one function, such as:
+/// \code
+/// var f = fun(x) { return x; }
+/// \endcode
+/// 
+/// Or it may represent multiple functions
+/// \code
+/// var f2 = `-`; // represents the unary - as well as the set of binary - operators
+/// \endcode
+///
+/// Guarded function example
+/// \code
+/// def f3(x) : x > 2 {
+///  return x;
+/// }
+/// \endcode
+///
+/// Examples in the function definitions below will reference these examples
+class Function
+{
+  public:
+    /// \brief Returns the annotation description of the function
+    string get_annotation() const;
+
+    /// \brief Returns the arity of the function, -1 if the function takes a variable number of parameters
+    ///
+    /// Example:
+    /// \code
+    /// eval> f.get_arity()
+    /// 1
+    /// eval> f2.get_arity()
+    /// -1
+    /// \endcode
+    int get_arity() const;
+
+    /// \brief Returns a vector of the contained functions
+    /// 
+    /// Example:
+    /// \code
+    /// eval> f.get_contained_functions().size()
+    /// 0
+    /// eval> f2.get_contained_functions().size()
+    /// 11
+    /// eval> var v = f2.get_contained_functions();
+    /// v[0].get_arity()
+    /// 2
+    /// \endcode
+    Vector get_contained_functions() const;
+
+    /// \brief Returns a vector of the contained functions
+    /// 
+    /// Example:
+    /// \code
+    /// eval> f.get_guard() // Throws exception
+    /// Function does not have a guard
+    /// eval> f3.get_guard().get_arity()
+    /// 1
+    /// \endcode
+    Function get_guard() const;
+
+    /// \brief Returns a vector of Type_Info objects that represent the param types for this function.
+    ///        The first value in the list is the return type.
+    /// 
+    /// If this function is a conglomeration of several functions (get_contained_values().size() > 0)
+    /// then the function returns as many Type_Info objects as it can. If the functions contained all have
+    /// the same arity, then it represents the arity. If they have different arities, it returns only
+    /// one value - the return type. 
+    /// 
+    /// For each parameter that is the same type, the type is returned. If the types are different
+    /// then a Type_Info for Object is returned.
+    ///
+    /// Example:
+    /// \code
+    /// eval> f2.get_param_types().size(); // Returns a Type_Info for Object for the return type
+    /// 1
+    /// \endcode
+    Vector get_param_types() const;
+
+    /// \brief Returns true if the function has a guard to it. Always returns falls for a conglomerate function
+    bool has_guard() const;
+
+    /// \brief Calls the function with the given set of parameters and returns the value;
+    /// 
+    /// Example:
+    /// \code
+    /// eval> `-`.call([2,1]);
+    /// 1
+    /// \endcode
+    Object call(Vector t_params) const;
+}
+
+
+
+/// \brief Returns the max of a or b. Requires that operator>(a, b) exists
+/// Equivalent to 
+/// \code
+/// return a>b?a:b;
+/// \endcode
+///
+/// Example:
+/// \code
+/// eval> max(4, 10)
+/// 10
+/// \endcode
+Object max(Object a, Object b);
+
+/// \brief Returns the min of a or b. Requires that operator<(a, b) exists
+///
+/// Equivalent to 
+/// \code
+/// return a<b?a:b;
+/// \endcode
+///
+/// Example:
+/// \code
+/// eval> min(4, 10)
+/// 4
+/// \endcode
+Object min(Object a, Object b);
+
+/// \brief Returns true if x is an even integer. 
+/// 
+/// Will also work on any non-integer type for which an operator%(x, int) exists
+///
+/// Example:
+/// \code
+/// eval> even(4)
+/// true
+/// \endcode
+bool even(Object x);
+
+/// \brief Returns true if x is an odd integer. 
+/// 
+/// Will also work on any non-integer type for which an operator%(x, int) exists
+///
+/// Example:
+/// \code
+/// eval> odd(4)
+/// false 
+/// \endcode
+bool even(Object x);
+
+
+/// \brief Applies the function f over each element in the Range c.
+///
+/// Example:
+/// \code
+/// eval> for_each([1, 2, 3], print)
+/// 1
+/// 2
+/// 3
+/// \endcode
+void for_each(Range c, Function f);
+
+
+/// \brief Applies f over each element in the Range c, joining all the results.
+///
+/// Example:
+/// \code
+/// eval> map([1, 2, 3], odd)
+/// [true, false, true]
+/// \endcode
+Object map(Range c, Function f);
+
+
+/// \brief Starts with the initial value and applies the function f to it and the first element of the Range c. 
+///        The result is then applied to the second element, and so on until the elements are exhausted.
+///
+/// Example:
+/// \code
+/// eval> foldl([1, 2, 3, 4], `+`, 0)
+/// 10
+/// \endcode
+Object foldl(Range c, Function f, Object initial);
+
+
+/// \brief Returns the sum total of the values in the Range c.
+///
+/// Example:
+/// \code
+/// eval> sum([1, 2, 3, 4])
+/// 10
+/// \endcode
+///
+/// Equivalent to:
+/// \code
+/// foldl(c, `+`, 0.0);
+/// \endcode
+Numeric sum(Range c);
+
+
+/// \brief Returns the product of the value in the Range c.
+///
+/// Example:
+/// \code
+/// eval> product([1, 2, 3, 4])
+/// 24
+/// \endcode
+///
+/// Equivalent to:
+/// \code
+/// foldl(c, `*`, 1.0);
+/// \endcode
+Numeric product(Range c);
+
+
+/// \brief Takes num elements from the Range c, returning them.
+///
+/// Example:
+/// \code
+/// eval> take([1, 2, 3, 4], 2)
+/// [1, 2]
+/// \endcode
+///
+/// \returns A container of the same type that was passed in
+Object take(Range c, int num);
+
+
+/// \brief Takes elements from the Range c that match function f, stopping at the first non-match, returning them as a new Vector.
+///
+/// Example:
+/// \code
+/// eval> take_while([1, 2, 3], odd)
+/// [1]
+/// \endcode
+///
+/// \returns A container of the same type that was passed in
+Object take_while(Range c, Function f);
+
+
+/// \brief Drops num elements from the Range c, returning the remainder.
+///
+/// Example:
+/// \code
+/// eval> drop([1, 2, 3, 4], 2)
+/// [3, 4]
+/// \endcode
+///
+/// \returns A container of the same type that was passed in
+Object drop(Range c, int num);
+
+
+/// \brief Drops elements from the Range c that match f, stopping at the first non-match, returning the remainder.
+///
+/// Example:
+/// \code
+/// eval> drop_while([1, 2, 3], odd)         
+/// [2, 3]
+/// \endcode
+Object drop_while(Range c, Function f);
+
+
+/// \brief Similar to foldl, this takes the first two elements as its starting values for f. This assumes Range c has at least 2 elements.
+///
+/// Example:
+/// \code
+/// eval> reduce([1, 2, 3, 4], `+`)
+/// 10
+/// \endcode
+Object reduce(Range c, Function f);
+
+
+/// \brief Takes elements from Range c that match function f, return them.
+///
+/// Example:
+/// \code
+/// eval> filter([1, 2, 3, 4], odd)
+/// [1, 3]
+/// \endcode
+Object filter(Range c, Function f);
+
+
+/// \brief Joins the elements of the Range c into a string, delimiting each with the delim string.
+///
+/// Example:
+/// \code
+/// eval> join([1, 2, 3], "*") 
+/// 1*2*3
+/// \endcode
+string join(Range c, string delim);
+
+
+/// \brief Returns the contents of the Container c in reversed order.
+///
+/// Example:
+/// \code
+/// eval> reverse([1, 2, 3, 4, 5, 6, 7])
+/// [7, 6, 5, 4, 3, 2, 1]
+/// \endcode
+Container reverse(Container c);
+
+
+/// \brief Generates a new Vector filled with values starting at x and ending with y.
+///
+/// Works on types supporting operator<=(x, y) and operator++(x)
+///
+/// Example:
+/// \code
+/// eval> generate_range(1, 10)
+/// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+/// \endcode
+Vector generate_range(Object x, Object y);
+
+
+/// \brief Returns a new Range with x and y concatenated.
+///
+/// Example:
+/// \code
+/// eval> concat([1, 2, 3], [4, 5, 6])
+/// [1, 2, 3, 4, 5, 6]
+/// \endcode
+Object concat(Range x, Range y);
+
+
+/// \brief Returns a new Vector with x and y as its values.
+///
+/// Example:
+/// \code
+/// eval> collate(1, 2)
+/// [1, 2]
+/// \endcode
+Vector collate(Object x, Object y);
+
+
+/// \brief Applies f to elements of x and y, returning a new Vector with the result of each application.
+///
+/// Example:
+/// \code
+/// eval> zip_with(`+`, [1, 2, 3], [4, 5, 6])
+/// [5, 7, 9]
+/// \endcode
+Vector zip_with(Function f, Range x, Range y);
+
+
+/// \brief Collates elements of x and y, returning a new Vector with the result.
+///
+/// Example:
+/// \code
+/// eval> zip([1, 2, 3], [4, 5, 6])
+/// [[1, 4], [2, 5], [3, 6]]
+/// \endcode
+Vector zip(Range x, Range y);
+
+
+/// \brief returns true if there exists a call to the Function f that takes the given parameters
+///
+/// Example:
+/// \code
+/// eval> call_exists(`+`, 1, 2)
+/// true
+/// \endcode
+bool call_exists(Function f, ...);
+
+/// \brief Reverses a Range object so that the elements are accessed in reverse
+Range retro(Range);
+
+/// \brief Reverses a Const_Range object so that the elements are accessed in reverse
+Const_Range retro(Const_Range);
+
+
+/// \brief Raises the given object as an exception. Any type of object can be thrown.
+///
+/// Example:
+/// \code
+/// eval> try { throw(1); } catch (e) { print("Exception caught: " + to_string(e)); }
+/// Exception caught: 1
+/// \endcode
+/// 
+/// \sa \ref keywordtry
+void throw(Object); 
+}
+

include/chaiscript/utility/utility.hpp

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

license.txt

@@ -1,4 +1,7 @@
-Copyright 2009 Jason 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:

msvc/chai-example/chai-example.vcproj

@@ -1,197 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="chai-example"
-	ProjectGUID="{CE422E94-B360-4588-8C65-6A9BE80798F9}"
-	RootNamespace="chaiexample"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
-			CharacterSet="0"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
-			CharacterSet="0"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				EnableIntrinsicFunctions="true"
-				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\..\src\example.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

msvc/chaiscript/Boost.vsprops

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioPropertySheet
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="Boost"
-	>
-	<Tool
-		Name="VCCLCompilerTool"
-		AdditionalIncludeDirectories="&quot;C:\boost\include\boost-1_38&quot;"
-	/>
-	<Tool
-		Name="VCLibrarianTool"
-		AdditionalLibraryDirectories="C:\Programming\Boost\lib"
-	/>
-	<Tool
-		Name="VCLinkerTool"
-		AdditionalLibraryDirectories="C:\Boost\lib"
-	/>
-</VisualStudioPropertySheet>

msvc/chaiscript/chaiscript.sln

@@ -1,32 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual C++ Express 2008
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chaiscript", "chaiscript.vcproj", "{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chai-example", "..\chai-example\chai-example.vcproj", "{CE422E94-B360-4588-8C65-6A9BE80798F9}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_module", "..\test_module\test_module.vcproj", "{775EDCC2-102F-4E75-A860-9AF398D04145}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Debug|Win32.ActiveCfg = Debug|Win32
-		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Debug|Win32.Build.0 = Debug|Win32
-		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.ActiveCfg = Release|Win32
-		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.Build.0 = Release|Win32
-		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.ActiveCfg = Debug|Win32
-		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.Build.0 = Debug|Win32
-		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.ActiveCfg = Release|Win32
-		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.Build.0 = Release|Win32
-		{775EDCC2-102F-4E75-A860-9AF398D04145}.Debug|Win32.ActiveCfg = Debug|Win32
-		{775EDCC2-102F-4E75-A860-9AF398D04145}.Debug|Win32.Build.0 = Debug|Win32
-		{775EDCC2-102F-4E75-A860-9AF398D04145}.Release|Win32.ActiveCfg = Release|Win32
-		{775EDCC2-102F-4E75-A860-9AF398D04145}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

msvc/chaiscript/chaiscript.vcproj

@@ -1,278 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="chaiscript"
-	ProjectGUID="{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}"
-	RootNamespace="chaiscript"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			InheritedPropertySheets=".\Boost.vsprops"
-			UseOfMFC="2"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				UseUnicodeResponseFiles="false"
-				Optimization="0"
-				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				DisableLanguageExtensions="false"
-				TreatWChar_tAsBuiltInType="false"
-				UsePrecompiledHeader="0"
-				WarningLevel="4"
-				DebugInformationFormat="4"
-				CompileAs="2"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			InheritedPropertySheets=".\Boost.vsprops"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="3"
-				EnableIntrinsicFunctions="true"
-				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="4"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\..\src\main.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\bootstrap.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\bootstrap_stl.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\boxed_value.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\chaiscript.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\language\chaiscript_engine.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\language\chaiscript_eval.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\language\chaiscript_parser.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\language\chaiscript_prelude.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\chaiscript_threading.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\dispatchkit.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\dynamic_object.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\function_call.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\function_call_detail.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\handle_return.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_constructors.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_functions.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_functions_detail.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\register_function.hpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\chaiscript\dispatchkit\type_info.hpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

msvc/test_module/test_module.vcproj

@@ -1,198 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="test_module"
-	ProjectGUID="{775EDCC2-102F-4E75-A860-9AF398D04145}"
-	RootNamespace="test_module"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="2"
-			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
-			UseOfMFC="0"
-			CharacterSet="0"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;TEST_MODULE_EXPORTS"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="2"
-			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				EnableIntrinsicFunctions="true"
-				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
-				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;TEST_MODULE_EXPORTS"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="2"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\..\src\test_module.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

readme.md

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

readme.txt

@@ -1,36 +0,0 @@
-ChaiScript v1.0 
-http://www.chaiscript.com
-(c) 2009 Jason Turner and Jonathan Turner
-Release under the BSD license, see "license.txt" for details.
-
-[Introduction]
-
-ChaiScript is one of the first (and perhaps only) embedded scripting language designed from the ground up to directly target C++.  Being a native C++ application, it has some advantages over existing embedded scripting languages:
-
-1) It uses a header-only approach, which makes it easy to integrate with existing projects.
-2) It maintains type safety between your C++ application and the user scripts.
-3) It supports a variety of C++ techniques including callbacks, overloaded functions, class methods, and stl containers.
-
-[Requirements]
-
-ChaiScript requires a recent version of Boost (http://www.boost.org) to build.
-
-[Usage]
-
-* Add the ChaiScript include directory to your project's header search path
-* Add "#include <chaiscript/chaiscript.hpp> to your source file
-* Instantiate the ChaiScript engine in your application.  For example, create a new engine with the name 'chai' like so: "chaiscript::ChaiScript_Engine chai"
-
-Once instantiated, the engine is ready to start running ChaiScript source.  You have two main options for processing ChaiScript source: a line at a time using "chai.evaluate_string(string)" and a file at a time using "chai.evaluate_file(fname)"
-
-To make functions in your C++ code visible to scripts, they must be registered with the scripting engine.  To do so, call register_function:
-
-dispatchkit::register_function(chai.get_eval_engine(), &my_function, "my_function_name");
-
-Once registered the function will be visible to scripts as "my_function_name"
-
-[Examples]
-
-ChaiScript is similar to ECMAScript (aka JavaScript(tm)), but with some modifications to make it easier to use.  For usage examples see the "samples" directory, and for more in-depth look at the language, the unit tests in the "unittests" directory cover the most ground.
-
-For example of how to register parts of your C++ application, see "example.cpp" in the "src" directory.

releasenotes.txt

@@ -0,0 +1,86 @@
+Current Version: 4.3.0
+
+Note: this is scheduled to be the last release that requires boost, new releases after this will require a C++11 compiler.
+
+### Changes since 4.2.0
+* Enhanced unit tests
+* Add `continue` statement, fix various use cases for `for`  loops
+* Fix use of suffixed numbers in vector initialization
+* Code cleanups
+* Eliminate global data, which makes code more portable and thread safe
+* Fix issue #79
+* Merge pretty_print fixes from @mgee #82
+* Compiler warning fixes for latest compiler releases
+* Fix threading problems
+* Fix linking error on MacOS Mavericks #88
+* Allow non-const globals
+* Make sure user cannot name a variable with `::` in it #91
+* Fix various string / map / vector `size` and `count` calls for compilers which have weird overloads for them. #90 #93 #95
+* Make module search path relative to the currently running executable
+* Build and work with wstring windows builds
+
+### Changes since 4.1.1
+* Add support for automatic conversion of arithmetic types when possible
+  and when no ambiguous method dispatch exists.
+
+### Changes since 4.1.0
+* Fix missed gcc build error in 4.1.0
+
+Changes since 4.0.0
+* Fix sizing of numeric constants to match that of the C++ standard
+* Add support for u,ll,l,f suffixes for numeric constants
+* Siginificant improvement in error reporting
+
+Changes since 3.1.0
+* svenstaro: Unused variables and CMake consistency fixes
+* Added support for returning pointers from functions (#13)
+* Compile with -pedantic (#9)
+* Fix issues with multiple ChaiScript object types having the same attribute name (#15)
+* Prevent variable redeclaration in same scope (#22)
+* mgee: Boxed_Number improvements (#27)
+* Support switch statements (#34)
+* Fix uint16 comparions (#26)
+* Add ability to add const_var globals in Module objects (#14)
+* Add support for ternary operators ?:
+* Add headers to CMakeLists so they show up in IDEs
+* Add ability to get vector of defined objects and vector of defined functions
+* Fix memory leak in cyclical references
+* Clean up static analysis issues discovered
+* Fix vector construction to be consistent with map construction
+* Increased unit tests to 161
+* Performance enhancements
+
+### Changes since 3.0.0
+* Numeric operations performance increased approximately 10x
+* Looping operations performance increased up to 2x
+* Engine start up time decreased
+* Several parsing bugs related to index operators fixed
+* Added full support for all C algebraic types: double, long double, float, int, long, char,
+  uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t
+* Enhanced support for capturing of exceptions thrown from ChaiScript in C++
+
+### Changes since 2.3.3
+* Code simplifications
+* Fully integrate documentation with source code in doxygen style comments
+* Unit tests increased from 114 to 137
+* Automatic conversion between boost::function objects and ChaiScript functions 
+* Many bug fixes
+* Minor performance improvements
+* Namespace reorganization to make end user code more accessible
+* clang support
+* VisualStudio 2010 Support
+* Support for C++ base classes and automatic upcasting 
+* Remove __ reserved identifiers
+* Better code organization to reduce #ifdefs 
+* clanmills: command line options for chai eval
+* clanmills: parser cleanups and code reduction
+* Function introspection and reflection 
+* Correct function dispatch order to account for base classes and provide a defined order of dispatch 
+* Predictable object lifetime that emulates C++ stack lifetime
+* emarcotte: pkgconfig support
+* standardize on method/member naming and indentation
+* 64bit Visual Studio support
+* Better support for const objects
+* Drastic reduction of runtime exceptions - making debug builds orders of magnitude faster
+* Support for platforms with no loadable module support
+* Add helper macro for registering class 

run_unit_tests.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-
-
-successes=0
-failures=0
-
-echo -n "Running unit tests"
-for file in unittests/*.chai
-do
-  tstname=${file%.*}
-	tst="$tstname.txt"
-	LD_LIBRARY_PATH=. ./chaiscript_eval $file > /tmp/tstout.txt
-	diff $tst /tmp/tstout.txt
-	if [ "$?" -eq "0" ]
-	then
-		echo -n "."
-		successes=$((successes+1))
-	else
-		echo "[from failed test $file]"
-		failures=$((failures+1))
-	fi
-done
-echo ""
-
-total=$((successes+failures))
-echo "$successes out of $total succeeded"

run_unit_tests_win.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-successes=0
-failures=0
-
-echo -n "Running unit tests"
-for file in unittests/*.chai
-do
-  tstname=${file%.*}
-	tst="$tstname.txt"
-	./chaiscript_eval $file > /tmp/tstout.txt
-        cat $tst > /tmp/tstmaster.txt
-        awk 'sub("$", "\r")' $tst > /tmp/tstmaster.txt
-	diff /tmp/tstmaster.txt /tmp/tstout.txt
-	if [ "$?" -eq "0" ]
-	then
-		echo -n "."
-		successes=$((successes+1))
-	else
-		echo "[from failed test $file]"
-		failures=$((failures+1))
-	fi
-done
-echo ""
-
-total=$((successes+failures))
-echo "$successes out of $total succeeded"

samples/bind.chai

@@ -1,22 +0,0 @@
-
-def add(x, y)
-{
-  return x + y;
-}
-
-var b = bind(add, 2, _);
-var c = bind(b, 3);
-
-print(b(4));
-print(c());
-
-
-def concat(a,b,c,d)
-{
-  return to_string(a) + to_string(b) + to_string(c) + to_string(d);
-}
-
-var d = bind(concat, _, " Hello ", _, " World ");
-print(d(1, 3));
-//This checks to make sure arity is handled correctly:
-//print(d(1, 3, 4));

samples/eval.chai

@@ -1,3 +1,2 @@
 var i = 1
 var j = eval("5 + 4")
-print(j)

samples/example.cpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
+// and Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <iostream>
@@ -9,7 +9,18 @@
 #include <chaiscript/chaiscript.hpp>
 #include <chaiscript/dispatchkit/function_call.hpp>
 #include <boost/function.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+
 #include <boost/date_time/posix_time/posix_time.hpp>
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
 #include <boost/regex.hpp>
 
 void log(const std::string &msg)
@@ -27,12 +38,12 @@ void bound_log(const std::string &msg)
   log(msg);
 }
 
-void hello_world(const chaiscript::Boxed_Value &o)
+void hello_world(const chaiscript::Boxed_Value & /*o*/)
 {
   std::cout << "Hello World" << std::endl;
 }
 
-void hello_constructor(const chaiscript::Boxed_Value &o)
+void hello_constructor(const chaiscript::Boxed_Value & /*o*/)
 {
   std::cout << "Hello Constructor" << std::endl;
 }
@@ -43,9 +54,9 @@ struct System
   std::map<std::string, boost::function<std::string (const std::string &) > > m_callbacks;
 
   void add_callback(const std::string &t_name, 
-      const chaiscript::Proxy_Function &t_func)
+      const boost::function<std::string (const std::string &)> &t_func)
   {
-    m_callbacks[t_name] = chaiscript::functor<std::string (const std::string &)>(t_func);
+    m_callbacks[t_name] = t_func;
   }
 
 
@@ -66,7 +77,7 @@ void take_shared_ptr(const boost::shared_ptr<const std::string> &p)
   std::cout << *p << std::endl;
 }
 
-int main(int argc, char *argv[]) {
+int main(int /*argc*/, char * /*argv*/[]) {
   using namespace chaiscript;
 
   ChaiScript chai;
@@ -110,12 +121,12 @@ int main(int argc, char *argv[]) {
 
   //Finally, it is possible to register any boost::function as a system function, in this 
   //way, we can, for instance add a bound member function to the system
-  chai.add(fun(&System::do_callbacks, boost::ref(system), "Bound Test"), "do_callbacks");
+  chai.add(fun(&System::do_callbacks, boost::ref(system), std::string("Bound Test")), "do_callbacks");
 
   //Call bound version of do_callbacks
   chai("do_callbacks()");
 
-  boost::function<void ()> caller = chai.functor<void ()>("fun() { system.do_callbacks(\"From Functor\"); }");
+  boost::function<void ()> caller = chai.eval<boost::function<void ()> >("fun() { system.do_callbacks(\"From Functor\"); }");
   caller();
 
 
@@ -139,14 +150,24 @@ int main(int argc, char *argv[]) {
   //To do: Add examples of handling Boxed_Values directly when needed
 
   //Creating a functor on the stack and using it immediatly 
-  int x = chai.functor<int (int, int)>("fun (x, y) { return x + y; }")(5, 6);
+  int x = chai.eval<boost::function<int (int, int)> >("fun (x, y) { return x + y; }")(5, 6);
 
-  log("Functor test output", boost::lexical_cast<std::string>(x));
+  std::stringstream ss;
+  ss << x;
+  log("Functor test output", ss.str());
+
+  chai.add(var(boost::shared_ptr<int>()), "nullvar");
+  chai("print(\"This should be true.\"); print(nullvar.is_var_null())");
+
+  // test the global const action
+  chai.add_global_const(const_var(1), "constvar");
+  chai("def getvar() { return constvar; }");
+  chai("print( getvar() )");
 
 
   //Ability to create our own container types when needed. std::vector and std::map are
   //mostly supported currently
-  chai.add(bootstrap::vector_type<std::vector<int> >("IntVector"));
+  chai.add(bootstrap::standard_library::vector_type<std::vector<int> >("IntVector"));
 
 
   // Test ability to register a function that excepts a shared_ptr version of a type
@@ -155,13 +176,13 @@ int main(int argc, char *argv[]) {
   chai.add(fun(&bound_log, std::string("Msg")), "BoundFun");
 
   //Dynamic objects test
-  chai.add(chaiscript::Proxy_Function(new Dynamic_Object_Function("TestType", fun(&hello_world))), "hello_world");
-  chai.add(chaiscript::Proxy_Function(new Dynamic_Object_Constructor("TestType", fun(&hello_constructor))), "TestType");
-  chai.add(fun(boost::function<Boxed_Value (Dynamic_Object &)>(boost::bind(&Dynamic_Object_Attribute::func, "TestType", "attr", _1))), "attr");
+  chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Function("TestType", fun(&hello_world))), "hello_world");
+  chai.add(chaiscript::Proxy_Function(new dispatch::detail::Dynamic_Object_Constructor("TestType", fun(&hello_constructor))), "TestType");
+//  chai.add(fun(boost::function<Boxed_Value (dispatch::Dynamic_Object &)>(boost::bind(&dispatch::detail::Dynamic_Object_Attribute::func, "TestType", "attr", _1))), "attr");
 
   chai.eval("var x = TestType()");
-  chai.eval("x.attr = \"hi\"");
-  chai.eval("print(x.attr)");
+//  chai.eval("x.attr = \"hi\"");
+//  chai.eval("print(x.attr)");
   chai.eval("x.hello_world()");
 }
 

samples/for.chai

@@ -2,11 +2,11 @@ for (var i = 0; i < 10; ++i) {
 	print(i)
 }
 
-for (i = 10; i >= 0; i -= 2) {
+for (var i = 10; i >= 0; i -= 2) {
 	print(i)
 }
 
-i = 0
+var i = 0
 
 for (; i < 5; ++i) {
 	print(i)

samples/memory_leak_test.cpp

@@ -0,0 +1,88 @@
+#include <iostream>
+
+#include "chaiscript/chaiscript.hpp"
+#ifdef READLINE_AVAILABLE
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+
+
+using namespace chaiscript;
+
+std::string get_next_command() {
+#ifdef READLINE_AVAILABLE
+  char *input_raw;
+  input_raw = readline("eval> ");
+  add_history(input_raw);
+  return std::string(input_raw);
+#else
+  std::string retval;
+  std::cout << "eval> ";
+  std::getline(std::cin, retval);
+  return retval;
+#endif
+}
+
+void fuction(void)
+{
+  // do nothing
+}
+
+class test
+{
+  ChaiScript chai;
+  ChaiScript::State backupState;
+  public:
+  test()
+  {		
+    backupState = chai.get_state();
+  }
+  ~test(){}
+
+  void ResetState()
+  {
+    chai.set_state(backupState);
+    chai.add(fun(&fuction),"Whatever()");
+  }
+
+  void RunFile(std::string sFile)
+  {
+    try {
+      chaiscript::Boxed_Value val = chai.eval_file(sFile);
+    }
+    catch (std::exception &e) {
+      std::cout << e.what() << std::endl;
+    }
+  }
+
+};
+
+
+
+int main(int /*argc*/, char * /*argv*/[]) {
+
+  test myChai;
+
+
+  std::string command = "";
+
+  //
+  // this loop increases memoryusage, if RunFile is not called (just hittin enter)
+  // as soon RunFile gets called, memory will be freed.
+  //
+  // scenario1 - RunFile gets called every Loop: memoryusage does not change
+  // scenario2 - RunFile gets never called (just hitting enter): memoryusage increases every loop
+  // scenario3 - RunFile gets in changing intervals: memoryusage goes up and down, but never as 
+  //            low as in case 1 scenario3 :
+
+  while(command != "quit")
+  {
+    for(int i = 1; i < 200; i++)
+      myChai.ResetState();
+
+    if(command == "runfile")
+      myChai.RunFile("Test.chai");
+
+    command = get_next_command();
+  }
+}

samples/range.chai

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

samples/sensors.chai

@@ -1,70 +0,0 @@
-
-
-def initialize_cpu_sensor(state, cpuname, sensor_manager)
-{
-  state[cpuname] = 0.0;
-  state[cpuname + ".user"] = 0.0;
-  state[cpuname + ".nice"] = 0.0;
-  state[cpuname + ".system"] = 0.0;
-  state[cpuname + ".idle"] = 0.0;
-  state[cpuname + ".iowait"] = 0.0;
-  state[cpuname + ".irq"] = 0.0;
-  state[cpuname + ".softirq"] = 0.0;
-}
-
-def update_cpu_state(state, statfile, cpuname)
-{
-  var regex = cpuname + "\\s+([0-9]+)\\s+([0-9]+)\\s+([0-9]+)\\s+([0-9]+)\\s+([0-9]+)\\s+([0-9]+)\\s+([0-9]+)";
-  var strs = regex_search(statfile, regex);
-
-  var user = to_double(strs[1]);
-  var nice = to_double(strs[2]);
-  var system = to_double(strs[3]);
-  var idle = to_double(strs[4]);
-  var iowait = to_double(strs[5]);
-  var irq = to_double(strs[6]);
-  var softirq = to_double(strs[7]);
-
-  var userd = user - state[cpuname + ".user"];
-  var niced = nice - state[cpuname + ".nice"];
-  var systemd = system - state[cpuname + ".system"];
-  var idled = idle - state[cpuname + ".idle"];
-  var iowaitd = iowait - state[cpuname + ".iowait"];
-  var irqd = irq - state[cpuname + ".irq"];
-  var softirqd = softirq - state[cpuname + ".softirq"];
-
-  var totalticks = userd + niced + systemd + idled + iowaitd + irqd + softirqd;
-
-  state[cpuname] = (totalticks - idled) / totalticks
-
-  state[cpuname + ".user"] = user;
-  state[cpuname + ".nice"] = nice;
-  state[cpuname + ".system"] = system;
-  state[cpuname + ".idle"] = idle;
-  state[cpuname + ".iowait"] = iowait;
-  state[cpuname + ".irq"] = irq;
-  state[cpuname + ".softirq"] = softirq;
-}                                                                     
-
-# annotation
-def update_state(state)
-{
-  var file = load_text_file("/proc/stat");
-
-  update_cpu_state(state, file, "cpu");
-  update_cpu_state(state, file, "cpu0");
-  update_cpu_state(state, file, "cpu1");
-}
-
-//dump_system()
-
-var global_state = Map()
-
-initialize_cpu_sensor(global_state, "cpu", sensor_manager);
-initialize_cpu_sensor(global_state, "cpu0", sensor_manager);
-initialize_cpu_sensor(global_state, "cpu1", sensor_manager);
-
-sensor_manager.add_sensor("cpu", 500, global_state, fun(state) { update_state(state); state["cpu"]; } )
-sensor_manager.add_sensor("cpu0", 500, global_state, fun(state) { state["cpu0"]; } )
-sensor_manager.add_sensor("cpu1", 500, global_state, fun(state) { state["cpu1"]; } )
-

src/main.cpp

@@ -1,93 +1,326 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
-// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
-// and Jason Turner (lefticus@gmail.com)
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <iostream>
-
 #include <list>
+#include <boost/algorithm/string/trim.hpp>
+
+#define _CRT_SECURE_NO_WARNINGS
+#include <chaiscript/chaiscript.hpp>
 
 #ifdef READLINE_AVAILABLE
 #include <readline/readline.h>
 #include <readline/history.h>
+#else
+char* readline(const char* p)
+{
+  std::string retval;
+  std::cout << p ;
+  std::getline(std::cin, retval);
+#ifdef BOOST_MSVC
+  return std::cin.eof() ? NULL : _strdup(retval.c_str());
+#else
+  return std::cin.eof() ? NULL : strdup(retval.c_str());
+#endif
+}
+void add_history(const char*){}
+void using_history(){}
 #endif
 
-#include <chaiscript/chaiscript.hpp>
 
-void print_help() {
+void *cast_module_symbol(std::string (*t_path)())
+{
+  union cast_union
+  {
+    std::string (*in_ptr)();
+    void *out_ptr;
+  };
+
+  cast_union c;
+  c.in_ptr = t_path;
+  return c.out_ptr;
+}
+
+std::string default_search_path()
+{
+#ifdef BOOST_WINDOWS  // force no unicode
+  CHAR path[4096];
+  int size = GetModuleFileNameA(0, path, sizeof(path)-1);
+
+  std::string exepath(path, size);
+
+  size_t secondtolastslash = exepath.rfind('\\', exepath.rfind('\\') - 1);
+  if (secondtolastslash != std::string::npos)
+  {
+    return exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\";
+  } else {
+    return "";
+  }
+
+#else
+
+  std::string exepath;
+
+  std::vector<char> buf(2048);
+  ssize_t size = -1;
+
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  {
+    exepath = std::string(&buf.front(), size);
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    Dl_info rInfo; 
+    memset( &rInfo, 0, sizeof(rInfo) ); 
+    if ( !dladdr(cast_module_symbol(&default_search_path), &rInfo)  || !rInfo.dli_fname ) { 
+      return "";
+    }
+
+    exepath = std::string(rInfo.dli_fname);
+  }
+
+  size_t secondtolastslash = exepath.rfind('/', exepath.rfind('/') - 1);
+  if (secondtolastslash != std::string::npos)
+  {
+    return exepath.substr(0, secondtolastslash) + "/lib/chaiscript/";
+  } else {
+    return "";
+  }
+#endif
+}
+
+
+void help(int n) {
+  if ( n >= 0 ) {
     std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>." << std::endl;
     std::cout << "Additionally, you can inspect the runtime system using:" << std::endl;
     std::cout << "  dump_system() - outputs all functions registered to the system" << std::endl;
     std::cout << "  dump_object(x) - dumps information about the given symbol" << std::endl;
+  } else {
+    std::cout << "usage : chai [option]+" << std::endl;
+    std::cout << "option:"                << std::endl;
+    std::cout << "   -h | --help"         << std::endl;
+    std::cout << "   -i | --interactive"  << std::endl;
+    std::cout << "   -c | --command cmd"  << std::endl;
+    std::cout << "   -v | --version"      << std::endl;
+    std::cout << "   -    --stdin"        << std::endl;
+    std::cout << "   filepath"            << std::endl;
+  }
+}
+
+void version(int){
+  std::cout << "chai: compiled " << __TIME__ << " " << __DATE__ << std::endl;
+}
+
+bool throws_exception(const boost::function<void ()> &f)
+{
+  try {
+    f();
+  } catch (...) {
+    return true;
+  }
+
+  return false;
+}
+
+chaiscript::exception::eval_error get_eval_error(const boost::function<void ()> &f)
+{
+  try {
+    f();
+  } catch (const chaiscript::exception::eval_error &e) {
+    return e;
+  }
+
+  throw std::runtime_error("no exception throw");
 }
 
 std::string get_next_command() {
-#ifdef READLINE_AVAILABLE
-    char *input_raw;
-    input_raw = readline("eval> ");
+  std::string retval("quit");
+  if ( ! std::cin.eof() ) {
+    char *input_raw = readline("eval> ");
+    if ( input_raw ) {
       add_history(input_raw);
-    return std::string(input_raw);
-#else
-    std::string retval;
-    std::cout << "eval> ";
-    std::getline(std::cin, retval);
+      std::string val(input_raw);     
+      size_t pos = val.find_first_not_of("\t \n");    
+      if (pos != std::string::npos)   
+      {      
+        val.erase(0, pos);  
+      }    
+      pos = val.find_last_not_of("\t \n");   
+      if (pos != std::string::npos)   
+      {      
+        val.erase(pos+1, std::string::npos);    
+      }   
+      retval = val;
+      ::free(input_raw);
+    }
+  }
+  if(   retval == "quit"
+     || retval == "exit"
+     || retval == "help"
+     || retval == "version") 
+  {
+    retval += "(0)";
+  }
   return retval;
-#endif
 }
 
-int main(int argc, char *argv[]) {
-    std::string input;
-    chaiscript::ChaiScript chai;
+// We have to wrap exit with our own because Clang has a hard time with
+// function pointers to functions with special attributes (system exit being marked NORETURN)
+void myexit(int return_val) {
+  exit(return_val);
+}
 
-
-    if (argc < 2) {
-        //std::cout << "eval> ";
-        //std::getline(std::cin, input);
-#ifdef READLINE_AVAILABLE
+void interactive(chaiscript::ChaiScript& chai)
+{
   using_history();
-#endif
-        input = get_next_command();
-        while (input != "quit") {
 
-            chaiscript::Boxed_Value val;
-
-            if (input == "help") {
-                print_help();
-            }
-            else {
+  for (;;) {
+    std::string input = get_next_command();
     try {
-                    //First, we evaluate it
-                    val = chai.eval(input);
+      // evaluate input
+      chaiscript::Boxed_Value val = chai.eval(input);
 
       //Then, we try to print the result of the evaluation to the user
       if (!val.get_type_info().bare_equal(chaiscript::user_type<void>())) {
         try {
-                            chaiscript::dispatch(chai.get_eval_engine().get_function("print"), chaiscript::Param_List_Builder() << val);
+          std::cout << chai.eval<boost::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
         }
-                        catch (...) {
-                            //If we can't, do nothing
+        catch (...) {} //If we can't, do nothing
       }
     }
+    catch (const chaiscript::exception::eval_error &ee) {
+      std::cout << ee.what();
+      if (ee.call_stack.size() > 0) {
+        std::cout << "during evaluation at (" << ee.call_stack[0]->start.line << ", " << ee.call_stack[0]->start.column << ")";
+      }
+      std::cout << std::endl;
+    }
+    catch (const std::exception &e) {
+      std::cout << e.what();
+      std::cout << std::endl;
     }
-                catch (std::exception &e) {
-                    std::cout << e.what() << std::endl;
   }
 }
 
-            input = get_next_command();
+int main(int argc, char *argv[])
+{
+  std::vector<std::string> usepaths;
+  std::vector<std::string> modulepaths;
+
+  // Disable deprecation warning for getenv call.
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+  const char *usepath = getenv("CHAI_USE_PATH");
+  const char *modulepath = getenv("CHAI_MODULE_PATH");
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+  usepaths.push_back("");
+  if (usepath)
+  {
+    usepaths.push_back(usepath);
   }
+
+  std::string searchpath = default_search_path();
+  modulepaths.push_back(searchpath);
+  modulepaths.push_back("");
+  if (modulepath)
+  {
+    modulepaths.push_back(modulepath);
   }
-    else {
-        for (int i = 1; i < argc; ++i) {
-            std::string filename(argv[i]);
+
+  chaiscript::ChaiScript chai(modulepaths,usepaths);
+
+  chai.add(chaiscript::fun(&myexit), "exit");
+  chai.add(chaiscript::fun(&myexit), "quit");
+  chai.add(chaiscript::fun(&help), "help");
+  chai.add(chaiscript::fun(&version), "version");
+  chai.add(chaiscript::fun(&throws_exception), "throws_exception");
+  chai.add(chaiscript::fun(&get_eval_error), "get_eval_error");
+
+  for (int i = 0; i < argc; ++i) {
+    if ( i == 0 && argc > 1 ) {
+      ++i;
+    }
+
+    std::string arg( i ? argv[i] : "--interactive" );
+
+    enum { eInteractive
+         , eCommand
+         , eFile
+    } mode = eCommand ;
+
+    if  ( arg == "-c" || arg == "--command" ) {
+      if ( (i+1) >= argc ) {
+        std::cout << "insufficient input following " << arg << std::endl;
+        return EXIT_FAILURE;
+      } else {
+        arg = argv[++i];
+      }
+    } else if ( arg == "-" || arg == "--stdin" ) {
+      arg = "" ;
+      std::string line;
+      while ( std::getline(std::cin, line) ) {
+        arg += line + '\n' ;
+      }
+    } else if ( arg == "-v" || arg == "--version" ) {
+      arg = "version(0)" ;
+    } else if ( arg == "-h" || arg == "--help" ) {
+      arg = "help(-1)";
+    } else if ( arg == "-i" || arg == "--interactive" ) {
+      mode = eInteractive ;
+    } else if ( arg.find('-') == 0 ) {
+      std::cout << "unrecognised argument " << arg << std::endl;
+      return EXIT_FAILURE;
+    } else {
+      mode = eFile;
+    }
+
+    chaiscript::Boxed_Value val ;
     try {
-              chaiscript::Boxed_Value val = chai.eval_file(argv[i]);
+      switch ( mode ) {
+        case eInteractive : interactive(chai); break;
+        case eCommand     : val = chai.eval(arg); break;
+        case eFile        : val = chai.eval_file(arg); break;
+        default           : std::cout << "Unrecognized execution mode" << std::endl; return EXIT_FAILURE;
+      }
+    }
+    catch (const chaiscript::exception::eval_error &ee) {
+      std::cout << ee.pretty_print();
+      std::cout << std::endl;
+      return EXIT_FAILURE;
     }
     catch (std::exception &e) {
       std::cout << e.what() << std::endl;
-            }
-        }
+      return EXIT_FAILURE;
     }
   }
 
+  return EXIT_SUCCESS;
+}

src/multithreaded.cpp

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

src/reflection.cpp

@@ -0,0 +1,118 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/utility/utility.hpp>
+#include <string>
+
+
+// MSVC doesn't like that we are using C++ return types from our C declared module
+// but this is the best way to do it for cross platform compatibility
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4190)
+#endif
+
+
+bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
+{
+  boost::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf
+    = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+  if (pf)
+  {
+    if (pf->get_parse_tree())
+    {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
+chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
+{
+  boost::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf 
+    = boost::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
+  if (pf)
+  {
+    if (pf->get_parse_tree())
+    {
+      return pf->get_parse_tree();
+    } else {
+      throw std::runtime_error("Function does not have a parse tree");
+    }
+  } else {
+    throw std::runtime_error("Function does not have a parse tree");
+  }
+}
+
+
+#ifdef __llvm__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#endif
+
+
+CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflection()
+{
+  chaiscript::ModulePtr m(new chaiscript::Module());
+
+  m->add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
+  m->add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
+
+  m->add(chaiscript::base_class<std::exception, chaiscript::exception::eval_error>());
+
+  chaiscript::bootstrap::standard_library::vector_type<std::vector<boost::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
+
+  CHAISCRIPT_CLASS_NO_CONSTRUCTOR( m,
+      chaiscript::exception::eval_error,
+      ((reason))
+      ((call_stack))
+    );
+
+  CHAISCRIPT_CLASS( m,
+      chaiscript::File_Position,
+      (chaiscript::File_Position())
+      (chaiscript::File_Position(int,int)),
+      ((line))
+      ((column))
+    );
+
+  CHAISCRIPT_CLASS_NO_CONSTRUCTOR( m, 
+      chaiscript::AST_Node,
+      ((text))
+      ((identifier))
+      ((filename))
+      ((start))
+      ((end))
+      ((internal_to_string))
+      ((children))
+      ((replace_child))
+    );
+
+  CHAISCRIPT_CLASS( m, 
+      chaiscript::parser::ChaiScript_Parser,
+      (chaiscript::parser::ChaiScript_Parser ()),
+      ((parse))
+      ((ast))
+    );
+
+
+  return m;
+}
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

src/stl_extra.cpp

@@ -1,9 +1,34 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
 
 #include <chaiscript/chaiscript.hpp>
+#include <list>
 #include <string>
 
+// MSVC doesn't like that we are using C++ return types from our C declared module
+// but this is the best way to do it for cross platform compatibility
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#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::list_type<std::list<chaiscript::Boxed_Value> >("List");
+  return chaiscript::bootstrap::standard_library::list_type<std::list<chaiscript::Boxed_Value> >("List");
 }
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

src/test_module.cpp

@@ -2,15 +2,107 @@
 #include <chaiscript/chaiscript.hpp>
 #include <string>
 
+class TestBaseType
+{
+  public:
+    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
+{
+  TestValue1 = 1
+};
+
+int to_int(TestEnum t)
+{
+  return t;
+}
+
+class TestDerivedType : public TestBaseType
+{
+  public:
+    virtual ~TestDerivedType() {}
+    virtual int func() { return 1; }
+
+  private:
+    TestDerivedType &operator=(const TestDerivedType &);
+};
+
 std::string hello_world()
 {
   return "Hello World";
 }
 
-CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test()
+int *get_new_int()
+{
+  return new int(1);
+}
+
+// MSVC doesn't like that we are using C++ return types from our C declared module
+// but this is the best way to do it for cross platform compatibility
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#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()
 {
   chaiscript::ModulePtr m(new chaiscript::Module());
 
   m->add(chaiscript::fun(hello_world), "hello_world");
+
+  m->add(chaiscript::user_type<TestBaseType>(), "TestBaseType");
+  m->add(chaiscript::user_type<TestDerivedType>(), "TestDerivedType");
+
+  m->add(chaiscript::constructor<TestBaseType ()>(), "TestBaseType");
+//  m->add(chaiscript::constructor<TestBaseType (int)>(), "TestBaseType");
+  m->add(chaiscript::constructor<TestBaseType (const TestBaseType &)>(), "TestBaseType");
+  m->add(chaiscript::constructor<TestBaseType (int *)>(), "TestBaseType");
+
+  m->add(chaiscript::constructor<TestDerivedType ()>(), "TestDerivedType");
+  m->add(chaiscript::constructor<TestDerivedType (const TestDerivedType &)>(), "TestDerivedType");
+
+  m->add(chaiscript::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");
+
+  m->add_global_const(chaiscript::const_var(TestValue1), "TestValue1");
+
+  m->add(chaiscript::user_type<TestEnum>(), "TestEnum");
+
+  m->add(chaiscript::fun(&to_int), "to_int");
+  m->add(chaiscript::fun(&TestBaseType::constMe), "constMe");
+
+
   return m;
 }
+
+
+#ifdef __llvm__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

src/work.chai

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

unittests/arithmetic_conversions_test.cpp

@@ -0,0 +1,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/assign_const.chai

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

unittests/bind.chai

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

unittests/bind.txt

@@ -1 +0,0 @@
-60

unittests/bind2.chai

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

unittests/block_start.txt

@@ -1 +0,0 @@
-hello

unittests/bool_not.chai

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

unittests/bool_not.txt

@@ -1 +0,0 @@
-false

unittests/boxed_cast_test.cpp

@@ -0,0 +1,319 @@
+#include <chaiscript/utility/utility.hpp>
+
+
+using namespace chaiscript;
+
+
+template<typename T>
+void use(T){}
+
+template<typename To>
+bool run_test_type_conversion(const Boxed_Value &bv, bool expectedpass)
+{
+  try {
+    To ret = chaiscript::boxed_cast<To>(bv);
+    use(ret);
+  } catch (const chaiscript::exception::bad_boxed_cast &/*e*/) {
+    if (expectedpass) {
+//      std::cerr << "Failure in run_test_type_conversion: " << e.what() << std::endl;
+      return false;
+    } else {
+      return true;
+    }
+  } catch (const std::exception &e) {
+    std::cerr << "Unexpected standard exception when attempting cast_conversion: " << e.what() << std::endl;
+    return false;
+  } catch (...) {
+    std::cerr << "Unexpected unknown exception when attempting cast_conversion." << std::endl;
+    return false;
+  }
+ 
+  if (expectedpass)
+  {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+template<typename To>
+bool test_type_conversion(const Boxed_Value &bv, bool expectedpass)
+{
+  bool ret = run_test_type_conversion<To>(bv, expectedpass);
+
+  if (!ret)
+  {
+    std::cerr << "Error with type conversion test. From: " 
+		<< (bv.is_const()?(std::string("const ")):(std::string())) << bv.get_type_info().name() 
+		<< " To: "  
+		<< (boost::is_const<To>::value?(std::string("const ")):(std::string())) << typeid(To).name() 
+      << " test was expected to " << ((expectedpass)?(std::string("succeed")):(std::string("fail"))) << " but did not" << std::endl;
+  }
+
+  return ret;
+}
+
+template<typename Type>
+bool do_test(const Boxed_Value &bv, bool T, bool ConstT, bool TRef, bool ConstTRef, bool TPtr, bool ConstTPtr, bool TPtrConst,
+    bool ConstTPtrConst, bool SharedPtrT, bool SharedConstPtrT,
+    bool ConstSharedPtrT, bool ConstSharedConstPtrT, bool ConstSharedPtrTRef, bool ConstSharedPtrTConstRef,
+    bool BoostRef, bool BoostConstRef, bool ConstBoostRef, bool ConstBoostConstRef,
+    bool ConstBoostRefRef, bool ConstBoostConstRefRef, bool Number,
+    bool ConstNumber, bool ConstNumberRef, bool TPtrConstRef, bool ConstTPtrConstRef)
+{
+  bool passed = true;
+  passed &= test_type_conversion<Type>(bv, T);
+  passed &= test_type_conversion<const Type>(bv, ConstT);
+  passed &= test_type_conversion<Type &>(bv, TRef);
+  passed &= test_type_conversion<const Type &>(bv, ConstTRef);
+  passed &= test_type_conversion<Type *>(bv, TPtr);
+  passed &= test_type_conversion<const Type *>(bv, ConstTPtr);
+  passed &= test_type_conversion<Type * const>(bv, TPtrConst);
+  passed &= test_type_conversion<const Type * const>(bv, ConstTPtrConst);
+  passed &= test_type_conversion<boost::shared_ptr<Type> >(bv, SharedPtrT);
+  passed &= test_type_conversion<boost::shared_ptr<const Type> >(bv, SharedConstPtrT);
+  passed &= test_type_conversion<boost::shared_ptr<Type> &>(bv, false);
+  passed &= test_type_conversion<boost::shared_ptr<const Type> &>(bv, false);
+  passed &= test_type_conversion<const boost::shared_ptr<Type> >(bv, ConstSharedPtrT);
+  passed &= test_type_conversion<const boost::shared_ptr<const Type> >(bv, ConstSharedConstPtrT);
+  passed &= test_type_conversion<const boost::shared_ptr<Type> &>(bv, ConstSharedPtrTRef);
+  passed &= test_type_conversion<const boost::shared_ptr<const Type> &>(bv, ConstSharedPtrTConstRef);
+  passed &= test_type_conversion<boost::reference_wrapper<Type> >(bv, BoostRef);
+  passed &= test_type_conversion<boost::reference_wrapper<const Type> >(bv, BoostConstRef);
+  passed &= test_type_conversion<boost::reference_wrapper<Type> &>(bv, false);
+  passed &= test_type_conversion<boost::reference_wrapper<const Type> &>(bv, false);
+  passed &= test_type_conversion<const boost::reference_wrapper<Type> >(bv, ConstBoostRef);
+  passed &= test_type_conversion<const boost::reference_wrapper<const Type> >(bv, ConstBoostConstRef);
+  passed &= test_type_conversion<const boost::reference_wrapper<Type> &>(bv, ConstBoostRefRef);
+  passed &= test_type_conversion<const boost::reference_wrapper<const Type> &>(bv, ConstBoostConstRefRef);
+  passed &= test_type_conversion<Boxed_Number>(bv, Number);
+  passed &= test_type_conversion<const Boxed_Number>(bv, ConstNumber);
+  passed &= test_type_conversion<Boxed_Number &>(bv, false);
+  passed &= test_type_conversion<const Boxed_Number &>(bv, ConstNumberRef);
+  passed &= test_type_conversion<Boxed_Number *>(bv, false);
+  passed &= test_type_conversion<const Boxed_Number *>(bv, false);
+  passed &= test_type_conversion<Boxed_Number * const>(bv, false);
+  passed &= test_type_conversion<const Boxed_Number *const>(bv, false);
+  passed &= test_type_conversion<Type *&>(bv, false);
+  passed &= test_type_conversion<const Type *&>(bv, false);
+  passed &= test_type_conversion<Type * const&>(bv, TPtrConstRef);
+  passed &= test_type_conversion<const Type * const&>(bv, ConstTPtrConstRef);
+  passed &= test_type_conversion<Boxed_Value>(bv, true);
+  passed &= test_type_conversion<const Boxed_Value>(bv, true);
+  passed &= test_type_conversion<const Boxed_Value &>(bv, true);
+
+  return passed;
+}
+
+/** Tests intended for built int types **/
+template<typename T>
+bool built_in_type_test(const T &initial, bool ispod)
+{
+  bool passed = true;
+
+  /** value tests **/
+  T i = T(initial);
+  passed &= do_test<T>(var(i), true, true, true, true, true, 
+                                 true, true, true, true, true,
+                                 true, true, true, true, true,
+                                 true, true, true, true, true,
+                                 ispod && true, ispod && true, ispod && true, true, true);
+
+  passed &= do_test<T>(const_var(i), true, true, false, true, false, 
+                                       true, false, true, false, true,
+                                       false, true, false, true, false,
+                                       true, false, true, false, true,
+                                       ispod && true, ispod && true, ispod && true, false, true);
+
+  passed &= do_test<T>(var(&i), true, true, true, true, true, 
+                                 true, true, true, false, false,
+                                 false, false, false, false, true,
+                                 true, true, true, true, true,
+                                 ispod && true, ispod && true, ispod && true, true, true);
+
+  passed &= do_test<T>(const_var(&i), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, ispod && false, true);
+
+  passed &= do_test<T>(var(boost::ref(i)), true, true, true, true, true, 
+                                 true, true, true, false, false,
+                                 false, false, false, false, true,
+                                 true, true, true, true, true,
+                                 ispod && true, ispod && true, ispod && true, true, true);
+
+  passed &= do_test<T>(var(boost::cref(i)), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, false, true);
+
+  /** Const Reference Variable tests */
+
+  // This reference will be copied on input, which is expected
+  const T &ir = i;
+
+  passed &= do_test<T>(var(i), true, true, true, true, true, 
+                                 true, true, true, true, true,
+                                 true, true, true, true, true,
+                                 true, true, true, true, true,
+                                 ispod && true, ispod && true, ispod && true, true, true);
+
+  // But a pointer or reference to it should be necessarily const
+  passed &= do_test<T>(var(&ir), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, false, true);
+
+  passed &= do_test<T>(var(boost::ref(ir)), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, false, true);
+
+  // Make sure const of const works too
+  passed &= do_test<T>(const_var(&ir), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, false, true);
+
+  passed &= do_test<T>(const_var(boost::ref(ir)), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, false, true);
+
+  /** Const Reference Variable tests */
+
+  // This will always be seen as a const
+  const T*cip = &i;
+  passed &= do_test<T>(var(cip), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, false, true);
+
+  // make sure const of const works
+  passed &= do_test<T>(const_var(cip), true, true, false, true, false, 
+                                 true, false, true, false, false,
+                                 false, false, false, false, false,
+                                 true, false, true, false, true,
+                                 ispod && true, ispod && true, ispod && true, false, true);
+
+  /** shared_ptr tests **/
+
+  boost::shared_ptr<T> ip(new T(initial));
+
+  passed &= do_test<T>(var(ip), true, true, true, true, true, 
+                                 true, true, true, true, true,
+                                 true, true, true, true, true,
+                                 true, true, true, true, true,
+                                 ispod && true, ispod && true, ispod && true, true, true);
+
+  passed &= do_test<T>(const_var(ip), true, true, false, true, false, 
+                                       true, false, true, false, true,
+                                       false, true, false, true, false,
+                                       true, false, true, false, true,
+                                       ispod && true, ispod && true, ispod && true, false, true);
+
+  /** const shared_ptr tests **/
+  boost::shared_ptr<const T> ipc(new T(initial));
+
+  passed &= do_test<T>(var(ipc), true, true, false, true, false, 
+                                       true, false, true, false, true,
+                                       false, true, false, true, false,
+                                       true, false, true, false, true,
+                                       ispod && true, ispod && true, ispod && true, false, true);
+
+  // const of this should be the same, making sure it compiles
+  passed &= do_test<T>(const_var(ipc), true, true, false, true, false, 
+                                       true, false, true, false, true,
+                                       false, true, false, true, false,
+                                       true, false, true, false, true,
+                                       ispod && true, ispod && true, ispod && true, false, true);
+
+
+  /** Double ptr tests **/
+
+  /*
+  T **doublep;
+
+  passed &= do_test<T*>(var(doublep), true, true, false, true, false, 
+                                       true, false, true, false, true,
+                                       false, true, false, true, false,
+                                       true, false, true, false, true,
+                                       ispod && true, ispod && true, ispod && true, false, true);
+*/
+
+  return passed;
+}
+
+
+template<typename T>
+bool pointer_test(const T& default_value, const T& new_value)
+{
+  T *p = new T(default_value);
+
+  // we store a pointer to a pointer, so we can get a pointer to a pointer
+  try {
+    T **result = boxed_cast<T **>(var(&p));
+    *(*result) = new_value;
+
+
+    if (p != (*result) ) { 
+      std::cerr << "Pointer passed in different than one returned" << std::endl;
+      return false;
+    }
+
+    if (*p != *(*result) ) {
+      std::cerr << "Somehow dereferenced pointer values are not the same?" << std::endl;
+      return false;
+    }
+
+    return true;
+  } catch (const exception::bad_boxed_cast &) {
+    std::cerr << "Bad boxed cast performing ** to ** test" << std::endl;
+    return false;
+  } catch (...) {
+    std::cerr << "Unknown exception performing ** to ** test" << std::endl;
+    return false;
+  }
+
+
+}
+
+
+int main()
+{
+  bool passed = true;
+
+  /*
+  bool T, bool ConstT, bool TRef, bool ConstTRef, bool TPtr, 
+  bool ConstTPtr, bool TPtrConst, bool ConstTPtrConst, bool SharedPtrT, bool SharedConstPtrT,
+    bool ConstSharedPtrT, bool ConstSharedConstPtrT, bool ConstSharedPtrTRef, bool ConstSharedPtrTConstRef, bool BoostRef, 
+    bool BoostConstRef, bool ConstBoostRef, bool ConstBoostConstRef, bool ConstBoostRefRef, bool ConstBoostConstRefRef, 
+    bool Number, bool ConstNumber, bool ConstNumberRef
+    */
+
+  passed &= built_in_type_test<int>(5, true);
+  passed &= built_in_type_test<double>(1.1, true);
+  passed &= built_in_type_test<char>('a', true);
+  passed &= built_in_type_test<boost::uint8_t>('a', true);
+  passed &= built_in_type_test<boost::int64_t>('a', true);
+  passed &= built_in_type_test<bool>(false, false);
+  passed &= built_in_type_test<std::string>("Hello World", false);
+  
+  // storing a pointer 
+  passed &= pointer_test<int>(1, 0);
+
+  if (passed)
+  {
+    return EXIT_SUCCESS;
+  } else {
+    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/break_while.chai

@@ -4,4 +4,4 @@ while (i < 10) {
 		break
 	}
 }
-print(i)
+assert_equal(5, i);

unittests/break_while.txt

@@ -1 +0,0 @@
-5

unittests/c_linkage_test.cpp

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

unittests/char_init.chai

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

unittests/char_init.txt

@@ -1 +0,0 @@
-b

unittests/classification.chai

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

unittests/collate.chai

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

unittests/collate.txt

@@ -1 +0,0 @@
-[1, 2]

unittests/compare_gt.chai

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

unittests/compare_gt.txt

@@ -1 +0,0 @@
-false

unittests/compare_lt.chai

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

unittests/compare_lt.txt

@@ -1 +0,0 @@
-true

unittests/concat.chai

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

unittests/concat.txt

@@ -1 +0,0 @@
-[1, 2, 3, 4]

unittests/const_range_test.chai

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

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