--- a/libinterp/corefcn/symtab.cc	Thu Dec 01 14:23:45 2022 -0800
+++ b/libinterp/corefcn/symtab.cc	Thu Dec 01 18:02:15 2022 -0800
@@ -50,677 +50,678 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  symbol_table::symbol_table (interpreter& interp)
-    : m_interpreter (interp), m_fcn_table (), m_class_precedence_table (),
-      m_parent_map ()
-  {
-    install_builtins ();
-  }
+symbol_table::symbol_table (interpreter& interp)
+  : m_interpreter (interp), m_fcn_table (), m_class_precedence_table (),
+    m_parent_map ()
+{
+  install_builtins ();
+}
 
-  symbol_scope symbol_table::current_scope (void) const
-  {
-    tree_evaluator& tw = m_interpreter.get_evaluator ();
+symbol_scope symbol_table::current_scope (void) const
+{
+  tree_evaluator& tw = m_interpreter.get_evaluator ();
 
-    return tw.get_current_scope ();
-  }
+  return tw.get_current_scope ();
+}
 
-  bool symbol_table::is_built_in_function_name (const std::string& name)
-  {
-    octave_value val = find_built_in_function (name);
+bool symbol_table::is_built_in_function_name (const std::string& name)
+{
+  octave_value val = find_built_in_function (name);
 
-    return val.is_defined ();
-  }
+  return val.is_defined ();
+}
 
-  octave_value
-  symbol_table::find_scoped_function (const std::string& name,
-                                      const symbol_scope& search_scope)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value
+symbol_table::find_scoped_function (const std::string& name,
+                                    const symbol_scope& search_scope)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    fcn_table_const_iterator p = m_fcn_table.find (name);
+  fcn_table_const_iterator p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      return p->second.find_scoped_function (search_scope);
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find_scoped_function (search_scope);
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find_scoped_function (search_scope);
+      octave_value fcn = finfo.find_scoped_function (search_scope);
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
-  }
+      return fcn;
+    }
+}
 
-  octave_value
-  symbol_table::find_private_function (const std::string& dir_name,
-                                       const std::string& name)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value
+symbol_table::find_private_function (const std::string& dir_name,
+                                     const std::string& name)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    fcn_table_const_iterator p = m_fcn_table.find (name);
+  fcn_table_const_iterator p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      return p->second.find_private_function (dir_name);
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find_private_function (dir_name);
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find_private_function (dir_name);
+      octave_value fcn = finfo.find_private_function (dir_name);
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
-  }
+      return fcn;
+    }
+}
 
-  // FIXME: this function only finds legacy class methods, not
-  // classdef methods.
+// FIXME: this function only finds legacy class methods, not
+// classdef methods.
 
-  octave_value symbol_table::find_method (const std::string& name,
-                                          const std::string& dispatch_type)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value symbol_table::find_method (const std::string& name,
+                                        const std::string& dispatch_type)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    fcn_table_const_iterator p = m_fcn_table.find (name);
+  fcn_table_const_iterator p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      return p->second.find_method (dispatch_type);
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find_method (dispatch_type);
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find_method (dispatch_type);
+      octave_value fcn = finfo.find_method (dispatch_type);
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
-  }
+      return fcn;
+    }
+}
 
-  octave_value symbol_table::find_built_in_function (const std::string& name)
-  {
-    fcn_table_const_iterator p = m_fcn_table.find (name);
+octave_value symbol_table::find_built_in_function (const std::string& name)
+{
+  fcn_table_const_iterator p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      return p->second.find_built_in_function ();
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find_built_in_function ();
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find_built_in_function ();
+      octave_value fcn = finfo.find_built_in_function ();
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
-  }
+      return fcn;
+    }
+}
 
-  octave_value symbol_table::find_autoload (const std::string& name)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value symbol_table::find_autoload (const std::string& name)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    auto p = m_fcn_table.find (name);
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      return p->second.find_autoload ();
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find_autoload ();
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find_autoload ();
+      octave_value fcn = finfo.find_autoload ();
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
-  }
+      return fcn;
+    }
+}
 
-  octave_value
-  symbol_table::builtin_find (const std::string& name,
-                              const symbol_scope& search_scope_arg)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value
+symbol_table::builtin_find (const std::string& name,
+                            const symbol_scope& search_scope_arg)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    fcn_table_iterator p = m_fcn_table.find (name);
+  fcn_table_iterator p = m_fcn_table.find (name);
 
-    symbol_scope search_scope
-      = (search_scope_arg ? search_scope_arg : current_scope ());
+  symbol_scope search_scope
+    = (search_scope_arg ? search_scope_arg : current_scope ());
 
-    if (p != m_fcn_table.end ())
-      return p->second.builtin_find (search_scope);
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.builtin_find (search_scope);
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.builtin_find (search_scope);
+      octave_value fcn = finfo.builtin_find (search_scope);
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
+      return fcn;
+    }
 
-    return octave_value ();
-  }
+  return octave_value ();
+}
 
-  octave_value
-  symbol_table::fcn_table_find (const std::string& name,
-                                const octave_value_list& args,
-                                const symbol_scope& search_scope_arg)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value
+symbol_table::fcn_table_find (const std::string& name,
+                              const octave_value_list& args,
+                              const symbol_scope& search_scope_arg)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    fcn_table_iterator p = m_fcn_table.find (name);
+  fcn_table_iterator p = m_fcn_table.find (name);
 
-    symbol_scope search_scope
-      = (search_scope_arg ? search_scope_arg : current_scope ());
+  symbol_scope search_scope
+    = (search_scope_arg ? search_scope_arg : current_scope ());
 
-    if (p != m_fcn_table.end ())
-      return p->second.find (search_scope, args);
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find (search_scope, args);
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find (search_scope, args);
+      octave_value fcn = finfo.find (search_scope, args);
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
+      return fcn;
+    }
 
-    return octave_value ();
-  }
+  return octave_value ();
+}
 
-  octave_value
-  symbol_table::find_function (const std::string& name,
-                               const symbol_scope& search_scope_arg)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value
+symbol_table::find_function (const std::string& name,
+                             const symbol_scope& search_scope_arg)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    if (name[0] == '@')
-      {
-        std::size_t pos = name.find_first_of ('/');
+  if (name[0] == '@')
+    {
+      std::size_t pos = name.find_first_of ('/');
 
-        if (pos == std::string::npos)
-          return octave_value ();
+      if (pos == std::string::npos)
+        return octave_value ();
 
-        std::string method = name.substr (pos+1);
-        std::string dispatch_type = name.substr (1, pos-1);
+      std::string method = name.substr (pos+1);
+      std::string dispatch_type = name.substr (1, pos-1);
 
-        return find_method (method, dispatch_type);
-      }
-    else
-      {
-        symbol_scope search_scope
-          = (search_scope_arg ? search_scope_arg : current_scope ());
+      return find_method (method, dispatch_type);
+    }
+  else
+    {
+      symbol_scope search_scope
+        = (search_scope_arg ? search_scope_arg : current_scope ());
 
-        return find_function (name, ovl (), search_scope);
-      }
-  }
+      return find_function (name, ovl (), search_scope);
+    }
+}
 
-  octave_value
-  symbol_table::find_function (const std::string& name,
-                               const octave_value_list& args,
-                               const symbol_scope& search_scope)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value
+symbol_table::find_function (const std::string& name,
+                             const octave_value_list& args,
+                             const symbol_scope& search_scope)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    return fcn_table_find (name, args, search_scope);
-  }
+  return fcn_table_find (name, args, search_scope);
+}
 
-  octave_value
-  symbol_table::find_user_function (const std::string& name)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value
+symbol_table::find_user_function (const std::string& name)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    auto p = m_fcn_table.find (name);
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      return p->second.find_user_function ();
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find_user_function ();
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find_user_function ();
+      octave_value fcn = finfo.find_user_function ();
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
-  }
+      return fcn;
+    }
+}
 
-  octave_value symbol_table::find_cmdline_function (const std::string& name)
-  {
-    if (name.empty ())
-      return octave_value ();
+octave_value symbol_table::find_cmdline_function (const std::string& name)
+{
+  if (name.empty ())
+    return octave_value ();
 
-    auto p = m_fcn_table.find (name);
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      return p->second.find_cmdline_function ();
-    else
-      {
-        fcn_info finfo (name);
+  if (p != m_fcn_table.end ())
+    return p->second.find_cmdline_function ();
+  else
+    {
+      fcn_info finfo (name);
 
-        octave_value fcn = finfo.find_cmdline_function ();
+      octave_value fcn = finfo.find_cmdline_function ();
 
-        if (fcn.is_defined ())
-          m_fcn_table[name] = finfo;
+      if (fcn.is_defined ())
+        m_fcn_table[name] = finfo;
 
-        return fcn;
-      }
-  }
+      return fcn;
+    }
+}
 
-  void symbol_table::install_cmdline_function (const std::string& name,
-                                               const octave_value& fcn)
-  {
-    auto p = m_fcn_table.find (name);
+void symbol_table::install_cmdline_function (const std::string& name,
+    const octave_value& fcn)
+{
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      {
-        fcn_info& finfo = p->second;
+  if (p != m_fcn_table.end ())
+    {
+      fcn_info& finfo = p->second;
 
-        finfo.install_cmdline_function (fcn);
-      }
-    else
-      {
-        fcn_info finfo (name);
+      finfo.install_cmdline_function (fcn);
+    }
+  else
+    {
+      fcn_info finfo (name);
 
-        finfo.install_cmdline_function (fcn);
+      finfo.install_cmdline_function (fcn);
 
-        m_fcn_table[name] = finfo;
-      }
-  }
+      m_fcn_table[name] = finfo;
+    }
+}
 
-  // Install local function FCN named NAME.  FILE_NAME is the name of
-  // the file containing the local function.
+// Install local function FCN named NAME.  FILE_NAME is the name of
+// the file containing the local function.
 
-  void symbol_table::install_local_function (const std::string& name,
-                                             const octave_value& fcn,
-                                             const std::string& file_name)
-  {
-    auto p = m_fcn_table.find (name);
+void symbol_table::install_local_function (const std::string& name,
+    const octave_value& fcn,
+    const std::string& file_name)
+{
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      {
-        fcn_info& finfo = p->second;
+  if (p != m_fcn_table.end ())
+    {
+      fcn_info& finfo = p->second;
 
-        finfo.install_local_function (fcn, file_name);
-      }
-    else
-      {
-        fcn_info finfo (name);
+      finfo.install_local_function (fcn, file_name);
+    }
+  else
+    {
+      fcn_info finfo (name);
 
-        finfo.install_local_function (fcn, file_name);
+      finfo.install_local_function (fcn, file_name);
 
-        m_fcn_table[name] = finfo;
-      }
-  }
+      m_fcn_table[name] = finfo;
+    }
+}
 
-  void symbol_table::install_user_function (const std::string& name,
-                                            const octave_value& fcn)
-  {
-    auto p = m_fcn_table.find (name);
+void symbol_table::install_user_function (const std::string& name,
+    const octave_value& fcn)
+{
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      {
-        fcn_info& finfo = p->second;
+  if (p != m_fcn_table.end ())
+    {
+      fcn_info& finfo = p->second;
 
-        finfo.install_user_function (fcn);
-      }
-    else
-      {
-        fcn_info finfo (name);
+      finfo.install_user_function (fcn);
+    }
+  else
+    {
+      fcn_info finfo (name);
 
-        finfo.install_user_function (fcn);
+      finfo.install_user_function (fcn);
 
-        m_fcn_table[name] = finfo;
-      }
-  }
+      m_fcn_table[name] = finfo;
+    }
+}
 
-  // FIXME: should we ensure that FCN really is a built-in function
-  // object?
-  void symbol_table::install_built_in_function (const std::string& name,
-                                                const octave_value& fcn)
-  {
-    auto p = m_fcn_table.find (name);
+// FIXME: should we ensure that FCN really is a built-in function
+// object?
+void symbol_table::install_built_in_function (const std::string& name,
+    const octave_value& fcn)
+{
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      {
-        fcn_info& finfo = p->second;
+  if (p != m_fcn_table.end ())
+    {
+      fcn_info& finfo = p->second;
 
-        finfo.install_built_in_function (fcn);
-      }
-    else
-      {
-        fcn_info finfo (name);
+      finfo.install_built_in_function (fcn);
+    }
+  else
+    {
+      fcn_info finfo (name);
 
-        finfo.install_built_in_function (fcn);
+      finfo.install_built_in_function (fcn);
 
-        m_fcn_table[name] = finfo;
-      }
-  }
+      m_fcn_table[name] = finfo;
+    }
+}
 
-  // This is written as two separate functions instead of a single
-  // function with default values so that it will work properly with
-  // unwind_protect.
+// This is written as two separate functions instead of a single
+// function with default values so that it will work properly with
+// unwind_protect.
 
-  void symbol_table::clear_functions (bool force)
-  {
-    auto p = m_fcn_table.begin ();
+void symbol_table::clear_functions (bool force)
+{
+  auto p = m_fcn_table.begin ();
 
-    while (p != m_fcn_table.end ())
-      (p++)->second.clear (force);
-  }
+  while (p != m_fcn_table.end ())
+    (p++)->second.clear (force);
+}
 
-  void symbol_table::clear_function (const std::string& name)
-  {
-    clear_user_function (name);
-  }
+void symbol_table::clear_function (const std::string& name)
+{
+  clear_user_function (name);
+}
 
-  void symbol_table::clear_function_pattern (const std::string& pat)
-  {
-    glob_match pattern (pat);
+void symbol_table::clear_function_pattern (const std::string& pat)
+{
+  glob_match pattern (pat);
 
-    auto p = m_fcn_table.begin ();
+  auto p = m_fcn_table.begin ();
 
-    while (p != m_fcn_table.end ())
-      {
-        if (pattern.match (p->first))
-          (p++)->second.clear_user_function ();
-        else
-          p++;
-      }
-  }
+  while (p != m_fcn_table.end ())
+    {
+      if (pattern.match (p->first))
+        (p++)->second.clear_user_function ();
+      else
+        p++;
+    }
+}
 
-  void symbol_table::clear_function_regexp (const std::string& pat)
-  {
-    regexp pattern (pat);
+void symbol_table::clear_function_regexp (const std::string& pat)
+{
+  regexp pattern (pat);
 
-    auto p = m_fcn_table.begin ();
+  auto p = m_fcn_table.begin ();
 
-    while (p != m_fcn_table.end ())
-      {
-        if (pattern.is_match (p->first))
-          (p++)->second.clear_user_function ();
-        else
-          p++;
-      }
-  }
+  while (p != m_fcn_table.end ())
+    {
+      if (pattern.is_match (p->first))
+        (p++)->second.clear_user_function ();
+      else
+        p++;
+    }
+}
 
-  void symbol_table::clear_user_function (const std::string& name)
-  {
-    auto p = m_fcn_table.find (name);
+void symbol_table::clear_user_function (const std::string& name)
+{
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      {
-        fcn_info& finfo = p->second;
+  if (p != m_fcn_table.end ())
+    {
+      fcn_info& finfo = p->second;
 
-        finfo.clear_user_function ();
-      }
-    // FIXME: is this necessary, or even useful?
-    // else
-    //   error ("clear: no such function '%s'", name.c_str ());
-  }
+      finfo.clear_user_function ();
+    }
+  // FIXME: is this necessary, or even useful?
+  // else
+  //   error ("clear: no such function '%s'", name.c_str ());
+}
 
-  // This clears oct and mex files, including autoloads.
-  void symbol_table::clear_dld_function (const std::string& name)
-  {
-    auto p = m_fcn_table.find (name);
+// This clears oct and mex files, including autoloads.
+void symbol_table::clear_dld_function (const std::string& name)
+{
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      {
-        fcn_info& finfo = p->second;
+  if (p != m_fcn_table.end ())
+    {
+      fcn_info& finfo = p->second;
 
-        finfo.clear_autoload_function ();
-        finfo.clear_user_function ();
-      }
-  }
+      finfo.clear_autoload_function ();
+      finfo.clear_user_function ();
+    }
+}
 
-  void symbol_table::clear_mex_functions (void)
-  {
-    auto p = m_fcn_table.begin ();
+void symbol_table::clear_mex_functions (void)
+{
+  auto p = m_fcn_table.begin ();
 
-    while (p != m_fcn_table.end ())
-      (p++)->second.clear_mex_function ();
-  }
+  while (p != m_fcn_table.end ())
+    (p++)->second.clear_mex_function ();
+}
 
-  // Insert INF_CLASS in the set of class names that are considered
-  // inferior to SUP_CLASS.  Return FALSE if INF_CLASS is currently
-  // marked as superior to SUP_CLASS.
+// Insert INF_CLASS in the set of class names that are considered
+// inferior to SUP_CLASS.  Return FALSE if INF_CLASS is currently
+// marked as superior to SUP_CLASS.
 
-  bool symbol_table::set_class_relationship (const std::string& sup_class,
-                                             const std::string& inf_class)
-  {
-    if (is_superiorto (inf_class, sup_class))
-      return false;
+bool symbol_table::set_class_relationship (const std::string& sup_class,
+    const std::string& inf_class)
+{
+  if (is_superiorto (inf_class, sup_class))
+    return false;
 
-    // If sup_class doesn't have an entry in the precedence table,
-    // this will automatically create it, and associate to it a
-    // singleton set {inf_class} of inferior classes.
-    m_class_precedence_table[sup_class].insert (inf_class);
+  // If sup_class doesn't have an entry in the precedence table,
+  // this will automatically create it, and associate to it a
+  // singleton set {inf_class} of inferior classes.
+  m_class_precedence_table[sup_class].insert (inf_class);
 
-    return true;
-  }
+  return true;
+}
 
-  // Has class A been marked as superior to class B?  Also returns
-  // TRUE if B has been marked as inferior to A, since we only keep
-  // one table, and convert inferiorto information to a superiorto
-  // relationship.  Two calls are required to determine whether there
-  // is no relationship between two classes:
-  //
-  //  if (symbol_table::is_superiorto (a, b))
-  //    // A is superior to B, or B has been marked inferior to A.
-  //  else if (symbol_table::is_superiorto (b, a))
-  //    // B is superior to A, or A has been marked inferior to B.
-  //  else
-  //    // No relation.
+// Has class A been marked as superior to class B?  Also returns
+// TRUE if B has been marked as inferior to A, since we only keep
+// one table, and convert inferiorto information to a superiorto
+// relationship.  Two calls are required to determine whether there
+// is no relationship between two classes:
+//
+//  if (symbol_table::is_superiorto (a, b))
+//    // A is superior to B, or B has been marked inferior to A.
+//  else if (symbol_table::is_superiorto (b, a))
+//    // B is superior to A, or A has been marked inferior to B.
+//  else
+//    // No relation.
 
-  bool symbol_table::is_superiorto (const std::string& a, const std::string& b)
-  {
-    class_precedence_table_const_iterator p = m_class_precedence_table.find (a);
-    // If a has no entry in the precedence table, return false
-    if (p == m_class_precedence_table.end ())
-      return false;
+bool symbol_table::is_superiorto (const std::string& a, const std::string& b)
+{
+  class_precedence_table_const_iterator p = m_class_precedence_table.find (a);
+  // If a has no entry in the precedence table, return false
+  if (p == m_class_precedence_table.end ())
+    return false;
 
-    const std::set<std::string>& inferior_classes = p->second;
-    std::set<std::string>::const_iterator q = inferior_classes.find (b);
-    return (q != inferior_classes.end ());
-  }
+  const std::set<std::string>& inferior_classes = p->second;
+  std::set<std::string>::const_iterator q = inferior_classes.find (b);
+  return (q != inferior_classes.end ());
+}
 
-  void symbol_table::alias_built_in_function (const std::string& alias,
-                                              const std::string& name)
-  {
-    octave_value fcn = find_built_in_function (name);
+void symbol_table::alias_built_in_function (const std::string& alias,
+    const std::string& name)
+{
+  octave_value fcn = find_built_in_function (name);
 
-    if (fcn.is_defined ())
-      {
-        fcn_info finfo (alias);
+  if (fcn.is_defined ())
+    {
+      fcn_info finfo (alias);
 
-        finfo.install_built_in_function (fcn);
+      finfo.install_built_in_function (fcn);
 
-        m_fcn_table[alias] = finfo;
-      }
-    else
-      panic ("alias: '%s' is undefined", name.c_str ());
-  }
+      m_fcn_table[alias] = finfo;
+    }
+  else
+    panic ("alias: '%s' is undefined", name.c_str ());
+}
 
-  void symbol_table::install_built_in_dispatch (const std::string& name,
-                                                const std::string& klass)
-  {
-    auto p = m_fcn_table.find (name);
+void symbol_table::install_built_in_dispatch (const std::string& name,
+    const std::string& klass)
+{
+  auto p = m_fcn_table.find (name);
 
-    if (p != m_fcn_table.end ())
-      {
-        fcn_info& finfo = p->second;
+  if (p != m_fcn_table.end ())
+    {
+      fcn_info& finfo = p->second;
 
-        finfo.install_built_in_dispatch (klass);
-      }
-    else
-      error ("install_built_in_dispatch: '%s' is undefined", name.c_str ());
-  }
+      finfo.install_built_in_dispatch (klass);
+    }
+  else
+    error ("install_built_in_dispatch: '%s' is undefined", name.c_str ());
+}
 
-  std::list<std::string> symbol_table::user_function_names (void)
-  {
-    std::list<std::string> retval;
+std::list<std::string> symbol_table::user_function_names (void)
+{
+  std::list<std::string> retval;
 
-    for (const auto& nm_finfo : m_fcn_table)
-      {
-        if (nm_finfo.second.is_user_function_defined ())
-          retval.push_back (nm_finfo.first);
-      }
+  for (const auto& nm_finfo : m_fcn_table)
+    {
+      if (nm_finfo.second.is_user_function_defined ())
+        retval.push_back (nm_finfo.first);
+    }
 
-    if (! retval.empty ())
-      retval.sort ();
+  if (! retval.empty ())
+    retval.sort ();
 
-    return retval;
-  }
+  return retval;
+}
 
-  std::list<std::string> symbol_table::built_in_function_names (void)
-  {
-    std::list<std::string> retval;
+std::list<std::string> symbol_table::built_in_function_names (void)
+{
+  std::list<std::string> retval;
 
-    for (const auto& nm_finfo : m_fcn_table)
-      {
-        octave_value fcn = nm_finfo.second.find_built_in_function ();
+  for (const auto& nm_finfo : m_fcn_table)
+    {
+      octave_value fcn = nm_finfo.second.find_built_in_function ();
 
-        if (fcn.is_defined ())
-          retval.push_back (nm_finfo.first);
-      }
+      if (fcn.is_defined ())
+        retval.push_back (nm_finfo.first);
+    }
 
-    if (! retval.empty ())
-      retval.sort ();
+  if (! retval.empty ())
+    retval.sort ();
 
-    return retval;
-  }
+  return retval;
+}
 
-  std::list<std::string> symbol_table::cmdline_function_names (void)
-  {
-    std::list<std::string> retval;
+std::list<std::string> symbol_table::cmdline_function_names (void)
+{
+  std::list<std::string> retval;
 
-    for (const auto& nm_finfo : m_fcn_table)
-      {
-        octave_value fcn = nm_finfo.second.find_cmdline_function ();
+  for (const auto& nm_finfo : m_fcn_table)
+    {
+      octave_value fcn = nm_finfo.second.find_cmdline_function ();
 
-        if (fcn.is_defined ())
-          retval.push_back (nm_finfo.first);
-      }
+      if (fcn.is_defined ())
+        retval.push_back (nm_finfo.first);
+    }
 
-    if (! retval.empty ())
-      retval.sort ();
+  if (! retval.empty ())
+    retval.sort ();
 
-    return retval;
-  }
+  return retval;
+}
 
-  template <template <typename, typename...> class C, typename V,
-            typename... A>
-  static octave_value
-  dump_container_map (const std::map<std::string, C<V, A...>>& container_map)
-  {
-    if (container_map.empty ())
-      return octave_value (Matrix ());
+template <template <typename, typename...> class C, typename V,
+          typename... A>
+static octave_value
+dump_container_map (const std::map<std::string, C<V, A...>>& container_map)
+{
+  if (container_map.empty ())
+    return octave_value (Matrix ());
 
-    std::map<std::string, octave_value> info_map;
+  std::map<std::string, octave_value> info_map;
 
-    for (const auto& nm_container : container_map)
-      {
-        std::string nm = nm_container.first;
-        const C<V, A...>& container = nm_container.second;
-        info_map[nm] = Cell (container);
-      }
+  for (const auto& nm_container : container_map)
+    {
+      std::string nm = nm_container.first;
+      const C<V, A...>& container = nm_container.second;
+      info_map[nm] = Cell (container);
+    }
 
-    return octave_value (info_map);
-  }
+  return octave_value (info_map);
+}
 
-  octave_value symbol_table::dump (void) const
-  {
-    std::map<std::string, octave_value> m
-      = {{ "function_info", dump_fcn_table_map () },
-         { "precedence_table", dump_container_map (m_class_precedence_table) },
-         { "parent_classes", dump_container_map (m_parent_map) }};
+octave_value symbol_table::dump (void) const
+{
+  std::map<std::string, octave_value> m
+  = {{ "function_info", dump_fcn_table_map () },
+    { "precedence_table", dump_container_map (m_class_precedence_table) },
+    { "parent_classes", dump_container_map (m_parent_map) }
+  };
 
-    return octave_value (m);
-  }
+  return octave_value (m);
+}
 
-  void symbol_table::add_to_parent_map (const std::string& classname,
-                          const std::list<std::string>& parent_list)
-  {
-    m_parent_map[classname] = parent_list;
-  }
+void symbol_table::add_to_parent_map (const std::string& classname,
+                                      const std::list<std::string>& parent_list)
+{
+  m_parent_map[classname] = parent_list;
+}
 
-  std::list<std::string> symbol_table::parent_classes (const std::string& dispatch_type)
-  {
-    std::list<std::string> retval;
+std::list<std::string> symbol_table::parent_classes (const std::string& dispatch_type)
+{
+  std::list<std::string> retval;
 
-    const_parent_map_iterator it = m_parent_map.find (dispatch_type);
+  const_parent_map_iterator it = m_parent_map.find (dispatch_type);
 
-    if (it != m_parent_map.end ())
-      retval = it->second;
+  if (it != m_parent_map.end ())
+    retval = it->second;
 
-    for (const auto& nm : retval)
-      {
-        // Search for parents of parents and append them to the list.
+  for (const auto& nm : retval)
+    {
+      // Search for parents of parents and append them to the list.
 
-        // FIXME: should we worry about a circular inheritance graph?
+      // FIXME: should we worry about a circular inheritance graph?
 
-        std::list<std::string> parents = parent_classes (nm);
+      std::list<std::string> parents = parent_classes (nm);
 
-        if (! parents.empty ())
-          retval.insert (retval.end (), parents.begin (), parents.end ());
-      }
+      if (! parents.empty ())
+        retval.insert (retval.end (), parents.begin (), parents.end ());
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  void symbol_table::cleanup (void)
-  {
-    clear_functions ();
+void symbol_table::cleanup (void)
+{
+  clear_functions ();
 
-    m_fcn_table.clear ();
-    m_class_precedence_table.clear ();
-    m_parent_map.clear ();
-  }
+  m_fcn_table.clear ();
+  m_class_precedence_table.clear ();
+  m_parent_map.clear ();
+}
 
-  fcn_info * symbol_table::get_fcn_info (const std::string& name)
-  {
-    auto p = m_fcn_table.find (name);
-    return p != m_fcn_table.end () ? &p->second : nullptr;
-  }
+fcn_info *symbol_table::get_fcn_info (const std::string& name)
+{
+  auto p = m_fcn_table.find (name);
+  return p != m_fcn_table.end () ? &p->second : nullptr;
+}
 
-  octave_value symbol_table::dump_fcn_table_map (void) const
-  {
-    if (m_fcn_table.empty ())
-      return octave_value (Matrix ());
+octave_value symbol_table::dump_fcn_table_map (void) const
+{
+  if (m_fcn_table.empty ())
+    return octave_value (Matrix ());
 
-    std::map<std::string, octave_value> info_map;
+  std::map<std::string, octave_value> info_map;
 
-    for (const auto& nm_finfo : m_fcn_table)
-      {
-        std::string nm = nm_finfo.first;
-        const fcn_info& finfo = nm_finfo.second;
-        info_map[nm] = finfo.dump ();
-      }
+  for (const auto& nm_finfo : m_fcn_table)
+    {
+      std::string nm = nm_finfo.first;
+      const fcn_info& finfo = nm_finfo.second;
+      info_map[nm] = finfo.dump ();
+    }
 
-    return octave_value (info_map);
-  }
+  return octave_value (info_map);
+}
 
 DEFMETHOD (__dump_symtab_info__, interp, args, ,
            doc: /* -*- texinfo -*-
@@ -740,7 +741,8 @@
     return symtab.dump ();
   else
     {
-      std::string fname = args(0).xstring_value ("__dump_symtab_info__: argument must be a function name");
+      std::string fname = args(
+                            0).xstring_value ("__dump_symtab_info__: argument must be a function name");
 
       fcn_info *finfo = symtab.get_fcn_info (fname);
 
@@ -760,7 +762,8 @@
   if (args.length () != 1)
     print_usage ();
 
-  std::string name = args(0).xstring_value ("__get_cmdline_fcn_txt__: first argument must be function name");
+  std::string name = args(
+                       0).xstring_value ("__get_cmdline_fcn_txt__: first argument must be function name");
 
   symbol_table& symtab = interp.get_symbol_table ();