--- a/liboctave/util/action-container.h	Thu Dec 01 14:23:45 2022 -0800
+++ b/liboctave/util/action-container.h	Thu Dec 01 18:02:15 2022 -0800
@@ -39,189 +39,189 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  class
-  action_container
+class
+action_container
+{
+public:
+
+  // A generic unwind_protect element.  Knows how to run itself and
+  // discard itself.  Also, contains a pointer to the next element.
+  class elem
+  {
+  public:
+
+    friend class action_container;
+
+    elem (void) { }
+
+    // No copying!
+
+    elem (const elem&) = delete;
+
+    elem& operator = (const elem&) = delete;
+
+    virtual ~elem (void) = default;
+
+    virtual void run (void) { }
+  };
+
+  // An element that merely runs a void (*)(void) function.
+
+  class fcn_elem : public elem
+  {
+  public:
+
+    // FIXME: Do we need to apply std::forward to the arguments to
+    // std::bind here?
+
+    template <typename F, typename... Args>
+    fcn_elem (F&& fcn, Args&& ... args)
+      : m_fcn (std::bind (fcn, args...))
+    { }
+
+    void run (void) { m_fcn (); }
+
+  private:
+
+    std::function<void (void)> m_fcn;
+  };
+
+  // An element that stores arbitrary variable, and restores it.
+
+  template <typename T>
+  class restore_var_elem : public elem
+  {
+  public:
+
+    restore_var_elem (T& ref, const T& val)
+      : m_ptr (&ref), m_val (val) { }
+
+    // No copying!
+
+    restore_var_elem (const restore_var_elem&) = delete;
+
+    restore_var_elem& operator = (const restore_var_elem&) = delete;
+
+    void run (void) { *m_ptr = m_val; }
+
+  private:
+
+    T *m_ptr, m_val;
+  };
+
+  // Deletes a class allocated using new.
+
+  template <typename T>
+  class delete_ptr_elem : public elem
   {
   public:
 
-    // A generic unwind_protect element.  Knows how to run itself and
-    // discard itself.  Also, contains a pointer to the next element.
-    class elem
-    {
-    public:
-
-      friend class action_container;
-
-      elem (void) { }
-
-      // No copying!
-
-      elem (const elem&) = delete;
-
-      elem& operator = (const elem&) = delete;
-
-      virtual ~elem (void) = default;
-
-      virtual void run (void) { }
-    };
-
-    // An element that merely runs a void (*)(void) function.
-
-    class fcn_elem : public elem
-    {
-    public:
-
-      // FIXME: Do we need to apply std::forward to the arguments to
-      // std::bind here?
-
-      template <typename F, typename... Args>
-      fcn_elem (F&& fcn, Args&&... args)
-        : m_fcn (std::bind (fcn, args...))
-      { }
-
-      void run (void) { m_fcn (); }
-
-    private:
-
-      std::function<void (void)> m_fcn;
-    };
-
-    // An element that stores arbitrary variable, and restores it.
-
-    template <typename T>
-    class restore_var_elem : public elem
-    {
-    public:
-
-      restore_var_elem (T& ref, const T& val)
-        : m_ptr (&ref), m_val (val) { }
-
-      // No copying!
-
-      restore_var_elem (const restore_var_elem&) = delete;
-
-      restore_var_elem& operator = (const restore_var_elem&) = delete;
-
-      void run (void) { *m_ptr = m_val; }
-
-    private:
-
-      T *m_ptr, m_val;
-    };
-
-    // Deletes a class allocated using new.
-
-    template <typename T>
-    class delete_ptr_elem : public elem
-    {
-    public:
-
-      delete_ptr_elem (T *ptr)
-        : m_ptr (ptr) { }
-
-      // No copying!
-
-      delete_ptr_elem (const delete_ptr_elem&) = delete;
-
-      delete_ptr_elem operator = (const delete_ptr_elem&) = delete;
-
-      void run (void) { delete m_ptr; }
-
-    private:
-
-      T *m_ptr;
-    };
-
-    action_container (void) { }
+    delete_ptr_elem (T *ptr)
+      : m_ptr (ptr) { }
 
     // No copying!
 
-    action_container (const action_container&) = delete;
+    delete_ptr_elem (const delete_ptr_elem&) = delete;
+
+    delete_ptr_elem operator = (const delete_ptr_elem&) = delete;
 
-    action_container& operator = (const action_container&) = delete;
+    void run (void) { delete m_ptr; }
 
-    virtual ~action_container (void) = default;
+  private:
 
-    template <typename F, typename... Args>
-    void add (F&& fcn, Args&&... args)
-    {
-      add_action (new fcn_elem (std::forward<F> (fcn),
-                                std::forward<Args> (args)...));
-    }
+    T *m_ptr;
+  };
+
+  action_container (void) { }
 
-    // Use separate template types for function pointer parameter
-    // declarations and captured arguments so that differences in
-    // const are handled properly.
+  // No copying!
+
+  action_container (const action_container&) = delete;
+
+  action_container& operator = (const action_container&) = delete;
+
+  virtual ~action_container (void) = default;
 
-    template <typename... Params, typename... Args>
-    void add_fcn (void (*fcn) (Params...), Args&&... args)
-    {
-      add_action (new fcn_elem (fcn, std::forward<Args> (args)...));
-    }
+  template <typename F, typename... Args>
+  void add (F&& fcn, Args&& ... args)
+  {
+    add_action (new fcn_elem (std::forward<F> (fcn),
+                              std::forward<Args> (args)...));
+  }
 
-    template <typename T, typename... Params, typename... Args>
-    void add_method (T *obj, void (T::*method) (Params...), Args&&... args)
-    {
-      add_action (new fcn_elem (method, obj, std::forward<Args> (args)...));
-    }
+  // Use separate template types for function pointer parameter
+  // declarations and captured arguments so that differences in
+  // const are handled properly.
 
-    template <typename T, typename... Params, typename... Args>
-    void add_method (T& obj, void (T::*method) (Params...), Args&&... args)
-    {
-      add_action (new fcn_elem (method, &obj, std::forward<Args> (args)...));
-    }
+  template <typename... Params, typename... Args>
+  void add_fcn (void (*fcn) (Params...), Args&& ... args)
+  {
+    add_action (new fcn_elem (fcn, std::forward<Args> (args)...));
+  }
 
-    // Call to delete (T*).
+  template <typename T, typename... Params, typename... Args>
+  void add_method (T *obj, void (T::*method) (Params...), Args&& ... args)
+  {
+    add_action (new fcn_elem (method, obj, std::forward<Args> (args)...));
+  }
 
-    template <typename T>
-    void add_delete (T *obj)
-    {
-      add_action (new delete_ptr_elem<T> (obj));
-    }
+  template <typename T, typename... Params, typename... Args>
+  void add_method (T& obj, void (T::*method) (Params...), Args&& ... args)
+  {
+    add_action (new fcn_elem (method, &obj, std::forward<Args> (args)...));
+  }
 
-    // Protect any variable.
-    template <typename T>
-    void protect_var (T& var)
-    {
-      add_action (new restore_var_elem<T> (var, var));
-    }
+  // Call to delete (T*).
+
+  template <typename T>
+  void add_delete (T *obj)
+  {
+    add_action (new delete_ptr_elem<T> (obj));
+  }
 
-    // Protect any variable, value given.
-    template <typename T>
-    void protect_var (T& var, const T& val)
-    {
-      add_action (new restore_var_elem<T> (var, val));
-    }
+  // Protect any variable.
+  template <typename T>
+  void protect_var (T& var)
+  {
+    add_action (new restore_var_elem<T> (var, var));
+  }
 
-    operator bool (void) const { return ! empty (); }
-
-    virtual void run_first (void) = 0;
+  // Protect any variable, value given.
+  template <typename T>
+  void protect_var (T& var, const T& val)
+  {
+    add_action (new restore_var_elem<T> (var, val));
+  }
 
-    OCTAVE_API void run (std::size_t num);
+  operator bool (void) const { return ! empty (); }
 
-    void run (void) { run (size ()); }
+  virtual void run_first (void) = 0;
 
-    virtual void discard_first (void) = 0;
+  OCTAVE_API void run (std::size_t num);
+
+  void run (void) { run (size ()); }
 
-    void discard (std::size_t num)
-    {
-      if (num > size ())
-        num = size ();
+  virtual void discard_first (void) = 0;
 
-      for (std::size_t i = 0; i < num; i++)
-        discard_first ();
-    }
+  void discard (std::size_t num)
+  {
+    if (num > size ())
+      num = size ();
 
-    void discard (void) { discard (size ()); }
+    for (std::size_t i = 0; i < num; i++)
+      discard_first ();
+  }
 
-    virtual std::size_t size (void) const = 0;
+  void discard (void) { discard (size ()); }
 
-    bool empty (void) const { return size () == 0; }
+  virtual std::size_t size (void) const = 0;
+
+  bool empty (void) const { return size () == 0; }
 
-  protected:
+protected:
 
-    virtual void add_action (elem *new_elem) = 0;
-  };
+  virtual void add_action (elem *new_elem) = 0;
+};
 
 OCTAVE_END_NAMESPACE(octave)