--- a/libinterp/corefcn/call-stack.cc	Thu Dec 01 14:23:45 2022 -0800
+++ b/libinterp/corefcn/call-stack.cc	Thu Dec 01 18:02:15 2022 -0800
@@ -49,1090 +49,1090 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  // Use static fields for the best efficiency.
-  // NOTE: C++0x will allow these two to be merged into one.
-  static const char *bt_fieldnames[] =
-    { "file", "name", "line", "column", nullptr };
+// Use static fields for the best efficiency.
+// NOTE: C++0x will allow these two to be merged into one.
+static const char *bt_fieldnames[] =
+{ "file", "name", "line", "column", nullptr };
 
-  static const octave_fields bt_fields (bt_fieldnames);
+static const octave_fields bt_fields (bt_fieldnames);
 
-  call_stack::call_stack (tree_evaluator& evaluator)
-    : m_evaluator (evaluator), m_cs (), m_curr_frame (0),
-      m_max_stack_depth (1024), m_global_values ()
-  {
-    push (symbol_scope ("top scope"));
-  }
+call_stack::call_stack (tree_evaluator& evaluator)
+  : m_evaluator (evaluator), m_cs (), m_curr_frame (0),
+    m_max_stack_depth (1024), m_global_values ()
+{
+  push (symbol_scope ("top scope"));
+}
 
-  octave_function * call_stack::current_function (bool skip_first) const
-  {
-    if (m_cs.empty ())
-      error ("current_function: call stack is empty");
+octave_function *call_stack::current_function (bool skip_first) const
+{
+  if (m_cs.empty ())
+    error ("current_function: call stack is empty");
 
-    octave_function *fcn = nullptr;
+  octave_function *fcn = nullptr;
 
-    std::size_t idx = m_curr_frame;
+  std::size_t idx = m_curr_frame;
 
-    if (idx > 0 && skip_first)
-      --idx;
+  if (idx > 0 && skip_first)
+    --idx;
 
-    while (true)
-      {
-        fcn = m_cs[idx]->function ();
+  while (true)
+    {
+      fcn = m_cs[idx]->function ();
 
-        if (fcn || idx == 0)
-          break;
+      if (fcn || idx == 0)
+        break;
 
-        --idx;
-      }
+      --idx;
+    }
 
-    return fcn;
-  }
+  return fcn;
+}
 
-  int call_stack::current_line (void) const
-  {
-    int retval = -1;
+int call_stack::current_line (void) const
+{
+  int retval = -1;
 
-    if (! m_cs.empty ())
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[m_curr_frame];
-        retval = elt->line ();
-      }
+  if (! m_cs.empty ())
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[m_curr_frame];
+      retval = elt->line ();
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  int call_stack::current_column (void) const
-  {
-    int retval = -1;
+int call_stack::current_column (void) const
+{
+  int retval = -1;
 
-    if (! m_cs.empty ())
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[m_curr_frame];
-        retval = elt->column ();
-      }
+  if (! m_cs.empty ())
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[m_curr_frame];
+      retval = elt->column ();
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_user_code * call_stack::current_user_code (void) const
-  {
-    // Start at current frame.
+octave_user_code *call_stack::current_user_code (void) const
+{
+  // Start at current frame.
 
-    std::size_t xframe = find_current_user_frame ();
+  std::size_t xframe = find_current_user_frame ();
 
-    if (xframe > 0)
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[xframe];
+  if (xframe > 0)
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[xframe];
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && f->is_user_code ())
-          return dynamic_cast<octave_user_code *> (f);
-      }
+      if (f && f->is_user_code ())
+        return dynamic_cast<octave_user_code *> (f);
+    }
 
-    return nullptr;
-  }
+  return nullptr;
+}
 
-  int call_stack::current_user_code_line (void) const
-  {
-    // Start at current frame.
+int call_stack::current_user_code_line (void) const
+{
+  // Start at current frame.
 
-    std::size_t xframe = find_current_user_frame ();
+  std::size_t xframe = find_current_user_frame ();
 
-    if (xframe > 0)
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[xframe];
+  if (xframe > 0)
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[xframe];
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && f->is_user_code ())
-          {
-            int line = elt->line ();
+      if (f && f->is_user_code ())
+        {
+          int line = elt->line ();
 
-            if (line > 0)
-              return line;
-          }
-      }
+          if (line > 0)
+            return line;
+        }
+    }
 
-    return -1;
-  }
+  return -1;
+}
 
-  int call_stack::current_user_code_column (void) const
-  {
-    // Start at current frame.
+int call_stack::current_user_code_column (void) const
+{
+  // Start at current frame.
 
-    std::size_t xframe = find_current_user_frame ();
+  std::size_t xframe = find_current_user_frame ();
 
-    if (xframe > 0)
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[xframe];
+  if (xframe > 0)
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[xframe];
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && f->is_user_code ())
-          {
-            int column = elt->column ();
+      if (f && f->is_user_code ())
+        {
+          int column = elt->column ();
 
-            if (column > 0)
-              return column;
-          }
-      }
+          if (column > 0)
+            return column;
+        }
+    }
 
-    return -1;
-  }
+  return -1;
+}
 
-  unwind_protect * call_stack::curr_fcn_unwind_protect_frame (void)
-  {
-    // Start at current frame.
+unwind_protect *call_stack::curr_fcn_unwind_protect_frame (void)
+{
+  // Start at current frame.
 
-    std::size_t xframe = find_current_user_frame ();
+  std::size_t xframe = find_current_user_frame ();
 
-    if (xframe > 0)
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[xframe];
+  if (xframe > 0)
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[xframe];
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && f->is_user_code ())
-          return elt->unwind_protect_frame ();
-      }
+      if (f && f->is_user_code ())
+        return elt->unwind_protect_frame ();
+    }
 
-    return nullptr;
-  }
+  return nullptr;
+}
 
-  octave_user_code * call_stack::debug_user_code (void) const
-  {
-    octave_user_code *retval = nullptr;
+octave_user_code *call_stack::debug_user_code (void) const
+{
+  octave_user_code *retval = nullptr;
 
-    // This should never happen...
-    if (m_curr_frame == 0)
-      return retval;
+  // This should never happen...
+  if (m_curr_frame == 0)
+    return retval;
 
-    std::size_t i = m_curr_frame;
+  std::size_t i = m_curr_frame;
 
-    while (i != 0)
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[i--];
+  while (i != 0)
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[i--];
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && f->is_user_code ())
-          {
-            retval = dynamic_cast<octave_user_code *> (f);
-            break;
-          }
-      }
+      if (f && f->is_user_code ())
+        {
+          retval = dynamic_cast<octave_user_code *> (f);
+          break;
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  int call_stack::debug_user_code_line (void) const
-  {
-    int retval = -1;
+int call_stack::debug_user_code_line (void) const
+{
+  int retval = -1;
 
-    // This should never happen...
-    if (m_curr_frame == 0)
-      return retval;
+  // This should never happen...
+  if (m_curr_frame == 0)
+    return retval;
 
-    std::size_t i = m_curr_frame;
+  std::size_t i = m_curr_frame;
 
-    while (i != 0)
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[i--];
+  while (i != 0)
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[i--];
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && f->is_user_code ())
-          {
-            if (elt->line ())
-              {
-                retval = elt->line ();
-                break;
-              }
-          }
-      }
+      if (f && f->is_user_code ())
+        {
+          if (elt->line ())
+            {
+              retval = elt->line ();
+              break;
+            }
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  int call_stack::debug_user_code_column (void) const
-  {
-    int retval = -1;
+int call_stack::debug_user_code_column (void) const
+{
+  int retval = -1;
 
-    // This should never happen...
-    if (m_curr_frame == 0)
-      return retval;
+  // This should never happen...
+  if (m_curr_frame == 0)
+    return retval;
 
-    // Start looking with the caller of the calling debug function.
-    std::size_t i = m_curr_frame;
+  // Start looking with the caller of the calling debug function.
+  std::size_t i = m_curr_frame;
 
-    while (i != 0)
-      {
-        const std::shared_ptr<stack_frame> elt = m_cs[i--];
+  while (i != 0)
+    {
+      const std::shared_ptr<stack_frame> elt = m_cs[i--];
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && f->is_user_code ())
-          {
-            if (elt->column ())
-              {
-                retval = elt->column ();
-                break;
-              }
-          }
-      }
+      if (f && f->is_user_code ())
+        {
+          if (elt->column ())
+            {
+              retval = elt->column ();
+              break;
+            }
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  std::string call_stack::get_dispatch_class (void) const
-  {
-    return m_cs[m_curr_frame]->get_dispatch_class ();
-  }
+std::string call_stack::get_dispatch_class (void) const
+{
+  return m_cs[m_curr_frame]->get_dispatch_class ();
+}
 
-  void call_stack::set_dispatch_class (const std::string& class_name)
-  {
-    m_cs[m_curr_frame]->set_dispatch_class (class_name);
-  }
+void call_stack::set_dispatch_class (const std::string& class_name)
+{
+  m_cs[m_curr_frame]->set_dispatch_class (class_name);
+}
 
-  bool call_stack::is_class_method_executing (std::string& dispatch_class) const
-  {
-    dispatch_class = "";
+bool call_stack::is_class_method_executing (std::string& dispatch_class) const
+{
+  dispatch_class = "";
 
-    octave_function *f = current_function ();
+  octave_function *f = current_function ();
 
-    bool retval = (f && f->is_class_method ());
+  bool retval = (f && f->is_class_method ());
 
-    if (retval)
-      dispatch_class = f->dispatch_class ();
+  if (retval)
+    dispatch_class = f->dispatch_class ();
 
-    return retval;
-  }
+  return retval;
+}
 
-  bool call_stack::is_class_constructor_executing (std::string& dispatch_class) const
-  {
-    dispatch_class = "";
+bool call_stack::is_class_constructor_executing (std::string& dispatch_class) const
+{
+  dispatch_class = "";
 
-    octave_function *f = current_function ();
+  octave_function *f = current_function ();
 
-    bool retval = (f && f->is_class_constructor ());
+  bool retval = (f && f->is_class_constructor ());
 
-    if (retval)
-      dispatch_class = f->dispatch_class ();
+  if (retval)
+    dispatch_class = f->dispatch_class ();
 
-    return retval;
-  }
+  return retval;
+}
 
-  bool call_stack::all_scripts (void) const
-  {
-    bool retval = true;
+bool call_stack::all_scripts (void) const
+{
+  bool retval = true;
 
-    auto p = m_cs.cend ();
+  auto p = m_cs.cend ();
 
-    while (p != m_cs.cbegin ())
-      {
-        const std::shared_ptr<stack_frame> elt = *(--p);
+  while (p != m_cs.cbegin ())
+    {
+      const std::shared_ptr<stack_frame> elt = *(--p);
 
-        octave_function *f = elt->function ();
+      octave_function *f = elt->function ();
 
-        if (f && ! f->is_user_script ())
-          {
-            retval = false;
-            break;
-          }
-      }
+      if (f && ! f->is_user_script ())
+        {
+          retval = false;
+          break;
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  void call_stack::get_new_frame_index_and_links
-    (std::size_t& new_frame_idx, std::shared_ptr<stack_frame>& parent_link,
-     std::shared_ptr<stack_frame>& static_link) const
-  {
-    // FIXME: is there a better way?
+void call_stack::get_new_frame_index_and_links
+(std::size_t& new_frame_idx, std::shared_ptr<stack_frame>& parent_link,
+ std::shared_ptr<stack_frame>& static_link) const
+{
+  // FIXME: is there a better way?
 
-    std::size_t prev_frame_idx = m_curr_frame;
+  std::size_t prev_frame_idx = m_curr_frame;
 
-    new_frame_idx = m_cs.size ();
+  new_frame_idx = m_cs.size ();
 
-    // m_max_stack_depth should never be less than zero.
-    if (new_frame_idx > static_cast<std::size_t> (m_max_stack_depth))
-      error ("max_stack_depth exceeded");
+  // m_max_stack_depth should never be less than zero.
+  if (new_frame_idx > static_cast<std::size_t> (m_max_stack_depth))
+    error ("max_stack_depth exceeded");
 
-    // There can't be any links to previous frames if this is the first
-    // frame on the stack.
+  // There can't be any links to previous frames if this is the first
+  // frame on the stack.
 
-    if (new_frame_idx == 0)
-      return;
+  if (new_frame_idx == 0)
+    return;
 
-    parent_link = m_cs[prev_frame_idx];
+  parent_link = m_cs[prev_frame_idx];
 
-    octave_function *t_fcn = parent_link->function ();
+  octave_function *t_fcn = parent_link->function ();
 
-    static_link = (t_fcn
-                   ? (t_fcn->is_user_code ()
-                      ? parent_link : parent_link->static_link ())
-                   : parent_link);
-  }
+  static_link = (t_fcn
+                 ? (t_fcn->is_user_code ()
+                    ? parent_link : parent_link->static_link ())
+                 : parent_link);
+}
 
-  void call_stack::push (const symbol_scope& scope)
-  {
-    std::size_t new_frame_idx;
-    std::shared_ptr<stack_frame> parent_link;
-    std::shared_ptr<stack_frame> static_link;
+void call_stack::push (const symbol_scope& scope)
+{
+  std::size_t new_frame_idx;
+  std::shared_ptr<stack_frame> parent_link;
+  std::shared_ptr<stack_frame> static_link;
 
-    get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
+  get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
 
-    std::shared_ptr<stack_frame>
-      new_frame (stack_frame::create (m_evaluator, scope, new_frame_idx,
-                                      parent_link, static_link));
+  std::shared_ptr<stack_frame>
+  new_frame (stack_frame::create (m_evaluator, scope, new_frame_idx,
+                                  parent_link, static_link));
 
-    m_cs.push_back (new_frame);
+  m_cs.push_back (new_frame);
 
-    m_curr_frame = new_frame_idx;
-  }
+  m_curr_frame = new_frame_idx;
+}
 
-  void call_stack::push (octave_user_function *fcn,
-                         const std::shared_ptr<stack_frame>& closure_frames)
-  {
-    std::size_t new_frame_idx;
-    std::shared_ptr<stack_frame> parent_link;
-    std::shared_ptr<stack_frame> static_link;
+void call_stack::push (octave_user_function *fcn,
+                       const std::shared_ptr<stack_frame>& closure_frames)
+{
+  std::size_t new_frame_idx;
+  std::shared_ptr<stack_frame> parent_link;
+  std::shared_ptr<stack_frame> static_link;
 
-    get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
+  get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
 
-    std::shared_ptr<stack_frame>
-      new_frame (stack_frame::create (m_evaluator, fcn, new_frame_idx,
-                                      parent_link, static_link,
-                                      closure_frames));
+  std::shared_ptr<stack_frame>
+  new_frame (stack_frame::create (m_evaluator, fcn, new_frame_idx,
+                                  parent_link, static_link,
+                                  closure_frames));
 
-    m_cs.push_back (new_frame);
+  m_cs.push_back (new_frame);
 
-    m_curr_frame = new_frame_idx;
-  }
+  m_curr_frame = new_frame_idx;
+}
 
-  void call_stack::push (octave_user_function *fcn,
-                         const stack_frame::local_vars_map& local_vars,
-                         const std::shared_ptr<stack_frame>& closure_frames)
-  {
-    std::size_t new_frame_idx;
-    std::shared_ptr<stack_frame> parent_link;
-    std::shared_ptr<stack_frame> static_link;
+void call_stack::push (octave_user_function *fcn,
+                       const stack_frame::local_vars_map& local_vars,
+                       const std::shared_ptr<stack_frame>& closure_frames)
+{
+  std::size_t new_frame_idx;
+  std::shared_ptr<stack_frame> parent_link;
+  std::shared_ptr<stack_frame> static_link;
 
-    get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
+  get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
 
-    std::shared_ptr<stack_frame>
-      new_frame (stack_frame::create (m_evaluator, fcn, new_frame_idx,
-                                      parent_link, static_link, local_vars,
-                                      closure_frames));
+  std::shared_ptr<stack_frame>
+  new_frame (stack_frame::create (m_evaluator, fcn, new_frame_idx,
+                                  parent_link, static_link, local_vars,
+                                  closure_frames));
 
-    m_cs.push_back (new_frame);
+  m_cs.push_back (new_frame);
 
-    m_curr_frame = new_frame_idx;
-  }
+  m_curr_frame = new_frame_idx;
+}
 
-  void call_stack::push (octave_user_script *script)
-  {
-    std::size_t new_frame_idx;
-    std::shared_ptr<stack_frame> parent_link;
-    std::shared_ptr<stack_frame> static_link;
+void call_stack::push (octave_user_script *script)
+{
+  std::size_t new_frame_idx;
+  std::shared_ptr<stack_frame> parent_link;
+  std::shared_ptr<stack_frame> static_link;
 
-    get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
+  get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
 
-    std::shared_ptr<stack_frame>
-      new_frame (stack_frame::create (m_evaluator, script, new_frame_idx,
-                                      parent_link, static_link));
+  std::shared_ptr<stack_frame>
+  new_frame (stack_frame::create (m_evaluator, script, new_frame_idx,
+                                  parent_link, static_link));
 
-    m_cs.push_back (new_frame);
+  m_cs.push_back (new_frame);
 
-    m_curr_frame = new_frame_idx;
-  }
+  m_curr_frame = new_frame_idx;
+}
 
-  void call_stack::push (octave_function *fcn)
-  {
-    std::size_t new_frame_idx;
-    std::shared_ptr<stack_frame> parent_link;
-    std::shared_ptr<stack_frame> static_link;
+void call_stack::push (octave_function *fcn)
+{
+  std::size_t new_frame_idx;
+  std::shared_ptr<stack_frame> parent_link;
+  std::shared_ptr<stack_frame> static_link;
 
-    get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
+  get_new_frame_index_and_links (new_frame_idx, parent_link, static_link);
 
-    std::shared_ptr<stack_frame>
-      new_frame (stack_frame::create (m_evaluator, fcn, new_frame_idx,
-                                      parent_link, static_link));
+  std::shared_ptr<stack_frame>
+  new_frame (stack_frame::create (m_evaluator, fcn, new_frame_idx,
+                                  parent_link, static_link));
 
-    m_cs.push_back (new_frame);
+  m_cs.push_back (new_frame);
 
-    m_curr_frame = new_frame_idx;
-  }
+  m_curr_frame = new_frame_idx;
+}
 
-  bool call_stack::goto_frame (std::size_t n, bool verbose)
-  {
-    bool retval = false;
+bool call_stack::goto_frame (std::size_t n, bool verbose)
+{
+  bool retval = false;
 
-    if (n < m_cs.size ())
-      {
-        retval = true;
+  if (n < m_cs.size ())
+    {
+      retval = true;
 
-        m_curr_frame = n;
+      m_curr_frame = n;
 
-        if (verbose)
-          {
-            const std::shared_ptr<stack_frame> elt = m_cs[n];
+      if (verbose)
+        {
+          const std::shared_ptr<stack_frame> elt = m_cs[n];
 
-            elt->display_stopped_in_message (octave_stdout);
-          }
-      }
+          elt->display_stopped_in_message (octave_stdout);
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  std::size_t call_stack::find_current_user_frame (void) const
-  {
-    std::size_t user_frame = m_curr_frame;
+std::size_t call_stack::find_current_user_frame (void) const
+{
+  std::size_t user_frame = m_curr_frame;
 
-    std::shared_ptr<stack_frame> frm = m_cs[user_frame];
+  std::shared_ptr<stack_frame> frm = m_cs[user_frame];
 
-    if (! (frm->is_user_fcn_frame () || frm->is_user_script_frame ()
-           || frm->is_scope_frame ()))
-      {
-        frm = frm->static_link ();
+  if (! (frm->is_user_fcn_frame () || frm->is_user_script_frame ()
+         || frm->is_scope_frame ()))
+    {
+      frm = frm->static_link ();
 
-        user_frame = frm->index ();
-      }
+      user_frame = frm->index ();
+    }
 
-    return user_frame;
-  }
+  return user_frame;
+}
 
-  std::shared_ptr<stack_frame> call_stack::current_user_frame (void) const
-  {
-    std::size_t frame = find_current_user_frame ();
+std::shared_ptr<stack_frame> call_stack::current_user_frame (void) const
+{
+  std::size_t frame = find_current_user_frame ();
 
-    return m_cs[frame];
-  }
+  return m_cs[frame];
+}
 
-  // Go to the Nth frame (up if N is negative or down if positive) in
-  // the call stack that corresponds to a script, function, or scope
-  // beginning with the frame indexed by START.
+// Go to the Nth frame (up if N is negative or down if positive) in
+// the call stack that corresponds to a script, function, or scope
+// beginning with the frame indexed by START.
 
-  std::size_t call_stack::dbupdown (std::size_t start, int n, bool verbose)
-  {
-    if (start >= m_cs.size ())
-      error ("invalid stack frame");
+std::size_t call_stack::dbupdown (std::size_t start, int n, bool verbose)
+{
+  if (start >= m_cs.size ())
+    error ("invalid stack frame");
 
-    // Can't go up from here.
+  // Can't go up from here.
 
-    if (start == 0 && n < 0)
-      {
-        if (verbose)
-          m_cs[start]->display_stopped_in_message (octave_stdout);
+  if (start == 0 && n < 0)
+    {
+      if (verbose)
+        m_cs[start]->display_stopped_in_message (octave_stdout);
 
-        return start;
-      }
+      return start;
+    }
 
-    std::shared_ptr<stack_frame> frm = m_cs[start];
+  std::shared_ptr<stack_frame> frm = m_cs[start];
 
-    if (! (frm && (frm->is_user_fcn_frame ()
-                   || frm->is_user_script_frame ()
-                   || frm->is_scope_frame ())))
-      error ("call_stack::dbupdown: invalid initial frame in call stack!");
+  if (! (frm && (frm->is_user_fcn_frame ()
+                 || frm->is_user_script_frame ()
+                 || frm->is_scope_frame ())))
+    error ("call_stack::dbupdown: invalid initial frame in call stack!");
 
-    // Use index into the call stack to begin the search.  At this point
-    // we iterate up or down using indexing instead of static links
-    // because ... FIXME: it's a bit complicated, but deserves
-    // explanation.  May be easiest with some pictures of the call stack
-    // for an example or two.
+  // Use index into the call stack to begin the search.  At this point
+  // we iterate up or down using indexing instead of static links
+  // because ... FIXME: it's a bit complicated, but deserves
+  // explanation.  May be easiest with some pictures of the call stack
+  // for an example or two.
 
-    std::size_t xframe = frm->index ();
+  std::size_t xframe = frm->index ();
 
-    if (n == 0)
-      {
-        if (verbose)
-          frm->display_stopped_in_message (octave_stdout);
+  if (n == 0)
+    {
+      if (verbose)
+        frm->display_stopped_in_message (octave_stdout);
 
-        return xframe;
-      }
+      return xframe;
+    }
 
-    int incr = 0;
+  int incr = 0;
 
-    if (n < 0)
-      {
-        incr = -1;
-        n = -n;
-      }
-    else if (n > 0)
-      incr = 1;
+  if (n < 0)
+    {
+      incr = -1;
+      n = -n;
+    }
+  else if (n > 0)
+    incr = 1;
 
-    std::size_t last_good_frame = 0;
+  std::size_t last_good_frame = 0;
 
-    while (true)
-      {
-        frm = m_cs[xframe];
+  while (true)
+    {
+      frm = m_cs[xframe];
 
-        if (frm->is_user_fcn_frame () || frm->is_user_script_frame ()
-            || frm->is_scope_frame ())
-          {
-            last_good_frame = xframe;
+      if (frm->is_user_fcn_frame () || frm->is_user_script_frame ()
+          || frm->is_scope_frame ())
+        {
+          last_good_frame = xframe;
 
-            if (n == 0)
-              break;
+          if (n == 0)
+            break;
 
-            n--;
-          }
+          n--;
+        }
 
-        xframe += incr;
+      xframe += incr;
 
-        if (xframe == 0)
-          {
-            last_good_frame = 0;
-            break;
-          }
+      if (xframe == 0)
+        {
+          last_good_frame = 0;
+          break;
+        }
 
-        if (xframe == m_cs.size ())
-          break;
-      }
+      if (xframe == m_cs.size ())
+        break;
+    }
 
-    if (verbose)
-      m_cs[last_good_frame]->display_stopped_in_message (octave_stdout);
+  if (verbose)
+    m_cs[last_good_frame]->display_stopped_in_message (octave_stdout);
 
-    return last_good_frame;
-  }
+  return last_good_frame;
+}
 
-  // Like dbupdown above but find the starting frame automatically from
-  // the current frame.  If the current frame is already a user
-  // function, script, or scope frame, use that.  Otherwise, follow
-  // the static link for the current frame.  If that is not a user
-  // function, script or scope frame then there is an error in the
-  // implementation.
+// Like dbupdown above but find the starting frame automatically from
+// the current frame.  If the current frame is already a user
+// function, script, or scope frame, use that.  Otherwise, follow
+// the static link for the current frame.  If that is not a user
+// function, script or scope frame then there is an error in the
+// implementation.
 
-  std::size_t call_stack::dbupdown (int n, bool verbose)
-  {
-    std::size_t start = find_current_user_frame ();
+std::size_t call_stack::dbupdown (int n, bool verbose)
+{
+  std::size_t start = find_current_user_frame ();
 
-    return dbupdown (start, n, verbose);
-  }
+  return dbupdown (start, n, verbose);
+}
 
-  // May be used to temporarily change the value ov m_curr_frame inside
-  // a function like evalin.  If used in a function like dbup, the new
-  // value of m_curr_frame would be wiped out when dbup returns and the
-  // stack frame for dbup is popped.
+// May be used to temporarily change the value ov m_curr_frame inside
+// a function like evalin.  If used in a function like dbup, the new
+// value of m_curr_frame would be wiped out when dbup returns and the
+// stack frame for dbup is popped.
 
-  void call_stack::goto_caller_frame (void)
-  {
-    std::size_t start = find_current_user_frame ();
+void call_stack::goto_caller_frame (void)
+{
+  std::size_t start = find_current_user_frame ();
 
-    std::shared_ptr<stack_frame> caller_frame = m_cs[start]->static_link ();
+  std::shared_ptr<stack_frame> caller_frame = m_cs[start]->static_link ();
 
-    // Allow evalin ('caller', ...) to work when called from the
-    // top-level prompt.
+  // Allow evalin ('caller', ...) to work when called from the
+  // top-level prompt.
 
-    m_curr_frame = caller_frame ? caller_frame->index () : 0;
-  }
+  m_curr_frame = caller_frame ? caller_frame->index () : 0;
+}
 
-  void call_stack::goto_base_frame (void)
-  {
-    if (m_curr_frame > 0)
-      m_curr_frame = 0;
-  }
+void call_stack::goto_base_frame (void)
+{
+  if (m_curr_frame > 0)
+    m_curr_frame = 0;
+}
 
-  std::list<std::shared_ptr<stack_frame>>
-  call_stack::backtrace_frames (octave_idx_type& curr_user_frame) const
-  {
-    std::list<std::shared_ptr<stack_frame>> frames;
+std::list<std::shared_ptr<stack_frame>>
+                                     call_stack::backtrace_frames (octave_idx_type& curr_user_frame) const
+{
+  std::list<std::shared_ptr<stack_frame>> frames;
 
-    // curr_frame is the index to the current frame in the overall call
-    // stack, which includes any compiled function frames and scope
-    // frames.  The curr_user_frame value we set is the index into the
-    // subset of frames returned in the octave_map object.
+  // curr_frame is the index to the current frame in the overall call
+  // stack, which includes any compiled function frames and scope
+  // frames.  The curr_user_frame value we set is the index into the
+  // subset of frames returned in the octave_map object.
 
-    std::size_t curr_frame = find_current_user_frame ();
+  std::size_t curr_frame = find_current_user_frame ();
 
-    // Don't include top-level stack frame in the list.
+  // Don't include top-level stack frame in the list.
 
-    for (std::size_t n = m_cs.size () - 1; n > 0; n--)
-      {
-        std::shared_ptr<stack_frame> frm = m_cs[n];
+  for (std::size_t n = m_cs.size () - 1; n > 0; n--)
+    {
+      std::shared_ptr<stack_frame> frm = m_cs[n];
 
-        if (frm->is_user_script_frame () || frm->is_user_fcn_frame ()
-            || frm->is_scope_frame ())
-          {
-            if (frm->index () == curr_frame)
-              curr_user_frame = frames.size ();
+      if (frm->is_user_script_frame () || frm->is_user_fcn_frame ()
+          || frm->is_scope_frame ())
+        {
+          if (frm->index () == curr_frame)
+            curr_user_frame = frames.size ();
 
-            frames.push_back (frm);
-          }
+          frames.push_back (frm);
+        }
 
-        if (n == 0)
-          break;
-      }
+      if (n == 0)
+        break;
+    }
 
-    return frames;
-  }
+  return frames;
+}
 
-  std::list<std::shared_ptr<stack_frame>>
-  call_stack::backtrace_frames (void) const
-  {
-    octave_idx_type curr_user_frame = -1;
+std::list<std::shared_ptr<stack_frame>>
+                                     call_stack::backtrace_frames (void) const
+{
+  octave_idx_type curr_user_frame = -1;
 
-    return backtrace_frames (curr_user_frame);
-  }
+  return backtrace_frames (curr_user_frame);
+}
 
-  std::list<frame_info>
-  call_stack::backtrace_info (octave_idx_type& curr_user_frame,
-                              bool print_subfn) const
-  {
-    std::list<std::shared_ptr<stack_frame>> frames
-      = backtrace_frames (curr_user_frame);
+std::list<frame_info>
+call_stack::backtrace_info (octave_idx_type& curr_user_frame,
+                            bool print_subfn) const
+{
+  std::list<std::shared_ptr<stack_frame>> frames
+                                       = backtrace_frames (curr_user_frame);
 
-    std::list<frame_info> retval;
+  std::list<frame_info> retval;
 
-    for (const auto& frm : frames)
-      {
-        if (frm->is_user_script_frame () || frm->is_user_fcn_frame ()
-            || frm->is_scope_frame ())
-          {
-            retval.push_back (frame_info (frm->fcn_file_name (),
-                                          frm->fcn_name (print_subfn),
-                                          frm->line (), frm->column ()));
-          }
-      }
+  for (const auto& frm : frames)
+    {
+      if (frm->is_user_script_frame () || frm->is_user_fcn_frame ()
+          || frm->is_scope_frame ())
+        {
+          retval.push_back (frame_info (frm->fcn_file_name (),
+                                        frm->fcn_name (print_subfn),
+                                        frm->line (), frm->column ()));
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  std::list<frame_info> call_stack::backtrace_info (void) const
-  {
-    octave_idx_type curr_user_frame = -1;
+std::list<frame_info> call_stack::backtrace_info (void) const
+{
+  octave_idx_type curr_user_frame = -1;
 
-    return backtrace_info (curr_user_frame, true);
-  }
+  return backtrace_info (curr_user_frame, true);
+}
 
-  octave_map call_stack::backtrace (octave_idx_type& curr_user_frame,
-                                    bool print_subfn) const
-  {
-    std::list<std::shared_ptr<stack_frame>> frames
-      = backtrace_frames (curr_user_frame);
+octave_map call_stack::backtrace (octave_idx_type& curr_user_frame,
+                                  bool print_subfn) const
+{
+  std::list<std::shared_ptr<stack_frame>> frames
+                                       = backtrace_frames (curr_user_frame);
 
-    std::size_t nframes = frames.size ();
+  std::size_t nframes = frames.size ();
 
-    octave_map retval (dim_vector (nframes, 1), bt_fields);
+  octave_map retval (dim_vector (nframes, 1), bt_fields);
 
-    Cell& file = retval.contents (0);
-    Cell& name = retval.contents (1);
-    Cell& line = retval.contents (2);
-    Cell& column = retval.contents (3);
+  Cell& file = retval.contents (0);
+  Cell& name = retval.contents (1);
+  Cell& line = retval.contents (2);
+  Cell& column = retval.contents (3);
 
-    octave_idx_type k = 0;
+  octave_idx_type k = 0;
 
-    for (const auto& frm : frames)
-      {
-        if (frm->is_user_script_frame () || frm->is_user_fcn_frame ()
-            || frm->is_scope_frame ())
-          {
-            file(k) = frm->fcn_file_name ();
-            name(k) = frm->fcn_name (print_subfn);
-            line(k) = frm->line ();
-            column(k) = frm->column ();
+  for (const auto& frm : frames)
+    {
+      if (frm->is_user_script_frame () || frm->is_user_fcn_frame ()
+          || frm->is_scope_frame ())
+        {
+          file(k) = frm->fcn_file_name ();
+          name(k) = frm->fcn_name (print_subfn);
+          line(k) = frm->line ();
+          column(k) = frm->column ();
 
-            k++;
-          }
-      }
+          k++;
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_map call_stack::backtrace (void) const
-  {
-    octave_idx_type curr_user_frame = -1;
+octave_map call_stack::backtrace (void) const
+{
+  octave_idx_type curr_user_frame = -1;
 
-    return backtrace (curr_user_frame, true);
-  }
+  return backtrace (curr_user_frame, true);
+}
 
-  octave_map call_stack::empty_backtrace (void) const
-  {
-    return octave_map (dim_vector (0, 1), bt_fields);
-  }
+octave_map call_stack::empty_backtrace (void) const
+{
+  return octave_map (dim_vector (0, 1), bt_fields);
+}
 
-  void call_stack::pop (void)
-  {
-    // Never pop top scope.
-    // FIXME: is it possible for this case to happen?
+void call_stack::pop (void)
+{
+  // Never pop top scope.
+  // FIXME: is it possible for this case to happen?
 
-    if (m_cs.size () > 1)
-      {
-        std::shared_ptr<stack_frame> elt = m_cs.back ();
+  if (m_cs.size () > 1)
+    {
+      std::shared_ptr<stack_frame> elt = m_cs.back ();
 
-        std::shared_ptr<stack_frame> caller = elt->parent_link ();
+      std::shared_ptr<stack_frame> caller = elt->parent_link ();
 
-        m_curr_frame = caller->index ();
+      m_curr_frame = caller->index ();
 
-        if (elt->is_closure_context ())
-          elt->break_closure_cycles (elt);
+      if (elt->is_closure_context ())
+        elt->break_closure_cycles (elt);
 
-        m_cs.pop_back ();
-      }
-  }
+      m_cs.pop_back ();
+    }
+}
 
-  void call_stack::clear (void)
-  {
-    while (! m_cs.empty ())
-      pop ();
-  }
+void call_stack::clear (void)
+{
+  while (! m_cs.empty ())
+    pop ();
+}
 
-  symbol_info_list call_stack::all_variables (void)
-  {
-    return m_cs[m_curr_frame]->all_variables ();
-  }
+symbol_info_list call_stack::all_variables (void)
+{
+  return m_cs[m_curr_frame]->all_variables ();
+}
 
-  std::list<std::string> call_stack::global_variable_names (void) const
-  {
-    std::list<std::string> retval;
+std::list<std::string> call_stack::global_variable_names (void) const
+{
+  std::list<std::string> retval;
 
-    for (const auto& nm_ov : m_global_values)
-      {
-        if (nm_ov.second.is_defined ())
-          retval.push_back (nm_ov.first);
-      }
+  for (const auto& nm_ov : m_global_values)
+    {
+      if (nm_ov.second.is_defined ())
+        retval.push_back (nm_ov.first);
+    }
 
-    retval.sort ();
+  retval.sort ();
 
-    return retval;
-  }
+  return retval;
+}
 
-  std::list<std::string> call_stack::top_level_variable_names (void) const
-  {
-    return m_cs[0]->variable_names ();
-  }
+std::list<std::string> call_stack::top_level_variable_names (void) const
+{
+  return m_cs[0]->variable_names ();
+}
 
-  std::list<std::string> call_stack::variable_names (void) const
-  {
-    return m_cs[m_curr_frame]->variable_names ();
-  }
+std::list<std::string> call_stack::variable_names (void) const
+{
+  return m_cs[m_curr_frame]->variable_names ();
+}
 
-  void call_stack::clear_global_variable (const std::string& name)
-  {
-    auto p = m_global_values.find (name);
+void call_stack::clear_global_variable (const std::string& name)
+{
+  auto p = m_global_values.find (name);
 
-    if (p != m_global_values.end ())
-      p->second = octave_value ();
-  }
+  if (p != m_global_values.end ())
+    p->second = octave_value ();
+}
 
-  void call_stack::clear_global_variable_pattern (const std::string& pattern)
-  {
-    glob_match pat (pattern);
+void call_stack::clear_global_variable_pattern (const std::string& pattern)
+{
+  glob_match pat (pattern);
 
-    for (auto& nm_ov : m_global_values)
-      {
-        if (pat.match (nm_ov.first))
-          nm_ov.second = octave_value ();
-      }
-  }
+  for (auto& nm_ov : m_global_values)
+    {
+      if (pat.match (nm_ov.first))
+        nm_ov.second = octave_value ();
+    }
+}
 
-  void call_stack::clear_global_variable_regexp (const std::string& pattern)
-  {
-    regexp pat (pattern);
+void call_stack::clear_global_variable_regexp (const std::string& pattern)
+{
+  regexp pat (pattern);
 
-    for (auto& nm_ov : m_global_values)
-      {
-        if (pat.is_match (nm_ov.first))
-          nm_ov.second = octave_value ();
-      }
-  }
+  for (auto& nm_ov : m_global_values)
+    {
+      if (pat.is_match (nm_ov.first))
+        nm_ov.second = octave_value ();
+    }
+}
 
-  void call_stack::clear_global_variables (void)
-  {
-    for (auto& nm_ov : m_global_values)
-      nm_ov.second = octave_value ();
-  }
+void call_stack::clear_global_variables (void)
+{
+  for (auto& nm_ov : m_global_values)
+    nm_ov.second = octave_value ();
+}
 
-  symbol_info_list
-  call_stack::glob_symbol_info (const std::string& pattern) const
-  {
-    return m_cs[m_curr_frame]->glob_symbol_info (pattern);
-  }
+symbol_info_list
+call_stack::glob_symbol_info (const std::string& pattern) const
+{
+  return m_cs[m_curr_frame]->glob_symbol_info (pattern);
+}
 
-  symbol_info_list
-  call_stack::regexp_symbol_info (const std::string& pattern) const
-  {
-    return m_cs[m_curr_frame]->regexp_symbol_info (pattern);
-  }
+symbol_info_list
+call_stack::regexp_symbol_info (const std::string& pattern) const
+{
+  return m_cs[m_curr_frame]->regexp_symbol_info (pattern);
+}
 
-  symbol_info_list call_stack::get_symbol_info (void)
-  {
-    return m_cs[m_curr_frame]->get_symbol_info ();
-  }
+symbol_info_list call_stack::get_symbol_info (void)
+{
+  return m_cs[m_curr_frame]->get_symbol_info ();
+}
 
-  symbol_info_list call_stack::top_scope_symbol_info (void) const
-  {
-    return m_cs[0]->get_symbol_info ();
-  }
+symbol_info_list call_stack::top_scope_symbol_info (void) const
+{
+  return m_cs[0]->get_symbol_info ();
+}
 
-  octave_value call_stack::max_stack_depth (const octave_value_list& args,
-                                            int nargout)
-  {
-    return set_internal_variable (m_max_stack_depth, args, nargout,
-                                  "max_stack_depth", 0);
-  }
+octave_value call_stack::max_stack_depth (const octave_value_list& args,
+    int nargout)
+{
+  return set_internal_variable (m_max_stack_depth, args, nargout,
+                                "max_stack_depth", 0);
+}
 
-  void call_stack::make_persistent (const symbol_record& sym)
-  {
-    m_cs[m_curr_frame]->make_persistent (sym);
-  }
+void call_stack::make_persistent (const symbol_record& sym)
+{
+  m_cs[m_curr_frame]->make_persistent (sym);
+}
 
-  void call_stack::make_global (const symbol_record& sym)
-  {
-    m_cs[m_curr_frame]->make_global (sym);
-  }
+void call_stack::make_global (const symbol_record& sym)
+{
+  m_cs[m_curr_frame]->make_global (sym);
+}
 
-  octave_value call_stack::global_varval (const std::string& name) const
-  {
-    auto p = m_global_values.find (name);
+octave_value call_stack::global_varval (const std::string& name) const
+{
+  auto p = m_global_values.find (name);
 
-    return p == m_global_values.end () ? octave_value () : p->second;
-  }
+  return p == m_global_values.end () ? octave_value () : p->second;
+}
 
-  octave_value& call_stack::global_varref (const std::string& name)
-  {
-    return m_global_values[name];
-  }
+octave_value& call_stack::global_varref (const std::string& name)
+{
+  return m_global_values[name];
+}
 
-  octave_value call_stack::get_top_level_value (const std::string& name) const
-  {
-    return m_cs[0]->varval (name);
-  }
+octave_value call_stack::get_top_level_value (const std::string& name) const
+{
+  return m_cs[0]->varval (name);
+}
 
-  void call_stack::set_top_level_value (const std::string& name,
-                                        const octave_value& value)
-  {
-    m_cs[0]->assign (name, value);
-  }
+void call_stack::set_top_level_value (const std::string& name,
+                                      const octave_value& value)
+{
+  m_cs[0]->assign (name, value);
+}
 
-  octave_value call_stack::do_who (int argc, const string_vector& argv,
-                                   bool return_list, bool verbose)
-  {
-    octave_value retval;
+octave_value call_stack::do_who (int argc, const string_vector& argv,
+                                 bool return_list, bool verbose)
+{
+  octave_value retval;
 
-    std::string my_name = argv[0];
+  std::string my_name = argv[0];
 
-    std::string file_name;
+  std::string file_name;
 
-    bool from_file = false;
-    bool global_only = false;
-    bool have_regexp = false;
+  bool from_file = false;
+  bool global_only = false;
+  bool have_regexp = false;
 
-    int i = 1;
-    while (i < argc)
-      {
-        if (argv[i] == "-file")
-          {
-            if (from_file)
-              error ("%s: -file option may only be specified once",
-                     my_name.c_str ());
+  int i = 1;
+  while (i < argc)
+    {
+      if (argv[i] == "-file")
+        {
+          if (from_file)
+            error ("%s: -file option may only be specified once",
+                   my_name.c_str ());
 
-            from_file = true;
+          from_file = true;
 
-            if (i == argc - 1)
-              error ("%s: -file argument must be followed by a filename",
-                     my_name.c_str ());
+          if (i == argc - 1)
+            error ("%s: -file argument must be followed by a filename",
+                   my_name.c_str ());
 
-            file_name = argv[++i];
-          }
-        else if (argv[i] == "-regexp")
-          {
-            have_regexp = true;
-          }
-        else if (argv[i] == "global")
-          global_only = true;
-        else if (argv[i][0] == '-')
-          warning ("%s: unrecognized option '%s'", my_name.c_str (),
-                   argv[i].c_str ());
-        else
-          break;
+          file_name = argv[++i];
+        }
+      else if (argv[i] == "-regexp")
+        {
+          have_regexp = true;
+        }
+      else if (argv[i] == "global")
+        global_only = true;
+      else if (argv[i][0] == '-')
+        warning ("%s: unrecognized option '%s'", my_name.c_str (),
+                 argv[i].c_str ());
+      else
+        break;
 
-        i++;
-      }
+      i++;
+    }
 
-    int npatterns = argc - i;
-    string_vector patterns;
-    if (npatterns > 0)
-      {
-        patterns.resize (npatterns);
-        for (int j = 0; j < npatterns; j++)
-          patterns[j] = argv[i+j];
-      }
-    else
-      {
-        patterns.resize (1);
-        patterns[0] = "*";
-      }
+  int npatterns = argc - i;
+  string_vector patterns;
+  if (npatterns > 0)
+    {
+      patterns.resize (npatterns);
+      for (int j = 0; j < npatterns; j++)
+        patterns[j] = argv[i+j];
+    }
+  else
+    {
+      patterns.resize (1);
+      patterns[0] = "*";
+    }
 
-    if (from_file)
-      {
-        // FIXME: This is an inefficient manner to implement this as the
-        // variables are loaded in to a temporary context and then treated.
-        // It would be better to refactor symbol_info_list to not store the
-        // symbol records and then use it in load-save.cc (do_load) to
-        // implement this option there so that the variables are never
-        // stored at all.
+  if (from_file)
+    {
+      // FIXME: This is an inefficient manner to implement this as the
+      // variables are loaded in to a temporary context and then treated.
+      // It would be better to refactor symbol_info_list to not store the
+      // symbol records and then use it in load-save.cc (do_load) to
+      // implement this option there so that the variables are never
+      // stored at all.
 
-        // Set up temporary scope.
+      // Set up temporary scope.
 
-        symbol_scope tmp_scope ("$dummy_scope$");
+      symbol_scope tmp_scope ("$dummy_scope$");
 
-        push (tmp_scope);
+      push (tmp_scope);
 
-        unwind_action restore_scope ([=] (void) { pop (); });
+      unwind_action restore_scope ([=] (void) { pop (); });
 
-        feval ("load", octave_value (file_name), 0);
+      feval ("load", octave_value (file_name), 0);
 
-        std::string newmsg = "Variables in the file " + file_name + ":\n\n";
+      std::string newmsg = "Variables in the file " + file_name + ":\n\n";
 
-        if (global_only)
-          return do_global_who_two (patterns, have_regexp, return_list,
-                                    verbose, newmsg);
-        else
-          return do_who_two (patterns, have_regexp, return_list, verbose,
-                             newmsg);
-      }
-    else
-      {
-        if (global_only)
-          return do_global_who_two (patterns, have_regexp, return_list,
-                                    verbose);
-        else
-          return do_who_two (patterns, have_regexp, return_list, verbose);
-      }
-  }
+      if (global_only)
+        return do_global_who_two (patterns, have_regexp, return_list,
+                                  verbose, newmsg);
+      else
+        return do_who_two (patterns, have_regexp, return_list, verbose,
+                           newmsg);
+    }
+  else
+    {
+      if (global_only)
+        return do_global_who_two (patterns, have_regexp, return_list,
+                                  verbose);
+      else
+        return do_who_two (patterns, have_regexp, return_list, verbose);
+    }
+}
 
-  octave_value call_stack::do_who_two (const string_vector& patterns,
-                                       bool have_regexp, bool return_list,
-                                       bool verbose, const std::string& msg)
-  {
-    return m_cs[m_curr_frame]->who (patterns, have_regexp, return_list,
-                                    verbose, m_evaluator.whos_line_format (),
-                                    msg);
-  }
+octave_value call_stack::do_who_two (const string_vector& patterns,
+                                     bool have_regexp, bool return_list,
+                                     bool verbose, const std::string& msg)
+{
+  return m_cs[m_curr_frame]->who (patterns, have_regexp, return_list,
+                                  verbose, m_evaluator.whos_line_format (),
+                                  msg);
+}
 
-  octave_value call_stack::do_global_who_two (const string_vector& patterns,
-                                              bool have_regexp,
-                                              bool return_list, bool verbose,
-                                              const std::string& msg)
-  {
-    symbol_info_list symbol_stats;
-    std::list<std::string> symbol_names;
+octave_value call_stack::do_global_who_two (const string_vector& patterns,
+    bool have_regexp,
+    bool return_list, bool verbose,
+    const std::string& msg)
+{
+  symbol_info_list symbol_stats;
+  std::list<std::string> symbol_names;
 
-    octave_idx_type npatterns = patterns.numel ();
+  octave_idx_type npatterns = patterns.numel ();
 
-    for (octave_idx_type j = 0; j < npatterns; j++)
-      {
-        std::string pattern = patterns[j];
+  for (octave_idx_type j = 0; j < npatterns; j++)
+    {
+      std::string pattern = patterns[j];
 
-        std::list<std::string> tmp;
+      std::list<std::string> tmp;
 
-        if (have_regexp)
-          {
-            regexp pat (pattern);
+      if (have_regexp)
+        {
+          regexp pat (pattern);
 
-            for (auto& nm_ov : m_global_values)
-              {
-                if (pat.is_match (nm_ov.first))
-                  tmp.push_back (nm_ov.first);
-              }
-          }
-        else
-          {
-            glob_match pat (pattern);
+          for (auto& nm_ov : m_global_values)
+            {
+              if (pat.is_match (nm_ov.first))
+                tmp.push_back (nm_ov.first);
+            }
+        }
+      else
+        {
+          glob_match pat (pattern);
 
-            for (auto& nm_ov : m_global_values)
-              {
-                if (pat.match (nm_ov.first))
-                  tmp.push_back (nm_ov.first);
-              }
-          }
+          for (auto& nm_ov : m_global_values)
+            {
+              if (pat.match (nm_ov.first))
+                tmp.push_back (nm_ov.first);
+            }
+        }
 
-        for (const auto& nm : tmp)
-          {
-            octave_value value = m_global_values[nm];
+      for (const auto& nm : tmp)
+        {
+          octave_value value = m_global_values[nm];
 
-            if (value.is_defined ())
-              {
-                if (verbose)
-                  {
-                    bool is_formal = false;
-                    bool is_global = true;
-                    bool is_persistent = false;
+          if (value.is_defined ())
+            {
+              if (verbose)
+                {
+                  bool is_formal = false;
+                  bool is_global = true;
+                  bool is_persistent = false;
 
-                    symbol_info syminf (nm, value, is_formal, is_global,
-                                        is_persistent);
+                  symbol_info syminf (nm, value, is_formal, is_global,
+                                      is_persistent);
 
-                    symbol_stats.append (syminf);
-                  }
-                else
-                  symbol_names.push_back (nm);
-              }
-          }
-      }
+                  symbol_stats.append (syminf);
+                }
+              else
+                symbol_names.push_back (nm);
+            }
+        }
+    }
 
-    if (return_list)
-      {
-        if (verbose)
-          {
-            std::string caller_fcn_name;
-            octave_function *caller_fcn = caller_function ();
-            if (caller_fcn)
-              caller_fcn_name = caller_fcn->name ();
+  if (return_list)
+    {
+      if (verbose)
+        {
+          std::string caller_fcn_name;
+          octave_function *caller_fcn = caller_function ();
+          if (caller_fcn)
+            caller_fcn_name = caller_fcn->name ();
 
-            return symbol_stats.map_value (caller_fcn_name, 1);
-          }
-        else
-          return Cell (string_vector (symbol_names));
-      }
-    else if (! (symbol_stats.empty () && symbol_names.empty ()))
-      {
-        if (msg.empty ())
-          octave_stdout << "Global variables:\n\n";
-        else
-          octave_stdout << msg;
+          return symbol_stats.map_value (caller_fcn_name, 1);
+        }
+      else
+        return Cell (string_vector (symbol_names));
+    }
+  else if (! (symbol_stats.empty () && symbol_names.empty ()))
+    {
+      if (msg.empty ())
+        octave_stdout << "Global variables:\n\n";
+      else
+        octave_stdout << msg;
 
-        if (verbose)
-          symbol_stats.display (octave_stdout,
-                                m_evaluator.whos_line_format ());
-        else
-          {
-            string_vector names (symbol_names);
+      if (verbose)
+        symbol_stats.display (octave_stdout,
+                              m_evaluator.whos_line_format ());
+      else
+        {
+          string_vector names (symbol_names);
 
-            names.list_in_columns (octave_stdout);
-          }
+          names.list_in_columns (octave_stdout);
+        }
 
-        octave_stdout << "\n";
-      }
+      octave_stdout << "\n";
+    }
 
-    return octave_value ();
-  }
+  return octave_value ();
+}
 
-  void call_stack::display (void) const
-  {
-    std::ostream& os = octave_stdout;
+void call_stack::display (void) const
+{
+  std::ostream& os = octave_stdout;
 
-    std::size_t nframes = size ();
+  std::size_t nframes = size ();
 
-    for (std::size_t i = 0; i < nframes; i++)
-      {
-        m_cs[i]->display (false);
-        if (i < nframes - 1)
-          os << std::endl;
-      }
-  }
+  for (std::size_t i = 0; i < nframes; i++)
+    {
+      m_cs[i]->display (false);
+      if (i < nframes - 1)
+        os << std::endl;
+    }
+}
 
-  void call_stack::set_auto_fcn_var (stack_frame::auto_var_type avt,
-                                     const octave_value& val)
-  {
-    m_cs[m_curr_frame]->set_auto_fcn_var (avt, val);
-  }
+void call_stack::set_auto_fcn_var (stack_frame::auto_var_type avt,
+                                   const octave_value& val)
+{
+  m_cs[m_curr_frame]->set_auto_fcn_var (avt, val);
+}
 
-  octave_value call_stack::get_auto_fcn_var (stack_frame::auto_var_type avt) const
-  {
-    return m_cs[m_curr_frame]->get_auto_fcn_var (avt);
-  }
+octave_value call_stack::get_auto_fcn_var (stack_frame::auto_var_type avt) const
+{
+  return m_cs[m_curr_frame]->get_auto_fcn_var (avt);
+}
 
 DEFMETHOD (max_stack_depth, interp, args, nargout,
            doc: /* -*- texinfo -*-