--- a/libinterp/parse-tree/pt-stmt.cc	Thu Dec 01 14:23:45 2022 -0800
+++ b/libinterp/parse-tree/pt-stmt.cc	Thu Dec 01 18:02:15 2022 -0800
@@ -51,251 +51,251 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  // A list of commands to be executed.
+// A list of commands to be executed.
 
-  tree_statement::~tree_statement (void)
-  {
-    delete m_command;
-    delete m_expression;
-    delete m_comment_list;
-  }
+tree_statement::~tree_statement (void)
+{
+  delete m_command;
+  delete m_expression;
+  delete m_comment_list;
+}
 
-  void
-  tree_statement::set_print_flag (bool print_flag)
-  {
-    if (m_expression)
-      m_expression->set_print_flag (print_flag);
-  }
+void
+tree_statement::set_print_flag (bool print_flag)
+{
+  if (m_expression)
+    m_expression->set_print_flag (print_flag);
+}
 
-  bool
-  tree_statement::print_result (void)
-  {
-    return m_expression && m_expression->print_result ();
-  }
+bool
+tree_statement::print_result (void)
+{
+  return m_expression && m_expression->print_result ();
+}
 
-  void
-  tree_statement::set_breakpoint (const std::string& condition)
-  {
-    if (m_command)
-      m_command->set_breakpoint (condition);
-    else if (m_expression)
-      m_expression->set_breakpoint (condition);
-  }
+void
+tree_statement::set_breakpoint (const std::string& condition)
+{
+  if (m_command)
+    m_command->set_breakpoint (condition);
+  else if (m_expression)
+    m_expression->set_breakpoint (condition);
+}
 
-  void
-  tree_statement::delete_breakpoint (void)
-  {
-    if (m_command)
-      m_command->delete_breakpoint ();
-    else if (m_expression)
-      m_expression->delete_breakpoint ();
-  }
+void
+tree_statement::delete_breakpoint (void)
+{
+  if (m_command)
+    m_command->delete_breakpoint ();
+  else if (m_expression)
+    m_expression->delete_breakpoint ();
+}
 
-  bool
-  tree_statement::is_breakpoint (void) const
-  {
-    return m_command ? m_command->is_breakpoint ()
-                     : (m_expression ? m_expression->is_breakpoint ()
-                                     : false);
-  }
+bool
+tree_statement::is_breakpoint (void) const
+{
+  return m_command ? m_command->is_breakpoint ()
+         : (m_expression ? m_expression->is_breakpoint ()
+            : false);
+}
 
-  bool
-  tree_statement::is_active_breakpoint (tree_evaluator& tw) const
-  {
-    return m_command ? m_command->is_active_breakpoint (tw)
-                     : (m_expression ? m_expression->is_active_breakpoint (tw)
-                                     : false);
-  }
+bool
+tree_statement::is_active_breakpoint (tree_evaluator& tw) const
+{
+  return m_command ? m_command->is_active_breakpoint (tw)
+         : (m_expression ? m_expression->is_active_breakpoint (tw)
+            : false);
+}
 
-  std::string
-  tree_statement::bp_cond () const
-  {
-    return (m_command
-            ? m_command->bp_cond ()
-            : (m_expression ? m_expression->bp_cond () : "0"));
-  }
+std::string
+tree_statement::bp_cond () const
+{
+  return (m_command
+          ? m_command->bp_cond ()
+          : (m_expression ? m_expression->bp_cond () : "0"));
+}
 
-  int
-  tree_statement::line (void) const
-  {
-    return (m_command
-            ? m_command->line ()
-            : (m_expression ? m_expression->line () : -1));
-  }
+int
+tree_statement::line (void) const
+{
+  return (m_command
+          ? m_command->line ()
+          : (m_expression ? m_expression->line () : -1));
+}
 
-  int
-  tree_statement::column (void) const
-  {
-    return (m_command
-            ? m_command->column ()
-            : (m_expression ? m_expression->column () : -1));
-  }
+int
+tree_statement::column (void) const
+{
+  return (m_command
+          ? m_command->column ()
+          : (m_expression ? m_expression->column () : -1));
+}
 
-  void
-  tree_statement::set_location (int l, int c)
-  {
-    if (m_command)
-      m_command->set_location (l, c);
-    else if (m_expression)
-      m_expression->set_location (l, c);
-  }
+void
+tree_statement::set_location (int l, int c)
+{
+  if (m_command)
+    m_command->set_location (l, c);
+  else if (m_expression)
+    m_expression->set_location (l, c);
+}
 
-  void
-  tree_statement::echo_code (const std::string& prefix)
-  {
-    tree_print_code tpc (octave_stdout, prefix);
+void
+tree_statement::echo_code (const std::string& prefix)
+{
+  tree_print_code tpc (octave_stdout, prefix);
 
-    accept (tpc);
-  }
+  accept (tpc);
+}
 
-  bool
-  tree_statement::is_end_of_fcn_or_script (void) const
-  {
-    bool retval = false;
+bool
+tree_statement::is_end_of_fcn_or_script (void) const
+{
+  bool retval = false;
 
-    if (m_command)
-      {
-        tree_no_op_command *no_op_cmd
-          = dynamic_cast<tree_no_op_command *> (m_command);
+  if (m_command)
+    {
+      tree_no_op_command *no_op_cmd
+        = dynamic_cast<tree_no_op_command *> (m_command);
 
-        if (no_op_cmd)
-          retval = no_op_cmd->is_end_of_fcn_or_script ();
-      }
+      if (no_op_cmd)
+        retval = no_op_cmd->is_end_of_fcn_or_script ();
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  bool
-  tree_statement::is_end_of_file (void) const
-  {
-    bool retval = false;
+bool
+tree_statement::is_end_of_file (void) const
+{
+  bool retval = false;
 
-    if (m_command)
-      {
-        tree_no_op_command *no_op_cmd
-          = dynamic_cast<tree_no_op_command *> (m_command);
+  if (m_command)
+    {
+      tree_no_op_command *no_op_cmd
+        = dynamic_cast<tree_no_op_command *> (m_command);
 
-        if (no_op_cmd)
-          retval = no_op_cmd->is_end_of_file ();
-      }
+      if (no_op_cmd)
+        retval = no_op_cmd->is_end_of_file ();
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  // Create a "breakpoint" tree-walker, and get it to "walk" this
-  // statement list
-  // (FIXME: What does that do???)
+// Create a "breakpoint" tree-walker, and get it to "walk" this
+// statement list
+// (FIXME: What does that do???)
 
-  int
-  tree_statement_list::set_breakpoint (int line, const std::string& condition)
-  {
-    tree_breakpoint tbp (line, tree_breakpoint::set, condition);
-    accept (tbp);
+int
+tree_statement_list::set_breakpoint (int line, const std::string& condition)
+{
+  tree_breakpoint tbp (line, tree_breakpoint::set, condition);
+  accept (tbp);
 
-    return tbp.get_line ();
-  }
+  return tbp.get_line ();
+}
 
-  void
-  tree_statement_list::delete_breakpoint (int line)
-  {
-    if (line < 0)
-      {
-        octave_value_list bp_lst = list_breakpoints ();
+void
+tree_statement_list::delete_breakpoint (int line)
+{
+  if (line < 0)
+    {
+      octave_value_list bp_lst = list_breakpoints ();
 
-        int len = bp_lst.length ();
+      int len = bp_lst.length ();
 
-        for (int i = 0; i < len; i++)
-          {
-            tree_breakpoint tbp (i, tree_breakpoint::clear);
-            accept (tbp);
-          }
-      }
-    else
-      {
-        tree_breakpoint tbp (line, tree_breakpoint::clear);
-        accept (tbp);
-      }
-  }
+      for (int i = 0; i < len; i++)
+        {
+          tree_breakpoint tbp (i, tree_breakpoint::clear);
+          accept (tbp);
+        }
+    }
+  else
+    {
+      tree_breakpoint tbp (line, tree_breakpoint::clear);
+      accept (tbp);
+    }
+}
 
-  octave_value_list
-  tree_statement_list::list_breakpoints (void)
-  {
-    tree_breakpoint tbp (0, tree_breakpoint::list);
-    accept (tbp);
+octave_value_list
+tree_statement_list::list_breakpoints (void)
+{
+  tree_breakpoint tbp (0, tree_breakpoint::list);
+  accept (tbp);
 
-    return tbp.get_list ();
-  }
+  return tbp.get_list ();
+}
 
-  // Get list of pairs (breakpoint line, breakpoint condition)
-  std::list<bp_type>
-  tree_statement_list::breakpoints_and_conds (void)
-  {
-    tree_breakpoint tbp (0, tree_breakpoint::list);
-    accept (tbp);
+// Get list of pairs (breakpoint line, breakpoint condition)
+std::list<bp_type>
+tree_statement_list::breakpoints_and_conds (void)
+{
+  tree_breakpoint tbp (0, tree_breakpoint::list);
+  accept (tbp);
 
-    std::list<bp_type> retval;
-    octave_value_list lines = tbp.get_list ();
-    octave_value_list conds = tbp.get_cond_list ();
+  std::list<bp_type> retval;
+  octave_value_list lines = tbp.get_list ();
+  octave_value_list conds = tbp.get_cond_list ();
 
-    for (int i = 0; i < lines.length (); i++)
-      {
-        retval.push_back (bp_type (lines(i).double_value (),
-                                   conds(i).string_value ()));
-      }
+  for (int i = 0; i < lines.length (); i++)
+    {
+      retval.push_back (bp_type (lines(i).double_value (),
+                                 conds(i).string_value ()));
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  // Add breakpoints to  file  at multiple lines (the second arguments
-  // of  line), to stop only if  condition  is true.
-  // Updates GUI via  event_manager::update_breakpoint.
-  // FIXME: COME BACK TO ME.
+// Add breakpoints to  file  at multiple lines (the second arguments
+// of  line), to stop only if  condition  is true.
+// Updates GUI via  event_manager::update_breakpoint.
+// FIXME: COME BACK TO ME.
 
-  bp_table::bp_lines
-  tree_statement_list::add_breakpoint (event_manager& evmgr,
-                                       const std::string& file,
-                                       const bp_table::bp_lines& lines,
-                                       const std::string& condition)
-  {
-    bp_table::bp_lines retval;
+bp_table::bp_lines
+tree_statement_list::add_breakpoint (event_manager& evmgr,
+                                     const std::string& file,
+                                     const bp_table::bp_lines& lines,
+                                     const std::string& condition)
+{
+  bp_table::bp_lines retval;
 
-    for (const auto& lineno : lines)
-      {
-        int line = set_breakpoint (lineno, condition);
+  for (const auto& lineno : lines)
+    {
+      int line = set_breakpoint (lineno, condition);
 
-        if (line)
-          {
-            if (! file.empty ())
-              evmgr.update_breakpoint (true, file, line, condition);
+      if (line)
+        {
+          if (! file.empty ())
+            evmgr.update_breakpoint (true, file, line, condition);
 
-            retval.insert (line);
-          }
-      }
+          retval.insert (line);
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  bp_table::bp_lines
-  tree_statement_list::remove_all_breakpoints (event_manager& evmgr,
-                                               const std::string& file)
-  {
-    bp_table::bp_lines retval;
+bp_table::bp_lines
+tree_statement_list::remove_all_breakpoints (event_manager& evmgr,
+    const std::string& file)
+{
+  bp_table::bp_lines retval;
 
-    octave_value_list bkpts = list_breakpoints ();
+  octave_value_list bkpts = list_breakpoints ();
 
-    for (int i = 0; i < bkpts.length (); i++)
-      {
-        int lineno = bkpts(i).int_value ();
+  for (int i = 0; i < bkpts.length (); i++)
+    {
+      int lineno = bkpts(i).int_value ();
 
-        delete_breakpoint (lineno);
+      delete_breakpoint (lineno);
 
-        retval.insert (lineno);
+      retval.insert (lineno);
 
-        if (! file.empty ())
-          evmgr.update_breakpoint (false, file, lineno);
-      }
+      if (! file.empty ())
+        evmgr.update_breakpoint (false, file, lineno);
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
 OCTAVE_END_NAMESPACE(octave)