Update release notes

* Throw error if class is in unexpected place
 * Allow catching of `eval_error` from inside of script

closes #297

CMakeLists.txt

@@ -103,7 +103,7 @@ set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt"
 
 set(CPACK_PACKAGE_VERSION_MAJOR 5)
 set(CPACK_PACKAGE_VERSION_MINOR 8)
-set(CPACK_PACKAGE_VERSION_PATCH 1)
+set(CPACK_PACKAGE_VERSION_PATCH 6)
 
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")

cheatsheet.md

@@ -84,6 +84,33 @@ chai.add(chaiscript::user_type<MyClass>(), "MyClass");
 
 User defined type conversions are possible, defined in either script or in C++.
 
+
+### ChaiScript Defined Conversions
+
+Function objects (including lambdas) can be used to add type conversions
+from inside of ChaiScript:
+
+```
+add_type_conversion(type("string"), type("Type_Info"), fun(s) { return type(s); });
+```
+
+### C++ Defined Conversions
+
+Invoking a C++ type conversion possible with `static_cast`
+
+```
+chai.add(chaiscript::type_conversion<T, bool>());
+```
+
+Calling a user defined type conversion that takes a lambda
+
+```
+chai.add(chaiscript::type_conversion<TestBaseType, Type2>([](const TestBaseType &t_bt) { /* return converted thing */ }));
+```
+
+
+### Helpers
+
 A helper function exists for strongly typed and ChaiScript `Vector` function conversion definition:
 
 ```
@@ -97,6 +124,7 @@ chai.add(chaiscript::map_conversion<std::map<std::string, int>>());
 ```
 
 
+
 This allows you to pass a ChaiScript function to a function requiring `std::vector<int>`
 
 ## Adding Objects
@@ -163,6 +191,28 @@ chaiscript::Boxed_Number(chai.eval("5.3 + 2.1")).get_as<int>(); // works with an
 static_cast<int>(chai.eval<double>("5.3+2.1")); // this version only works if we know that it's a double
 ```
 
+### Conversion Caveats
+
+Conversion to `std::shared_ptr<T> &` is supported for function calls, but if you attempt to keep a reference to a `shared_ptr<>` you might invoke undefined behavior
+
+```cpp
+// ok this is supported, you can register it with chaiscript engine
+void nullify_shared_ptr(std::shared_ptr<int> &t) {
+  t == nullptr
+}
+```
+
+```cpp
+int main()
+{
+  // do some stuff and create a chaiscript instance
+  std::shared_ptr<int> &ptr = chai.eval<std::shared_ptr<int> &>(somevalue);
+  // DO NOT do this. Taking a non-const reference to a shared_ptr is not 
+  // supported and causes undefined behavior in the chaiscript engine
+}
+```
+
+
 ## Sharing Values
 
 ```

include/chaiscript/chaiscript_defines.hpp

@@ -99,7 +99,7 @@
 namespace chaiscript {
   static const int version_major = 5;
   static const int version_minor = 8;
-  static const int version_patch = 1;
+  static const int version_patch = 6;
 
   static const char *compiler_version = CHAISCRIPT_COMPILER_VERSION;
   static const char *compiler_name = CHAISCRIPT_COMPILER_NAME;

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -173,6 +173,21 @@ namespace chaiscript
       {
       };
 
+    template<typename Result>
+      struct Cast_Helper_Inner<std::shared_ptr<Result> &>
+      {
+        static_assert(!std::is_const<Result>::value, "Non-const reference to std::shared_ptr<const T> is not supported");
+
+        typedef Boxed_Value::Sentinel<Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions_State *)
+        {
+          std::shared_ptr<Result> &res = ob.get().cast<std::shared_ptr<Result> >();
+          return ob.pointer_sentinel(res);
+        }
+      };
+
+
     /// Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
     template<typename Result>
       struct Cast_Helper_Inner<const std::shared_ptr<const Result> > : Cast_Helper_Inner<std::shared_ptr<const Result> >

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -231,6 +231,50 @@ namespace chaiscript
         return m_data->m_type_info.bare_equal(ti);
       }
 
+      template<typename T>
+      struct Sentinel {
+        Sentinel(std::shared_ptr<T> &ptr, Data &data)
+          : m_ptr(ptr), m_data(data)
+        {
+        }
+
+        ~Sentinel()
+        {
+          // save new pointer data
+          m_data.get().m_data_ptr = m_ptr.get().get();
+          m_data.get().m_const_data_ptr = m_ptr.get().get();
+        }
+
+        Sentinel& operator=(Sentinel&&s) {
+          m_ptr = std::move(s.m_ptr);
+          m_data = std::move(s.m_data);
+        }
+
+        Sentinel(Sentinel &&s)
+          : m_ptr(std::move(s.m_ptr)),
+            m_data(std::move(s.m_data))
+        {
+        }
+
+        operator std::shared_ptr<T>&() const
+        {
+          return m_ptr.get();
+        }
+
+        Sentinel &operator=(const Sentinel &) = delete;
+        Sentinel(Sentinel&) = delete;
+
+        std::reference_wrapper<std::shared_ptr<T>> m_ptr;
+        std::reference_wrapper<Data> m_data;
+      };
+
+
+      template<typename T>
+      Sentinel<T> pointer_sentinel(std::shared_ptr<T> &ptr) const
+      {
+        return Sentinel<T>(ptr, *(m_data.get()));
+      }
+
       bool is_null() const CHAISCRIPT_NOEXCEPT
       {
         return (m_data->m_data_ptr == nullptr && m_data->m_const_data_ptr == nullptr);

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -430,7 +430,8 @@ namespace chaiscript
         };
 
         Dispatch_Engine()
-          : m_stack_holder(this)
+          : m_stack_holder(this),
+            m_method_missing_loc(0)
         {
         }
 
@@ -962,14 +963,20 @@ namespace chaiscript
 
                 This_Foist fi(*this, l_params.front());
 
-                auto func = boxed_cast<std::shared_ptr<const dispatch::Proxy_Function_Base>>(bv);
                 try {
-                  return (*func)({l_params.begin() + l_num_params, l_params.end()}, l_conversions);
+                  auto func = boxed_cast<std::shared_ptr<const dispatch::Proxy_Function_Base>>(bv);
+                  try {
+                    return (*func)({l_params.begin() + l_num_params, l_params.end()}, l_conversions);
+                  } catch (const chaiscript::exception::bad_boxed_cast &) {
+                  } catch (const chaiscript::exception::arity_error &) {
+                  } catch (const chaiscript::exception::guard_error &) {
+                  }
+                  throw chaiscript::exception::dispatch_error({l_params.begin() + l_num_params, l_params.end()}, std::vector<Const_Proxy_Function>{func});
                 } catch (const chaiscript::exception::bad_boxed_cast &) {
-                } catch (const chaiscript::exception::arity_error &) {
-                } catch (const chaiscript::exception::guard_error &) {
+                  // unable to convert bv into a Proxy_Function_Base
+                  throw chaiscript::exception::dispatch_error({l_params.begin() + l_num_params, l_params.end()}, 
+                      std::vector<Const_Proxy_Function>(l_funs.begin(), l_funs.end()));
                 }
-                throw chaiscript::exception::dispatch_error({l_params.begin() + l_num_params, l_params.end()}, std::vector<Const_Proxy_Function>{func});
               } else {
                 return bv;
               }

include/chaiscript/dispatchkit/handle_return.hpp

@@ -115,6 +115,24 @@ namespace chaiscript
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<Ret *&>
+        {
+          static Boxed_Value handle(Ret *p)
+          {
+            return Boxed_Value(p, true);
+          }
+        };
+
+      template<typename Ret>
+        struct Handle_Return<const Ret *&>
+        {
+          static Boxed_Value handle(const Ret *p)
+          {
+            return Boxed_Value(p, true);
+          }
+        };
+
       template<typename Ret>
         struct Handle_Return<Ret *>
         {

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -846,7 +846,8 @@ namespace chaiscript
                          plist.begin(),
                          std::back_inserter(newplist),
                          [](const Type_Info &ti, const Boxed_Value &param) -> Boxed_Value {
-                           if (ti.is_arithmetic() && param.get_type_info().is_arithmetic()) {
+                           if (ti.is_arithmetic() && param.get_type_info().is_arithmetic()
+                               && param.get_type_info() != ti) {
                              return Boxed_Number(param).get_as(ti).bv;
                            } else {
                              return param;
@@ -854,8 +855,6 @@ namespace chaiscript
                          }
                        );
 
-
-
           try {
             return (*(matching_func->second))(newplist, t_conversions);
           } catch (const exception::bad_boxed_cast &) {

include/chaiscript/dispatchkit/type_info.hpp

@@ -60,6 +60,16 @@ namespace chaiscript
         return m_type_info < ti.m_type_info;
       }
 
+      CHAISCRIPT_CONSTEXPR bool operator!=(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
+      {
+        return !(operator==(ti));
+      }
+
+      CHAISCRIPT_CONSTEXPR bool operator!=(const std::type_info &ti) const CHAISCRIPT_NOEXCEPT
+      {
+        return !(operator==(ti));
+      }
+
       CHAISCRIPT_CONSTEXPR bool operator==(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return ti.m_type_info == m_type_info
@@ -162,6 +172,11 @@ namespace chaiscript
         }
       };
 
+    template<typename T>
+      struct Get_Type_Info<std::shared_ptr<T> &> : Get_Type_Info<std::shared_ptr<T>>
+      {
+      };
+
     template<typename T>
       struct Get_Type_Info<const std::shared_ptr<T> &>
       {

include/chaiscript/language/chaiscript_common.hpp

@@ -489,9 +489,9 @@ namespace chaiscript
         }
       }
 
-      static bool get_bool_condition(const Boxed_Value &t_bv) {
+      static bool get_bool_condition(const Boxed_Value &t_bv, const chaiscript::detail::Dispatch_State &t_ss) {
         try {
-          return boxed_cast<bool>(t_bv);
+          return t_ss->boxed_cast<bool>(t_bv);
         }
         catch (const exception::bad_boxed_cast &) {
           throw exception::eval_error("Condition not boolean");

include/chaiscript/language/chaiscript_eval.hpp

@@ -85,7 +85,8 @@ namespace chaiscript
       public:
         Binary_Operator_AST_Node(const std::string &t_oper, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
           AST_Node(t_oper, AST_Node_Type::Binary, std::move(t_loc), std::move(t_children)),
-          m_oper(Operators::to_operator(t_oper))
+          m_oper(Operators::to_operator(t_oper)),
+          m_loc(0)
       { }
 
         virtual ~Binary_Operator_AST_Node() {}
@@ -166,7 +167,7 @@ namespace chaiscript
         Id_AST_Node(const std::string &t_ast_node_text, Parse_Location t_loc) :
           AST_Node(t_ast_node_text, AST_Node_Type::Id, std::move(t_loc)),
           m_value(get_value(t_ast_node_text)), m_loc(0)
-      { }
+        { }
 
         virtual ~Id_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE {
@@ -393,7 +394,10 @@ namespace chaiscript
       public:
         Equation_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
           AST_Node(std::move(t_ast_node_text), AST_Node_Type::Equation, std::move(t_loc), std::move(t_children)), 
-          m_oper(Operators::to_operator(children[1]->text))
+          m_oper(Operators::to_operator(children[1]->text)),
+          m_loc(0),
+          m_clone_loc(0)
+
         { assert(children.size() == 3); }
 
         Operators::Opers m_oper;
@@ -535,7 +539,7 @@ namespace chaiscript
     struct Array_Call_AST_Node : public AST_Node {
       public:
         Array_Call_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
-          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Array_Call, std::move(t_loc), std::move(t_children)) { }
+          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Array_Call, std::move(t_loc), std::move(t_children)), m_loc(0) { }
         virtual ~Array_Call_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE{
           chaiscript::eval::detail::Function_Push_Pop fpp(t_ss);
@@ -574,6 +578,8 @@ namespace chaiscript
       public:
         Dot_Access_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
           AST_Node(std::move(t_ast_node_text), AST_Node_Type::Dot_Access, std::move(t_loc), std::move(t_children)),
+          m_loc(0),
+          m_array_loc(0),
           m_fun_name(
               ((children[2]->identifier == AST_Node_Type::Fun_Call) || (children[2]->identifier == AST_Node_Type::Array_Call))?
               children[2]->children[0]->text:children[2]->text) { }
@@ -803,7 +809,7 @@ namespace chaiscript
           chaiscript::eval::detail::Scope_Push_Pop spp(t_ss);
 
           try {
-            while (get_bool_condition(this->children[0]->eval(t_ss))) {
+            while (get_bool_condition(this->children[0]->eval(t_ss), t_ss)) {
               try {
                 this->children[1]->eval(t_ss);
               } catch (detail::Continue_Loop &) {
@@ -845,7 +851,7 @@ namespace chaiscript
           { assert(children.size() == 3); }
         virtual ~Ternary_Cond_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE {
-          if (get_bool_condition(children[0]->eval(t_ss))) {
+          if (get_bool_condition(children[0]->eval(t_ss), t_ss)) {
             return children[1]->eval(t_ss);
           }
           else {
@@ -862,7 +868,7 @@ namespace chaiscript
         virtual ~If_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE{
 
-          if (get_bool_condition(children[0]->eval(t_ss))) {
+          if (get_bool_condition(children[0]->eval(t_ss), t_ss)) {
             return children[1]->eval(t_ss);
           } else {
             if (children.size() > 2) {
@@ -872,7 +878,7 @@ namespace chaiscript
                   return children[i+1]->eval(t_ss);
                 }
                 else if (children[i]->text == "else if") {
-                  if (get_bool_condition(children[i+1]->eval(t_ss))) {
+                  if (get_bool_condition(children[i+1]->eval(t_ss), t_ss)) {
                     return children[i+2]->eval(t_ss);
                   }
                 }
@@ -899,7 +905,7 @@ namespace chaiscript
           try {
             for (
                 children[0]->eval(t_ss);
-                get_bool_condition(children[1]->eval(t_ss));
+                get_bool_condition(children[1]->eval(t_ss), t_ss);
                 children[2]->eval(t_ss)
                 ) {
               try {
@@ -923,7 +929,7 @@ namespace chaiscript
     struct Switch_AST_Node : public AST_Node {
       public:
         Switch_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
-          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Switch, std::move(t_loc), std::move(t_children)) { }
+          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Switch, std::move(t_loc), std::move(t_children)), m_loc(0) { }
         virtual ~Switch_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE {
           bool breaking = false;
@@ -999,7 +1005,10 @@ namespace chaiscript
     struct Inline_Array_AST_Node : public AST_Node {
       public:
         Inline_Array_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
-          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Inline_Array, std::move(t_loc), std::move(t_children)) { }
+          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Inline_Array, std::move(t_loc), std::move(t_children)),
+          m_loc(0)
+        { }
+
         virtual ~Inline_Array_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE {
           try {
@@ -1033,7 +1042,7 @@ namespace chaiscript
     struct Inline_Map_AST_Node : public AST_Node {
       public:
         Inline_Map_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
-          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Inline_Map, std::move(t_loc), std::move(t_children)) { }
+          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Inline_Map, std::move(t_loc), std::move(t_children)), m_loc(0) { }
         virtual ~Inline_Map_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE{
           try {
@@ -1123,7 +1132,8 @@ namespace chaiscript
       public:
         Prefix_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
           AST_Node(std::move(t_ast_node_text), AST_Node_Type::Prefix, std::move(t_loc), std::move(t_children)),
-          m_oper(Operators::to_operator(children[0]->text, true))
+          m_oper(Operators::to_operator(children[0]->text, true)),
+          m_loc(0)
         { }
 
         virtual ~Prefix_AST_Node() {}
@@ -1204,7 +1214,7 @@ namespace chaiscript
     struct Inline_Range_AST_Node : public AST_Node {
       public:
         Inline_Range_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_NodePtr> t_children) :
-          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Inline_Range, std::move(t_loc), std::move(t_children)) { }
+          AST_Node(std::move(t_ast_node_text), AST_Node_Type::Inline_Range, std::move(t_loc), std::move(t_children)), m_loc(0) { }
         virtual ~Inline_Range_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE{
           try {
@@ -1303,11 +1313,8 @@ namespace chaiscript
           try {
             retval = this->children[0]->eval(t_ss);
           }
-          catch (exception::eval_error &) {
-            if (this->children.back()->identifier == AST_Node_Type::Finally) {
-              this->children.back()->children[0]->eval(t_ss);
-            }
-            throw;
+          catch (const exception::eval_error &e) {
+            retval = handle_exception(t_ss, Boxed_Value(std::ref(e)));
           }
           catch (const std::runtime_error &e) {
             retval = handle_exception(t_ss, Boxed_Value(std::ref(e)));
@@ -1488,8 +1495,8 @@ namespace chaiscript
 
         virtual ~Logical_And_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE{
-          return const_var(get_bool_condition(children[0]->eval(t_ss))
-              && get_bool_condition(children[2]->eval(t_ss)));
+          return const_var(get_bool_condition(children[0]->eval(t_ss), t_ss)
+              && get_bool_condition(children[2]->eval(t_ss), t_ss));
         }
 
         virtual std::string pretty_print() const CHAISCRIPT_OVERRIDE
@@ -1505,8 +1512,8 @@ namespace chaiscript
         { assert(children.size() == 3); }
         virtual ~Logical_Or_AST_Node() {}
         virtual Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const CHAISCRIPT_OVERRIDE{
-          return const_var(get_bool_condition(children[0]->eval(t_ss))
-              || get_bool_condition(children[2]->eval(t_ss)));
+          return const_var(get_bool_condition(children[0]->eval(t_ss), t_ss)
+              || get_bool_condition(children[2]->eval(t_ss), t_ss));
         }
 
         virtual std::string pretty_print() const CHAISCRIPT_OVERRIDE

include/chaiscript/language/chaiscript_parser.hpp

@@ -219,6 +219,10 @@ namespace chaiscript
         m_operators.emplace_back(AST_Node_Type::Multiplication);
         m_operator_matches.emplace_back(std::initializer_list<std::string>({"*", "/", "%"}));
 
+        // Prefix placeholder
+        m_operators.emplace_back(AST_Node_Type::Prefix);
+        m_operator_matches.emplace_back(std::initializer_list<std::string>({}));
+
         for (auto & elem : m_alphabet) {
           std::fill(std::begin(elem), std::end(elem), false);
         }
@@ -343,7 +347,7 @@ namespace chaiscript
       {
         for (auto &c : p->children)
         {
-          if (c->identifier == AST_Node_Type::Def && c->children.size() > 0) {
+          if ( (c->identifier == AST_Node_Type::Def || c->identifier == AST_Node_Type::Lambda) && c->children.size() > 0) {
             auto &last_child = c->children.back();
             if (last_child->identifier == AST_Node_Type::Block) {
               auto &block_last_child = last_child->children.back();
@@ -1696,12 +1700,16 @@ namespace chaiscript
       }
 
       /// Reads a class block from input
-      bool Class() {
+      bool Class(const bool t_class_allowed) {
         bool retval = false;
 
         size_t prev_stack_top = m_match_stack.size();
 
         if (Keyword("class")) {
+          if (!t_class_allowed) {
+            throw exception::eval_error("Class definitions only allowed at top scope", File_Position(m_position.line, m_position.col), *m_filename);
+          }
+
           retval = true;
 
           if (!Id()) {
@@ -2160,7 +2168,7 @@ namespace chaiscript
       /// Reads a unary prefixed expression from input
       bool Prefix() {
         const auto prev_stack_top = m_match_stack.size();
-        const std::vector<std::string> prefix_opers{"++", "--", "-", "+", "!", "~", "&"};
+        const std::vector<std::string> prefix_opers{"++", "--", "-", "+", "!", "~"};
 
         for (const auto &oper : prefix_opers)
         {
@@ -2197,7 +2205,7 @@ namespace chaiscript
         bool retval = false;
         const auto prev_stack_top = m_match_stack.size();
 
-        if (t_precedence < m_operators.size()) {
+        if (m_operators[t_precedence] != AST_Node_Type::Prefix) {
           if (Operator(t_precedence+1)) {
             retval = true;
             if (Operator_Helper(t_precedence)) {
@@ -2257,8 +2265,7 @@ namespace chaiscript
               } while (Operator_Helper(t_precedence));
             }
           }
-        }
-        else {
+        } else {
           return Value();
         }
 
@@ -2372,7 +2379,7 @@ namespace chaiscript
       }
 
       /// Top level parser, starts parsing of all known parses
-      bool Statements() {
+      bool Statements(const bool t_class_allowed = false) {
         bool retval = false;
 
         bool has_more = true;
@@ -2380,7 +2387,7 @@ namespace chaiscript
 
         while (has_more) {
           const auto start = m_position;
-          if (Def() || Try() || If() || While() || Class() || For() || Switch()) {
+          if (Def() || Try() || If() || While() || Class(t_class_allowed) || For() || Switch()) {
             if (!saw_eol) {
               throw exception::eval_error("Two function definitions missing line separator", File_Position(start.line, start.col), *m_filename);
             }
@@ -2421,7 +2428,7 @@ namespace chaiscript
           /// \todo respect // -*- coding: utf-8 -*- on line 1 or 2 see: http://evanjones.ca/python-utf8.html)
         }
 
-        if (Statements()) {
+        if (Statements(true)) {
           if (m_position.has_more()) {
             throw exception::eval_error("Unparsed input", File_Position(m_position.line, m_position.col), t_fname);
           } else {

releasenotes.md

@@ -1,6 +1,28 @@
 Notes:
 =======
-Current Version: 5.8.1
+
+Current Version: 5.8.6
+
+### Changes since 5.8.5
+* Optimize away `return` statements in lambdas also
+* Allow conversions to bool in conditionals
+* Don't allow `class` statements inside of scopes
+* Properly error when a dynamic object non-function member is called
+
+### Changes since 5.8.4
+* Fix order of operations for prefix operators
+* Make sure atomics are initialized properly
+* Remove parsing of unused prefix `&` operator
+
+### Changes since 5.8.3
+* Fix case with some numeric conversions mixed with numerics that do not need conversion
+
+### Changes since 5.8.2
+* Add support for reference of pointer return types
+
+### Changes since 5.8.1
+* Allow casting to non-const & std::shared_ptr<T>
+
 
 ### Changes since 5.8.0
 * Fix parsing of floats to be locale independent #250

src/test_module.cpp

@@ -114,6 +114,16 @@ std::shared_ptr<TestBaseType> null_factory()
   return std::shared_ptr<TestBaseType>();
 }
 
+void update_shared_ptr(std::shared_ptr<TestBaseType> &ptr)
+{
+  ptr = std::make_shared<TestDerivedType>();
+}
+
+void nullify_shared_ptr(std::shared_ptr<TestBaseType> &ptr)
+{
+  ptr = nullptr;
+}
+
 std::string hello_world()
 {
   return "Hello World";
@@ -209,6 +219,10 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::type_conversion<const char *, std::string>());
   m->add(chaiscript::constructor<Type2 (const TestBaseType &)>(), "Type2");
 
+  m->add(chaiscript::fun(&update_shared_ptr), "update_shared_ptr");
+  m->add(chaiscript::fun(&nullify_shared_ptr), "nullify_shared_ptr");
+
+
   return m;
 }
 

unittests/boxed_cast_test.cpp

@@ -54,12 +54,13 @@ bool test_type_conversion(const Boxed_Value &bv, bool expectedpass)
 }
 
 template<typename Type>
-bool do_test(const Boxed_Value &bv, bool T, bool ConstT, bool TRef, bool ConstTRef, bool TPtr, bool ConstTPtr, bool TPtrConst,
-    bool ConstTPtrConst, bool SharedPtrT, bool SharedConstPtrT,
-    bool ConstSharedPtrT, bool ConstSharedConstPtrT, bool ConstSharedPtrTRef, bool ConstSharedPtrTConstRef,
-    bool WrappedRef, bool WrappedConstRef, bool ConstWrappedRef, bool ConstWrappedConstRef,
-    bool ConstWrappedRefRef, bool ConstWrappedConstRefRef, bool Number,
-    bool ConstNumber, bool ConstNumberRef, bool TPtrConstRef, bool ConstTPtrConstRef)
+bool do_test(const Boxed_Value &bv, 
+    bool T, bool ConstT, bool TRef, bool ConstTRef, bool TPtr, 
+    bool ConstTPtr, bool TPtrConst, bool ConstTPtrConst, bool SharedPtrT, bool SharedConstPtrT, 
+    bool SharedPtrTRef, bool ConstSharedPtrT, bool ConstSharedConstPtrT, bool ConstSharedPtrTRef, bool ConstSharedPtrTConstRef,
+    bool WrappedRef, bool WrappedConstRef, bool ConstWrappedRef, bool ConstWrappedConstRef, bool ConstWrappedRefRef, 
+    bool ConstWrappedConstRefRef, bool Number, bool ConstNumber, bool ConstNumberRef, bool TPtrConstRef, 
+    bool ConstTPtrConstRef)
 {
   bool passed = true;
   passed &= test_type_conversion<Type>(bv, T);
@@ -72,8 +73,8 @@ bool do_test(const Boxed_Value &bv, bool T, bool ConstT, bool TRef, bool ConstTR
   passed &= test_type_conversion<const Type * const>(bv, ConstTPtrConst);
   passed &= test_type_conversion<std::shared_ptr<Type> >(bv, SharedPtrT);
   passed &= test_type_conversion<std::shared_ptr<const Type> >(bv, SharedConstPtrT);
-  passed &= test_type_conversion<std::shared_ptr<Type> &>(bv, false);
-  passed &= test_type_conversion<std::shared_ptr<const Type> &>(bv, false);
+  passed &= test_type_conversion<std::shared_ptr<Type> &>(bv, SharedPtrTRef);
+  //passed &= test_type_conversion<std::shared_ptr<const Type> &>(bv, false);
   passed &= test_type_conversion<const std::shared_ptr<Type> >(bv, ConstSharedPtrT);
   passed &= test_type_conversion<const std::shared_ptr<const Type> >(bv, ConstSharedConstPtrT);
   passed &= test_type_conversion<const std::shared_ptr<Type> &>(bv, ConstSharedPtrTRef);
@@ -115,37 +116,37 @@ bool built_in_type_test(const T &initial, bool ispod)
   T i = T(initial);
   passed &= do_test<T>(var(i), true, true, true, true, true, 
                                  true, true, true, true, true,
-                                 true, true, true, true, true,
+                                 true, true, true, true, true, true,
                                  true, true, true, true, true,
                                  ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(const_var(i), true, true, false, true, false, 
                                        true, false, true, false, true,
-                                       false, true, false, true, false,
+                                       false, false, true, false, true, false,
                                        true, false, true, false, true,
                                        ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(var(&i), true, true, true, true, true, 
                                  true, true, true, false, false,
-                                 false, false, false, false, true,
+                                 false, false, false, false, false, true,
                                  true, true, true, true, true,
                                  ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(const_var(&i), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(var(std::ref(i)), true, true, true, true, true, 
                                  true, true, true, false, false,
-                                 false, false, false, false, true,
+                                 false, false, false, false, false, true,
                                  true, true, true, true, true,
                                  ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(var(std::cref(i)), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
@@ -156,33 +157,33 @@ bool built_in_type_test(const T &initial, bool ispod)
 
   passed &= do_test<T>(var(i), true, true, true, true, true, 
                                  true, true, true, true, true,
-                                 true, true, true, true, true,
+                                 true, true, true, true, true, true,
                                  true, true, true, true, true,
                                  ispod, ispod, ispod, true, true);
 
   // But a pointer or reference to it should be necessarily const
   passed &= do_test<T>(var(&ir), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(var(std::ref(ir)), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
   // Make sure const of const works too
   passed &= do_test<T>(const_var(&ir), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
   passed &= do_test<T>(const_var(std::ref(ir)), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
@@ -192,14 +193,14 @@ bool built_in_type_test(const T &initial, bool ispod)
   const T*cip = &i;
   passed &= do_test<T>(var(cip), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
   // make sure const of const works
   passed &= do_test<T>(const_var(cip), true, true, false, true, false, 
                                  true, false, true, false, false,
-                                 false, false, false, false, false,
+                                 false, false, false, false, false, false,
                                  true, false, true, false, true,
                                  ispod, ispod, ispod, false, true);
 
@@ -209,13 +210,13 @@ bool built_in_type_test(const T &initial, bool ispod)
 
   passed &= do_test<T>(var(ip), true, true, true, true, true, 
                                  true, true, true, true, true,
-                                 true, true, true, true, true,
+                                 true, true, true, true, true, true,
                                  true, true, true, true, true,
                                  ispod, ispod, ispod, true, true);
 
   passed &= do_test<T>(const_var(ip), true, true, false, true, false, 
                                        true, false, true, false, true,
-                                       false, true, false, true, false,
+                                       false, false, true, false, true, false,
                                        true, false, true, false, true,
                                        ispod, ispod, ispod, false, true);
 
@@ -224,14 +225,14 @@ bool built_in_type_test(const T &initial, bool ispod)
 
   passed &= do_test<T>(var(ipc), true, true, false, true, false, 
                                        true, false, true, false, true,
-                                       false, true, false, true, false,
+                                       false, false, true, false, true, false,
                                        true, false, true, false, true,
                                        ispod, ispod, ispod, false, true);
 
   // const of this should be the same, making sure it compiles
   passed &= do_test<T>(const_var(ipc), true, true, false, true, false, 
                                        true, false, true, false, true,
-                                       false, true, false, true, false,
+                                       false, false, true, false, true, false,
                                        true, false, true, false, true,
                                        ispod, ispod, ispod, false, true);
 

unittests/class_inside_scope.chai

@@ -0,0 +1,8 @@
+
+
+try {
+  parse("{  class C {    var data;    def C() {}  } }")
+  assert_false(true)
+} catch  (e) {
+  assert_true(true)
+}

unittests/compiled_tests.cpp

@@ -950,4 +950,34 @@ TEST_CASE("Parse floats with non-posix locale")
 
 
 
+bool FindBitmap(int &ox, int &oy, long) {
+  ox = 1; 
+  oy = 2; 
+  return true;
+}
+
+TEST_CASE("Mismatched numeric types only convert necessary params")
+{
+  chaiscript::ChaiScript chai;
+
+  chai.add(chaiscript::fun(&FindBitmap), "FindBitmap");
+  int x = 0;
+  int y = 0;
+  chai.add(chaiscript::var(&x), "x");
+  chai.add(chaiscript::var(&y), "y");
+  chai.eval( "if ( FindBitmap ( x, y, 0) ) { print(\"found at \" + to_string(x) + \", \" + to_string(y))}" );
+  CHECK(x == 1);
+  CHECK(y == 2);
+
+}
+
+TEST_CASE("type_conversion to bool")
+{
+  auto module = std::make_shared<chaiscript::Module>();
+  struct T {
+    operator bool() const { return true; }
+  };
+  module->add(chaiscript::type_conversion<T, bool>());
+}
+
 

unittests/conversion_to_bool.chai

@@ -0,0 +1,17 @@
+
+// all we care is that this executes, really
+
+add_type_conversion(type("int"), type("bool"), fun(int i) { return i != 0; });
+
+if (0) {
+  assert_true(false);
+}
+
+while (0) {
+  assert_true(false);
+}
+
+for (; 0; ) {
+  assert_true(false);
+}
+

unittests/precedence_4.chai

@@ -0,0 +1,4 @@
+
+var i = 2;
+
+assert_equal(++i * i, 9)

unittests/shared_ptr_update.chai

@@ -0,0 +1,25 @@
+load_module("test_module")
+
+auto o := null_factory();
+
+assert_true(o.is_var_null());
+
+update_shared_ptr(o);
+
+assert_false(o.is_var_null());
+assert_true(o.base_only_func() == -9);
+
+nullify_shared_ptr(o);
+o.nullify_shared_ptr();
+
+assert_true(o.is_var_null());
+
+try {
+  o.func();
+} catch (e) {
+  exit(0);
+}
+
+assert_true(false);
+
+