Get system introspection functions fully working

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -496,28 +496,24 @@ namespace chaiscript
           }
         }
 
-        /**
-         * Swaps out the stack with a new stack
-         * \returns the old stack
-         * \param[in] s The new stack
-         */
-        Stack set_stack(const Stack &s)
-        {
-          Stack old = m_stack_holder->stack;
-          m_stack_holder->stack = s;
-          return old;
-        }
 
-        Stack new_stack() const
+        /// Pushes a new stack on to the list of stacks
+        void new_stack()
         {
           Stack s(new Stack::element_type());
           s->push_back(Scope());
-          return s;
+          m_stack_holder->stacks.push_back(s);
         }
 
+        void pop_stack()
+        {
+          m_stack_holder->stacks.pop_back();
+        }
+
+        /// \returns the current stack
         Stack get_stack() const
         {
-          return m_stack_holder->stack;
+          return m_stack_holder->stacks.back();
         }
 
         /**
@@ -674,7 +670,8 @@ namespace chaiscript
         ///
         std::map<std::string, Boxed_Value> get_scripting_objects() const
         {
-          StackData &stack = get_stack_data();
+          // We don't want the current context, but one up if it exists
+          StackData &stack = (m_stack_holder->stacks.size()==1)?(*(m_stack_holder->stacks.back())):(*m_stack_holder->stacks[m_stack_holder->stacks.size()-2]);
 
           std::map<std::string, Boxed_Value> retval;
 
@@ -914,7 +911,7 @@ namespace chaiscript
          */
         StackData &get_stack_data() const
         {
-          return *(m_stack_holder->stack);
+          return *(m_stack_holder->stacks.back());
         }
 
         const std::map<std::string, std::vector<Proxy_Function> > &get_functions_int() const
@@ -1076,12 +1073,13 @@ namespace chaiscript
         struct Stack_Holder
         {
           Stack_Holder()
-            : stack(new StackData())
           {
-            stack->push_back(Scope());
+            Stack s(new StackData());
+            s->push_back(Scope());
+            stacks.push_back(s);
           }
 
-          Stack stack;
+          std::deque<Stack> stacks;
         };  
 
         std::vector<Dynamic_Cast_Conversion> m_conversions;

include/chaiscript/language/chaiscript_common.hpp

@@ -213,6 +213,29 @@ namespace chaiscript
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
+
+      /// Creates a new scope then pops it on destruction
+      struct Stack_Push_Pop
+      {
+        Stack_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
+          : m_de(t_de)
+        {
+          m_de.new_stack();
+        }
+
+        ~Stack_Push_Pop()
+        {
+          m_de.pop_stack();
+        }
+
+
+        private:
+        // explicitly unimplemented copy and assignment
+        Stack_Push_Pop(const Scope_Push_Pop &);
+        Stack_Push_Pop& operator=(const Scope_Push_Pop &);
+
+        chaiscript::detail::Dispatch_Engine &m_de;
+      };
     }
   }
 }

include/chaiscript/language/chaiscript_eval.hpp

@@ -190,33 +190,25 @@ namespace chaiscript
             }
           }
 
-          chaiscript::detail::Dispatch_Engine::Stack prev_stack = t_ss.get_stack();
-          chaiscript::detail::Dispatch_Engine::Stack new_stack = t_ss.new_stack();
-
           try {
             Boxed_Value fn = this->children[0]->eval(t_ss);
 
             try {
-              t_ss.set_stack(new_stack);
+              chaiscript::eval::detail::Stack_Push_Pop spp(t_ss);
               const Boxed_Value &retval = (*boxed_cast<const Const_Proxy_Function &>(fn))(plb);
-              t_ss.set_stack(prev_stack);
               return retval;
             }
             catch(const exception::dispatch_error &e){
-              t_ss.set_stack(prev_stack);
               throw exception::eval_error(std::string(e.what()) + " with function '" + this->children[0]->text + "'");
             }
             catch(detail::Return_Value &rv) {
-              t_ss.set_stack(prev_stack);
               return rv.retval;
             }
             catch(...) {
-              t_ss.set_stack(prev_stack);
               throw;
             }
           }
           catch(exception::eval_error &) {
-            t_ss.set_stack(prev_stack);
             throw;
           }
 
@@ -466,24 +458,17 @@ namespace chaiscript
                 fun_name = this->children[i]->text;
               }
 
-              chaiscript::detail::Dispatch_Engine::Stack prev_stack = t_ss.get_stack();
-              chaiscript::detail::Dispatch_Engine::Stack new_stack = t_ss.new_stack();
-
               try {
-                t_ss.set_stack(new_stack);
+                chaiscript::eval::detail::Stack_Push_Pop spp(t_ss);
                 retval = t_ss.call_function(fun_name, plb);
-                t_ss.set_stack(prev_stack);
               }
               catch(const exception::dispatch_error &e){
-                t_ss.set_stack(prev_stack);
                 throw exception::eval_error(std::string(e.what()) + " for function: " + fun_name);
               }
               catch(detail::Return_Value &rv) {
-                t_ss.set_stack(prev_stack);
                 retval = rv.retval;
               }
               catch(...) {
-                t_ss.set_stack(prev_stack);
                 throw;
               }
               if (this->children[i]->identifier == AST_Node_Type::Array_Call) {

unittests/system_introspection.chai

@@ -5,9 +5,9 @@ assert_true(funcs.size() > 0);
 assert_true(funcs["to_string"].get_type_info().bare_equal(Function_type));
 
 
+var i = 1;
 var objs = get_objects();
 
-var i = 1;
 assert_true(objs.size() > 0);
 assert_true(objs["i"].get_type_info().bare_equal(int_type));
 assert_true(objs.count("j") == 0);