Merge branch 'master' into ChaiScript_5_0_CPP_11 / update version numbers

Conflicts: CMakeLists.txt releasenotes.txt
Update releasenotes and version numbers for 4.1.0 release
2012-11-17 18:33:13 -07:00 · 2012-11-17 18:31:48 -07:00 · 2012-11-16 16:32:39 -07:00 · 2012-11-16 13:58:03 -07:00 · 2012-11-16 12:57:15 -07:00 · 2012-11-16 12:27:41 -07:00
47 changed files with 2265 additions and 550 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,11 +13,11 @@ list(APPEND CPACK_SOURCE_IGNORE_FILES ".swp")
 list(APPEND CPACK_SOURCE_IGNORE_FILES ".*~")

 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt")
-set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.txt")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")

 set(CPACK_PACKAGE_VERSION_MAJOR 5)
-set(CPACK_PACKAGE_VERSION_MINOR 0)
+set(CPACK_PACKAGE_VERSION_MINOR 1)
 set(CPACK_PACKAGE_VERSION_PATCH 0)
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
@@ -37,8 +37,16 @@ configure_file(Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile)
 include(CTest)
 include(CPack)

+include(cmake/CheckCXX11Features.cmake)
+
 find_library(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)

+if(HAS_CXX11_VARIADIC_TEMPLATES)
+  message(STATUS "Variadic Template support detected")
+else()
+  message(SEND_ERROR "The selected compiler does not support the C++11 feature Variadic Templates.")
+endif()
+
 enable_testing()


@@ -83,7 +91,7 @@ endif()
 include_directories(include)


-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 (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.chai include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)

 set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)

@@ -93,10 +101,16 @@ else()
 endif()

 if (CMAKE_HOST_UNIX)
-  set(DYNAMIC_LOADER "dl")
-endif(CMAKE_HOST_UNIX)
+  list(APPEND LIBS "dl")
+
+  if (MULTITHREAD_SUPPORT_ENABLED)
+    list(APPEND LIBS "pthread")
+    add_definitions(-pthread)
+  endif()
+endif(CMAKE_HOST_UNIX)
+  
+list(APPEND LIBS ${READLINE_LIB})

-set(LIBS ${DYNAMIC_LOADER} ${READLINE_LIB})

 if (CMAKE_COMPILER_2005)
  # vs2005 is a bit too loud about possible loss of data warnings
@@ -137,7 +151,7 @@ if(BUILD_TESTING)
  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)
+ endforeach(filename)

  set_property(TEST ${UNIT_TESTS}
   PROPERTY ENVIRONMENT
@@ -190,6 +204,38 @@ if(BUILD_TESTING)
    target_link_libraries(cpp_lambda_test ${LIBS} ${EXTRA_LINKER_FLAGS})
    add_test(NAME cpp_lambda_test COMMAND cpp_lambda_test)

+    add_executable(expected_eval_errors_test unittests/expected_eval_errors_test.cpp)
+    target_link_libraries(expected_eval_errors_test ${LIBS})
+    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)
+
+    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)
--- a/cmake/CheckCXX11Features.cmake
+++ b/cmake/CheckCXX11Features.cmake
@@ -0,0 +1,103 @@
+# Checks for C++11 features
+#  CXX11_FEATURE_LIST - a list containing all supported features
+#  HAS_CXX11_AUTO               - auto keyword
+#  HAS_CXX11_NULLPTR            - nullptr
+#  HAS_CXX11_LAMBDA             - lambdas
+#  HAS_CXX11_STATIC_ASSERT      - static_assert()
+#  HAS_CXX11_RVALUE_REFERENCES  - rvalue references
+#  HAS_CXX11_DECLTYPE           - decltype keyword
+#  HAS_CXX11_CSTDINT_H          - cstdint header
+#  HAS_CXX11_LONG_LONG          - long long signed & unsigned types
+#  HAS_CXX11_VARIADIC_TEMPLATES - variadic templates
+#  HAS_CXX11_CONSTEXPR          - constexpr keyword
+#  HAS_CXX11_SIZEOF_MEMBER      - sizeof() non-static members
+#  HAS_CXX11_FUNC               - __func__ preprocessor constant
+#
+# Original script by Rolf Eike Beer
+# Modifications by Andreas Weis
+#
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.3)
+
+SET(CHECK_CXX11_OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+IF(CMAKE_COMPILER_IS_GNUCXX)
+	SET(CMAKE_CXX_FLAGS "-std=c++0x")
+endif()
+
+MACRO(CXX11_CHECK_FEATURE FEATURE_NAME FEATURE_NUMBER RESULT_VAR)
+	IF (NOT DEFINED ${RESULT_VAR})
+		SET(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11/cxx11_${FEATURE_NAME}")
+
+		IF (${FEATURE_NUMBER})
+			SET(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/c++11-test-${FEATURE_NAME}-N${FEATURE_NUMBER})
+			SET(_LOG_NAME "\"${FEATURE_NAME}\" (N${FEATURE_NUMBER})")
+		ELSE (${FEATURE_NUMBER})
+			SET(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/c++11-test-${FEATURE_NAME})
+			SET(_LOG_NAME "\"${FEATURE_NAME}\"")
+		ENDIF (${FEATURE_NUMBER})
+		MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME}")
+
+		SET(_SRCFILE "${_SRCFILE_BASE}.cpp")
+		SET(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp")
+		SET(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp")
+
+		IF (CROSS_COMPILING)
+			try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}")
+			IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+				try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}")
+			ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+		ELSE (CROSS_COMPILING)
+			try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+					"${_bindir}" "${_SRCFILE}")
+			IF (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+				SET(${RESULT_VAR} TRUE)
+			ELSE (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+				SET(${RESULT_VAR} FALSE)
+			ENDIF (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+			IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+				try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+						"${_bindir}_fail" "${_SRCFILE_FAIL}")
+				IF (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+					SET(${RESULT_VAR} TRUE)
+				ELSE (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+					SET(${RESULT_VAR} FALSE)
+				ENDIF (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+			ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+		ENDIF (CROSS_COMPILING)
+		IF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+			try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}")
+			IF (_TMP_RESULT)
+				SET(${RESULT_VAR} FALSE)
+			ELSE (_TMP_RESULT)
+				SET(${RESULT_VAR} TRUE)
+			ENDIF (_TMP_RESULT)
+		ENDIF (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+
+		IF (${RESULT_VAR})
+			MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME} -- works")
+			LIST(APPEND CXX11_FEATURE_LIST ${RESULT_VAR})
+		ELSE (${RESULT_VAR})
+			MESSAGE(STATUS "Checking C++11 support for ${_LOG_NAME} -- not supported")
+		ENDIF (${RESULT_VAR})
+		SET(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}")
+	ENDIF (NOT DEFINED ${RESULT_VAR})
+ENDMACRO(CXX11_CHECK_FEATURE)
+
+CXX11_CHECK_FEATURE("auto"               2546 HAS_CXX11_AUTO)
+CXX11_CHECK_FEATURE("nullptr"            2431 HAS_CXX11_NULLPTR)
+CXX11_CHECK_FEATURE("lambda"             2927 HAS_CXX11_LAMBDA)
+CXX11_CHECK_FEATURE("static_assert"      1720 HAS_CXX11_STATIC_ASSERT)
+CXX11_CHECK_FEATURE("rvalue_references"  2118 HAS_CXX11_RVALUE_REFERENCES)
+CXX11_CHECK_FEATURE("decltype"           2343 HAS_CXX11_DECLTYPE)
+CXX11_CHECK_FEATURE("cstdint"            ""   HAS_CXX11_CSTDINT_H)
+CXX11_CHECK_FEATURE("long_long"          1811 HAS_CXX11_LONG_LONG)
+CXX11_CHECK_FEATURE("variadic_templates" 2555 HAS_CXX11_VARIADIC_TEMPLATES)
+CXX11_CHECK_FEATURE("constexpr"          2235 HAS_CXX11_CONSTEXPR)
+CXX11_CHECK_FEATURE("sizeof_member"      2253 HAS_CXX11_SIZEOF_MEMBER)
+CXX11_CHECK_FEATURE("__func__"           2340 HAS_CXX11_FUNC)
+
+SET(CXX11_FEATURE_LIST ${CXX11_FEATURE_LIST} CACHE STRING "C++11 feature support list")
+MARK_AS_ADVANCED(FORCE CXX11_FEATURE_LIST)
+
+SET(CMAKE_CXX_FLAGS ${CHECK_CXX11_OLD_CMAKE_CXX_FLAGS})
+UNSET(CHECK_CXX11_OLD_CMAKE_CXX_FLAGS)
+
--- a/cmake/c++11-test-func-N2340.cpp
+++ b/cmake/c++11-test-func-N2340.cpp
@@ -0,0 +1,8 @@
+#include <cstring>
+
+int main()
+{
+	if (!__func__) { return 1; }
+	if(std::strlen(__func__) <= 0) { return 1; }
+	return 0;
+}
--- a/cmake/c++11-test-auto-N2546.cpp
+++ b/cmake/c++11-test-auto-N2546.cpp
@@ -0,0 +1,12 @@
+
+int main()
+{
+	auto i = 5;
+	auto f = 3.14159f;
+	auto d = 3.14159;
+	bool ret = (
+		(sizeof(f) < sizeof(d)) &&
+		(sizeof(i) == sizeof(int))
+	);
+	return ret ? 0 : 1;
+}
--- a/cmake/c++11-test-constexpr-N2235.cpp
+++ b/cmake/c++11-test-constexpr-N2235.cpp
@@ -0,0 +1,19 @@
+constexpr int square(int x)
+{
+	return x*x;
+}
+
+constexpr int the_answer()
+{
+	return 42;
+}
+
+int main()
+{
+	int test_arr[square(3)];
+	bool ret = (
+		(square(the_answer()) == 1764) &&
+		(sizeof(test_arr)/sizeof(test_arr[0]) == 9)
+	);
+	return ret ? 0 : 1;
+}
--- a/cmake/c++11-test-cstdint.cpp
+++ b/cmake/c++11-test-cstdint.cpp
@@ -0,0 +1,10 @@
+#include <cstdint>
+int main()
+{
+	bool test = 
+		(sizeof(int8_t) == 1) &&
+		(sizeof(int16_t) == 2) &&
+		(sizeof(int32_t) == 4) &&
+		(sizeof(int64_t) == 8);
+	return test ? 0 : 1;
+}
--- a/cmake/c++11-test-decltype-N2343.cpp
+++ b/cmake/c++11-test-decltype-N2343.cpp
@@ -0,0 +1,11 @@
+
+bool check_size(int i)
+{
+	return sizeof(int) == sizeof(decltype(i));
+}
+
+int main()
+{
+	bool ret = check_size(42);
+	return ret ? 0 : 1;
+}
--- a/cmake/c++11-test-lambda-N2927.cpp
+++ b/cmake/c++11-test-lambda-N2927.cpp
@@ -0,0 +1,5 @@
+int main()
+{
+	int ret = 0;
+	return ([&ret]() -> int { return ret; })();
+}
--- a/cmake/c++11-test-long_long-N1811.cpp
+++ b/cmake/c++11-test-long_long-N1811.cpp
@@ -0,0 +1,7 @@
+int main(void)
+{
+	long long l;
+	unsigned long long ul;
+
+	return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
+}
--- a/cmake/c++11-test-nullptr-N2431.cpp
+++ b/cmake/c++11-test-nullptr-N2431.cpp
@@ -0,0 +1,5 @@
+int main()
+{
+	int* test = nullptr;
+	return test ? 1 : 0;
+}
--- a/cmake/c++11-test-nullptr-N2431_fail_compile.cpp
+++ b/cmake/c++11-test-nullptr-N2431_fail_compile.cpp
@@ -0,0 +1,5 @@
+int main()
+{
+	int i = nullptr;
+	return 1;
+}
--- a/cmake/c++11-test-rvalue_references-N2118.cpp
+++ b/cmake/c++11-test-rvalue_references-N2118.cpp
@@ -0,0 +1,15 @@
+int foo(int& lvalue)
+{
+	return 123;
+}
+
+int foo(int&& rvalue)
+{
+	return 321;
+}
+
+int main()
+{
+	int i = 42;
+	return ((foo(i) == 123) && (foo(42) == 321)) ? 0 : 1;
+}
--- a/cmake/c++11-test-sizeof_member-N2253.cpp
+++ b/cmake/c++11-test-sizeof_member-N2253.cpp
@@ -0,0 +1,14 @@
+struct foo {
+	char bar;
+	int baz;
+};
+
+int main(void)
+{
+	bool ret = (
+		(sizeof(foo::bar) == 1) &&
+		(sizeof(foo::baz) >= sizeof(foo::bar)) &&
+		(sizeof(foo) >= sizeof(foo::bar)+sizeof(foo::baz))
+	);
+	return ret ? 0 : 1;
+}
--- a/cmake/c++11-test-static_assert-N1720.cpp
+++ b/cmake/c++11-test-static_assert-N1720.cpp
@@ -0,0 +1,5 @@
+int main()
+{
+	static_assert(0 < 1, "your ordering of integers is screwed");
+	return 0;
+}
--- a/cmake/c++11-test-static_assert-N1720_fail_compile.cpp
+++ b/cmake/c++11-test-static_assert-N1720_fail_compile.cpp
@@ -0,0 +1,5 @@
+int main()
+{
+	static_assert(1 < 0, "this should fail");
+	return 0;
+}
--- a/cmake/c++11-test-variadic_templates-N2555.cpp
+++ b/cmake/c++11-test-variadic_templates-N2555.cpp
@@ -0,0 +1,23 @@
+int Accumulate()
+{
+	return 0;
+}
+
+template<typename T, typename... Ts>
+int Accumulate(T v, Ts... vs)
+{
+	return v + Accumulate(vs...);
+}
+
+template<int... Is>
+int CountElements()
+{
+	return sizeof...(Is);
+}
+
+int main()
+{
+	int acc = Accumulate(1, 2, 3, 4, -5);
+	int count = CountElements<1,2,3,4,5>();
+	return ((acc == 5) && (count == 5)) ? 0 : 1;
+}
--- a/include/chaiscript/chaiscript.hpp
+++ b/include/chaiscript/chaiscript.hpp
@@ -140,7 +140,10 @@
 ///
 /// \subsubsection addingobjects Adding Objects
 ///
-/// Named objects can be created with the chaiscript::var function.
+/// Named objects can be created with the chaiscript::var function. Note: adding a object
+/// adds it to the current thread scope, not to a global scope. If you have multiple 
+/// threads that need to access the same variables you will need to add them
+/// separately for each thread, from the thread itself.
 /// 
 /// \code
 /// using namespace chaiscript;
--- a/include/chaiscript/chaiscript_threading.hpp
+++ b/include/chaiscript/chaiscript_threading.hpp
@@ -7,6 +7,8 @@
 #ifndef CHAISCRIPT_THREADING_HPP_
 #define CHAISCRIPT_THREADING_HPP_

+#include <unordered_map>
+
 #ifndef CHAISCRIPT_NO_THREADS
 #include <thread>
 #include <mutex>
@@ -86,6 +88,7 @@ namespace chaiscript
          private:
            std::shared_ptr<T> get_tls() const
            {
+              
              unique_lock<mutex> lock(m_mutex);
             
              auto itr = m_instances.find(std::this_thread::get_id());
@@ -97,10 +100,20 @@ namespace chaiscript
              m_instances.insert(std::make_pair(std::this_thread::get_id(), new_instance));

              return new_instance;
+              
+
+              /*
+              static __thread std::shared_ptr<T> *m_data = 0;
+              
+              if (!m_data) { m_data = new std::shared_ptr<T>(new T()); }
+
+              return *m_data;
+              */
            }

+
            mutable mutex m_mutex;
-            mutable std::map<std::thread::id, std::shared_ptr<T> > m_instances;
+            mutable std::unordered_map<std::thread::id, std::shared_ptr<T> > m_instances;
        };

 #else
--- a/include/chaiscript/dispatchkit/bootstrap.hpp
+++ b/include/chaiscript/dispatchkit/bootstrap.hpp
@@ -423,6 +423,7 @@ namespace chaiscript
        m->add(fun(&Type_Info::is_void), "is_type_void");
        m->add(fun(&Type_Info::is_undef), "is_type_undef");
        m->add(fun(&Type_Info::is_pointer), "is_type_pointer");
+        m->add(fun(&Type_Info::is_arithmetic), "is_type_arithmetic");
        m->add(fun(&Type_Info::name), "cpp_name");
        m->add(fun(&Type_Info::bare_name), "cpp_bare_name");
        m->add(fun(&Type_Info::bare_equal), "bare_equal");
@@ -442,6 +443,7 @@ namespace chaiscript
        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);
--- a/include/chaiscript/dispatchkit/bootstrap_stl.hpp
+++ b/include/chaiscript/dispatchkit/bootstrap_stl.hpp
@@ -149,6 +149,20 @@ namespace chaiscript

      namespace detail {

+        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
         */
@@ -393,6 +407,21 @@ namespace chaiscript
        {
          m->add(fun<int (const ContainerType *, const typename ContainerType::key_type &)>(&ContainerType::count), "count");

+          typedef size_t (ContainerType::*erase_ptr)(const typename ContainerType::key_type &);
+
+          m->add(fun<int (ContainerType *, const typename ContainerType::key_type &)>(static_cast<erase_ptr>(&ContainerType::erase)), "erase");
+
+          m->add(fun(&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;
        }

@@ -514,6 +543,7 @@ namespace chaiscript

          typedef std::function<int (const String *, const String &, int)> find_func;

+
          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find(f, pos); } )), "find");
          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->rfind(f, pos); } ) ), "rfind");
          m->add(fun(find_func( [](const String *s, const String &f, int pos) { return s->find_first_of(f, pos); } ) ), "find_first_of");
@@ -523,7 +553,7 @@ namespace chaiscript

          m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->c_str(); } ) ), "c_str");
          m->add(fun( std::function<const char *(const String *)>( [](const String *s) { return s->data(); } ) ), "data");
-
+          m->add(fun( std::function<String (const String *, int, int)>( [](const String *s, int pos, int len) { return s->substr(pos, len); } ) ), "substr");          

          return m;
        }
--- a/include/chaiscript/dispatchkit/boxed_number.hpp
+++ b/include/chaiscript/dispatchkit/boxed_number.hpp
@@ -9,6 +9,7 @@

 #include "boxed_value.hpp"
 #include "../language/chaiscript_algebraic.hpp"
+#include <sstream>

 namespace chaiscript 
 {
@@ -300,7 +301,20 @@ namespace chaiscript
            throw chaiscript::detail::exception::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:
@@ -315,6 +329,93 @@ namespace chaiscript
        validate_boxed_number(v);
      }

+      template<typename T> explicit Boxed_Number(T t)
+        : bv(Boxed_Value(t))
+      {
+        validate_boxed_number(bv);
+      }
+
+      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(std::int8_t)) {
+          return get_as_aux<Target, std::int8_t>();
+        } else if (inp_ == typeid(std::int16_t)) {
+          return get_as_aux<Target, std::int16_t>();
+        } else if (inp_ == typeid(std::int32_t)) {
+          return get_as_aux<Target, std::int32_t>();
+        } else if (inp_ == typeid(std::int64_t)) {
+          return get_as_aux<Target, std::int64_t>();
+        } else if (inp_ == typeid(std::uint8_t)) {
+          return get_as_aux<Target, std::uint8_t>();
+        } else if (inp_ == typeid(std::uint16_t)) {
+          return get_as_aux<Target, std::uint16_t>();
+        } else if (inp_ == typeid(std::uint32_t)) {
+          return get_as_aux<Target, std::uint32_t>();
+        } else if (inp_ == typeid(std::uint64_t)) {
+          return get_as_aux<Target, std::uint64_t>();
+        } else {
+          throw chaiscript::detail::exception::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(std::int8_t)) {
+          return to_string_aux<int>(Boxed_Value(get_as_aux<int, std::int8_t>()));
+        } else if (inp_ == typeid(std::int16_t)) {
+          return to_string_aux<std::int16_t>(bv);
+        } else if (inp_ == typeid(std::int32_t)) {
+          return to_string_aux<std::int32_t>(bv);
+        } else if (inp_ == typeid(std::int64_t)) {
+          return to_string_aux<std::int64_t>(bv);
+        } else if (inp_ == typeid(std::uint8_t)) {
+          return to_string_aux<unsigned int>(Boxed_Value(get_as_aux<unsigned int, std::uint8_t>()));
+        } else if (inp_ == typeid(std::uint16_t)) {
+          return to_string_aux<std::uint16_t>(bv);
+        } else if (inp_ == typeid(std::uint32_t)) {
+          return to_string_aux<std::uint32_t>(bv);
+        } else if (inp_ == typeid(std::uint64_t)) {
+          return to_string_aux<std::uint64_t>(bv);
+        } else {
+          throw chaiscript::detail::exception::bad_any_cast();
+        }
+      }

      bool operator==(const Boxed_Number &t_rhs) const
      {
--- a/include/chaiscript/dispatchkit/dispatchkit.hpp
+++ b/include/chaiscript/dispatchkit/dispatchkit.hpp
@@ -673,6 +673,27 @@ namespace chaiscript
          return functions.find(name) != functions.end();
        }

+        /// \returns All values in the local thread state, added through the add() function
+        std::map<std::string, Boxed_Value> get_locals() const
+        {
+          StackData &stack = get_stack_data();
+          Scope &scope = stack.front();
+          return scope;
+        }
+
+        /// \brief Sets all of the locals for the current thread state.
+        ///
+        /// \param[in] t_locals The map<name, value> set of variables to replace the current state with
+        ///
+        /// Any existing locals are removed and the given set of variables is added
+        void set_locals(const std::map<std::string, Boxed_Value> &t_locals)
+        {
+          StackData &stack = get_stack_data();
+          Scope &scope = stack.front();
+          scope = t_locals;
+        }
+
+

        ///
        /// Get a map of all objects that can be seen from the current scope in a scripting context
--- a/include/chaiscript/dispatchkit/proxy_functions.hpp
+++ b/include/chaiscript/dispatchkit/proxy_functions.hpp
@@ -25,7 +25,6 @@ namespace chaiscript

  typedef std::shared_ptr<struct AST_Node> AST_NodePtr;

-
  namespace dispatch
  {
    /**
@@ -558,14 +557,16 @@ namespace chaiscript
    class dispatch_error : public std::runtime_error
    {
      public:
-        dispatch_error(const std::vector<Boxed_Value> &t_bvs)
-          : std::runtime_error("Error with function dispatch"), parameters(t_bvs)
+        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() noexcept {}

        std::vector<Boxed_Value> parameters;
+        std::vector<Const_Proxy_Function> functions;
    };
  } 

@@ -581,6 +582,7 @@ namespace chaiscript
      Boxed_Value dispatch(InItr begin, const InItr &end,
          const std::vector<Boxed_Value> &plist)
      {
+        InItr orig(begin);
        while (begin != end)
        {
          try {
@@ -599,7 +601,7 @@ namespace chaiscript
          ++begin;
        }

-        throw exception::dispatch_error(plist);
+        throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
      }

    /**
--- a/include/chaiscript/dispatchkit/proxy_functions_detail.hpp
+++ b/include/chaiscript/dispatchkit/proxy_functions_detail.hpp
@@ -143,7 +143,6 @@ namespace chaiscript
    }
  }

-
 }


--- a/include/chaiscript/dispatchkit/type_info.hpp
+++ b/include/chaiscript/dispatchkit/type_info.hpp
@@ -138,7 +138,7 @@ namespace chaiscript
      {
        typedef T type;

-        static Type_Info get()
+        constexpr static Type_Info get()
        {
          return Type_Info(std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
              std::is_void<T>::value,
@@ -153,7 +153,7 @@ namespace chaiscript
      {
        typedef T type;

-        static Type_Info get()
+        constexpr static Type_Info get()
        {
          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
              std::is_void<T>::value,
@@ -168,7 +168,7 @@ namespace chaiscript
      {
        typedef T type;

-        static Type_Info get()
+        constexpr static Type_Info get()
        {
          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
              std::is_void<T>::value,
@@ -183,7 +183,7 @@ namespace chaiscript
      {
        typedef T type;

-        static Type_Info get()
+        constexpr static Type_Info get()
        {
          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
              std::is_void<T>::value,
@@ -198,7 +198,7 @@ namespace chaiscript
      {
        typedef T type;

-        static Type_Info get()
+        constexpr static Type_Info get()
        {
          return Type_Info(std::is_const<T>::value, std::is_reference<T>::value, std::is_pointer<T>::value, 
              std::is_void<T>::value,
@@ -225,7 +225,7 @@ namespace chaiscript
  /// chaiscript::Type_Info ti = chaiscript::user_type(i);
  /// \endcode
  template<typename T>
-  Type_Info user_type(const T &/*t*/)
+  constexpr Type_Info user_type(const T &/*t*/)
  {
    return detail::Get_Type_Info<T>::get();
  }
@@ -240,7 +240,7 @@ namespace chaiscript
  /// chaiscript::Type_Info ti = chaiscript::user_type<int>();
  /// \endcode
  template<typename T>
-  Type_Info user_type()
+  constexpr Type_Info user_type()
  {
    return detail::Get_Type_Info<T>::get();
  }
--- a/include/chaiscript/language/chaiscript_common.hpp
+++ b/include/chaiscript/language/chaiscript_common.hpp
@@ -69,18 +69,23 @@ namespace chaiscript
      File_Position start_position;
      File_Position end_position;
      std::string filename;
+      std::string detail;
      std::vector<AST_NodePtr> call_stack;

      eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
-          const std::vector<Boxed_Value> &t_parameters, const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
-        std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_ss)),
-        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname)
+          const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+          bool t_dot_notation,
+          const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
+        std::runtime_error(format(t_why, t_where, t_fname, t_parameters, t_dot_notation, t_ss)),
+        reason(t_why), start_position(t_where), end_position(t_where), filename(t_fname), detail(format_detail(t_functions, t_dot_notation, t_ss)) 
      {}

      eval_error(const std::string &t_why, 
-           const std::vector<Boxed_Value> &t_parameters, const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
-        std::runtime_error(format(t_why, t_parameters, t_ss)),
-        reason(t_why)
+           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
+           bool t_dot_notation,
+           const chaiscript::detail::Dispatch_Engine &t_ss) noexcept :
+        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))
      {}


@@ -94,29 +99,203 @@ namespace chaiscript
        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() noexcept {}

    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_parameters(const std::vector<Boxed_Value> &t_parameters,
+      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();
+        }
+
+
+        std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfun 
+          = std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(t_func);
+
+        if (dynfun)
+        {
+          Proxy_Function f = dynfun->get_guard();
+
+          if (f)
+          {
+            std::shared_ptr<const dispatch::Dynamic_Proxy_Function> dynfunguard 
+              = std::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;
-        ss << "With parameters: (";
+        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 (const Boxed_Value &bv: t_parameters)
+          for (std::vector<Boxed_Value>::const_iterator itr = t_parameters.begin();
+               itr != t_parameters.end();
+               ++itr)
          {
-            paramstr += (bv.is_const()?"const ":"");
-            paramstr += t_ss.type_name(bv);
-            paramstr += ", ";
+            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);
@@ -148,14 +327,14 @@ namespace chaiscript
      }

      static std::string format(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
-          const std::vector<Boxed_Value> &t_parameters, const chaiscript::detail::Dispatch_Engine &t_ss)
+          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 << format_parameters(t_parameters, t_ss);
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
        ss << " ";

        ss << format_filename(t_fname);
@@ -167,14 +346,16 @@ namespace chaiscript
      }

      static std::string format(const std::string &t_why, 
-          const std::vector<Boxed_Value> &t_parameters, const chaiscript::detail::Dispatch_Engine &t_ss)
+          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 << format_parameters(t_parameters, t_ss);
+        ss << "With parameters: " << format_parameters(t_parameters, t_dot_notation, t_ss);
        ss << " ";

        return ss.str();
@@ -220,6 +401,19 @@ namespace chaiscript
      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
       */
--- a/include/chaiscript/language/chaiscript_engine.hpp
+++ b/include/chaiscript/language/chaiscript_engine.hpp
@@ -28,7 +28,7 @@
 #endif


-#include "chaiscript_prelude.hpp"
+#include "chaiscript_prelude.chai"
 #include "chaiscript_parser.hpp"
 #include "../dispatchkit/exception_specification.hpp"

@@ -351,7 +351,7 @@ namespace chaiscript
      m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
      m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");

-      do_eval(chaiscript_prelude, "standard prelude");
+      do_eval(ChaiScript_Prelude::chaiscript_prelude, "standard prelude");
    }

    /**
@@ -522,8 +522,12 @@ namespace chaiscript
      std::set<std::string> active_loaded_modules;
    };

-    /// \brief Returns a state object that represents the current state of the system
-    /// \return Current state of the system
+    /// \brief Returns a state object that represents the current state of the global system
+    ///
+    /// The global system includes the reserved words, global const objects, functions and types.
+    /// local variables are thread specific and not included.
+    ///
+    /// \return Current state of the global system
    ///
    /// \b Example:
    ///
@@ -544,6 +548,10 @@ namespace chaiscript
    }

    /// \brief Sets the state of the system
+    ///
+    /// The global system includes the reserved words, global objects, functions and types.
+    /// local variables are thread specific and not included.
+    ///
    /// \param[in] t_state New state to set
    ///
    /// \b Example:
@@ -563,7 +571,23 @@ namespace chaiscript
      m_engine.set_state(t_state.engine_state);
    }

-    /// \brief Adds a type, function or object to ChaiScript
+    /// \returns All values in the local thread state, added through the add() function
+    std::map<std::string, Boxed_Value> get_locals() const
+    {
+      return m_engine.get_locals();
+    }
+
+    /// \brief Sets all of the locals for the current thread state.
+    ///
+    /// \param[in] t_locals The map<name, value> set of variables to replace the current state with
+    ///
+    /// Any existing locals are removed and the given set of variables is added
+    void set_locals(const std::map<std::string, Boxed_Value> &t_locals)
+    {
+      m_engine.set_locals(t_locals);
+    }
+
+    /// \brief Adds a type, function or object to ChaiScript. Objects are added to the local thread state.
    /// \param[in] t_t Item to add
    /// \param[in] t_name Name of item to add
    /// \returns Reference to current ChaiScript object
@@ -718,6 +742,8 @@ namespace chaiscript
    /// \tparam T Type to extract from the result value of the script execution
    /// \param[in] t_input Script to execute
    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
+    /// \param[in] t_filename Optional filename to report to the user for where the error occured. Useful
+    ///                       in special cases where you are loading a file internally instead of using eval_file
    ///
    /// \return result of the script execution
    /// 
@@ -725,10 +751,10 @@ namespace chaiscript
    /// \throw chaiscript::exception::bad_boxed_cast In the case that evaluation succeeds but the result value cannot be converted
    ///        to the requested type.
    template<typename T>
-    T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler())
+    T eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
    {
      try {
-        return boxed_cast<T>(do_eval(t_input));
+        return boxed_cast<T>(do_eval(t_input, t_filename));
      } catch (Boxed_Value &bv) {
        if (t_handler) {
          t_handler->handle(bv);
@@ -741,14 +767,16 @@ namespace chaiscript
    ///
    /// \param[in] t_input Script to execute
    /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
+    /// \param[in] t_filename Optional filename to report to the user for where the error occured. Useful
+    ///                       in special cases where you are loading a file internally instead of using eval_file
    ///
    /// \return result of the script execution
    /// 
-    /// \throw chaiscript::exception::eval_error In the case that evaluation fails.
-    Boxed_Value eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler())
+    /// \throw exception::eval_error In the case that evaluation fails.
+    Boxed_Value eval(const std::string &t_input, const Exception_Handler &t_handler = Exception_Handler(), const std::string &t_filename="__EVAL__")
    {
      try {
-        return do_eval(t_input);
+        return do_eval(t_input, t_filename);
      } catch (Boxed_Value &bv) {
        if (t_handler) {
          t_handler->handle(bv);
--- a/include/chaiscript/language/chaiscript_eval.hpp
+++ b/include/chaiscript/language/chaiscript_eval.hpp
@@ -50,6 +50,16 @@ namespace chaiscript
              this->children[2]->eval(t_ss));
        }

+        virtual std::string pretty_print() const 
+        {
+          if (children.size() == 3)
+          {
+            return "(" + this->children[0]->pretty_print() + " " + this->children[1]->text + " " + this->children[2]->pretty_print() + ")";
+          } else {
+            return "(" + this->children[0]->pretty_print() + " " + text + " " + this->children[1]->pretty_print() + ")";
+          }
+        }
+
      protected:
        Boxed_Value do_oper(chaiscript::detail::Dispatch_Engine &t_ss, 
            Operators::Opers t_oper, const std::string &t_oper_string, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
@@ -76,7 +86,7 @@ namespace chaiscript
            }
          }
          catch(const exception::dispatch_error &e){
-            throw exception::eval_error("Can not find appropriate '" + t_oper_string + "' operator.", e.parameters, t_ss);
+            throw exception::eval_error("Can not find appropriate '" + t_oper_string + "' operator.", e.parameters, e.functions, false, t_ss);
          }
        }
    };
@@ -94,6 +104,9 @@ namespace chaiscript
        Int_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Int, const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col), 
          m_value(const_var(int(atoi(t_ast_node_text.c_str())))) { }
+        Int_AST_Node(const std::string &t_ast_node_text, const Boxed_Value &t_bv, int t_id = AST_Node_Type::Int, const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col), 
+          m_value(t_bv) { }
        virtual ~Int_AST_Node() {}
        virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
          return m_value;
@@ -109,6 +122,9 @@ namespace chaiscript
        Float_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Float, const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
          m_value(const_var(double(atof(t_ast_node_text.c_str())))) { }
+        Float_AST_Node(const std::string &t_ast_node_text, const Boxed_Value &t_bv, int t_id = AST_Node_Type::Float, const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
+          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col),
+          m_value(t_bv) { }
        virtual ~Float_AST_Node() {}
        virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &){
          return m_value;
@@ -182,6 +198,11 @@ namespace chaiscript
        Eol_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Eol, const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
        virtual ~Eol_AST_Node() {}
+
+        virtual std::string pretty_print() const 
+        {
+          return "\n";
+        }
    };

    struct Fun_Call_AST_Node : public AST_Node {
@@ -202,22 +223,30 @@ namespace chaiscript
          fpp.save_params(params);


+          Boxed_Value fn = this->children[0]->eval(t_ss);
          try {
-            Boxed_Value fn = this->children[0]->eval(t_ss);
-
-            try {
-              chaiscript::eval::detail::Stack_Push_Pop spp(t_ss);
-              const Boxed_Value &retval = (*boxed_cast<const Const_Proxy_Function &>(fn))(params);
-              return retval;
-            }
-            catch(const exception::dispatch_error &e){
-              throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'", e.parameters, t_ss);
-            }
-            catch(detail::Return_Value &rv) {
-              return rv.retval;
-            }
+            chaiscript::eval::detail::Stack_Push_Pop spp(t_ss);
+            const Boxed_Value &retval = (*boxed_cast<const Const_Proxy_Function &>(fn))(params);
+            return retval;
          }
          catch(const exception::dispatch_error &e){
+            throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'", e.parameters, e.functions, false, t_ss);
+          }
+          catch(const exception::bad_boxed_cast &){
+            try {
+              Const_Proxy_Function f = boxed_cast<const Const_Proxy_Function &>(fn);
+              // handle the case where there is only 1 function to try to call and dispatch fails on it
+              std::vector<Const_Proxy_Function> funcs;
+              funcs.push_back(f);
+              throw exception::eval_error("Error calling function '" + this->children[0]->text + "'", params, funcs, false, t_ss);
+            } catch (const exception::bad_boxed_cast &) {
+              throw exception::eval_error("'" + this->children[0]->pretty_print() + "' does not evaluate to a function.");
+            }
+          }
+          catch(const exception::arity_error &e){
+            throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'");
+          }
+          catch(const exception::guard_error &e){
            throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'");
          }
          catch(detail::Return_Value &rv) {
@@ -225,6 +254,24 @@ namespace chaiscript
          }
        }

+        virtual std::string pretty_print() const 
+        {
+          std::ostringstream oss;
+
+          for (unsigned int j = 0; j < this->children.size(); ++j) {
+            oss << this->children[j]->pretty_print();
+
+            if (j == 0)
+            {
+              oss << "(";
+            }
+          }
+
+          oss << ")";
+
+          return oss.str();
+        }
+
    };

    struct Inplace_Fun_Call_AST_Node : public AST_Node {
@@ -241,18 +288,53 @@ namespace chaiscript
            }
          }

+          Boxed_Value bv;
+          Const_Proxy_Function fn;
+
          try {
-            return (*boxed_cast<const Const_Proxy_Function &>(this->children[0]->eval(t_ss)))(params);
+            bv = this->children[0]->eval(t_ss);
+            try {
+              fn = boxed_cast<const Const_Proxy_Function &>(bv);
+            } catch (const exception::bad_boxed_cast &) {
+              throw exception::eval_error("'" + this->children[0]->pretty_print() + "' does not evaluate to a function.");
+            }
+            return (*fn)(params);
          }
          catch(const exception::dispatch_error &e){
-            throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'", e.parameters, t_ss);
+            throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'", e.parameters, e.functions, false, t_ss);
+          }
+          catch(const exception::bad_boxed_cast &){
+            // handle the case where there is only 1 function to try to call and dispatch fails on it
+            std::vector<Const_Proxy_Function> funcs;
+            funcs.push_back(fn);
+            throw exception::eval_error("Error calling function '" + this->children[0]->text + "'", params, funcs, false, t_ss);
+          }
+          catch(const exception::arity_error &e){
+            throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'");
+          }
+          catch(const exception::guard_error &e){
+            throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'");
          }
          catch(detail::Return_Value &rv) {
            return rv.retval;
          }
-          catch(...) {
-            throw;
+        }
+
+        virtual std::string pretty_print() const 
+        {
+          std::ostringstream oss;
+          for (unsigned int j = 0; j < this->children.size(); ++j) {
+            oss << this->children[j]->pretty_print();
+
+            if (j == 0)
+            {
+              oss << "(";
+            }
          }
+
+          oss << ")";
+
+          return oss.str();
        }

    };
@@ -262,6 +344,21 @@ namespace chaiscript
        Arg_List_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Arg_List, const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
        virtual ~Arg_List_AST_Node() {}
+
+        virtual std::string pretty_print() const 
+        {
+          std::ostringstream oss;
+          for (unsigned int j = 0; j < this->children.size(); ++j) {
+            if (j != 0)
+            {
+              oss << ", ";
+            }
+
+            oss << this->children[j]->pretty_print();
+          }
+
+          return oss.str();
+        }
    };

    struct Variable_AST_Node : public AST_Node {
@@ -315,11 +412,11 @@ namespace chaiscript
                  retval = t_ss.call_function(this->children[1]->text, lhs, retval);
                }
                catch(const exception::dispatch_error &e){
-                  throw exception::eval_error("Unable to find appropriate'" + this->children[1]->text + "' operator.", e.parameters, t_ss);
+                  throw exception::eval_error("Unable to find appropriate'" + this->children[1]->text + "' operator.", e.parameters, e.functions, false, t_ss);
                }
              }
              catch(const exception::dispatch_error &e){
-                throw exception::eval_error("Missing clone or copy constructor for right hand side of equation", e.parameters, t_ss);
+                throw exception::eval_error("Missing clone or copy constructor for right hand side of equation", e.parameters, e.functions, false, t_ss);
              }
            }
            else if (this->children[1]->text == ":=") {
@@ -333,7 +430,7 @@ namespace chaiscript
              try {
                retval = t_ss.call_function(this->children[1]->text, lhs, retval);
              } catch(const exception::dispatch_error &e){
-                  throw exception::eval_error("Unable to find appropriate'" + this->children[1]->text + "' operator.", e.parameters, t_ss);
+                  throw exception::eval_error("Unable to find appropriate'" + this->children[1]->text + "' operator.", e.parameters, e.functions, false, t_ss);
              }
            }
          }
@@ -366,6 +463,11 @@ namespace chaiscript

        }

+        virtual std::string pretty_print() const 
+        {
+          return "var " + this->children[0]->text;
+        }
+
    };

    struct Comparison_AST_Node : public Binary_Operator_AST_Node {
@@ -377,7 +479,7 @@ namespace chaiscript

    struct Addition_AST_Node : public Binary_Operator_AST_Node {
      public:
-        Addition_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Addition,
+        Addition_AST_Node(const std::string &t_ast_node_text = "+", int t_id = AST_Node_Type::Addition,
            const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(),
            int t_start_line = 0, int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
@@ -389,7 +491,7 @@ namespace chaiscript

    struct Subtraction_AST_Node : public Binary_Operator_AST_Node {
      public:
-        Subtraction_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Subtraction,
+        Subtraction_AST_Node(const std::string &t_ast_node_text = "-", int t_id = AST_Node_Type::Subtraction,
            const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0,
            int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
@@ -401,7 +503,7 @@ namespace chaiscript

    struct Multiplication_AST_Node : public Binary_Operator_AST_Node {
      public:
-        Multiplication_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Multiplication,
+        Multiplication_AST_Node(const std::string &t_ast_node_text = "*", int t_id = AST_Node_Type::Multiplication,
            const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0,
            int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
@@ -413,7 +515,7 @@ namespace chaiscript

    struct Division_AST_Node : public Binary_Operator_AST_Node {
      public:
-        Division_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Division,
+        Division_AST_Node(const std::string &t_ast_node_text = "/", int t_id = AST_Node_Type::Division,
            const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0,
            int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
@@ -425,7 +527,7 @@ namespace chaiscript

    struct Modulus_AST_Node : public Binary_Operator_AST_Node {
      public:
-        Modulus_AST_Node(const std::string &t_ast_node_text = "", int t_id = AST_Node_Type::Modulus,
+        Modulus_AST_Node(const std::string &t_ast_node_text = "%", int t_id = AST_Node_Type::Modulus,
            const std::shared_ptr<std::string> &t_fname=std::shared_ptr<std::string>(), int t_start_line = 0,
            int t_start_col = 0, int t_end_line = 0, int t_end_col = 0) :
          Binary_Operator_AST_Node(t_ast_node_text, t_id, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
@@ -460,12 +562,27 @@ namespace chaiscript
              throw exception::eval_error("Out of bounds exception");
            }
            catch(const exception::dispatch_error &e){
-              throw exception::eval_error("Can not find appropriate array lookup operator '[]'.", e.parameters, t_ss );
+              throw exception::eval_error("Can not find appropriate array lookup operator '[]'.", e.parameters, e.functions, false, t_ss );
            }
          }

          return retval;
        }
+
+        virtual std::string pretty_print() const 
+        {
+          std::ostringstream oss;
+          oss << this->children[0]->pretty_print();
+
+          for (size_t i = 1; i < this->children.size(); ++i)
+          {
+            oss << "[";
+            oss << this->children[i]->pretty_print();
+            oss << "]";
+          }
+
+          return oss.str();
+        }
    };

    struct Dot_Access_AST_Node : public AST_Node {
@@ -503,7 +620,12 @@ namespace chaiscript
                retval = t_ss.call_function(fun_name, params);
              }
              catch(const exception::dispatch_error &e){
-                throw exception::eval_error(std::string(e.what()) + " for function: " + fun_name, e.parameters, t_ss);
+                if (e.functions.empty())
+                {
+                  throw exception::eval_error("'" + fun_name + "' is not a function.");
+                } else {
+                  throw exception::eval_error(std::string(e.what()) + " for function '" + fun_name + "'", e.parameters, e.functions, true, t_ss);
+                }
              }
              catch(detail::Return_Value &rv) {
                retval = rv.retval;
@@ -518,7 +640,7 @@ namespace chaiscript
                    throw exception::eval_error("Out of bounds exception");
                  }
                  catch(const exception::dispatch_error &e){
-                    throw exception::eval_error("Can not find appropriate array lookup operator '[]'.", e.parameters, t_ss);
+                    throw exception::eval_error("Can not find appropriate array lookup operator '[]'.", e.parameters, e.functions, true, t_ss);
                  }
                }
              }
@@ -540,6 +662,11 @@ namespace chaiscript
          return m_value;
        }

+        virtual std::string pretty_print() const 
+        {
+          return "\"" + text + "\"";
+        }
+
      private:
        Boxed_Value m_value;

@@ -555,6 +682,11 @@ namespace chaiscript
          return m_value;
        }

+        virtual std::string pretty_print() const 
+        {
+          return "'" + text + "'";
+        }
+
      private:
        Boxed_Value m_value;
    };
@@ -938,7 +1070,7 @@ namespace chaiscript
            return const_var(retval);
          }
          catch (const exception::dispatch_error &e) {
-            throw exception::eval_error("Can not find appropriate copy constructor or clone while inserting into Map.", e.parameters, t_ss);
+            throw exception::eval_error("Can not find appropriate copy constructor or 'clone' while inserting into Map.", e.parameters, e.functions, false, t_ss);
          }
        }

@@ -1020,7 +1152,7 @@ namespace chaiscript
              return t_ss.call_function(this->children[0]->text, bv);
            }
          } catch (const exception::dispatch_error &e) {
-            throw exception::eval_error("Error with prefix operator evaluation: '" + children[0]->text + "'", e.parameters, t_ss);
+            throw exception::eval_error("Error with prefix operator evaluation: '" + children[0]->text + "'", e.parameters, e.functions, false, t_ss);
          }
        }

@@ -1062,7 +1194,7 @@ namespace chaiscript
                this->children[0]->children[0]->children[1]->eval(t_ss));
          }
          catch (const exception::dispatch_error &e) {
-            throw exception::eval_error("Unable to generate range vector, while calling 'generate_range'", e.parameters, t_ss);
+            throw exception::eval_error("Unable to generate range vector, while calling 'generate_range'", e.parameters, e.functions, false, t_ss);
          }
        }

@@ -1392,6 +1524,11 @@ namespace chaiscript
          }
          return retval;
        }
+
+        virtual std::string pretty_print() const
+        {
+          return "(" + AST_Node::pretty_print() + ")";
+        }
    };

    struct Logical_Or_AST_Node : public AST_Node {
@@ -1419,6 +1556,11 @@ namespace chaiscript
          return retval;
        }

+        virtual std::string pretty_print() const
+        {
+          return "(" + AST_Node::pretty_print() + ")";
+        }
+
    };
  }

--- a/include/chaiscript/language/chaiscript_parser.hpp
+++ b/include/chaiscript/language/chaiscript_parser.hpp
@@ -12,7 +12,6 @@
 #include <sstream>
 #include <cstring>

-#include "chaiscript_prelude.hpp"
 #include "chaiscript_common.hpp"

 namespace chaiscript
@@ -34,6 +33,8 @@ namespace chaiscript
          ,   bin_alphabet
          ,   id_alphabet
          ,   white_alphabet
+          ,   int_suffix_alphabet
+          ,   float_suffix_alphabet
          ,   max_alphabet
          ,   lengthof_alphabet = 256
      };
@@ -176,6 +177,17 @@ namespace chaiscript

        m_alphabet[detail::white_alphabet][static_cast<int>(' ')]=true;
        m_alphabet[detail::white_alphabet][static_cast<int>('\t')]=true;
+
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('l')] = true;
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('L')] = true;
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('u')] = true;
+        m_alphabet[detail::int_suffix_alphabet][static_cast<int>('U')] = true;
+
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('l')] = true;
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('L')] = true;
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('f')] = true;
+        m_alphabet[detail::float_suffix_alphabet][static_cast<int>('F')] = true;
+
      }

      /**
@@ -344,6 +356,12 @@ namespace chaiscript
                ++m_input_pos;
                ++m_col;
              }
+
+              while (has_more_input() && char_in_alphabet(*m_input_pos, detail::float_suffix_alphabet))
+              {
+                ++m_input_pos;
+                ++m_col;
+              }
            }
            else {
              --m_input_pos;
@@ -372,6 +390,11 @@ namespace chaiscript
                ++m_input_pos;
                ++m_col;
              }
+              while (has_more_input() && char_in_alphabet(*m_input_pos, detail::int_suffix_alphabet))
+              {
+                ++m_input_pos;
+                ++m_col;
+              }
            }
            else {
              --m_input_pos;
@@ -387,6 +410,14 @@ namespace chaiscript
        return retval;
      }

+      void IntSuffix_() {
+        while (has_more_input() && char_in_alphabet(*m_input_pos, detail::int_suffix_alphabet))
+        {
+          ++m_input_pos;
+          ++m_col;
+        }
+      }
+
      /**
       * Reads a binary value from input, without skipping initial whitespace
       */
@@ -420,6 +451,164 @@ namespace chaiscript
        return retval;
      }

+      Boxed_Value buildFloat(const std::string &t_val)
+      {
+        bool float_ = false;
+        bool long_ = false;
+
+        size_t i = t_val.size();
+
+        for (; i > 0; --i)
+        {
+          char val = t_val[i-1];
+
+          if (val == 'f' || val == 'F')
+          {
+            float_ = true;
+          } else if (val == 'l' || val == 'L') {
+            long_ = true;
+          } else {
+            break;
+          }
+        }
+
+        std::stringstream ss(t_val.substr(0, i));
+
+        if (float_)
+        {
+          float f;
+          ss >> f;   
+          return Boxed_Value(const_var(f));
+        } else if (long_) {
+          long double f;
+          ss >> f;   
+          return Boxed_Value(const_var(f));
+        } else {
+          double f;
+          ss >> f;   
+          return Boxed_Value(const_var(f));
+        }
+      }
+
+
+
+      template<typename IntType>
+      Boxed_Value buildInt(const IntType &t_type, const std::string &t_val)
+      {
+        bool unsigned_ = false;
+        bool long_ = false;
+        bool longlong_ = false;
+
+        size_t i = t_val.size();
+
+        for (; i > 0; --i)
+        {
+          char val = t_val[i-1];
+
+          if (val == 'u' || val == 'U')
+          {
+            unsigned_ = true;
+          } else if (val == 'l' || val == 'L') {
+            if (long_)
+            {
+              longlong_ = true;
+            }
+
+            long_ = true;
+          } else {
+            break;
+          }
+        }
+
+        std::stringstream ss(t_val.substr(0, i));
+        ss >> t_type;
+
+        std::stringstream testu(t_val.substr(0, i));
+        uint64_t u;
+        testu >> t_type >> u;
+
+        bool unsignedrequired = false;
+        size_t size = sizeof(int) * 8;
+
+        if ((u >> (sizeof(int) * 8)) > 0)
+        {
+          //requires something bigger than int
+          long_ = true;
+        }
+
+        static_assert(sizeof(long) == sizeof(uint64_t) || sizeof(long) * 2 == sizeof(uint64_t), "Unexpected sizing of integer types");
+
+        if ((sizeof(long) < sizeof(uint64_t)) 
+            && (u >> ((sizeof(uint64_t) - sizeof(long)) * 8)) > 0)
+        {
+          //requires something bigger than long
+          longlong_ = true;
+        }
+
+
+        if (longlong_)
+        {
+          size = sizeof(int64_t) * 8;
+        } else if (long_) {
+          size = sizeof(long) * 8;
+        } 
+
+        if ( (u >> (size - 1)) > 0)
+        {
+          unsignedrequired = true;
+        }
+
+        if (unsignedrequired && !unsigned_)
+        {
+          if (t_type == &std::hex || t_type == &std::oct)
+          {
+            // with hex and octal we are happy to just make it unsigned
+            unsigned_ = true;
+          } else {
+            // with decimal we must bump it up to the next size
+            if (long_)
+            {
+              longlong_ = true;
+            } else if (!long_ && !longlong_) {
+              long_ = true;
+            }
+          }
+        }
+
+        if (unsigned_)
+        {
+          if (longlong_)
+          {
+            uint64_t val;
+            ss >> val;   
+            return Boxed_Value(const_var(val));
+          } else if (long_) {
+            unsigned long val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          } else {
+            unsigned int val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          }
+        } else {
+          if (longlong_)
+          {
+            int64_t val;
+            ss >> val;   
+            return Boxed_Value(const_var(val));
+          } else if (long_) {
+            long val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          } else {
+            int val;
+            ss >> val;
+            return Boxed_Value(const_var(val));
+          }
+        }
+      }
+
      /**
       * Reads a number from the input, detecting if it's an integer or floating point
       */
@@ -436,19 +625,14 @@ namespace chaiscript
          if (has_more_input() && char_in_alphabet(*m_input_pos, detail::float_alphabet) ) {
            if (Hex_()) {
              std::string match(start, m_input_pos);
-              std::stringstream ss(match);
-              unsigned int temp_int;
-              ss >> std::hex >> temp_int;
-
-              std::ostringstream out_int;
-              out_int << static_cast<int>(temp_int);
-              AST_NodePtr t(new eval::Int_AST_Node(out_int.str(), AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+              Boxed_Value i = buildInt(std::hex, match);
+              AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
              m_match_stack.push_back(t);
              return true;
            }
            if (Binary_()) {
              std::string match(start, m_input_pos);
-              int temp_int = 0;
+              int64_t temp_int = 0;
              size_t pos = 0, end = match.length();

              while ((pos < end) && (pos < (2 + sizeof(int) * 8))) {
@@ -459,32 +643,36 @@ namespace chaiscript
                ++pos;
              }

-              std::ostringstream out_int;
-              out_int << temp_int;
-              AST_NodePtr t(new eval::Int_AST_Node(out_int.str(), AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+              Boxed_Value i;
+              if (match.length() <= sizeof(int) * 8)
+              {
+                i = Boxed_Value(const_var(int(temp_int)));
+              } else {
+                i = Boxed_Value(const_var(temp_int));
+              }
+
+              AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
              m_match_stack.push_back(t);
              return true;
            }
            if (Float_()) {
              std::string match(start, m_input_pos);
-              AST_NodePtr t(new eval::Float_AST_Node(match, AST_Node_Type::Float, m_filename, prev_line, prev_col, m_line, m_col));
+              Boxed_Value f = buildFloat(match);
+              AST_NodePtr t(new eval::Float_AST_Node(match, f, AST_Node_Type::Float, m_filename, prev_line, prev_col, m_line, m_col));
              m_match_stack.push_back(t);
              return true;
            }
            else {
+              IntSuffix_();
              std::string match(start, m_input_pos);
              if ((match.size() > 0) && (match[0] == '0')) {
-                std::stringstream ss(match);
-                unsigned int temp_int;
-                ss >> std::oct >> temp_int;
-
-                std::ostringstream out_int;
-                out_int << int(temp_int);
-                AST_NodePtr t(new eval::Int_AST_Node(out_int.str(), AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+                Boxed_Value i = buildInt(std::oct, match);
+                AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
                m_match_stack.push_back(t);
              }
              else {
-                AST_NodePtr t(new eval::Int_AST_Node(match, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
+                Boxed_Value i = buildInt(std::dec, match);
+                AST_NodePtr t(new eval::Int_AST_Node(match, i, AST_Node_Type::Int, m_filename, prev_line, prev_col, m_line, m_col));
                m_match_stack.push_back(t);
              }
              return true;
@@ -1691,7 +1879,7 @@ namespace chaiscript
            retval = true;
            Container_Arg_List();
            if (!Char(']')) {
-              throw exception::eval_error("Missing closing brace '}' in container initializer", File_Position(m_line, m_col), *m_filename);
+              throw exception::eval_error("Missing closing square bracket ']' in container initializer", File_Position(m_line, m_col), *m_filename);
            }
            if ((prev_stack_top != m_match_stack.size()) && (m_match_stack.back()->children.size() > 0)) {
              if (m_match_stack.back()->children[0]->identifier == AST_Node_Type::Value_Range) {
--- a/include/chaiscript/language/chaiscript_prelude.chai
+++ b/include/chaiscript/language/chaiscript_prelude.chai
@@ -0,0 +1,530 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// and Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_PRELUDE_HPP_
+#define CHAISCRIPT_PRELUDE_HPP_
+
+namespace chaiscript {
+struct ChaiScript_Prelude { 
+  constexpr static const char *chaiscript_prelude=R""(
+
+def lt(l, r) { 
+  if (call_exists(`<`, l, r)) { 
+    l < r 
+  } else { 
+    type_name(l) < type_name(r) 
+  } 
+}
+
+
+def gt(l, r) { 
+  if (call_exists(`>`, l, r)) { 
+    l > r 
+  } else { 
+    type_name(l) > type_name(r) 
+  } 
+}
+
+def eq(l, r) { 
+  if (call_exists(`==`, l, r)) { 
+    l == r 
+  } else { 
+    false 
+  } 
+}
+
+def new(x) { 
+  eval(type_name(x))(); 
+} 
+
+def clone(x) : function_exists(type_name(x)) && call_exists(eval(type_name(x)), x)  
+{ 
+  eval(type_name(x))(x); 
+}
+
+
+# to_string for Pair()
+def to_string(x) : call_exists(first, x) && call_exists(second, x) { 
+  "<" + x.first.to_string() + ", " + x.second.to_string() + ">"; 
+}
+
+# to_string for containers
+def to_string(x) : call_exists(range, x) && !x.is_type("string"){ 
+  "[" + x.join(", ") + "]"; 
+}
+
+# Basic to_string function
+def to_string(x) { 
+  internal_to_string(x); 
+}
+
+# Prints to console with no carriage return
+def puts(x) { 
+  print_string(x.to_string()); 
+}
+
+# Prints to console with carriage return
+def print(x) { 
+  println_string(x.to_string()); 
+}
+
+# Returns the maximum value of two numbers
+def max(a, b) {
+  if (a>b) { 
+    a 
+  } else { 
+    b 
+  } 
+} 
+
+# Returns the minimum value of two numbers
+def min(a, b) 
+{ 
+  if (a<b) 
+  { 
+    a 
+  } else { 
+    b 
+  } 
+}
+
+
+# Returns true if the value is odd
+def odd(x)  { 
+  if (x % 2 == 1) 
+  { 
+    true 
+  } else { 
+    false 
+  } 
+}
+
+
+# Returns true if the value is even
+def even(x) 
+{ 
+  if (x % 2 == 0) 
+  { 
+    true 
+  } else { 
+    false 
+  } 
+} 
+
+
+# Pushes the second value onto the container first value while making a clone of the value
+def push_back(container, x) : call_exists(push_back_ref, container, x) 
+{ 
+  container.push_back_ref(clone(x))
+} 
+
+# Pushes the second value onto the front of the container first value while making a clone of the value
+def push_front(container, x) : call_exists(push_front_ref, container, x) 
+{ 
+  container.push_front_ref(clone(x)) 
+} 
+
+# Inserts the third value at the position of the second value into the container of the first
+# while making a clone. 
+def insert_at(container, pos, x) 
+{ 
+  container.insert_ref_at(pos, clone(x)); 
+} 
+
+# Returns the reverse of the given container
+def reverse(container) {
+  auto retval = new(container); 
+  auto r = range(container); 
+  while (!r.empty()) { 
+    retval.push_back(r.back()); 
+    r.pop_back(); 
+  } 
+  retval; 
+}
+
+# Return a range from a range 
+def range(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) 
+{ 
+  return clone(r); 
+}
+
+
+# The retro attribute that contains the underlying range 
+attr retro::m_range; 
+
+# Creates a retro from a retro by returning the original range
+def retro(r) : call_exists(get_type_name, r) && get_type_name(r) == "retro" 
+{ 
+  clone(r.m_range) 
+}
+
+
+# Creates a retro range from a range
+def retro::retro(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) 
+{ 
+  this.m_range = r; 
+}
+
+# Returns the first value of a retro
+def retro::front()  
+{ 
+  back(this.m_range) 
+}
+
+# Returns the last value of a retro
+def retro::back()  
+{ 
+  front(this.m_range) 
+}
+
+# Moves the back iterator of a retro towards the front by one 
+def retro::pop_back()  
+{
+  pop_front(this.m_range) 
+}
+
+# Moves the front iterator of a retro towards the back by one 
+def retro::pop_front()  
+{ 
+  pop_back(this.m_range) 
+} 
+
+# returns true if the retro is out of elements 
+def retro::empty() 
+{ 
+  empty(this.m_range); 
+} 
+
+# Performs the second value function over the container first value
+def for_each(container, func) : call_exists(range, container) { 
+  var t_range = range(container); 
+  while (!t_range.empty()) { 
+    func(t_range.front()); 
+    t_range.pop_front(); 
+  } 
+} 
+
+def back_inserter(container) { 
+  bind(push_back, container, _);     
+}
+
+def contains(container, item, compare_func) : call_exists(range, container) { 
+  auto t_range = range(container); 
+  while (!t_range.empty()) { 
+    if ( compare_func(t_range.front(), item) ) { 
+      return true; 
+    } 
+
+    t_range.pop_front(); 
+  } 
+  return false; 
+} 
+
+def contains(container, item) { 
+  return contains(container, item, eq) 
+} 
+
+def map(container, func, inserter) : call_exists(range, container) { 
+  auto range = range(container); 
+  while (!range.empty()) { 
+    inserter(func(range.front())); 
+    range.pop_front(); 
+  } 
+} 
+
+# Performs the second value function over the container first value. Creates a new container with the results
+def map(container, func) { 
+  auto retval = new(container); 
+  map(container, func, back_inserter(retval));
+  retval;
+}
+
+# Performs the second value function over the container first value. Starts with initial and continues with each element.
+def foldl(container, func, initial) : call_exists(range, container){ 
+  auto retval = initial; 
+  auto range = range(container); 
+  while (!range.empty()) { 
+    retval = (func(range.front(), retval)); 
+    range.pop_front(); 
+  } 
+  retval; 
+}
+
+# Returns the sum of the elements of the given value
+def sum(container) { 
+  foldl(container, `+`, 0.0) 
+} 
+
+# Returns the product of the elements of the given value
+def product(container) { 
+  foldl(container, `*`, 1.0) 
+} 
+
+# Returns a new container with the elements of the first value concatenated with the elements of the second value
+def concat(x, y) : call_exists(clone, x) { 
+  auto retval = x; 
+  auto inserter = back_inserter(retval); 
+  auto range = range(y); 
+  while (!range.empty()) { 
+    inserter(range.front()); 
+    range.pop_front(); 
+  } 
+  retval; 
+}
+
+
+def take(container, num, inserter) : call_exists(range, container) { 
+  auto r = range(container); 
+  auto i = num; 
+  while ((i > 0) && (!r.empty())) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+    --i; 
+  } 
+}
+
+
+# Returns a new container with the given number of elements taken from the container
+def take(container, num) {
+  auto retval = new(container); 
+  take(container, num, back_inserter(retval)); 
+  retval; 
+}
+
+
+def take_while(container, f, inserter) : call_exists(range, container) { 
+  auto r = range(container); 
+  while ((!r.empty()) && f(r.front())) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+  } 
+} 
+
+
+# Returns a new container with the given elements match the second value function
+def take_while(container, f) {
+  auto retval = new(container); 
+  take_while(container, f, back_inserter(retval)); 
+  retval;
+}
+
+
+def drop(container, num, inserter) : call_exists(range, container) { 
+  auto r = range(container); 
+  auto i = num; 
+  while ((i > 0) && (!r.empty())) { 
+    r.pop_front(); 
+    --i; 
+  } 
+  while (!r.empty()) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+  } 
+}
+
+
+# Returns a new container with the given number of elements dropped from the given container 
+def drop(container, num) {
+  auto retval = new(container); 
+  drop(container, num, back_inserter(retval)); 
+  retval; 
+}
+
+
+def drop_while(container, f, inserter) : call_exists(range, container) { 
+  auto r = range(container); 
+  while ((!r.empty())&& f(r.front())) { 
+    r.pop_front(); 
+  } 
+  while (!r.empty()) { 
+    inserter(r.front()); 
+    r.pop_front(); 
+  } 
+}
+
+
+# Returns a new container with the given elements dropped that match the second value function
+def drop_while(container, f) {
+  auto retval = new(container); 
+  drop_while(container, f, back_inserter(retval)); 
+  retval; 
+}
+
+
+# Applies the second value function to the container. Starts with the first two elements. Expects at least 2 elements.
+def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { 
+  auto r = range(container); 
+  auto retval = r.front(); 
+  r.pop_front(); 
+  retval = func(retval, r.front()); 
+  r.pop_front(); 
+  while (!r.empty()) { 
+    retval = func(retval, r.front()); 
+    r.pop_front(); 
+  } 
+  retval; 
+}
+
+
+# Returns a string of the elements in container delimited by the second value string
+def join(container, delim) { 
+  auto retval = ""; 
+  auto range = range(container); 
+  if (!range.empty()) { 
+    retval += to_string(range.front()); 
+    range.pop_front(); 
+    while (!range.empty()) { 
+      retval += delim; 
+      retval += to_string(range.front()); 
+      range.pop_front(); 
+    } 
+  } 
+  retval; 
+}
+
+
+def filter(container, f, inserter) : call_exists(range, container) { 
+  auto r = range(container); 
+  while (!r.empty()) { 
+    if (f(r.front())) { 
+      inserter(r.front()); 
+    } 
+    r.pop_front(); 
+  } 
+} 
+
+
+# Returns a new Vector which match the second value function
+def filter(container, f) { 
+  auto retval = new(container); 
+  filter(container, f, back_inserter(retval));
+  retval;
+}
+
+
+def generate_range(x, y, inserter) { 
+  auto i = x; 
+  while (i <= y) { 
+    inserter(i); 
+    ++i; 
+  } 
+}
+
+
+# Returns a new Vector which represents the range from the first value to the second value
+def generate_range(x, y) { 
+  auto retval = Vector(); 
+  generate_range(x,y,back_inserter(retval)); 
+  retval; 
+}
+
+
+# Returns a new Vector with the first value to the second value as its elements
+def collate(x, y) { 
+  return [x, y]; 
+}
+
+
+def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { 
+  auto r_x = range(x); 
+  auto r_y = range(y); 
+  while (!r_x.empty() && !r_y.empty()) { 
+    inserter(f(r_x.front(), r_y.front())); 
+    r_x.pop_front(); 
+    r_y.pop_front(); 
+  } 
+}
+
+
+# Returns a new Vector which joins matching elements of the second and third value with the first value function
+def zip_with(f, x, y) { 
+  auto retval = Vector(); 
+  zip_with(f,x,y,back_inserter(retval)); 
+  retval;
+}
+
+
+# Returns a new Vector which joins matching elements of the first and second
+def zip(x, y) { 
+  zip_with(collate, x, y); 
+}
+
+
+# Returns the position of the second value string in the first value string
+def string::find(substr) : is_type(substr, "string") { 
+  int(find(this, substr, 0)); 
+}
+
+
+# Returns the position of last match of the second value string in the first value string
+def string::rfind(substr) : is_type(substr, "string") { 
+  int(rfind(this, substr, -1)); 
+}
+
+
+# Returns the position of the first match of elements in the second value string in the first value string
+def string::find_first_of(list) : is_type(list, "string") { 
+  int(find_first_of(this, list, 0)); 
+} 
+
+
+# Returns the position of the last match of elements in the second value string in the first value string
+def string::find_last_of(list) : is_type(list, "string") { 
+  int(find_last_of(this, list, -1)); 
+} 
+
+
+# Returns the position of the first non-matching element in the second value string in the first value string
+def string::find_first_not_of(list) : is_type(list, "string") { 
+  int(find_first_not_of(this, list, 0)); 
+} 
+
+
+# Returns the position of the last non-matching element in the second value string in the first value string
+def string::find_last_not_of(list) : is_type(list, "string") { 
+  int(find_last_not_of(this, list, -1)); 
+} 
+
+
+def string::ltrim() { 
+  drop_while(this, fun(x) { x == ' ' || x == '\t' || x == '\r' || x == '\n'}); 
+} 
+
+
+def string::rtrim() { 
+  reverse(drop_while(reverse(this), fun(x) { x == ' ' || x == '\t' || x == '\r' || x == '\n'})); 
+} 
+
+
+def string::trim() { 
+  ltrim(rtrim(this)); 
+}
+
+
+def find(container, value, compare_func) : call_exists(range, container) && is_type(compare_func, "Function") { 
+  auto range = range(container); 
+  while (!range.empty()) { 
+    if (compare_func(range.front(), value)) { 
+      return range; 
+    } else { 
+      range.pop_front(); 
+    } 
+  } 
+  return range; 
+} 
+
+
+def find(container, value) { 
+  return find(container, value, eq) 
+} 
+
+
+)"";
+
+};
+}
+
+#endif /* CHAISCRIPT_PRELUDE_HPP_ */
--- a/include/chaiscript/language/chaiscript_prelude.hpp
+++ b/include/chaiscript/language/chaiscript_prelude.hpp
@@ -1,329 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#ifndef CHAISCRIPT_PRELUDE_HPP_
-#define CHAISCRIPT_PRELUDE_HPP_
-
-//Note, the expression "[x,y]" in "collate" is parsed as two separate expressions
-//by C++, so CODE_STRING, takes two expressions and adds in the missing comma
-#define CODE_STRING(x, y) #x ", " #y 
-
-#define chaiscript_prelude CODE_STRING(\
-def lt(l, r) { if (call_exists(`<`, l, r)) { l < r } else { type_name(l) < type_name(r) } } \n\
-def gt(l, r) { if (call_exists(`>`, l, r)) { l > r } else { type_name(l) > type_name(r) } } \n\
-def eq(l, r) { if (call_exists(`==`, l, r)) { l == r } else { false } } \n\
-def new(x) { eval(type_name(x))(); } \n\
-def clone(x) : function_exists(type_name(x)) && call_exists(eval(type_name(x)), x)  { eval(type_name(x))(x); } \n\
-# to_string for Pair()\n\
-def to_string(x) : call_exists(first, x) && call_exists(second, x) { \n\
-  "<" + x.first.to_string() + ", " + x.second.to_string() + ">"; \n\
-}\n\
-# to_string for containers\n\
-def to_string(x) : call_exists(range, x) && !x.is_type("string"){ \n\
-  "[" + x.join(", ") + "]"; \n\
-}\n\
-# Basic to_string function\n\
-def to_string(x) { \n\
-  internal_to_string(x); \n\
-}\n\
-# Prints to console with no carriage return\n\
-def puts(x) { \n\
-  print_string(x.to_string()); \n\
-} \n\
-# Prints to console with carriage return\n\
-def print(x) { \n\
-  println_string(x.to_string()); \n\
-} \n\
-# Returns the maximum value of two numbers\n\
-def max(a, b) { if (a>b) { a } else { b } } \n\
-# Returns the minimum value of two numbers\n\
-def min(a, b) { if (a<b) { a } else { b } } \n\
-# Returns true if the value is odd\n\
-def odd(x)  { if (x % 2 == 1) { true } else { false } } \n\
-# Returns true if the value is even\n\
-def even(x) { if (x % 2 == 0) { true } else { false } } \n\
-# Pushes the second value onto the container first value while making a clone of the value\n\
-def push_back(container, x) : call_exists(push_back_ref, container, x) { container.push_back_ref(clone(x)) } \n\
-# Pushes the second value onto the front of the container first value while making a clone of the value\n\
-def push_front(container, x) : call_exists(push_front_ref, container, x) { container.push_front_ref(clone(x)) } \n\
-# Inserts the third value at the position of the second value into the container of the first\n\
-# while making a clone. \n\
-def insert_at(container, pos, x) { container.insert_ref_at(pos, clone(x)); } \n\
-# Returns the reverse of the given container\n\
-def reverse(container) {\n\
-  auto retval = new(container); \n\
-  auto r = range(container); \n\
-  while (!r.empty()) { \n\
-    retval.push_back(r.back()); \n\
-    r.pop_back(); \n\
-  } \n\
-  retval; \n\
-} \n\
-# Return a range from a range \n\
-def range(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) { return clone(r); }\n\
-# The retro attribute that contains the underlying range \n\
-attr retro::m_range; \n\
-# Creates a retro from a retro by returning the original range\n\
-def retro(r) : call_exists(get_type_name, r) && get_type_name(r) == "retro" { clone(r.m_range) }\n\
-# Creates a retro range from a range\n\
-def retro::retro(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) { this.m_range = r; }\n\
-# Returns the first value of a retro\n\
-def retro::front()  { back(this.m_range) }\n\
-# Returns the last value of a retro\n\
-def retro::back()  { front(this.m_range) }\n\
-# Moves the back iterator of a retro towards the front by one \n\
-def retro::pop_back()  { pop_front(this.m_range) }\n\
-# Moves the front iterator of a retro towards the back by one \n\
-def retro::pop_front()  { pop_back(this.m_range) } \n\
-# returns true if the retro is out of elements \n\
-def retro::empty() { empty(this.m_range); } \n\
-# Performs the second value function over the container first value\n\
-def for_each(container, func) : call_exists(range, container) { \n\
-  auto t_range = range(container); \n\
-  while (!t_range.empty()) { \n\
-    func(t_range.front()); \n\
-    t_range.pop_front(); \n\
-  } \n\
-} \n\
-def back_inserter(container) { \n\
-  bind(push_back, container, _);     \n\
-}\n\
-\n\
-def contains(container, item, compare_func) : call_exists(range, container) { \n\
-  auto t_range = range(container); \n\
-  while (!t_range.empty()) { \n\
-    if ( compare_func(t_range.front(), item) ) { return true; } \n\
-    t_range.pop_front(); \n\
-  } \n\
-  return false; \n\
-} \n\
-def contains(container, item) { return contains(container, item, eq) } \n\
-def map(container, func, inserter) : call_exists(range, container) { \n\
-  auto range = range(container); \n\
-  while (!range.empty()) { \n\
-    inserter(func(range.front())); \n\
-    range.pop_front(); \n\
-  } \n\
-} \n\
-# Performs the second value function over the container first value. Creates a new container with the results\n\
-def map(container, func) { \n\
-  auto retval = new(container); \n\
-  map(container, func, back_inserter(retval));\n\
-  retval;\n\
-}\n\
-# Performs the second value function over the container first value. Starts with initial and continues with each element.\n\
-def foldl(container, func, initial) : call_exists(range, container){ \n\
-  auto retval = initial; \n\
-  auto range = range(container); \n\
-  while (!range.empty()) { \n\
-    retval = (func(range.front(), retval)); \n\
-    range.pop_front(); \n\
-  } \n\
-  retval; \n\
-} \n\
-# Returns the sum of the elements of the given value\n\
-def sum(container) { foldl(container, `+`, 0.0) } \n\
-# Returns the product of the elements of the given value\n\
-def product(container) { foldl(container, `*`, 1.0) } \n\
-# Returns a new container with the elements of the first value concatenated with the elements of the second value\n\
-def concat(x, y) : call_exists(clone, x) { \n\
-  auto retval = x; \n\
-  auto inserter = back_inserter(retval); \n\
-  auto range = range(y); \n\
-  while (!range.empty()) { \n\
-    inserter(range.front()); \n\
-    range.pop_front(); \n\
-  } \n\
-  retval; \n\
-} \n\
-def take(container, num, inserter) : call_exists(range, container) { \n\
-  auto r = range(container); \n\
-  auto i = num; \n\
-  while ((i > 0) && (!r.empty())) { \n\
-    inserter(r.front()); \n\
-    r.pop_front(); \n\
-    --i; \n\
-  } \n\
-} \n\
-# Returns a new container with the given number of elements taken from the container\n\
-def take(container, num) {\n\
-  auto retval = new(container); \n\
-  take(container, num, back_inserter(retval)); \n\
-  retval; \n\
-}\n\
-def take_while(container, f, inserter) : call_exists(range, container) { \n\
-  auto r = range(container); \n\
-  while ((!r.empty()) && f(r.front())) { \n\
-    inserter(r.front()); \n\
-    r.pop_front(); \n\
-  } \n\
-} \n\
-# Returns a new container with the given elements match the second value function\n\
-def take_while(container, f) {\n\
-  auto retval = new(container); \n\
-  take_while(container, f, back_inserter(retval)); \n\
-  retval;\n\
-}\n\
-def drop(container, num, inserter) : call_exists(range, container) { \n\
-  auto r = range(container); \n\
-  auto i = num; \n\
-  while ((i > 0) && (!r.empty())) { \n\
-    r.pop_front(); \n\
-    --i; \n\
-  } \n\
-  while (!r.empty()) { \n\
-    inserter(r.front()); \n\
-    r.pop_front(); \n\
-  } \n\
-} \n\
-# Returns a new container with the given number of elements dropped from the given container \n\
-def drop(container, num) {\n\
-  auto retval = new(container); \n\
-  drop(container, num, back_inserter(retval)); \n\
-  retval; \n\
-}\n\
-def drop_while(container, f, inserter) : call_exists(range, container) { \n\
-  auto r = range(container); \n\
-  while ((!r.empty())&& f(r.front())) { \n\
-    r.pop_front(); \n\
-  } \n\
-  while (!r.empty()) { \n\
-    inserter(r.front()); \n\
-    r.pop_front(); \n\
-  } \n\
-} \n\
-# Returns a new container with the given elements dropped that match the second value function\n\
-def drop_while(container, f) {\n\
-  auto retval = new(container); \n\
-  drop_while(container, f, back_inserter(retval)); \n\
-  retval; \n\
-}\n\
-# Applies the second value function to the container. Starts with the first two elements. Expects at least 2 elements.\n\
-def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { \n\
-  auto r = range(container); \n\
-  auto retval = r.front(); \n\
-  r.pop_front(); \n\
-  retval = func(retval, r.front()); \n\
-  r.pop_front(); \n\
-  while (!r.empty()) { \n\
-    retval = func(retval, r.front()); \n\
-    r.pop_front(); \n\
-  } \n\
-  retval; \n\
-} \n\
-# Returns a string of the elements in container delimited by the second value string\n\
-def join(container, delim) { \n\
-  auto retval = ""; \n\
-  auto range = range(container); \n\
-  if (!range.empty()) { \n\
-    retval += to_string(range.front()); \n\
-    range.pop_front(); \n\
-    while (!range.empty()) { \n\
-      retval += delim; \n\
-      retval += to_string(range.front()); \n\
-      range.pop_front(); \n\
-    } \n\
-  } \n\
-  retval; \n\
-} \n\
-def filter(container, f, inserter) : call_exists(range, container) { \n\
-  auto r = range(container); \n\
-  while (!r.empty()) { \n\
-    if (f(r.front())) { \n\
-      inserter(r.front()); \n\
-    } \n\
-    r.pop_front(); \n\
-  } \n\
-} \n\
-# Returns a new Vector which match the second value function\n\
-def filter(container, f) { \n\
-  auto retval = new(container); \n\
-  filter(container, f, back_inserter(retval));\n\
-  retval;\n\
-}\n\
-def generate_range(x, y, inserter) { \n\
-  auto i = x; \n\
-  while (i <= y) { \n\
-    inserter(i); \n\
-    ++i; \n\
-  } \n\
-} \n\
-# Returns a new Vector which represents the range from the first value to the second value\n\
-def generate_range(x, y) { \n\
-  auto retval = Vector(); \n\
-  generate_range(x,y,back_inserter(retval)); \n\
-  retval; \n\
-}\n\
-# Returns a new Vector with the first value to the second value as its elements\n\
-def collate(x, y) { \n\
-  return [x, y]; \n\
-} \n\
-def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { \n\
-  auto r_x = range(x); \n\
-  auto r_y = range(y); \n\
-  while (!r_x.empty() && !r_y.empty()) { \n\
-    inserter(f(r_x.front(), r_y.front())); \n\
-    r_x.pop_front(); \n\
-    r_y.pop_front(); \n\
-  } \n\
-} \n\
-# Returns a new Vector which joins matching elements of the second and third value with the first value function\n\
-def zip_with(f, x, y) { \n\
-  auto retval = Vector(); \n\
-  zip_with(f,x,y,back_inserter(retval)); \n\
-  retval;\n\
-}\n\
-# Returns a new Vector which joins matching elements of the first and second\n\
-def zip(x, y) { \n\
-  zip_with(collate, 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, 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, -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, 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, -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, 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, -1)); \n\
-} \n\
-def string::ltrim() { \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' || 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\
-  auto range = range(container); \n\
-  while (!range.empty()) { \n\
-    if (compare_func(range.front(), value)) { \n\
-      return range; \n\
-    } else { \n\
-      range.pop_front(); \n\
-    } \n\
-  } \n\
-  return range; \n\
-} \n\
-def find(container, value) { return find(container, value, eq) } \
-)
-#endif /* CHAISCRIPT_PRELUDE_HPP_ */
--- a/readme.md
+++ b/readme.md
@@ -0,0 +1,113 @@
+ChaiScript
+
+http://www.chaiscript.com
+
+(c) 2009-2012 Jason Turner and Jonathan 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 C++11 compiler to build with support for variadic 
+templates.  It has been tested with gcc 4.7 and clang 3.1 (with libcxx). MacOS 
+10.8 (Mountain Lion) is also known to support the C++11 build with Apple's 
+clang 4.0.
+
+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`
+* The default behavior is to load the ChaiScript standard library from a 
+  loadable module. A second option is to compile the library into your code,
+  see below for an example.
+
+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);");
+    }
+
+
+
+Or, if you want to compile the std lib into your code, which reduces
+runtime requirements.
+
+    /// main.cpp
+
+    #include <chaiscript/chaiscript.hpp>
+    #include <chaiscript/chaiscript_stdlib.hpp>
+
+    double function(int i, double j)
+    {
+      return i * j;
+    }
+
+    int main()
+    {
+      chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
+      chai.add(chaiscript::fun(&function), "function");
+
+      double d = chai.eval<double>("function(3, 4.75);");
+    }
+
+
--- a/readme.txt
+++ b/readme.txt
@@ -1,55 +0,0 @@
-ChaiScript
-http://www.chaiscript.com
-(c) 2009-2012 Jason Turner and Jonathan 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 C++11 compiler to build with support for variadic templates.  It has been tested with gcc 4.7 and clang 3.1 (with libcxx).
-
-[Usage]
-
-* Add the ChaiScript include directory to your project's header search path
-* Add "#include <chaiscript/chaiscript.hpp> to your source file
-* Instantiate the ChaiScript engine in your application.  For example, create a new engine with the name 'chai' like so: "chaiscript::ChaiScript chai"
-
-Once instantiated, the engine is ready to start running ChaiScript source.  You have two main options for processing ChaiScript source: a line at a time using "chai.evaluate_string(string)" and a file at a time using "chai.evaluate_file(fname)"
-
-To make functions in your C++ code visible to scripts, they must be registered with the scripting engine.  To do so, call add:
-
-chai.add(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);");
-}
--- a/releasenotes.txt
+++ b/releasenotes.txt
@@ -1,3 +1,8 @@
+Changes since 5.0.0
+* Fix sizing of numeric constants to match that of the C++ standard
+* Add support for u,ll,l,f suffixes for numeric constants
+* Siginificant improvement in error reporting
+
 Changes since 4.0.0
 * Dropped boost in favor of C++11
 * Separated out stdlib to make more options for compile time improvements
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -233,18 +233,7 @@ int main(int argc, char *argv[])
      }
    }
    catch (const chaiscript::exception::eval_error &ee) {
-      std::cout << ee.what();
-      if (ee.call_stack.size() > 0) {
-        std::cout << "during evaluation at (" << *(ee.call_stack[0]->filename) << " " << ee.call_stack[0]->start.line << ", " << ee.call_stack[0]->start.column << ")";
-        for (size_t j = 1; j < ee.call_stack.size(); ++j) {
-          if (ee.call_stack[j]->identifier != chaiscript::AST_Node_Type::Block
-              && ee.call_stack[j]->identifier != chaiscript::AST_Node_Type::File)
-          {
-            std::cout << std::endl;
-            std::cout << "  from " << *(ee.call_stack[j]->filename) << " (" << ee.call_stack[j]->start.line << ", " << ee.call_stack[j]->start.column << ")";
-          }
-        }
-      }
+      std::cout << ee.pretty_print();
      std::cout << std::endl;
      return EXIT_FAILURE;
    }
--- a/src/multithreaded.cpp
+++ b/src/multithreaded.cpp
@@ -1,41 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
-// and Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#include <iostream>
-
-#include <list>
-
-#include <chaiscript/chaiscript.hpp>
-#include <thread>
-
-void do_work(chaiscript::ChaiScript &c)
-{
-//  c("use(\"work.chai\"); do_chai_work(num_iterations);"); 
-  std::stringstream ss;
-  ss << "MyVar" << rand();
-  c.add(chaiscript::var(5), ss.str());
-  c("use(\"work.chai\"); do_chai_work(10000);");
-}
-
-int main(int argc, char *argv[]) {
-  std::string input;
-  chaiscript::ChaiScript chai;
-
-  //chai.add_shared_object(chaiscript::Boxed_Value(10000), "num_iterations");
-
-  std::vector<std::shared_ptr<std::thread> > threads;
-
-  for (int i = 0; i < argc - 1; ++i)
-  {
-    threads.push_back(std::shared_ptr<std::thread>(new std::thread(std::bind(do_work, std::ref(chai)))));
-  }
-
-  for (int i = 0; i < argc - 1; ++i)
-  {
-    threads[i]->join();
-  }
-}
-
--- a/src/work.chai
+++ b/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);
-}
--- a/unittests/c_linkage_test.cpp
+++ b/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;
+
+}
--- a/unittests/expected_eval_errors_test.cpp
+++ b/unittests/expected_eval_errors_test.cpp
@@ -0,0 +1,111 @@
+// Tests to make sure no arity, dispatch or guard errors leak up past eval
+
+#include <chaiscript/utility/utility.hpp>
+
+int test_one(const int &)
+{
+  return 1;
+}
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::fun(&test_one), "test_fun");
+
+  chai.eval("def guard_fun(i) : i.get_type_info().is_type_arithmetic() {} ");
+
+  bool eval_error = true;
+
+  // Dot notation
+
+  try {
+    // non-existant function
+    chai.eval("\"test\".test_one()");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong parameter type
+    chai.eval("\"test\".test_fun()");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong number of parameters
+    chai.eval("\"test\".test_fun(1)");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // guard failure
+    chai.eval("\"test\".guard_fun(1)");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+
+
+  // regular notation
+
+  try {
+    // non-existant function
+    chai.eval("test_one(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong parameter type
+    chai.eval("test_fun(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // wrong number of parameters
+    chai.eval("test_fun(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  try {
+    // guard failure
+    chai.eval("guard_fun(\"test\")");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+
+  // index operator
+  try {
+    chai.eval("var a = [1,2,3]; a[\"bob\"];");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  // unary operator
+  try {
+    chai.eval("++\"bob\"");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+  // binary operator
+  try {
+    chai.eval("\"bob\" + 1");
+    eval_error = false;
+  } catch (const chaiscript::exception::eval_error &) {
+  }
+
+
+  if (eval_error)
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+
+}
--- a/unittests/integer_literal_test.cpp
+++ b/unittests/integer_literal_test.cpp
@@ -0,0 +1,90 @@
+// Tests to make sure that the order in which function dispatches occur is correct
+
+#include <chaiscript/chaiscript.hpp>
+
+#define TEST_LITERAL(v) test_literal(v, #v)
+
+template<typename T>
+bool test_literal(T val, const std::string &str)
+{
+  chaiscript::ChaiScript chai;
+  T val2 = chai.eval<T>(str);
+  std::cout << "Comparing : " << val << " " << val2 << std::endl;
+  return val == val2;
+}
+
+int main()
+{
+  if( TEST_LITERAL(0xF)
+ && TEST_LITERAL(0xFF)
+ && TEST_LITERAL(0xFFF)
+ && TEST_LITERAL(0xFFFF)
+ && TEST_LITERAL(0xFFFFF)
+ && TEST_LITERAL(0xFFFFFF)
+ && TEST_LITERAL(0xFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFFFF)
+ && TEST_LITERAL(0xFFFFFFFFFFFFFFFF) 
+ 
+ 
+ && TEST_LITERAL(01)
+ && TEST_LITERAL(017)
+ && TEST_LITERAL(0177)
+ && TEST_LITERAL(01777)
+ && TEST_LITERAL(017777)
+ && TEST_LITERAL(0177777)
+ && TEST_LITERAL(01777777)
+ && TEST_LITERAL(017777777)
+ && TEST_LITERAL(0177777777)
+ && TEST_LITERAL(01777777777)
+ && TEST_LITERAL(017777777777)
+ && TEST_LITERAL(0177777777777)
+ && TEST_LITERAL(01777777777777)
+ && TEST_LITERAL(017777777777777)
+ && TEST_LITERAL(0177777777777777)
+ && TEST_LITERAL(01777777777777777)
+ && TEST_LITERAL(017777777777777777)
+ && TEST_LITERAL(0177777777777777777)
+ && TEST_LITERAL(01777777777777777777)
+ && TEST_LITERAL(017777777777777777777)
+ && TEST_LITERAL(0177777777777777777777)
+ && TEST_LITERAL(01777777777777777777777)
+
+ && TEST_LITERAL(1)
+ && TEST_LITERAL(17)
+ && TEST_LITERAL(177)
+ && TEST_LITERAL(1777)
+ && TEST_LITERAL(17777)
+ && TEST_LITERAL(177777)
+ && TEST_LITERAL(1777777)
+ && TEST_LITERAL(17777777)
+ && TEST_LITERAL(177777777)
+ && TEST_LITERAL(1777777777)
+ && TEST_LITERAL(17777777777)
+ && TEST_LITERAL(177777777777)
+ && TEST_LITERAL(1777777777777)
+ && TEST_LITERAL(17777777777777)
+ && TEST_LITERAL(177777777777777)
+ && TEST_LITERAL(1777777777777777)
+ && TEST_LITERAL(17777777777777777)
+ && TEST_LITERAL(177777777777777777)
+ && TEST_LITERAL(1777777777777777777)
+
+)
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+
+
+
+
+
+}
--- a/unittests/map.chai
+++ b/unittests/map.chai
@@ -1 +1,29 @@
 assert_equal([true, false, true], map([1,2,3], odd))
+
+
+
+var m = ["a":1, "b":2];
+
+assert_equal(1, m.count("a"))
+assert_equal(0, m.count("c"))
+assert_equal(1, m.erase("a"))
+assert_equal(1, m.size())
+assert_equal(0, m.erase("a"))
+
+assert_equal(1, m.size());
+
+var m2 = ["c":3, "b":4]
+m.insert(m2);
+
+assert_equal(3, m["c"])
+// The inserted values do not overwrite the existing ones
+assert_equal(2, m["b"])
+assert_equal(2, m.size())
+
+var v = "bob";
+
+m.insert_ref(Map_Pair("d", v))
+
+assert_equal("bob", m["d"])
+v = "bob2"
+assert_equal("bob2", m["d"])
--- a/unittests/multithreaded_test.cpp
+++ b/unittests/multithreaded_test.cpp
@@ -0,0 +1,100 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2010, Jonathan Turner (jonathan@emptycrate.com)
+// and Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+
+#include <list>
+#include <algorithm>
+
+#include <chaiscript/chaiscript.hpp>
+
+int expected_value(int num_iters)
+{
+  int i = 0;
+  for (int k = 0; k<num_iters * 10; ++k)
+  {
+    i += k;
+  }
+
+  return i;
+}
+
+void do_work(chaiscript::ChaiScript &c, int id)
+{
+  std::stringstream ss;
+  ss << "MyVar" << rand();
+  c.add(chaiscript::var(5), ss.str());
+  ss.str("");
+  ss << id;
+  c.use("multithreaded_work.inc");
+  c("do_chai_work(4000, " + ss.str() + ");");
+}
+
+int main()
+{
+  // Disable deprecation warning for getenv call.
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+  const char *usepath = getenv("CHAI_USE_PATH");
+  const char *modulepath = getenv("CHAI_MODULE_PATH");
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+  std::vector<std::string> usepaths;
+  usepaths.push_back("");
+  if (usepath)
+  {
+    usepaths.push_back(usepath);
+  }
+
+  std::vector<std::string> modulepaths;
+  modulepaths.push_back("");
+  if (modulepath)
+  {
+    modulepaths.push_back(modulepath);
+  }
+
+  chaiscript::ChaiScript chai(modulepaths,usepaths);
+
+  std::vector<std::shared_ptr<std::thread> > threads;
+
+  // Ensure at least two, but say only 7 on an 8 core processor
+  int num_threads = std::max(std::thread::hardware_concurrency() - 1, 2u);
+
+  for (int i = 0; i < num_threads; ++i)
+  {
+    threads.push_back(std::shared_ptr<std::thread>(new std::thread(do_work, std::ref(chai), i)));
+  }
+
+  for (int i = 0; i < num_threads; ++i)
+  {
+    threads[i]->join();
+  }
+
+
+  for (int i = 0; i < num_threads; ++i)
+  {
+    std::stringstream ss;
+    ss << i;
+    if (chai.eval<int>("getvalue(" + ss.str() + ")") != expected_value(4000))
+    {
+      return EXIT_FAILURE;
+    }
+
+    if (chai.eval<int>("getid(" + ss.str() + ")") != i)
+    {
+      return EXIT_FAILURE;
+    }
+  }
+
+  return EXIT_SUCCESS;
+}
+
--- a/unittests/multithreaded_work.inc
+++ b/unittests/multithreaded_work.inc
@@ -0,0 +1,15 @@
+def do_chai_work(num_iters, id)
+{
+  var i = 0;
+  for (var k = 0; k<num_iters * 10; ++k)
+  {
+    if (k == 1000)
+    {
+      eval("def getid(id) : id == " + to_string(id) + " { return " + to_string(id) + "}");
+    }
+    i += k;
+  }
+
+  eval("def getvalue(id) : id == " + to_string(id) + " { return " + to_string(i) + "}");
+
+}
--- a/unittests/number_suffixes.chai
+++ b/unittests/number_suffixes.chai
@@ -0,0 +1,11 @@
+assert_equal(true, int_type.bare_equal(1.get_type_info()))
+assert_equal(true, unsigned_int_type.bare_equal(1u.get_type_info()))
+assert_equal(true, unsigned_long_type.bare_equal(1lu.get_type_info()))
+assert_equal(true, long_type.bare_equal(1l.get_type_info()))
+assert_equal(true, int64_t_type.bare_equal(1ll.get_type_info()))
+assert_equal(true, uint64_t_type.bare_equal(1ull.get_type_info()))
+
+assert_equal(true, double_type.bare_equal(1.6.get_type_info()))
+assert_equal(true, float_type.bare_equal(1.6f.get_type_info()))
+assert_equal(true, long_double_type.bare_equal(1.6l.get_type_info()))
+
--- a/unittests/set_state_test.cpp
+++ b/unittests/set_state_test.cpp
@@ -0,0 +1,61 @@
+#include <chaiscript/chaiscript.hpp>
+
+
+int myfun()
+{
+  return 2;
+}
+
+int main()
+{
+
+  chaiscript::ChaiScript chai;
+
+  // save the initial state of globals and locals
+  chaiscript::ChaiScript::State firststate = chai.get_state();
+  std::map<std::string, chaiscript::Boxed_Value> locals = chai.get_locals();
+  
+  // add some new globals and locals
+  chai.add(chaiscript::var(1), "i");
+
+  chai.add(chaiscript::fun(&myfun), "myfun");
+
+
+  bool didcall = chai.eval<int>("myfun()") == 2;
+
+  bool hadi = chai.eval<int>("i") == 1;
+
+  chai.set_state(firststate);
+
+  // set state should have reverted the state of the functions and dropped
+  // the 'myfun'
+  bool didnotcall = false;
+
+  try {
+    chai.eval<int>("myfun()");
+  } catch (const chaiscript::exception::eval_error &) {
+    didnotcall = true;
+  }
+
+  // set state should not affect the local variables
+  bool stillhasid = chai.eval<int>("i") == 1;
+
+  // After resetting the locals we expect the 'i' to be gone
+  chai.set_locals(locals);
+
+
+  bool nolongerhasid = false;
+
+  try {
+    chai.eval<int>("i");
+  } catch (const chaiscript::exception::eval_error &) {
+    nolongerhasid = true;
+  }
+
+  if (didcall && hadi && didnotcall && stillhasid && nolongerhasid)
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+}
--- a/unittests/simultaneous_chaiscript_test.cpp
+++ b/unittests/simultaneous_chaiscript_test.cpp
@@ -0,0 +1,60 @@
+#include <chaiscript/chaiscript.hpp>
+
+int dosomething(int i)
+{
+  return i + 2;
+}
+
+int dosomethingelse(int i)
+{
+  return i * 2;
+}
+
+
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+  chai.add(chaiscript::fun(&dosomething), "dosomething");
+  chai.add(chaiscript::var(1), "i");
+
+  for (int i = 0; i < 10; ++i)
+  {
+    chaiscript::ChaiScript chai2;
+    chai2.add(chaiscript::fun(&dosomethingelse), "dosomethingelse");
+
+    std::stringstream ss;
+    ss << i;
+
+    if (chai.eval<int>("dosomething(" + ss.str() + ")") != i + 2)
+    {
+      return EXIT_FAILURE;
+    }
+
+    if (chai2.eval<int>("dosomethingelse(" + ss.str() + ")") != i * 2)
+    {
+      return EXIT_FAILURE;
+    }
+
+    try {
+      chai2.eval("dosomething(1)");
+      return EXIT_FAILURE; // should not get here
+    } catch (const chaiscript::exception::eval_error &) {
+      // nothing to do, expected case
+    }
+
+    try {
+      chai2.eval("i");
+      return EXIT_FAILURE; // should not get here
+    } catch (const chaiscript::exception::eval_error &) {
+      // nothing to do, expected case
+    }
+
+    try {
+      chai.eval("dosomethingelse(1)");
+      return EXIT_FAILURE; // should not get here
+    } catch (const chaiscript::exception::eval_error &) {
+      // nothing to do, expected case
+    }
+  }
+}
--- a/unittests/string_substr.chai
+++ b/unittests/string_substr.chai
@@ -0,0 +1 @@
+assert_equal("3ab", "123abab".substr(2,3))
Author	SHA1	Message	Date
Jason Turner	455324bf13	Merge branch 'master' into ChaiScript_5_0_CPP_11 / update version numbers Conflicts: CMakeLists.txt releasenotes.txt	2012-11-17 18:33:13 -07:00
Jason Turner	deef33640c	Update releasenotes and version numbers for 4.1.0 release	2012-11-17 18:31:48 -07:00
Jason Turner	85ba42849b	Merge branch 'master' into ChaiScript_5_0_CPP_11 Conflicts: include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/language/chaiscript_parser.hpp unittests/multithreaded_test.cpp	2012-11-16 16:32:39 -07:00
Jason Turner	58f3256389	Fix function pointer issue for substr on VS 2010 32bit	2012-11-16 13:58:03 -07:00
Jason Turner	f1a4c4c427	Fix compiler warning found on VS 2008 64bit	2012-11-16 12:57:15 -07:00
Jason Turner	afd27a4b01	Fix errors and warnings found on VisualStudio 2005	2012-11-16 12:27:41 -07:00
Jason Turner	6bb90f9d6d	Merge branch 'master' into ChaiScript_5_0_CPP_11 Conflicts: include/chaiscript/language/chaiscript_eval.hpp	2012-11-10 16:59:32 -07:00
Jason Turner	4c65e45598	Correct signing and sizing of integer literals #77	2012-11-10 16:31:05 -07:00
Jason Turner	57c6d72a79	Merge branch 'master' into ChaiScript_5_0_CPP_11 Conflicts: include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp	2012-11-07 17:04:54 -07:00
Jason Turner	923369a4f4	Add support for string::substr #75 Also add forgotten missing test for number suffixes	2012-11-07 15:48:25 -07:00
Jason Turner	964342bff3	Prevent leaking macros #76	2012-11-07 14:13:08 -07:00
Jason Turner	c5a86401aa	Merge branch 'master' into ChaiScript_5_0_CPP_11 Conflicts: include/chaiscript/dispatchkit/bootstrap_stl.hpp	2012-11-07 13:47:09 -07:00
Jason Turner	623c64299a	Add ability to specify number prefixes for floating point and integers.	2012-11-07 12:05:34 -07:00
Jason Turner	9832d1ce39	Add insert and insert_ref methods to "map" types	2012-09-26 12:38:32 -06:00
Jason Turner	ed7bdfb172	Add "erase" function to associative sets (maps)	2012-09-26 11:31:19 -06:00
Jason Turner	87c9006174	Merge branch 'master' into ChaiScript_5_0_CPP_11 Conflicts: CMakeLists.txt readme.md	2012-08-14 12:07:45 -06:00
Jason Turner	204ab53afc	Update readme.txt to readme.md for better formatting.	2012-08-14 12:00:44 -06:00
Jason Turner	d47cd63fec	One more round of updates to readme.md	2012-08-14 11:45:00 -06:00
Jason Turner	193151f52e	Minor syntax updates for C++11 readme.md	2012-08-14 11:43:11 -06:00
Jason Turner	6642e02496	Update readme for C++11	2012-08-14 11:37:58 -06:00
Jason Turner	8f7226051e	Add boost::system to linkage to support boost 1.50. Should not cause any issue for older users of boost	2012-08-14 08:59:48 -06:00
Jason Turner	d84b4c0b37	Merge branch 'master' into ChaiScript_5_0_CPP_11	2012-07-18 07:30:34 -06:00
Jason Turner	46d1c50923	Merge pull request #66 from mgee/master Make Boxed_Number utility functions const	2012-07-18 06:29:22 -07:00
Markus Groß	9e3c2960aa	Make some Boxed_Number functions const.	2012-07-17 18:26:58 +02:00
Jason Turner	84e17b8d06	Port Boxed_Number enhancements from mgee to C++11 branch. #53	2012-07-16 22:24:25 -06:00
Jason Turner	9fd4a1b9f5	Merge pull request #53 from mgee/master More Boxed_Number enhancements	2012-07-16 21:18:18 -07:00
Jason Turner	32fab64882	Merge branch 'master' into 2011-09-09-CxScript	2012-07-16 22:17:37 -06:00
Jason Turner	8cb49e9494	Merge branch 'master' into 2011-09-09-CxScript	2012-07-16 22:12:29 -06:00
Jason Turner	441cdf0935	Add test showing c linkage working fine [#16 ]	2012-07-16 22:10:40 -06:00
Jason Turner	f0016d978a	Add test to make sure simultaneous ChaiScript instantiations work	2012-07-16 21:51:06 -06:00
Jason Turner	1155720b14	Add the ability to save and restore the state of local variables #25	2012-07-16 21:27:42 -06:00
Jason Turner	7052234650	Revert "Use unique_ptr instead of shared_ptr in our any implementation, >10% speed improvement" This reverts commit `f27739cf71`.	2012-07-13 13:54:48 -06:00
Jason Turner	c2934caad6	Merge branch 'master' into 2011-09-09-CxScript Conflicts: include/chaiscript/language/chaiscript_engine.hpp src/multithreaded.cpp	2012-07-13 13:32:29 -06:00
Jason Turner	f5b7be3743	Correct building on threadless	2012-07-13 13:14:48 -06:00
Jason Turner	d8f881239f	Merge branch 'master' of https://github.com/ChaiScript/ChaiScript	2012-07-13 12:36:37 -06:00
Jason Turner	199b1f5233	Merge branch 'master' into 2011-09-09-CxScript Conflicts: include/chaiscript/dispatchkit/boxed_value.hpp	2012-07-13 12:36:08 -06:00
Jason Turner	0a436398dd	Use make_shared #64	2012-07-13 12:25:50 -06:00
Jason Turner	9f309fcbe9	Add tests for multithreaded features #55	2012-07-10 15:10:09 -06:00
Jason Turner	4e33e969dc	Minor header file include cleanup	2012-07-10 13:27:47 -06:00
Jason Turner	f27739cf71	Use unique_ptr instead of shared_ptr in our any implementation, >10% speed improvement	2012-07-09 16:20:55 -06:00
Markus Groß	08d9d9e28e	Adapt toString to proper naming scheme.	2012-07-03 18:42:27 +02:00
Markus Groß	935276fccd	Adapt getAs function to proper naming scheme.	2012-07-03 18:42:04 +02:00
Markus Groß	f8feaf6ea8	Add toString function to Boxed_Number. For uint8_t, int8_t and char the value is first converted to an appropriate int type. This way the value is converted to a number rather than a character.	2012-06-29 16:48:53 +02:00
Markus Groß	dfcc415c31	Add getAs<T> function to Boxed_Number to enable casting to a target type.	2012-06-29 08:00:00 +02:00
Markus Groß	927235d871	Add templated constructor to Boxed_Number to allow creating from primitive number types.	2012-06-29 07:42:16 +02:00
Jason Turner	a6924bcc9e	Use C++11 Raw Strings for chaiscript prelude	2012-06-28 21:24:51 -06:00
Jason Turner	a3b50d4151	Merge branch 'master' into 2011-09-09-CxScript Conflicts: include/chaiscript/dispatchkit/bootstrap.hpp	2012-06-25 16:50:21 -06:00
Jason Turner	bf4f90a4ff	Fix build error for building without threads	2012-06-25 16:44:22 -06:00
Jason Turner	45f07f9924	Update method error output to show the expression it is trying to execute.	2012-06-25 16:26:36 -06:00
Jason Turner	d3b8daeff0	Merge branch 'master' into 2011-09-09-CxScript Conflicts: CMakeLists.txt include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp	2012-06-25 15:40:19 -06:00
Jason Turner	39d817469c	Optionally allow the user to specify the file name to report to end users when calling "eval"	2012-06-25 08:05:58 -06:00
Jason Turner	7a25625fdd	Fix failing error reporting for solitary (non-dispatched) guarded function	2012-06-25 07:53:15 -06:00
Jason Turner	5e6a51ba63	Add failing unit test for remaining error condition to check for.	2012-06-25 07:44:14 -06:00
Jason Turner	a8ea5f151d	Extreme error reporting capabilities update and bug fixes	2012-06-25 06:31:34 -06:00
Jason Turner	6cda1140c4	Merge branch 'master' into 2011-09-09-CxScript Conflicts: include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp	2012-06-22 18:12:51 -06:00
Jason Turner	5a76d98692	Enhance and correct error messages Backported from C++11 branch. Conflicts: include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp	2012-06-22 18:00:10 -06:00
Jason Turner	949f54b9c4	Use constexpr where possible in user_type() functions - Task #52 - Gives some performance improvement	2012-06-22 14:19:52 -06:00
Jason Turner	f6e53dd42d	Correct some threading issues - prototype avoiding a lock with __thread in g++ - pass -pthread and -lpthread when building to get threading actually working	2012-06-22 14:18:44 -06:00
Jason Turner	d55439a7ac	Fix multithreaded.cpp to compile / run with C++11	2012-06-19 09:40:51 -06:00
Jason Turner	953c4e4847	Merge branch 'master' into 2011-09-09-CxScript Conflicts: CMakeLists.txt	2012-06-13 21:54:48 -06:00
Jason Turner	3bccf4d977	Explicitly link to pthreads, seems some systems need this #47	2012-06-09 18:02:35 -04:00