--- a/libinterp/parse-tree/profiler.cc	Thu Dec 01 14:23:45 2022 -0800
+++ b/libinterp/parse-tree/profiler.cc	Thu Dec 01 18:02:15 2022 -0800
@@ -37,350 +37,350 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  profiler::stats::stats (void)
-    : m_time (0.0), m_calls (0), m_recursive (false),
-      m_parents (), m_children ()
-  { }
+profiler::stats::stats (void)
+  : m_time (0.0), m_calls (0), m_recursive (false),
+    m_parents (), m_children ()
+{ }
+
+octave_value
+profiler::stats::function_set_value (const function_set& list)
+{
+  const octave_idx_type n = list.size ();
+
+  RowVector retval (n);
+  octave_idx_type i = 0;
+  for (const auto& nm : list)
+    retval(i++) = nm;
 
-  octave_value
-  profiler::stats::function_set_value (const function_set& list)
-  {
-    const octave_idx_type n = list.size ();
+  return retval;
+}
+
+profiler::tree_node::tree_node (tree_node *p, octave_idx_type f)
+  : m_parent (p), m_fcn_id (f), m_children (), m_time (0.0), m_calls (0)
+{ }
 
-    RowVector retval (n);
-    octave_idx_type i = 0;
-    for (const auto& nm : list)
-      retval(i++) = nm;
+profiler::tree_node::~tree_node ()
+{
+  for (auto& idx_tnode : m_children)
+    delete idx_tnode.second;
+}
+
+profiler::tree_node *
+profiler::tree_node::enter (octave_idx_type fcn)
+{
+  tree_node *retval;
 
-    return retval;
-  }
+  child_map::iterator pos = m_children.find (fcn);
+  if (pos == m_children.end ())
+    {
+      retval = new tree_node (this, fcn);
+      m_children[fcn] = retval;
+    }
+  else
+    retval = pos->second;
 
-  profiler::tree_node::tree_node (tree_node *p, octave_idx_type f)
-    : m_parent (p), m_fcn_id (f), m_children (), m_time (0.0), m_calls (0)
-  { }
+  ++retval->m_calls;
+  return retval;
+}
 
-  profiler::tree_node::~tree_node ()
-  {
-    for (auto& idx_tnode : m_children)
-      delete idx_tnode.second;
-  }
+profiler::tree_node *
+profiler::tree_node::exit (octave_idx_type /* fcn */)
+{
+  // FIXME: These panic_unless statements don't make sense if profile() is
+  //  called from within a function hierarchy to begin with.  See bug #39587.
+  //  panic_unless (m_parent);
+  //  panic_unless (m_fcn_id == fcn);
 
-  profiler::tree_node*
-  profiler::tree_node::enter (octave_idx_type fcn)
-  {
-    tree_node *retval;
+  return m_parent;
+}
+
+void
+profiler::tree_node::build_flat (flat_profile& data) const
+{
+  // If this is not the top-level node,
+  // update profile entry for this function.
+  if (m_fcn_id != 0)
+    {
+      stats& entry = data[m_fcn_id - 1];
 
-    child_map::iterator pos = m_children.find (fcn);
-    if (pos == m_children.end ())
-      {
-        retval = new tree_node (this, fcn);
-        m_children[fcn] = retval;
-      }
-    else
-      retval = pos->second;
+      entry.m_time += m_time;
+      entry.m_calls += m_calls;
+
+      panic_unless (m_parent);
+      if (m_parent->m_fcn_id != 0)
+        {
+          entry.m_parents.insert (m_parent->m_fcn_id);
+          data[m_parent->m_fcn_id - 1].m_children.insert (m_fcn_id);
+        }
 
-    ++retval->m_calls;
-    return retval;
-  }
+      if (! entry.m_recursive)
+        for (const tree_node *i = m_parent; i; i = i->m_parent)
+          if (i->m_fcn_id == m_fcn_id)
+            {
+              entry.m_recursive = true;
+              break;
+            }
+    }
 
-  profiler::tree_node*
-  profiler::tree_node::exit (octave_idx_type /* fcn */)
-  {
-    // FIXME: These panic_unless statements don't make sense if profile() is
-    //  called from within a function hierarchy to begin with.  See bug #39587.
-    //  panic_unless (m_parent);
-    //  panic_unless (m_fcn_id == fcn);
+  // Recurse on children.
+  for (const auto& idx_tnode : m_children)
+    idx_tnode.second->build_flat (data);
+}
+
+octave_value
+profiler::tree_node::get_hierarchical (double *total) const
+{
+  // Note that we don't generate the entry just for this node, but
+  // rather a struct-array with entries for all children.  This way, the
+  // top-node (for which we don't want a real entry) generates already
+  // the final hierarchical profile data.
+
+  const octave_idx_type n = m_children.size ();
 
-    return m_parent;
-  }
+  Cell rv_indices (n, 1);
+  Cell rv_times (n, 1);
+  Cell rv_totals (n, 1);
+  Cell rv_calls (n, 1);
+  Cell rv_children (n, 1);
+
+  octave_idx_type i = 0;
+  for (const auto& idx_tnode : m_children)
+    {
+      const tree_node& entry = *idx_tnode.second;
+      double child_total = entry.m_time;
 
-  void
-  profiler::tree_node::build_flat (flat_profile& data) const
-  {
-    // If this is not the top-level node,
-    // update profile entry for this function.
-    if (m_fcn_id != 0)
-      {
-        stats& entry = data[m_fcn_id - 1];
+      rv_indices(i) = octave_value (idx_tnode.first);
+      rv_times(i) = octave_value (entry.m_time);
+      rv_calls(i) = octave_value (entry.m_calls);
+      rv_children(i) = entry.get_hierarchical (&child_total);
+      rv_totals(i) = octave_value (child_total);
+
+      if (total)
+        *total += child_total;
 
-        entry.m_time += m_time;
-        entry.m_calls += m_calls;
+      ++i;
+    }
+
+  octave_map retval;
 
-        panic_unless (m_parent);
-        if (m_parent->m_fcn_id != 0)
-          {
-            entry.m_parents.insert (m_parent->m_fcn_id);
-            data[m_parent->m_fcn_id - 1].m_children.insert (m_fcn_id);
-          }
+  retval.assign ("Index", rv_indices);
+  retval.assign ("SelfTime", rv_times);
+  retval.assign ("TotalTime", rv_totals);
+  retval.assign ("NumCalls", rv_calls);
+  retval.assign ("Children", rv_children);
+
+  return retval;
+}
 
-        if (! entry.m_recursive)
-          for (const tree_node *i = m_parent; i; i = i->m_parent)
-            if (i->m_fcn_id == m_fcn_id)
-              {
-                entry.m_recursive = true;
-                break;
-              }
-      }
+profiler::profiler (void)
+  : m_known_functions (), m_fcn_index (),
+    m_enabled (false), m_call_tree (new tree_node (nullptr, 0)),
+    m_active_fcn (nullptr), m_last_time (-1.0)
+{ }
+
+profiler::~profiler (void)
+{
+  delete m_call_tree;
+}
 
-    // Recurse on children.
-    for (const auto& idx_tnode : m_children)
-      idx_tnode.second->build_flat (data);
-  }
+void
+profiler::set_active (bool value)
+{
+  m_enabled = value;
+}
 
-  octave_value
-  profiler::tree_node::get_hierarchical (double *total) const
-  {
-    // Note that we don't generate the entry just for this node, but
-    // rather a struct-array with entries for all children.  This way, the
-    // top-node (for which we don't want a real entry) generates already
-    // the final hierarchical profile data.
+void
+profiler::enter_function (const std::string& fcn)
+{
+  // The enter class will check and only call us if the profiler is active.
+  panic_unless (enabled ());
+  panic_unless (m_call_tree);
+
+  // If there is already an active function, add to its time before
+  // pushing the new one.
+  if (m_active_fcn && m_active_fcn != m_call_tree)
+    add_current_time ();
 
-    const octave_idx_type n = m_children.size ();
+  // Map the function's name to its index.
+  octave_idx_type fcn_idx;
+  fcn_index_map::iterator pos = m_fcn_index.find (fcn);
+  if (pos == m_fcn_index.end ())
+    {
+      m_known_functions.push_back (fcn);
+      fcn_idx = m_known_functions.size ();
+      m_fcn_index[fcn] = fcn_idx;
+    }
+  else
+    fcn_idx = pos->second;
 
-    Cell rv_indices (n, 1);
-    Cell rv_times (n, 1);
-    Cell rv_totals (n, 1);
-    Cell rv_calls (n, 1);
-    Cell rv_children (n, 1);
+  if (! m_active_fcn)
+    m_active_fcn = m_call_tree;
+
+  m_active_fcn = m_active_fcn->enter (fcn_idx);
+
+  m_last_time = query_time ();
 
-    octave_idx_type i = 0;
-    for (const auto& idx_tnode : m_children)
-      {
-        const tree_node& entry = *idx_tnode.second;
-        double child_total = entry.m_time;
+}
 
-        rv_indices(i) = octave_value (idx_tnode.first);
-        rv_times(i) = octave_value (entry.m_time);
-        rv_calls(i) = octave_value (entry.m_calls);
-        rv_children(i) = entry.get_hierarchical (&child_total);
-        rv_totals(i) = octave_value (child_total);
+void
+profiler::exit_function (const std::string& fcn)
+{
+  if (m_active_fcn)
+    {
+      panic_unless (m_call_tree);
+      // FIXME: This panic_unless statements doesn't make sense if profile()
+      //        is called from within a function hierarchy to begin with.
+      //        See bug #39587.
+      // panic_unless (m_active_fcn != m_call_tree);
 
-        if (total)
-          *total += child_total;
+      // Usually, if we are disabled this function is not even called.  But
+      // the call disabling the profiler is an exception.  So also check here
+      // and only record the time if enabled.
+      if (enabled ())
+        add_current_time ();
 
-        ++i;
-      }
+      fcn_index_map::iterator pos = m_fcn_index.find (fcn);
+      // FIXME: This panic_unless statements doesn't make sense if profile()
+      //        is called from within a function hierarchy to begin with.
+      //        See bug #39587.
+      // panic_unless (pos != m_fcn_index.end ());
+      m_active_fcn = m_active_fcn->exit (pos->second);
 
-    octave_map retval;
+      // If this was an "inner call", we resume executing the parent function
+      // up the stack.  So note the start-time for this!
+      m_last_time = query_time ();
+    }
+}
 
-    retval.assign ("Index", rv_indices);
-    retval.assign ("SelfTime", rv_times);
-    retval.assign ("TotalTime", rv_totals);
-    retval.assign ("NumCalls", rv_calls);
-    retval.assign ("Children", rv_children);
+void
+profiler::reset (void)
+{
+  if (enabled ())
+    error ("profile: can't reset active profiler");
+
+  m_known_functions.clear ();
+  m_fcn_index.clear ();
 
-    return retval;
-  }
+  if (m_call_tree)
+    {
+      delete m_call_tree;
+      m_call_tree = new tree_node (nullptr, 0);
+      m_active_fcn = nullptr;
+    }
 
-  profiler::profiler (void)
-    : m_known_functions (), m_fcn_index (),
-      m_enabled (false), m_call_tree (new tree_node (nullptr, 0)),
-      m_active_fcn (nullptr), m_last_time (-1.0)
-  { }
+  m_last_time = -1.0;
+}
+
+octave_value
+profiler::get_flat (void) const
+{
+  octave_value retval;
 
-  profiler::~profiler (void)
-  {
-    delete m_call_tree;
-  }
+  const octave_idx_type n = m_known_functions.size ();
+
+  flat_profile flat (n);
 
-  void
-  profiler::set_active (bool value)
-  {
-    m_enabled = value;
-  }
+  if (m_call_tree)
+    {
+      m_call_tree->build_flat (flat);
+
+      Cell rv_names (n, 1);
+      Cell rv_times (n, 1);
+      Cell rv_calls (n, 1);
+      Cell rv_recursive (n, 1);
+      Cell rv_parents (n, 1);
+      Cell rv_children (n, 1);
 
-  void
-  profiler::enter_function (const std::string& fcn)
-  {
-    // The enter class will check and only call us if the profiler is active.
-    panic_unless (enabled ());
-    panic_unless (m_call_tree);
+      for (octave_idx_type i = 0; i != n; ++i)
+        {
+          rv_names(i) = octave_value (m_known_functions[i]);
+          rv_times(i) = octave_value (flat[i].m_time);
+          rv_calls(i) = octave_value (flat[i].m_calls);
+          rv_recursive(i) = octave_value (flat[i].m_recursive);
+          rv_parents(i) = stats::function_set_value (flat[i].m_parents);
+          rv_children(i) = stats::function_set_value (flat[i].m_children);
+        }
+
+      octave_map m;
 
-    // If there is already an active function, add to its time before
-    // pushing the new one.
-    if (m_active_fcn && m_active_fcn != m_call_tree)
-      add_current_time ();
+      m.assign ("FunctionName", rv_names);
+      m.assign ("TotalTime", rv_times);
+      m.assign ("NumCalls", rv_calls);
+      m.assign ("IsRecursive", rv_recursive);
+      m.assign ("Parents", rv_parents);
+      m.assign ("Children", rv_children);
 
-    // Map the function's name to its index.
-    octave_idx_type fcn_idx;
-    fcn_index_map::iterator pos = m_fcn_index.find (fcn);
-    if (pos == m_fcn_index.end ())
+      retval = m;
+    }
+  else
+    {
+      static const char *fn[] =
       {
-        m_known_functions.push_back (fcn);
-        fcn_idx = m_known_functions.size ();
-        m_fcn_index[fcn] = fcn_idx;
-      }
-    else
-      fcn_idx = pos->second;
-
-    if (! m_active_fcn)
-      m_active_fcn = m_call_tree;
-
-    m_active_fcn = m_active_fcn->enter (fcn_idx);
-
-    m_last_time = query_time ();
-
-  }
+        "FunctionName",
+        "TotalTime",
+        "NumCalls",
+        "IsRecursive",
+        "Parents",
+        "Children",
+        nullptr
+      };
 
-  void
-  profiler::exit_function (const std::string& fcn)
-  {
-    if (m_active_fcn)
-      {
-        panic_unless (m_call_tree);
-        // FIXME: This panic_unless statements doesn't make sense if profile()
-        //        is called from within a function hierarchy to begin with.
-        //        See bug #39587.
-        // panic_unless (m_active_fcn != m_call_tree);
-
-        // Usually, if we are disabled this function is not even called.  But
-        // the call disabling the profiler is an exception.  So also check here
-        // and only record the time if enabled.
-        if (enabled ())
-          add_current_time ();
-
-        fcn_index_map::iterator pos = m_fcn_index.find (fcn);
-        // FIXME: This panic_unless statements doesn't make sense if profile()
-        //        is called from within a function hierarchy to begin with.
-        //        See bug #39587.
-        // panic_unless (pos != m_fcn_index.end ());
-        m_active_fcn = m_active_fcn->exit (pos->second);
+      static octave_map m (dim_vector (0, 1), string_vector (fn));
 
-        // If this was an "inner call", we resume executing the parent function
-        // up the stack.  So note the start-time for this!
-        m_last_time = query_time ();
-      }
-  }
-
-  void
-  profiler::reset (void)
-  {
-    if (enabled ())
-      error ("profile: can't reset active profiler");
-
-    m_known_functions.clear ();
-    m_fcn_index.clear ();
-
-    if (m_call_tree)
-      {
-        delete m_call_tree;
-        m_call_tree = new tree_node (nullptr, 0);
-        m_active_fcn = nullptr;
-      }
+      retval = m;
+    }
 
-    m_last_time = -1.0;
-  }
-
-  octave_value
-  profiler::get_flat (void) const
-  {
-    octave_value retval;
-
-    const octave_idx_type n = m_known_functions.size ();
+  return retval;
+}
 
-    flat_profile flat (n);
-
-    if (m_call_tree)
-      {
-        m_call_tree->build_flat (flat);
-
-        Cell rv_names (n, 1);
-        Cell rv_times (n, 1);
-        Cell rv_calls (n, 1);
-        Cell rv_recursive (n, 1);
-        Cell rv_parents (n, 1);
-        Cell rv_children (n, 1);
+octave_value
+profiler::get_hierarchical (void) const
+{
+  octave_value retval;
 
-        for (octave_idx_type i = 0; i != n; ++i)
-          {
-            rv_names(i) = octave_value (m_known_functions[i]);
-            rv_times(i) = octave_value (flat[i].m_time);
-            rv_calls(i) = octave_value (flat[i].m_calls);
-            rv_recursive(i) = octave_value (flat[i].m_recursive);
-            rv_parents(i) = stats::function_set_value (flat[i].m_parents);
-            rv_children(i) = stats::function_set_value (flat[i].m_children);
-          }
-
-        octave_map m;
-
-        m.assign ("FunctionName", rv_names);
-        m.assign ("TotalTime", rv_times);
-        m.assign ("NumCalls", rv_calls);
-        m.assign ("IsRecursive", rv_recursive);
-        m.assign ("Parents", rv_parents);
-        m.assign ("Children", rv_children);
+  if (m_call_tree)
+    retval = m_call_tree->get_hierarchical ();
+  else
+    {
+      static const char *fn[] =
+      {
+        "Index",
+        "SelfTime",
+        "NumCalls",
+        "Children",
+        nullptr
+      };
 
-        retval = m;
-      }
-    else
-      {
-        static const char *fn[] =
-          {
-            "FunctionName",
-            "TotalTime",
-            "NumCalls",
-            "IsRecursive",
-            "Parents",
-            "Children",
-            nullptr
-          };
+      static octave_map m (dim_vector (0, 1), string_vector (fn));
 
-        static octave_map m (dim_vector (0, 1), string_vector (fn));
+      retval = m;
+    }
 
-        retval = m;
-      }
-
-    return retval;
-  }
+  return retval;
+}
 
-  octave_value
-  profiler::get_hierarchical (void) const
-  {
-    octave_value retval;
+double
+profiler::query_time (void) const
+{
+  sys::time now;
 
-    if (m_call_tree)
-      retval = m_call_tree->get_hierarchical ();
-    else
-      {
-        static const char *fn[] =
-          {
-            "Index",
-            "SelfTime",
-            "NumCalls",
-            "Children",
-            nullptr
-          };
-
-        static octave_map m (dim_vector (0, 1), string_vector (fn));
-
-        retval = m;
-      }
+  // FIXME: is this volatile declaration really needed?
+  // See bug #34210 for additional details.
+  volatile double dnow = now.double_value ();
 
-    return retval;
-  }
-
-  double
-  profiler::query_time (void) const
-  {
-    sys::time now;
-
-    // FIXME: is this volatile declaration really needed?
-    // See bug #34210 for additional details.
-    volatile double dnow = now.double_value ();
+  return dnow;
+}
 
-    return dnow;
-  }
+void
+profiler::add_current_time (void)
+{
+  if (m_active_fcn)
+    {
+      const double t = query_time ();
 
-  void
-  profiler::add_current_time (void)
-  {
-    if (m_active_fcn)
-      {
-        const double t = query_time ();
-
-        m_active_fcn->add_time (t - m_last_time);
-      }
-  }
+      m_active_fcn->add_time (t - m_last_time);
+    }
+}
 
 // Enable or disable the profiler data collection.
 DEFMETHOD (__profiler_enable__, interp, args, ,