--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,31 @@
+2008-04-25  John W. Eaton  <jwe@octave.org>
+
+	* error.cc (verror, pr_where): Use octave_call_stack instead of
+	tree_statement stack to get line and column information.
+	(pr_where): Use octave_call_stack instead of tree_statement stack
+	to get current statement.
+	* input.cc (get_user_input): Extract current line number from
+	octave_call_stack instead of tree_statement_stack.
+	* pt-stmt.cc (tree_statement::eval): Put current statement on
+	octave_call_stack instead of tree_statement_stack.
+	* pt-stmt.h, pt-stmt.cc (class tree_statement_stack): Delete.
+
+	* toplev.h, toplev.cc (octave_call_stack::call_stack_elt):
+	New nested struct.
+	(octave_call_stack::cs): Now a deque of call_stack_elts.
+	Change all uses.
+	(octave_call_stack::current_statement,
+	octave_call_stack::current_line,
+	octave_call_stack::current_column,
+	octave_call_stack::top_statement,
+	octave_call_stack::set_statement, octave_call_stack::backtrace):
+	New static functions.
+	(octave_call_stack::do_current_line,
+	octave_call_stack::do_current_column,
+	octave_call_stack::do_top_statement,
+	octave_call_stack::do_set_statement,
+	octave_call_stack::do_backtrace): New member functions.
+
 2008-04-24  John W. Eaton  <jwe@octave.org>
 
 	* toplev.h, toplev.cc (octave_call_stack::unwind_pop_script):

--- a/src/error.cc
+++ b/src/error.cc
@@ -232,7 +232,7 @@
       Vlast_error_name = std::string ();
       Vlast_error_file = std::string ();
 
-      if (tree_statement_stack::current ())
+      if (octave_call_stack::current_statement ())
 	{
 	  octave_user_code *fcn = octave_call_stack::caller_user_code ();
 
@@ -240,8 +240,8 @@
 	    {
 	      Vlast_error_file = fcn->fcn_file_name ();
 	      Vlast_error_name = fcn->name();
-	      Vlast_error_line = tree_statement_stack::current_line ();
-	      Vlast_error_column = tree_statement_stack::current_column ();
+	      Vlast_error_line = octave_call_stack::current_line ();
+	      Vlast_error_column = octave_call_stack::current_column ();
 	    }
 	}
     }
@@ -421,7 +421,7 @@
 static void
 pr_where (const char *name, bool print_code = true)
 {
-  if (tree_statement_stack::current ())
+  if (octave_call_stack::current_statement ())
     {
       std::string nm;
 
@@ -437,8 +437,8 @@
 	  if (nm.empty ())
 	    nm = fcn->name ();
 
-	  l = tree_statement_stack::current_line ();
-	  c = tree_statement_stack::current_column ();
+	  l = octave_call_stack::current_line ();
+	  c = octave_call_stack::current_column ();
 	}
 
       if (nm.empty ())
@@ -469,7 +469,7 @@
 
 	  tree_print_code tpc (output_buf, ">>> ");
 
-	  tree_statement *curr_stmt = tree_statement_stack::current ();
+	  tree_statement *curr_stmt = octave_call_stack::current_statement ();
 
 	  if (curr_stmt)
 	    curr_stmt->accept (tpc);

--- a/src/input.cc
+++ b/src/input.cc
@@ -607,7 +607,7 @@
 	  if (nm.empty ())
 	    nm = caller->name ();
 
-	  line = tree_statement_stack::current_line ();
+	  line = octave_call_stack::current_line ();
 	}
     }
 
@@ -699,7 +699,7 @@
 	    {
 	      tree::break_next = true;
 
-	      tree::last_line = tree_statement_stack::current_line ();
+	      tree::last_line = octave_call_stack::current_line ();
 
 	      tree::break_function = octave_call_stack::current ();
 

--- a/src/pt-stmt.cc
+++ b/src/pt-stmt.cc
@@ -87,8 +87,7 @@
 
   if (cmd || expr)
     {
-      unwind_protect::add (tree_statement_stack::unwind_pop, 0);
-      tree_statement_stack::push (this);
+      octave_call_stack::set_statement (this);
 
       maybe_echo_code (in_function_body);
 
@@ -131,8 +130,6 @@
 	  octave_exception_state = octave_no_exception;
 	  error ("caught execution error in library function");
 	}
-
-      unwind_protect::run ();
     }
 
   return retval;
@@ -285,8 +282,6 @@
   tw.visit_statement_list (*this);
 }
 
-tree_statement_stack *tree_statement_stack::instance = 0;
-
 /*
 ;;; Local Variables: ***
 ;;; mode: C++ ***

--- a/src/pt-stmt.h
+++ b/src/pt-stmt.h
@@ -160,106 +160,6 @@
   tree_statement_list& operator = (const tree_statement_list&);
 };
 
-class tree_statement_stack
-{
-protected:
-
-  tree_statement_stack (void) : tss () { }
-
-public:
-
-  typedef std::deque<tree_statement *>::iterator iterator ;
-
-  static bool instance_ok (void)
-  {
-    bool retval = true;
-
-    if (! instance)
-      instance = new tree_statement_stack ();
-
-    if (! instance)
-      {
-	::error ("unable to create stmt stack object!");
-
-	retval = false;
-      }
-
-    return retval;
-  }
-
-  // Current statement (top of stack).
-  static tree_statement *current (void) { return top (); }
-
-  static int current_line (void)
-  {
-    tree_statement *s = current ();
-    return s ? s->line () : -1;
-  }
-
-  static int current_column (void)
-  {
-    tree_statement *s = current ();
-    return s ? s->column () : -1;
-  }
-
-  // Statement at position N on the call stack (N == 0 is current).
-  static tree_statement *element (size_t n)
-  {
-    return instance_ok () ? instance->do_element (n) : 0;
-  }
-
-  // Caller statement
-  static tree_statement *caller (void) { return element (1); }
-
-  static void push (tree_statement *f)
-  {
-    if (instance_ok ())
-      instance->do_push (f);
-  }
-
-  static tree_statement *top (void)
-  {
-    return instance_ok () ? instance->do_top (): 0;
-  }
-
-  static void pop (void)
-  {
-    if (instance_ok ())
-      instance->do_pop ();
-  }
-  
-  // A function for popping the top of the call stack that is suitable
-  // for use as an unwind_protect handler.
-  static void unwind_pop (void *) { pop (); }
-
-  static void clear (void)
-  {
-    if (instance_ok ())
-      instance->do_clear ();
-  }
-
-private:
-
-  // The current stmt stack.
-  std::deque<tree_statement *> tss;
-
-  static tree_statement_stack *instance;
-
-  tree_statement *do_element (size_t n) { return tss.size () > n ? tss[n] : 0; }
-
-  void do_push (tree_statement *f) { tss.push_front (f); }
-
-  tree_statement *do_top (void) { return tss.empty () ? 0 : tss.front (); }
-
-  void do_pop (void)
-  {
-    if (! tss.empty ())
-      tss.pop_front ();
-  }
-
-  void do_clear (void) { tss.clear (); }
-};
-
 #endif
 
 /*

--- a/src/toplev.cc
+++ b/src/toplev.cc
@@ -95,14 +95,32 @@
 
 octave_call_stack *octave_call_stack::instance = 0;
 
+int
+octave_call_stack::do_current_line (void) const
+{
+  tree_statement *stmt = do_top_statement ();
+
+  return stmt ? stmt->line () : -1;
+}
+
+int
+octave_call_stack::do_current_column (void) const
+{
+  tree_statement *stmt = do_top_statement ();
+
+  return stmt ? stmt->column () : -1;
+}
+
 octave_user_script *
-octave_call_stack::do_caller_user_script (void)
+octave_call_stack::do_caller_user_script (void) const
 {
   octave_user_script *retval = 0;
 
-  for (iterator p = cs.begin (); p != cs.end (); p++)
+  for (const_iterator p = cs.begin (); p != cs.end (); p++)
     {
-      octave_function *f = *p;
+      const call_stack_elt& elt = *p;
+
+      octave_function *f = elt.fcn;
 
       if (f && f->is_user_script ())
 	{
@@ -115,13 +133,15 @@
 }
 
 octave_user_function *
-octave_call_stack::do_caller_user_function (void)
+octave_call_stack::do_caller_user_function (void) const
 {
   octave_user_function *retval = 0;
 
-  for (iterator p = cs.begin (); p != cs.end (); p++)
+  for (const_iterator p = cs.begin (); p != cs.end (); p++)
     {
-      octave_function *f = *p;
+      const call_stack_elt& elt = *p;
+
+      octave_function *f = elt.fcn;
 
       if (f && f->is_user_function ())
 	{
@@ -134,13 +154,15 @@
 }
 
 octave_user_code *
-octave_call_stack::do_caller_user_code (void)
+octave_call_stack::do_caller_user_code (void) const
 {
   octave_user_code *retval = 0;
 
-  for (iterator p = cs.begin (); p != cs.end (); p++)
+  for (const_iterator p = cs.begin (); p != cs.end (); p++)
     {
-      octave_function *f = *p;
+      const call_stack_elt& elt = *p;
+
+      octave_function *f = elt.fcn;
 
       if (f && f->is_user_code ())
 	{
@@ -152,6 +174,77 @@
   return retval;
 }
 
+Octave_map
+octave_call_stack::do_backtrace (void) const
+{
+  Octave_map retval;
+
+  size_t nframes = cs.size () - 1;
+
+  Cell keys (4, 1);
+
+  keys(0) = "file";
+  keys(1) = "name";
+  keys(2) = "line";
+  keys(3) = "column";
+
+  Cell file (nframes, 1);
+  Cell name (nframes, 1);
+  Cell line (nframes, 1);
+  Cell column (nframes, 1);
+
+  const_iterator p = cs.begin ();
+  
+  // Skip innermost function as it will be the dbstatus function
+  // itself.  FIXME -- Is it best to do this here?
+  p++;
+
+  octave_idx_type k = 0;
+
+  while (p != cs.end ())
+    {
+      const call_stack_elt& elt = *p;
+
+      octave_function *f = elt.fcn;
+
+      if (f)
+	{
+	  file(k) = f->fcn_file_name ();
+	  name(k) = f->name ();
+
+	  tree_statement *stmt = elt.stmt;
+
+	  if (stmt)
+	    {
+	      line(k) = stmt->line ();
+	      column(k) = stmt->column ();
+	    }
+	  else
+	    {
+	      line(k) = -1;
+	      column(k) = -1;
+	    }
+	}
+      else
+	{
+	  file(k) = "<unknown>";
+	  name(k) = "<unknown>";
+	  line(k) = -1;
+	  column(k) = -1;
+	}
+
+      k++;
+      p++;
+    }
+
+  retval.assign ("file", file);
+  retval.assign ("name", name);
+  retval.assign ("line", line);
+  retval.assign ("column", column);
+
+  return retval;
+}
+
 void
 recover_from_exception (void)
 {

--- a/src/toplev.h
+++ b/src/toplev.h
@@ -33,9 +33,12 @@
 class octave_value_list;
 class octave_function;
 class octave_user_script;
+class tree_statement;
 class tree_statement_list;
 class charMatrix;
 
+#include "oct-map.h"
+
 extern OCTINTERP_API void
 clean_up_and_exit (int) GCC_ATTR_NORETURN;
 
@@ -68,13 +71,24 @@
 class
 octave_call_stack
 {
+private:
+
+  struct call_stack_elt
+  {
+    call_stack_elt (octave_function *f) : fcn (f), stmt (0) { }
+
+    octave_function *fcn;
+    tree_statement *stmt;
+  };
+
 protected:
 
   octave_call_stack (void) : cs () { }
 
 public:
 
-  typedef std::deque<octave_function *>::iterator iterator ;
+  typedef std::deque<call_stack_elt>::iterator iterator;
+  typedef std::deque<call_stack_elt>::const_iterator const_iterator;
 
   static bool instance_ok (void)
   {
@@ -96,6 +110,21 @@
   // Current function (top of stack).
   static octave_function *current (void) { return top (); }
 
+  // Current statement (top of stack).
+  static tree_statement *current_statement (void) { return top_statement (); }
+
+  // Current line in current function.
+  static int current_line (void)
+  {
+    return instance_ok () ? instance->do_current_line () : 0;
+  }
+
+  // Current column in current function.
+  static int current_column (void)
+  {
+    return instance_ok () ? instance->do_current_column () : 0;
+  }
+
   // Caller function, may be built-in.
   static octave_function *caller (void)
   {
@@ -138,6 +167,22 @@
     return instance_ok () ? instance->do_top (): 0;
   }
 
+  static tree_statement *top_statement (void)
+  {
+    return instance_ok () ? instance->do_top_statement (): 0;
+  }
+
+  static void set_statement (tree_statement *s)
+  {
+    if (instance_ok ())
+      instance->do_set_statement (s);
+  }
+
+  static Octave_map backtrace (void)
+  {
+    return instance_ok () ? instance->do_backtrace () : Octave_map ();
+  }
+
   static void pop (void)
   {
     if (instance_ok ())
@@ -157,21 +202,74 @@
 private:
 
   // The current call stack.
-  std::deque<octave_function *> cs;
+  std::deque<call_stack_elt> cs;
 
   static octave_call_stack *instance;
 
-  octave_function *do_element (size_t n) { return cs.size () > n ? cs[n] : 0; }
+  int do_current_line (void) const;
+
+  int do_current_column (void) const;
+
+  octave_function *do_element (size_t n)
+  {
+    octave_function *retval = 0;
+
+    if (cs.size () > n)
+      {
+	call_stack_elt& elt = cs[n];
+	retval = elt.fcn;
+      }
 
-  octave_user_script *do_caller_user_script (void);
+    return retval;
+  }
+
+  octave_user_script *do_caller_user_script (void) const;
+
+  octave_user_function *do_caller_user_function (void) const;
+
+  octave_user_code *do_caller_user_code (void) const;
 
-  octave_user_function *do_caller_user_function (void);
+  void do_push (octave_function *f)
+  {
+    cs.push_front (call_stack_elt (f));
+  }
+
+  octave_function *do_top (void) const
+  {
+    octave_function *retval = 0;
 
-  octave_user_code *do_caller_user_code (void);
+    if (! cs.empty ())
+      {
+	const call_stack_elt& elt = cs.front ();
+	retval = elt.fcn;
+      }
+
+    return retval;
+  }
+
+  tree_statement *do_top_statement (void) const
+  {
+    tree_statement *retval = 0;
 
-  void do_push (octave_function *f) { cs.push_front (f); }
+    if (! cs.empty ())
+      {
+	const call_stack_elt& elt = cs.front ();
+	retval = elt.stmt;
+      }
+
+    return retval;
+  }
 
-  octave_function *do_top (void) { return cs.empty () ? 0 : cs.front (); }
+  void do_set_statement (tree_statement *s)
+  {
+    if (! cs.empty ())
+      {
+	call_stack_elt& elt = cs.front ();
+	elt.stmt = s;
+      }
+  }
+
+  Octave_map do_backtrace (void) const;
 
   void do_pop (void)
   {