Mercurial > octave

changeset 32832:f3c1a77bcc6b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: Replace (void) in function declarations with () where possible See: https://octave.discourse.group/t/remove-void-from-mex-cc-and-elsewhere/5221 Most instances of (void) that could be replaced with () have been replaced already. This changeset is for some files that weren't covered previously. The .c files and their headers are left untouched.
author Arun Giridhar <arungiridhar@gmail.com>
date Wed, 24 Jan 2024 19:31:35 -0500
parents ad4c271d6faa
children e586064e2e09
files libgui/qterminal/libqterminal/QTerminal.cc libgui/qterminal/libqterminal/QTerminal.h libgui/qterminal/libqterminal/unix/QUnixTerminalImpl.cpp libgui/qterminal/libqterminal/unix/TerminalView.h libgui/qterminal/libqterminal/win32/QTerminalColors.cpp libgui/qterminal/libqterminal/win32/QTerminalColors.h libgui/qterminal/libqterminal/win32/QWinTerminalImpl.cpp libgui/qterminal/libqterminal/win32/QWinTerminalImpl.h libinterp/corefcn/defun-int.h libinterp/corefcn/mex.cc libinterp/octave-value/ov-java.cc liboctave/system/mach-info.cc liboctave/util/f77-dummy-main.cc liboctave/util/lo-ieee.h liboctave/util/oct-shlib.cc liboctave/util/quit.cc liboctave/util/quit.h
diffstat 17 files changed, 359 insertions(+), 359 deletions(-) [+]
line wrap: on
line diff
--- a/libgui/qterminal/libqterminal/QTerminal.cc	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/QTerminal.cc	Wed Jan 24 19:31:35 2024 -0500
@@ -204,7 +204,7 @@
 }
 
 void
-QTerminal::notice_settings (void)
+QTerminal::notice_settings ()
 {
   octave::gui_settings settings;
 
@@ -278,7 +278,7 @@
 }
 
 void
-QTerminal::construct (void)
+QTerminal::construct ()
 {
   octave::gui_settings settings;
 
--- a/libgui/qterminal/libqterminal/QTerminal.h	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/QTerminal.h	Wed Jan 24 19:31:35 2024 -0500
@@ -45,7 +45,7 @@
 
   static QTerminal * create (QWidget *xparent);
 
-  virtual ~QTerminal (void) = default;
+  virtual ~QTerminal () = default;
 
   virtual void setTerminalFont (const QFont& font) = 0;
 
@@ -91,7 +91,7 @@
 
   void report_status_message (const QString&);
 
-  void interrupt_signal (void);
+  void interrupt_signal ();
 
   void edit_mfile_request (const QString&, int);
 
@@ -105,36 +105,36 @@
 
   void set_screen_size_signal (int, int);
 
-  void clear_command_window_request (void);
+  void clear_command_window_request ();
 
   void interpreter_event (const octave::fcn_callback& fcn);
   void interpreter_event (const octave::meth_callback& meth);
 
 public slots:
 
-  virtual void copyClipboard (void) = 0;
+  virtual void copyClipboard () = 0;
 
-  virtual void pasteClipboard (void) = 0;
+  virtual void pasteClipboard () = 0;
 
-  virtual void selectAll (void) = 0;
+  virtual void selectAll () = 0;
 
   virtual void handleCustomContextMenuRequested (const QPoint& at);
 
-  void notice_settings (void);
+  void notice_settings ();
 
-  virtual void init_terminal_size (void) { }
+  virtual void init_terminal_size () { }
 
-  void terminal_interrupt (void) { emit interrupt_signal (); }
+  void terminal_interrupt () { emit interrupt_signal (); }
 
-  void run_selection (void);
+  void run_selection ();
 
-  void edit_file (void);
+  void edit_file ();
 
-  void edit_selected (void);
+  void edit_selected ();
 
-  void help_on_expression (void);
+  void help_on_expression ();
 
-  void doc_on_expression (void);
+  void doc_on_expression ();
 
   virtual void handle_visibility_changed (bool) { };
 
--- a/libgui/qterminal/libqterminal/unix/QUnixTerminalImpl.cpp	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/unix/QUnixTerminalImpl.cpp	Wed Jan 24 19:31:35 2024 -0500
@@ -57,7 +57,7 @@
     connect(m_terminalView, SIGNAL(customContextMenuRequested(QPoint)),
             this, SLOT(handleCustomContextMenuRequested(QPoint)));
 
-    connect (m_terminalView, SIGNAL (interrupt_signal (void)),
+    connect (m_terminalView, SIGNAL (interrupt_signal ()),
              this, SLOT (terminal_interrupt ()));
 
 #ifdef Q_OS_MAC
--- a/libgui/qterminal/libqterminal/unix/TerminalView.h	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/unix/TerminalView.h	Wed Jan 24 19:31:35 2024 -0500
@@ -466,7 +466,7 @@
 
 signals:
 
-    void interrupt_signal (void);
+    void interrupt_signal ();
 
     /**
      * Emitted when the user presses a key whilst the terminal widget has focus.
--- a/libgui/qterminal/libqterminal/win32/QTerminalColors.cpp	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/win32/QTerminalColors.cpp	Wed Jan 24 19:31:35 2024 -0500
@@ -27,7 +27,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-QConsoleColors::QConsoleColors (void)
+QConsoleColors::QConsoleColors ()
     : QMap<int, QColor> ()
 {
   (*this)[0]  = Qt::white;
--- a/libgui/qterminal/libqterminal/win32/QTerminalColors.h	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/win32/QTerminalColors.h	Wed Jan 24 19:31:35 2024 -0500
@@ -31,7 +31,7 @@
 class QConsoleColors : public QMap<int, QColor>
 {
 public:
-  QConsoleColors (void);
+  QConsoleColors ();
 };
 
 //////////////////////////////////////////////////////////////////////////////
--- a/libgui/qterminal/libqterminal/win32/QWinTerminalImpl.cpp	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/win32/QWinTerminalImpl.cpp	Wed Jan 24 19:31:35 2024 -0500
@@ -77,7 +77,7 @@
 {
 public:
   QConsoleView (QWinTerminalImpl *parent = 0) : QWidget (parent), q (parent) { }
-  ~QConsoleView (void) { }
+  ~QConsoleView () { }
 
 protected:
   void paintEvent (QPaintEvent *event) { q->viewPaintEvent (this, event); }
@@ -95,7 +95,7 @@
   QConsoleThread (QWinTerminalImpl *console) : QThread (console), q (console) { }
 
 protected:
-  void run (void)
+  void run ()
     { q->start (); }
 
 private:
@@ -180,21 +180,21 @@
     };
 
   QConsolePrivate (QWinTerminalImpl *parent, const QString& cmd = QString ());
-  ~QConsolePrivate (void);
+  ~QConsolePrivate ();
 
   void updateConsoleSize (bool sync = false, bool allow_smaller_width = false);
-  void syncConsoleParameters (void);
+  void syncConsoleParameters ();
   void grabConsoleBuffer (CHAR_INFO* buf = 0);
-  void updateHorizontalScrollBar (void);
-  void updateVerticalScrollBar (void);
+  void updateHorizontalScrollBar ();
+  void updateVerticalScrollBar ();
   void setHorizontalScrollValue (int value);
   void setVerticalScrollValue (int value);
   void updateConsoleView (bool grab = true);
-  void monitorConsole (void);
-  void startCommand (void);
+  void monitorConsole ();
+  void startCommand ();
   void sendConsoleText (const QString& s);
-  QRect cursorRect (void);
-  QRect boundingRect (void);
+  QRect cursorRect ();
+  QRect boundingRect ();
   void selectAll ();
   void selectWord (const QPoint& cellPos);
   void selectLine (const QPoint& cellPos);
@@ -206,14 +206,14 @@
                         const char *devName);
 
   QPoint posToCell (const QPoint& pt);
-  QString getSelection (void);
-  void updateSelection (void);
-  void clearSelection (void);
+  QString getSelection ();
+  void updateSelection ();
+  void clearSelection ();
 
-  QColor backgroundColor (void) const;
-  QColor foregroundColor (void) const;
-  QColor selectionColor (void) const;
-  QColor cursorColor (void) const;
+  QColor backgroundColor () const;
+  QColor foregroundColor () const;
+  QColor selectionColor () const;
+  QColor cursorColor () const;
 
   void setBackgroundColor (const QColor& color);
   void setForegroundColor (const QColor& color);
@@ -435,8 +435,8 @@
   QObject::connect (m_verticalScrollBar, SIGNAL (valueChanged (int)),
                     q, SLOT (verticalScrollValueChanged (int)));
 
-  QObject::connect (m_consoleWatcher, SIGNAL (timeout (void)),
-                    q, SLOT (monitorConsole (void)));
+  QObject::connect (m_consoleWatcher, SIGNAL (timeout ()),
+                    q, SLOT (monitorConsole ()));
 
   m_consoleWatcher->start ();
 
@@ -445,15 +445,15 @@
   else
     {
       m_consoleThread = new QConsoleThread (q);
-      QObject::connect (m_consoleThread, SIGNAL (finished (void)),
-                        q, SIGNAL (terminated (void)));
+      QObject::connect (m_consoleThread, SIGNAL (finished ()),
+                        q, SIGNAL (terminated ()));
       m_consoleThread->start ();
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-QConsolePrivate::~QConsolePrivate (void)
+QConsolePrivate::~QConsolePrivate ()
 {
   if (m_consoleThread && m_consoleThread->isRunning () && m_process)
     {
@@ -505,7 +505,7 @@
                                / m_charSize.height ()));
 }
 
-QString QConsolePrivate::getSelection (void)
+QString QConsolePrivate::getSelection ()
 {
   QString selection;
 
@@ -566,7 +566,7 @@
   return selection;
 }
 
-void QConsolePrivate::updateSelection (void)
+void QConsolePrivate::updateSelection ()
 {
   QPoint begin = m_beginSelection;
   QPoint end = m_endSelection;
@@ -579,29 +579,29 @@
   m_consoleView->update ();
 }
 
-void QConsolePrivate::clearSelection (void)
+void QConsolePrivate::clearSelection ()
 {
   m_beginSelection = m_endSelection = QPoint ();
 
   m_consoleView->update ();
 }
 
-QColor QConsolePrivate::backgroundColor (void) const
+QColor QConsolePrivate::backgroundColor () const
 {
   return m_colors[0];
 }
 
-QColor QConsolePrivate::foregroundColor (void) const
+QColor QConsolePrivate::foregroundColor () const
 {
   return m_colors[7];
 }
 
-QColor QConsolePrivate::selectionColor (void) const
+QColor QConsolePrivate::selectionColor () const
 {
   return m_selectionColor;
 }
 
-QColor QConsolePrivate::cursorColor (void) const
+QColor QConsolePrivate::cursorColor () const
 {
   return m_cursorColor.isValid () ? m_cursorColor : foregroundColor ();
 }
@@ -1088,7 +1088,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QConsolePrivate::syncConsoleParameters (void)
+void QConsolePrivate::syncConsoleParameters ()
 {
   CONSOLE_SCREEN_BUFFER_INFO sbi;
   HANDLE hStdOut = m_stdOut;
@@ -1154,7 +1154,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QConsolePrivate::updateHorizontalScrollBar (void)
+void QConsolePrivate::updateHorizontalScrollBar ()
 {
   m_horizontalScrollBar->setMinimum (0);
   if (m_bufferSize.width () > m_consoleRect.width ())
@@ -1172,7 +1172,7 @@
        m_horizontalScrollBar->pageStep ());
 }
 
-void QConsolePrivate::updateVerticalScrollBar (void)
+void QConsolePrivate::updateVerticalScrollBar ()
 {
   m_verticalScrollBar->setMinimum (0);
   if (m_bufferSize.height () > m_consoleRect.height ())
@@ -1266,7 +1266,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QConsolePrivate::monitorConsole (void)
+void QConsolePrivate::monitorConsole ()
 {
   CONSOLE_SCREEN_BUFFER_INFO sbi;
   HANDLE hStdOut = GetStdHandle (STD_OUTPUT_HANDLE);
@@ -1362,7 +1362,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QConsolePrivate::startCommand (void)
+void QConsolePrivate::startCommand ()
 {
   QString cmd = m_command;
 
@@ -1469,7 +1469,7 @@
 }
 
 QRect
-QConsolePrivate::cursorRect (void)
+QConsolePrivate::cursorRect ()
 {
   // The actual character width might be fractional (with non-integer scaling -
   // high DPI).  But m_charSize.width () is integer.
@@ -1492,7 +1492,7 @@
 }
 
 QRect
-QConsolePrivate::boundingRect (void)
+QConsolePrivate::boundingRect ()
 {
   // This is slightly larger than cursorRect to make sure the entirety of a
   // character is redrawn.
@@ -1524,7 +1524,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-QWinTerminalImpl::~QWinTerminalImpl (void)
+QWinTerminalImpl::~QWinTerminalImpl ()
 {
   delete d;
 }
@@ -1632,7 +1632,7 @@
   d->drawText (p, cx1, cy1, cx2, cy2, ch);
 }
 
-void QWinTerminalImpl::blinkCursorEvent (void)
+void QWinTerminalImpl::blinkCursorEvent ()
 {
   if (d->m_hasBlinkingCursor)
     d->m_cursorBlinking = ! d->m_cursorBlinking;
@@ -1665,7 +1665,7 @@
 
 // Reset width of console buffer and terminal window to be the same.
 
-void QWinTerminalImpl::init_terminal_size (void)
+void QWinTerminalImpl::init_terminal_size ()
 {
   d->updateConsoleSize (true, true);
 }
@@ -1697,12 +1697,12 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QWinTerminalImpl::monitorConsole (void)
+void QWinTerminalImpl::monitorConsole ()
 {
   d->monitorConsole ();
 }
 
-void QWinTerminalImpl::updateSelection (void)
+void QWinTerminalImpl::updateSelection ()
 {
   d->updateSelection ();
 }
@@ -1761,7 +1761,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QWinTerminalImpl::start (void)
+void QWinTerminalImpl::start ()
 {
   d->startCommand ();
 }
@@ -1862,7 +1862,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QWinTerminalImpl::pasteClipboard (void)
+void QWinTerminalImpl::pasteClipboard ()
 {
   if(!hasFocus()) return;
 
@@ -1882,7 +1882,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void QWinTerminalImpl::selectAll (void)
+void QWinTerminalImpl::selectAll ()
 {
   if(!hasFocus()) return;
 
--- a/libgui/qterminal/libqterminal/win32/QWinTerminalImpl.h	Wed Jan 24 17:17:15 2024 -0500
+++ b/libgui/qterminal/libqterminal/win32/QWinTerminalImpl.h	Wed Jan 24 19:31:35 2024 -0500
@@ -50,7 +50,7 @@
 
 public:
   QWinTerminalImpl (QWidget *parent);
-  ~QWinTerminalImpl (void);
+  ~QWinTerminalImpl ();
 
   void setTerminalFont (const QFont& font);
   void setSize (int columns, int lines);
@@ -68,14 +68,14 @@
   void has_extra_interrupt (bool);
 
 public slots:
-  void copyClipboard (void);
-  void pasteClipboard (void);
-  void selectAll (void);
-  void blinkCursorEvent (void);
-  void init_terminal_size (void);
+  void copyClipboard ();
+  void pasteClipboard ();
+  void selectAll ();
+  void blinkCursorEvent ();
+  void init_terminal_size ();
 
 signals:
-  void terminated (void);
+  void terminated ();
   void titleChanged (const QString&);
 
 protected:
@@ -87,7 +87,7 @@
   void focusInEvent (QFocusEvent *);
   void focusOutEvent (QFocusEvent *);
   void keyPressEvent (QKeyEvent *);
-  virtual void start (void);
+  virtual void start ();
   void mouseMoveEvent (QMouseEvent *event);
   void mousePressEvent (QMouseEvent *event);
   void mouseReleaseEvent (QMouseEvent *event);
@@ -102,9 +102,9 @@
 private slots:
   void horizontalScrollValueChanged (int value);
   void verticalScrollValueChanged (int value);
-  void monitorConsole (void);
-  void updateSelection (void);
-  void tripleClickTimeout (void);
+  void monitorConsole ();
+  void updateSelection ();
+  void tripleClickTimeout ();
 
 private:
   QConsolePrivate *d;
--- a/libinterp/corefcn/defun-int.h	Wed Jan 24 17:17:15 2024 -0500
+++ b/libinterp/corefcn/defun-int.h	Wed Jan 24 19:31:35 2024 -0500
@@ -40,7 +40,7 @@
 
 class interpreter;
 
-extern OCTINTERP_API void print_usage (void);
+extern OCTINTERP_API void print_usage ();
 
 extern OCTINTERP_API void print_usage (const std::string&);
 
@@ -62,14 +62,14 @@
                       const dynamic_library& shl, bool relative = false);
 
 // Gets the shlib of the currently executing DLD function, if any.
-extern OCTINTERP_API dynamic_library get_current_shlib (void);
+extern OCTINTERP_API dynamic_library get_current_shlib ();
 
 OCTAVE_END_NAMESPACE(octave)
 
 // Some of these functions are widely used, so maybe we should avoid
 // deprecating them for now?
 
-inline void print_usage (void)
+inline void print_usage ()
 {
   octave::print_usage ();
 }
@@ -110,7 +110,7 @@
 }
 
 // Gets the shlib of the currently executing DLD function, if any.
-inline octave::dynamic_library get_current_shlib (void)
+inline octave::dynamic_library get_current_shlib ()
 {
   return octave::get_current_shlib ();
 }
--- a/libinterp/corefcn/mex.cc	Wed Jan 24 17:17:15 2024 -0500
+++ b/libinterp/corefcn/mex.cc	Wed Jan 24 19:31:35 2024 -0500
@@ -442,7 +442,7 @@
   RET_TYPE FCN_NAME ARG_LIST const { request_mutation (); return RET_VAL; }
 
 #define GET_DATA_METHOD(RT, FCN_NAME, ID, COMPLEXITY)                   \
-  RT * FCN_NAME (void) const { return get_data<RT> (ID, COMPLEXITY); }
+  RT * FCN_NAME () const { return get_data<RT> (ID, COMPLEXITY); }
 
 class mxArray_octave_value : public mxArray_base
 {
@@ -461,9 +461,9 @@
 
   mxArray_octave_value& operator = (const mxArray_octave_value&) = delete;
 
-  mxArray_base * dup (void) const { return new mxArray_octave_value (*this); }
-
-  mxArray * as_mxArray (void) const
+  mxArray_base * dup () const { return new mxArray_octave_value (*this); }
+
+  mxArray * as_mxArray () const
   {
     mxArray *retval = m_val.as_mxArray (m_interleaved);
 
@@ -500,62 +500,62 @@
     return retval;
   }
 
-  ~mxArray_octave_value (void)
+  ~mxArray_octave_value ()
   {
     mxFree (m_class_name);
     mxFree (m_dims);
   }
 
-  bool is_octave_value (void) const { return true; }
-
-  int iscell (void) const { return m_val.iscell (); }
-
-  int is_char (void) const { return m_val.is_string (); }
-
-  int is_complex (void) const { return m_val.iscomplex (); }
-
-  int is_double (void) const { return m_val.is_double_type (); }
-
-  int is_function_handle (void) const { return m_val.is_function_handle (); }
-
-  int is_int16 (void) const { return m_val.is_int16_type (); }
-
-  int is_int32 (void) const { return m_val.is_int32_type (); }
-
-  int is_int64 (void) const { return m_val.is_int64_type (); }
-
-  int is_int8 (void) const { return m_val.is_int8_type (); }
-
-  int is_logical (void) const { return m_val.islogical (); }
-
-  int is_numeric (void) const { return m_val.isnumeric (); }
-
-  int is_single (void) const { return m_val.is_single_type (); }
-
-  int is_sparse (void) const { return m_val.issparse (); }
-
-  int is_struct (void) const { return m_val.isstruct (); }
-
-  int is_uint16 (void) const { return m_val.is_uint16_type (); }
-
-  int is_uint32 (void) const { return m_val.is_uint32_type (); }
-
-  int is_uint64 (void) const { return m_val.is_uint64_type (); }
-
-  int is_uint8 (void) const { return m_val.is_uint8_type (); }
-
-  int is_range (void) const { return m_val.is_range (); }
-
-  int isreal (void) const { return m_val.isreal (); }
-
-  int is_logical_scalar_true (void) const
+  bool is_octave_value () const { return true; }
+
+  int iscell () const { return m_val.iscell (); }
+
+  int is_char () const { return m_val.is_string (); }
+
+  int is_complex () const { return m_val.iscomplex (); }
+
+  int is_double () const { return m_val.is_double_type (); }
+
+  int is_function_handle () const { return m_val.is_function_handle (); }
+
+  int is_int16 () const { return m_val.is_int16_type (); }
+
+  int is_int32 () const { return m_val.is_int32_type (); }
+
+  int is_int64 () const { return m_val.is_int64_type (); }
+
+  int is_int8 () const { return m_val.is_int8_type (); }
+
+  int is_logical () const { return m_val.islogical (); }
+
+  int is_numeric () const { return m_val.isnumeric (); }
+
+  int is_single () const { return m_val.is_single_type (); }
+
+  int is_sparse () const { return m_val.issparse (); }
+
+  int is_struct () const { return m_val.isstruct (); }
+
+  int is_uint16 () const { return m_val.is_uint16_type (); }
+
+  int is_uint32 () const { return m_val.is_uint32_type (); }
+
+  int is_uint64 () const { return m_val.is_uint64_type (); }
+
+  int is_uint8 () const { return m_val.is_uint8_type (); }
+
+  int is_range () const { return m_val.is_range (); }
+
+  int isreal () const { return m_val.isreal (); }
+
+  int is_logical_scalar_true () const
   {
     return (is_logical_scalar () && m_val.is_true ());
   }
 
-  mwSize get_m (void) const { return m_val.rows (); }
-
-  mwSize get_n (void) const
+  mwSize get_m () const { return m_val.rows (); }
+
+  mwSize get_n () const
   {
     mwSize n = 1;
 
@@ -568,7 +568,7 @@
     return n;
   }
 
-  mwSize * get_dimensions (void) const
+  mwSize * get_dimensions () const
   {
     if (! m_dims)
       {
@@ -586,7 +586,7 @@
     return m_dims;
   }
 
-  mwSize get_number_of_dimensions (void) const
+  mwSize get_number_of_dimensions () const
   {
     // Force m_dims and m_ndims to be cached.
     get_dimensions ();
@@ -599,11 +599,11 @@
 
   MUTATION_METHOD (int, set_dimensions, (mwSize *, mwSize), 0)
 
-  mwSize get_number_of_elements (void) const { return m_val.numel (); }
-
-  int isempty (void) const { return m_val.isempty (); }
-
-  bool is_scalar (void) const
+  mwSize get_number_of_elements () const { return m_val.numel (); }
+
+  int isempty () const { return m_val.isempty (); }
+
+  bool is_scalar () const
   {
     // Force m_dims and m_ndims to be cached.
     get_dimensions ();
@@ -611,7 +611,7 @@
     return m_ndims == 2 && m_dims[0] == 1 && m_dims[1] == 1;
   }
 
-  mxClassID get_class_id (void) const
+  mxClassID get_class_id () const
   {
     m_id = mxUNKNOWN_CLASS;
 
@@ -651,7 +651,7 @@
     return m_id;
   }
 
-  const char * get_class_name (void) const
+  const char * get_class_name () const
   {
     if (! m_class_name)
       {
@@ -703,7 +703,7 @@
   // Not allowed.
   VOID_MUTATION_METHOD (set_cell, (mwIndex, mxArray *))
 
-  double get_scalar (void) const
+  double get_scalar () const
   {
     if (m_val.issparse ())
       {
@@ -723,7 +723,7 @@
       return m_val.scalar_value (true);
   }
 
-  void * get_data (void) const
+  void * get_data () const
   {
     // Casting away const required for MEX interface.
 
@@ -784,7 +784,7 @@
   GET_DATA_METHOD (mxComplexSingle, get_complex_singles,
                    mxDOUBLE_CLASS, mxCOMPLEX);
 
-  void * get_imag_data (void) const
+  void * get_imag_data () const
   {
     void *retval = nullptr;
 
@@ -816,7 +816,7 @@
   // Not allowed.
   VOID_MUTATION_METHOD (set_imag_data, (void *))
 
-  mwIndex * get_ir (void) const
+  mwIndex * get_ir () const
   {
     // Casting away const required for MEX interface.
 
@@ -824,7 +824,7 @@
     return static_cast<mwIndex *> (maybe_mark_foreign (ptr));
   }
 
-  mwIndex * get_jc (void) const
+  mwIndex * get_jc () const
   {
     // Casting away const required for MEX interface.
 
@@ -832,7 +832,7 @@
     return static_cast<mwIndex *> (maybe_mark_foreign (ptr));
   }
 
-  mwSize get_nzmax (void) const { return m_val.nzmax (); }
+  mwSize get_nzmax () const { return m_val.nzmax (); }
 
   // Not allowed.
   VOID_MUTATION_METHOD (set_ir, (mwIndex *))
@@ -854,7 +854,7 @@
   // Not allowed.
   VOID_MUTATION_METHOD (set_field_by_number, (mwIndex, int, mxArray *))
 
-  int get_number_of_fields (void) const { return m_val.nfields (); }
+  int get_number_of_fields () const { return m_val.nfields (); }
 
   CONST_MUTATION_METHOD (const char *, get_field_name_by_number, (int), nullptr)
 
@@ -883,7 +883,7 @@
     return retval;
   }
 
-  char * array_to_string (void) const
+  char * array_to_string () const
   {
     // FIXME: this is supposed to handle multi-byte character strings.
 
@@ -919,7 +919,7 @@
     return calc_single_subscript_internal (m_ndims, m_dims, nsubs, subs);
   }
 
-  std::size_t get_element_size (void) const
+  std::size_t get_element_size () const
   {
     // Force m_id to be cached.
     get_class_id ();
@@ -947,9 +947,9 @@
       }
   }
 
-  bool mutation_needed (void) const { return m_mutate_flag; }
-
-  void request_mutation (void) const
+  bool mutation_needed () const { return m_mutate_flag; }
+
+  void request_mutation () const
   {
     if (m_mutate_flag)
       panic_impossible ();
@@ -957,9 +957,9 @@
     m_mutate_flag = true;
   }
 
-  mxArray * mutate (void) const { return as_mxArray (); }
-
-  octave_value as_octave_value (void) const { return m_val; }
+  mxArray * mutate () const { return as_mxArray (); }
+
+  octave_value as_octave_value () const { return m_val; }
 
 protected:
 
@@ -1009,33 +1009,33 @@
 
   mxArray_matlab& operator = (const mxArray_matlab&) = delete;
 
-  ~mxArray_matlab (void)
+  ~mxArray_matlab ()
   {
     mxFree (m_class_name);
     mxFree (m_dims);
   }
 
-  int iscell (void) const { return m_id == mxCELL_CLASS; }
-
-  int is_char (void) const { return m_id == mxCHAR_CLASS; }
-
-  int is_complex (void) const { return m_is_complex; }
-
-  int is_double (void) const { return m_id == mxDOUBLE_CLASS; }
-
-  int is_function_handle (void) const { return m_id == mxFUNCTION_CLASS; }
-
-  int is_int16 (void) const { return m_id == mxINT16_CLASS; }
-
-  int is_int32 (void) const { return m_id == mxINT32_CLASS; }
-
-  int is_int64 (void) const { return m_id == mxINT64_CLASS; }
-
-  int is_int8 (void) const { return m_id == mxINT8_CLASS; }
-
-  int is_logical (void) const { return m_id == mxLOGICAL_CLASS; }
-
-  int is_numeric (void) const
+  int iscell () const { return m_id == mxCELL_CLASS; }
+
+  int is_char () const { return m_id == mxCHAR_CLASS; }
+
+  int is_complex () const { return m_is_complex; }
+
+  int is_double () const { return m_id == mxDOUBLE_CLASS; }
+
+  int is_function_handle () const { return m_id == mxFUNCTION_CLASS; }
+
+  int is_int16 () const { return m_id == mxINT16_CLASS; }
+
+  int is_int32 () const { return m_id == mxINT32_CLASS; }
+
+  int is_int64 () const { return m_id == mxINT64_CLASS; }
+
+  int is_int8 () const { return m_id == mxINT8_CLASS; }
+
+  int is_logical () const { return m_id == mxLOGICAL_CLASS; }
+
+  int is_numeric () const
   {
     return (m_id == mxDOUBLE_CLASS || m_id == mxSINGLE_CLASS
             || m_id == mxINT8_CLASS || m_id == mxUINT8_CLASS
@@ -1044,29 +1044,29 @@
             || m_id == mxINT64_CLASS || m_id == mxUINT64_CLASS);
   }
 
-  int is_single (void) const { return m_id == mxSINGLE_CLASS; }
-
-  int is_sparse (void) const { return 0; }
-
-  int is_struct (void) const { return m_id == mxSTRUCT_CLASS; }
-
-  int is_uint16 (void) const { return m_id == mxUINT16_CLASS; }
-
-  int is_uint32 (void) const { return m_id == mxUINT32_CLASS; }
-
-  int is_uint64 (void) const { return m_id == mxUINT64_CLASS; }
-
-  int is_uint8 (void) const { return m_id == mxUINT8_CLASS; }
-
-  int is_logical_scalar_true (void) const
+  int is_single () const { return m_id == mxSINGLE_CLASS; }
+
+  int is_sparse () const { return 0; }
+
+  int is_struct () const { return m_id == mxSTRUCT_CLASS; }
+
+  int is_uint16 () const { return m_id == mxUINT16_CLASS; }
+
+  int is_uint32 () const { return m_id == mxUINT32_CLASS; }
+
+  int is_uint64 () const { return m_id == mxUINT64_CLASS; }
+
+  int is_uint8 () const { return m_id == mxUINT8_CLASS; }
+
+  int is_logical_scalar_true () const
   {
     return (is_logical_scalar ()
             && static_cast<mxLogical *> (get_data ())[0] != 0);
   }
 
-  mwSize get_m (void) const { return m_dims[0]; }
-
-  mwSize get_n (void) const
+  mwSize get_m () const { return m_dims[0]; }
+
+  mwSize get_n () const
   {
     mwSize n = 1;
 
@@ -1076,9 +1076,9 @@
     return n;
   }
 
-  mwSize * get_dimensions (void) const { return m_dims; }
-
-  mwSize get_number_of_dimensions (void) const { return m_ndims; }
+  mwSize * get_dimensions () const { return m_dims; }
+
+  mwSize get_number_of_dimensions () const { return m_ndims; }
 
   void set_m (mwSize m) { m_dims[0] = m; }
 
@@ -1110,7 +1110,7 @@
       }
   }
 
-  mwSize get_number_of_elements (void) const
+  mwSize get_number_of_elements () const
   {
     mwSize retval = m_dims[0];
 
@@ -1120,16 +1120,16 @@
     return retval;
   }
 
-  int isempty (void) const { return get_number_of_elements () == 0; }
-
-  bool is_scalar (void) const
+  int isempty () const { return get_number_of_elements () == 0; }
+
+  bool is_scalar () const
   {
     return m_ndims == 2 && m_dims[0] == 1 && m_dims[1] == 1;
   }
 
-  mxClassID get_class_id (void) const { return m_id; }
-
-  const char * get_class_name (void) const
+  mxClassID get_class_id () const { return m_id; }
+
+  const char * get_class_name () const
   {
     switch (m_id)
       {
@@ -1171,77 +1171,77 @@
     err_invalid_type ("set_cell");
   }
 
-  double get_scalar (void) const
+  double get_scalar () const
   {
     err_invalid_type ("get_scalar");
   }
 
-  void * get_data (void) const
+  void * get_data () const
   {
     err_invalid_type ("get_data");
   }
 
-  mxDouble * get_doubles (void) const
+  mxDouble * get_doubles () const
   {
     err_invalid_type ("get_doubles");
   }
 
-  mxSingle * get_singles (void) const
+  mxSingle * get_singles () const
   {
     err_invalid_type ("get_singles");
   }
 
-  mxInt8 * get_int8s (void) const
+  mxInt8 * get_int8s () const
   {
     err_invalid_type ("get_int8s");
   }
 
-  mxInt16 * get_int16s (void) const
+  mxInt16 * get_int16s () const
   {
     err_invalid_type ("get_int16s");
   }
 
-  mxInt32 * get_int32s (void) const
+  mxInt32 * get_int32s () const
   {
     err_invalid_type ("get_int32s");
   }
 
-  mxInt64 * get_int64s (void) const
+  mxInt64 * get_int64s () const
   {
     err_invalid_type ("get_int64s");
   }
 
-  mxUint8 * get_uint8s (void) const
+  mxUint8 * get_uint8s () const
   {
     err_invalid_type ("get_uint8s");
   }
 
-  mxUint16 * get_uint16s (void) const
+  mxUint16 * get_uint16s () const
   {
     err_invalid_type ("get_uint16s");
   }
 
-  mxUint32 * get_uint32s (void) const
+  mxUint32 * get_uint32s () const
   {
     err_invalid_type ("get_uint32s");
   }
 
-  mxUint64 * get_uint64s (void) const
+  mxUint64 * get_uint64s () const
   {
     err_invalid_type ("get_uint64s");
   }
 
-  mxComplexDouble * get_complex_doubles (void) const
+  mxComplexDouble * get_complex_doubles () const
   {
     err_invalid_type ("get_complex_doubles");
   }
 
-  mxComplexSingle * get_complex_singles (void) const
+  mxComplexSingle * get_complex_singles () const
   {
     err_invalid_type ("get_complex_singles");
   }
 
-  void * get_imag_data (void) const
+  void * get_imag_data () const
   {
     err_invalid_type ("get_imag_data");
   }
@@ -1316,17 +1316,17 @@
     err_invalid_type ("set_imag_data");
   }
 
-  mwIndex * get_ir (void) const
+  mwIndex * get_ir () const
   {
     err_invalid_type ("get_ir");
   }
 
-  mwIndex * get_jc (void) const
+  mwIndex * get_jc () const
   {
     err_invalid_type ("get_jc");
   }
 
-  mwSize get_nzmax (void) const
+  mwSize get_nzmax () const
   {
     err_invalid_type ("get_nzmax");
   }
@@ -1367,7 +1367,7 @@
     err_invalid_type ("set_field_by_number");
   }
 
-  int get_number_of_fields (void) const
+  int get_number_of_fields () const
   {
     err_invalid_type ("get_number_of_fields");
   }
@@ -1387,7 +1387,7 @@
     err_invalid_type ("get_string");
   }
 
-  char * array_to_string (void) const
+  char * array_to_string () const
   {
     err_invalid_type ("array_to_string");
   }
@@ -1397,7 +1397,7 @@
     return calc_single_subscript_internal (m_ndims, m_dims, nsubs, subs);
   }
 
-  std::size_t get_element_size (void) const
+  std::size_t get_element_size () const
   {
     switch (m_id)
       {
@@ -1493,7 +1493,7 @@
   void set_complexity (bool is_complex) { m_is_complex = is_complex; }
 
   dim_vector
-  dims_to_dim_vector (void) const
+  dims_to_dim_vector () const
   {
     mwSize nd = get_number_of_dimensions ();
 
@@ -1605,17 +1605,17 @@
 
   mxArray_base_full& operator = (const mxArray_base_full&) = delete;
 
-  mxArray_base * dup (void) const
+  mxArray_base * dup () const
   {
     return new mxArray_base_full (*this);
   }
 
-  ~mxArray_base_full (void)
+  ~mxArray_base_full ()
   {
     mxFree (m_pr);
   }
 
-  double get_scalar (void) const
+  double get_scalar () const
   {
     // FIXME: how does this work for interleaved complex arrays?
 
@@ -1678,7 +1678,7 @@
     return retval;
   }
 
-  void * get_data (void) const { return m_pr; }
+  void * get_data () const { return m_pr; }
 
   void set_data (void *pr) { m_pr = pr; }
 
@@ -1687,62 +1687,62 @@
   // definitions in the mxArray_separate_full class that override these
   // functions.
 
-  mxDouble * get_doubles (void) const
+  mxDouble * get_doubles () const
   {
     return static_cast<mxDouble *> (m_pr);
   }
 
-  mxSingle * get_singles (void) const
+  mxSingle * get_singles () const
   {
     return static_cast<mxSingle *> (m_pr);
   }
 
-  mxInt8 * get_int8s (void) const
+  mxInt8 * get_int8s () const
   {
     return static_cast<mxInt8 *> (m_pr);
   }
 
-  mxInt16 * get_int16s (void) const
+  mxInt16 * get_int16s () const
   {
     return static_cast<mxInt16 *> (m_pr);
   }
 
-  mxInt32 * get_int32s (void) const
+  mxInt32 * get_int32s () const
   {
     return static_cast<mxInt32 *> (m_pr);
   }
 
-  mxInt64 * get_int64s (void) const
+  mxInt64 * get_int64s () const
   {
     return static_cast<mxInt64 *> (m_pr);
   }
 
-  mxUint8 * get_uint8s (void) const
+  mxUint8 * get_uint8s () const
   {
     return static_cast<mxUint8 *> (m_pr);
   }
 
-  mxUint16 * get_uint16s (void) const
+  mxUint16 * get_uint16s () const
   {
     return static_cast<mxUint16 *> (m_pr);
   }
 
-  mxUint32 * get_uint32s (void) const
+  mxUint32 * get_uint32s () const
   {
     return static_cast<mxUint32 *> (m_pr);
   }
 
-  mxUint64 * get_uint64s (void) const
+  mxUint64 * get_uint64s () const
   {
     return static_cast<mxUint64 *> (m_pr);
   }
 
-  mxComplexDouble * get_complex_doubles (void) const
+  mxComplexDouble * get_complex_doubles () const
   {
     return static_cast<mxComplexDouble *> (m_pr);
   }
 
-  mxComplexSingle * get_complex_singles (void) const
+  mxComplexSingle * get_complex_singles () const
   {
     return static_cast<mxComplexSingle *> (m_pr);
   }
@@ -1845,7 +1845,7 @@
     return retval;
   }
 
-  char * array_to_string (void) const
+  char * array_to_string () const
   {
     // FIXME: this is supposed to handle multi-byte character strings.
 
@@ -1866,7 +1866,7 @@
     return buf;
   }
 
-  octave_value as_octave_value (void) const
+  octave_value as_octave_value () const
   {
     octave_value retval;
 
@@ -2043,14 +2043,14 @@
 
   mxArray_interleaved_full& operator = (const mxArray_interleaved_full&) = delete;
 
-  mxArray_base * dup (void) const
+  mxArray_base * dup () const
   {
     return new mxArray_interleaved_full (*this);
   }
 
-  ~mxArray_interleaved_full (void) = default;
-
-  void * get_imag_data (void) const { panic_impossible (); }
+  ~mxArray_interleaved_full () = default;
+
+  void * get_imag_data () const { panic_impossible (); }
 
   void set_imag_data (void */*pi*/) { panic_impossible (); }
 
@@ -2113,17 +2113,17 @@
 
   mxArray_separate_full& operator = (const mxArray_separate_full&) = delete;
 
-  mxArray_base * dup (void) const
+  mxArray_base * dup () const
   {
     return new mxArray_separate_full (*this);
   }
 
-  ~mxArray_separate_full (void)
+  ~mxArray_separate_full ()
   {
     mxFree (m_pi);
   }
 
-  void * get_imag_data (void) const { return m_pi; }
+  void * get_imag_data () const { return m_pi; }
 
   void set_imag_data (void *pi)
   {
@@ -2132,30 +2132,30 @@
     set_complexity (m_pi != nullptr);
   }
 
-  mxDouble * get_doubles (void) const { panic_impossible (); }
-  mxSingle * get_singles (void) const { panic_impossible (); }
-  mxInt8 * get_int8s (void) const { panic_impossible (); }
-  mxInt16 * get_int16s (void) const { panic_impossible (); }
-  mxInt32 * get_int32s (void) const { panic_impossible (); }
-  mxInt64 * get_int64s (void) const { panic_impossible (); }
-  mxUint8 * get_uint8s (void) const { panic_impossible (); }
-  mxUint16 * get_uint16s (void) const { panic_impossible (); }
-  mxUint32 * get_uint32s (void) const { panic_impossible (); }
-  mxUint64 * get_uint64s (void) const { panic_impossible (); }
-
-  mxComplexDouble * get_complex_doubles (void) const { panic_impossible (); }
-  mxComplexSingle * get_complex_singles (void) const { panic_impossible (); }
+  mxDouble * get_doubles () const { panic_impossible (); }
+  mxSingle * get_singles () const { panic_impossible (); }
+  mxInt8 * get_int8s () const { panic_impossible (); }
+  mxInt16 * get_int16s () const { panic_impossible (); }
+  mxInt32 * get_int32s () const { panic_impossible (); }
+  mxInt64 * get_int64s () const { panic_impossible (); }
+  mxUint8 * get_uint8s () const { panic_impossible (); }
+  mxUint16 * get_uint16s () const { panic_impossible (); }
+  mxUint32 * get_uint32s () const { panic_impossible (); }
+  mxUint64 * get_uint64s () const { panic_impossible (); }
+
+  mxComplexDouble * get_complex_doubles () const { panic_impossible (); }
+  mxComplexSingle * get_complex_singles () const { panic_impossible (); }
 
   // We don't have complex integer types, but for separate storage they
   // still would not work.
-  mxComplexInt8 * get_complex_int8s (void) const { panic_impossible (); }
-  mxComplexInt16 * get_complex_int16s (void) const { panic_impossible (); }
-  mxComplexInt32 * get_complex_int32s (void) const { panic_impossible (); }
-  mxComplexInt64 * get_complex_int64s (void) const { panic_impossible (); }
-  mxComplexUint8 * get_complex_uint8s (void) const { panic_impossible (); }
-  mxComplexUint16 * get_complex_uint16s (void) const { panic_impossible (); }
-  mxComplexUint32 * get_complex_uint32s (void) const { panic_impossible (); }
-  mxComplexUint64 * get_complex_uint64s (void) const { panic_impossible (); }
+  mxComplexInt8 * get_complex_int8s () const { panic_impossible (); }
+  mxComplexInt16 * get_complex_int16s () const { panic_impossible (); }
+  mxComplexInt32 * get_complex_int32s () const { panic_impossible (); }
+  mxComplexInt64 * get_complex_int64s () const { panic_impossible (); }
+  mxComplexUint8 * get_complex_uint8s () const { panic_impossible (); }
+  mxComplexUint16 * get_complex_uint16s () const { panic_impossible (); }
+  mxComplexUint32 * get_complex_uint32s () const { panic_impossible (); }
+  mxComplexUint64 * get_complex_uint64s () const { panic_impossible (); }
 
   int set_doubles (mxDouble *) { panic_impossible (); }
   int set_singles (mxSingle *) { panic_impossible (); }
@@ -2182,7 +2182,7 @@
   int set_complex_uint32s (mxComplexUint32 *) { panic_impossible (); }
   int set_complex_uint64s (mxComplexUint64 *) { panic_impossible (); }
 
-  octave_value as_octave_value (void) const
+  octave_value as_octave_value () const
   {
     if (! is_complex ())
       return mxArray_base_full::as_octave_value ();
@@ -2301,30 +2301,30 @@
 
   mxArray_base_sparse& operator = (const mxArray_base_sparse&) = delete;
 
-  mxArray_base * dup (void) const
+  mxArray_base * dup () const
   {
     return new mxArray_base_sparse (*this);
   }
 
-  ~mxArray_base_sparse (void)
+  ~mxArray_base_sparse ()
   {
     mxFree (m_ir);
     mxFree (m_jc);
     mxFree (m_pr);
   }
 
-  int is_sparse (void) const { return 1; }
-
-  void * get_data (void) const { return m_pr; }
+  int is_sparse () const { return 1; }
+
+  void * get_data () const { return m_pr; }
 
   void set_data (void *pr) { m_pr = pr; }
 
-  mxDouble * get_doubles (void) const
+  mxDouble * get_doubles () const
   {
     return static_cast<mxDouble *> (m_pr);
   }
 
-  mxComplexDouble * get_complex_doubles (void) const
+  mxComplexDouble * get_complex_doubles () const
   {
     return static_cast<mxComplexDouble *> (m_pr);
   }
@@ -2341,11 +2341,11 @@
     return 0;
   }
 
-  mwIndex * get_ir (void) const { return m_ir; }
-
-  mwIndex * get_jc (void) const { return m_jc; }
-
-  mwSize get_nzmax (void) const { return m_nzmax; }
+  mwIndex * get_ir () const { return m_ir; }
+
+  mwIndex * get_jc () const { return m_jc; }
+
+  mwSize get_nzmax () const { return m_nzmax; }
 
   void set_ir (mwIndex *ir) { m_ir = ir; }
 
@@ -2357,7 +2357,7 @@
     m_nzmax = (nzmax > 0 ? nzmax : 1);
   }
 
-  octave_value as_octave_value (void) const
+  octave_value as_octave_value () const
   {
     octave_value retval;
 
@@ -2469,14 +2469,14 @@
 
   mxArray_interleaved_sparse& operator = (const mxArray_interleaved_sparse&) = delete;
 
-  mxArray_base * dup (void) const
+  mxArray_base * dup () const
   {
     return new mxArray_interleaved_sparse (*this);
   }
 
-  ~mxArray_interleaved_sparse (void) = default;
-
-  void * get_imag_data (void) const { panic_impossible (); }
+  ~mxArray_interleaved_sparse () = default;
+
+  void * get_imag_data () const { panic_impossible (); }
 
   void set_imag_data (void */*pi*/) { panic_impossible (); }
 };
@@ -2514,17 +2514,17 @@
 
   mxArray_separate_sparse& operator = (const mxArray_separate_sparse&) = delete;
 
-  mxArray_base * dup (void) const
+  mxArray_base * dup () const
   {
     return new mxArray_separate_sparse (*this);
   }
 
-  ~mxArray_separate_sparse (void)
+  ~mxArray_separate_sparse ()
   {
     mxFree (m_pi);
   }
 
-  void * get_imag_data (void) const { return m_pi; }
+  void * get_imag_data () const { return m_pi; }
 
   void set_imag_data (void *pi)
   {
@@ -2532,13 +2532,13 @@
     set_complexity (m_pi != nullptr);
   }
 
-  mxDouble * get_doubles (void) const { panic_impossible (); }
-  mxComplexDouble * get_complex_doubles (void) const { panic_impossible (); }
+  mxDouble * get_doubles () const { panic_impossible (); }
+  mxComplexDouble * get_complex_doubles () const { panic_impossible (); }
 
   int set_doubles (mxDouble *) { panic_impossible (); }
   int set_complex_doubles (mxComplexDouble *) { panic_impossible (); }
 
-  octave_value as_octave_value (void) const
+  octave_value as_octave_value () const
   {
     if (! is_complex ())
       return mxArray_base_sparse::as_octave_value ();
@@ -2668,9 +2668,9 @@
       m_fields[i] = mxArray::strsave (keys[i]);
   }
 
-  mxArray_base * dup (void) const { return new mxArray_struct (*this); }
-
-  ~mxArray_struct (void)
+  mxArray_base * dup () const { return new mxArray_struct (*this); }
+
+  ~mxArray_struct ()
   {
     for (int i = 0; i < m_nfields; i++)
       mxFree (m_fields[i]);
@@ -2793,7 +2793,7 @@
 
   void set_field_by_number (mwIndex index, int key_num, mxArray *val);
 
-  int get_number_of_fields (void) const { return m_nfields; }
+  int get_number_of_fields () const { return m_nfields; }
 
   const char * get_field_name_by_number (int key_num) const
   {
@@ -2816,11 +2816,11 @@
     return retval;
   }
 
-  void * get_data (void) const { return m_data; }
+  void * get_data () const { return m_data; }
 
   void set_data (void *data) { m_data = static_cast<mxArray **> (data); }
 
-  octave_value as_octave_value (void) const
+  octave_value as_octave_value () const
   {
     const dim_vector& dv = dims_to_dim_vector ();
 
@@ -2900,9 +2900,9 @@
 
   mxArray_cell& operator = (const mxArray_cell&) = delete;
 
-  mxArray_base * dup (void) const { return new mxArray_cell (*this); }
-
-  ~mxArray_cell (void)
+  mxArray_base * dup () const { return new mxArray_cell (*this); }
+
+  ~mxArray_cell ()
   {
     mwSize nel = get_number_of_elements ();
 
@@ -2919,11 +2919,11 @@
 
   void set_cell (mwIndex idx, mxArray *val);
 
-  void * get_data (void) const { return m_data; }
+  void * get_data () const { return m_data; }
 
   void set_data (void *data) { m_data = static_cast<mxArray **> (data); }
 
-  octave_value as_octave_value (void) const
+  octave_value as_octave_value () const
   {
     const dim_vector& dv = dims_to_dim_vector ();
 
@@ -3018,7 +3018,7 @@
   : m_rep (new mxArray_cell (interleaved, m, n)), m_name (nullptr)
 { }
 
-mxArray::~mxArray (void)
+mxArray::~mxArray ()
 {
   mxFree (m_name);
 
@@ -3043,7 +3043,7 @@
 }
 
 octave_value
-mxArray::as_octave_value (void) const
+mxArray::as_octave_value () const
 {
   return m_rep->as_octave_value ();
 }
@@ -3131,7 +3131,7 @@
 }
 
 void
-mxArray::maybe_mutate (void) const
+mxArray::maybe_mutate () const
 {
   if (m_rep->is_octave_value ())
     {
@@ -3165,7 +3165,7 @@
 
   OCTAVE_DISABLE_CONSTRUCT_COPY_MOVE (mex)
 
-  ~mex (void)
+  ~mex ()
   {
     // We can't use mex::free here because it modifies memlist.
     while (! m_memlist.empty ())
@@ -3189,7 +3189,7 @@
     mxFree (m_fname);
   }
 
-  const char * function_name (void) const
+  const char * function_name () const
   {
     if (! m_fname)
       {
@@ -3414,7 +3414,7 @@
     return inlist;
   }
 
-  octave_mex_function& current_mex_function (void) const
+  octave_mex_function& current_mex_function () const
   {
     return m_curr_mex_fcn;
   }
@@ -3575,19 +3575,19 @@
 }
 
 double
-mxGetEps (void)
+mxGetEps ()
 {
   return std::numeric_limits<double>::epsilon ();
 }
 
 double
-mxGetInf (void)
+mxGetInf ()
 {
   return lo_ieee_inf_value ();
 }
 
 double
-mxGetNaN (void)
+mxGetNaN ()
 {
   return lo_ieee_nan_value ();
 }
@@ -4541,7 +4541,7 @@
 // C interface to mex functions:
 
 const char *
-mexFunctionName (void)
+mexFunctionName ()
 {
   return mex_context ? mex_context->function_name () : "unknown";
 }
@@ -4985,7 +4985,7 @@
 }
 
 int
-mexAtExit (void (*f) (void))
+mexAtExit (void (*f) ())
 {
   if (mex_context)
     {
@@ -5032,7 +5032,7 @@
 }
 
 int
-mexIsLocked (void)
+mexIsLocked ()
 {
   int retval = 0;
 
@@ -5051,7 +5051,7 @@
 std::map<std::string, int> mex_lock_count;
 
 void
-mexLock (void)
+mexLock ()
 {
   if (mex_context)
     {
@@ -5090,7 +5090,7 @@
 }
 
 void
-mexUnlock (void)
+mexUnlock ()
 {
   if (mex_context)
     {
--- a/libinterp/octave-value/ov-java.cc	Wed Jan 24 17:17:15 2024 -0500
+++ b/libinterp/octave-value/ov-java.cc	Wed Jan 24 19:31:35 2024 -0500
@@ -104,7 +104,7 @@
   java_local_ref (JNIEnv *env, T obj)
     : m_jobj (obj), m_detached (false), m_env (env) { }
 
-  ~java_local_ref (void) { release (); }
+  ~java_local_ref () { release (); }
 
   T& operator = (T obj)
   {
@@ -119,7 +119,7 @@
   operator bool () const { return (m_jobj != 0); }
   operator T () { return m_jobj; }
 
-  void detach (void) { m_detached = true; }
+  void detach () { m_detached = true; }
 
 protected:
 
@@ -129,11 +129,11 @@
 
 private:
 
-  java_local_ref (void)
+  java_local_ref ()
     : m_jobj (0), m_detached (false), m_env (0)
   { }
 
-  void release (void)
+  void release ()
   {
     if (m_env && m_jobj && ! m_detached)
       m_env->DeleteLocalRef (m_jobj);
--- a/liboctave/system/mach-info.cc	Wed Jan 24 17:17:15 2024 -0500
+++ b/liboctave/system/mach-info.cc	Wed Jan 24 19:31:35 2024 -0500
@@ -33,9 +33,9 @@
 
 extern "C"
 {
-  int octave_get_float_format (void);
+  int octave_get_float_format ();
 
-  int octave_is_big_endian (void);
+  int octave_is_big_endian ();
 }
 
 OCTAVE_BEGIN_NAMESPACE(octave)
--- a/liboctave/util/f77-dummy-main.cc	Wed Jan 24 17:17:15 2024 -0500
+++ b/liboctave/util/f77-dummy-main.cc	Wed Jan 24 19:31:35 2024 -0500
@@ -37,7 +37,7 @@
 
 extern "C"
 int
-F77_DUMMY_MAIN (void)
+F77_DUMMY_MAIN ()
 {
   assert (0);
 
--- a/liboctave/util/lo-ieee.h	Wed Jan 24 17:17:15 2024 -0500
+++ b/liboctave/util/lo-ieee.h	Wed Jan 24 19:31:35 2024 -0500
@@ -67,7 +67,7 @@
   unsigned int word;
 } lo_ieee_float;
 
-extern OCTAVE_API void octave_ieee_init (void);
+extern OCTAVE_API void octave_ieee_init ();
 
 inline int __lo_ieee_isnan (double x) { return std::isnan (x); }
 inline int __lo_ieee_isfinite (double x) { return std::isfinite (x); }
@@ -75,9 +75,9 @@
 
 extern OCTAVE_API int __lo_ieee_is_NA (double);
 
-extern OCTAVE_API double lo_ieee_inf_value (void);
-extern OCTAVE_API double lo_ieee_na_value (void);
-extern OCTAVE_API double lo_ieee_nan_value (void);
+extern OCTAVE_API double lo_ieee_inf_value ();
+extern OCTAVE_API double lo_ieee_na_value ();
+extern OCTAVE_API double lo_ieee_nan_value ();
 
 inline int __lo_ieee_signbit (double x) { return std::signbit (x); }
 
@@ -87,9 +87,9 @@
 
 extern OCTAVE_API int __lo_ieee_float_is_NA (float);
 
-extern OCTAVE_API float lo_ieee_float_inf_value (void);
-extern OCTAVE_API float lo_ieee_float_na_value (void);
-extern OCTAVE_API float lo_ieee_float_nan_value (void);
+extern OCTAVE_API float lo_ieee_float_inf_value ();
+extern OCTAVE_API float lo_ieee_float_na_value ();
+extern OCTAVE_API float lo_ieee_float_nan_value ();
 
 inline int __lo_ieee_float_signbit (float x) { return std::signbit (x); }
 
--- a/liboctave/util/oct-shlib.cc	Wed Jan 24 17:17:15 2024 -0500
+++ b/liboctave/util/oct-shlib.cc	Wed Jan 24 19:31:35 2024 -0500
@@ -37,7 +37,7 @@
 #    include <dlfcn.h>
 #  else
   extern void * dlopen (const char *, int);
-  extern const char * dlerror (void);
+  extern const char * dlerror ();
   extern void * dlsym (void *, const char *);
   extern int dlclose (void *);
 #  endif
--- a/liboctave/util/quit.cc	Wed Jan 24 17:17:15 2024 -0500
+++ b/liboctave/util/quit.cc	Wed Jan 24 19:31:35 2024 -0500
@@ -100,7 +100,7 @@
 OCTAVE_END_NAMESPACE(octave)
 
 extern "C" OCTAVE_API void
-octave_quit_c (void)
+octave_quit_c ()
 {
   octave_quit ();
 }
--- a/liboctave/util/quit.h	Wed Jan 24 17:17:15 2024 -0500
+++ b/liboctave/util/quit.h	Wed Jan 24 19:31:35 2024 -0500
@@ -48,7 +48,7 @@
 {
 public:
 
-  frame_info (void) = default;
+  frame_info () = default;
 
   frame_info (const std::string& file_name, const std::string& fcn_name,
               int line, int column)
@@ -60,15 +60,15 @@
 
   frame_info& operator = (const frame_info&) = default;
 
-  ~frame_info (void) = default;
+  ~frame_info () = default;
 
-  std::string file_name (void) const { return m_file_name; }
+  std::string file_name () const { return m_file_name; }
 
-  std::string fcn_name (void) const { return m_fcn_name; }
+  std::string fcn_name () const { return m_fcn_name; }
 
-  int line (void) const { return m_line; }
+  int line () const { return m_line; }
 
-  int column (void) const { return m_column; }
+  int column () const { return m_column; }
 
 private:
 
@@ -107,35 +107,35 @@
 
   execution_exception& operator = (const execution_exception&) = default;
 
-  ~execution_exception (void) = default;
+  ~execution_exception () = default;
 
   void set_err_type (const std::string& et)
   {
     m_err_type = et;
   }
 
-  std::string err_type (void) const { return m_err_type; }
+  std::string err_type () const { return m_err_type; }
 
-  virtual std::string stack_trace (void) const;
+  virtual std::string stack_trace () const;
 
   void set_identifier (const std::string& id)
   {
     m_id = id;
   }
 
-  virtual std::string identifier (void) const { return m_id; }
+  virtual std::string identifier () const { return m_id; }
 
   void set_message (const std::string& msg)
   {
     m_message = msg;
   }
 
-  std::string message (void) const { return m_message; }
+  std::string message () const { return m_message; }
 
   // Provided for std::exception interface.
-  const char * what (void) const noexcept { return m_message.c_str (); }
+  const char * what () const noexcept { return m_message.c_str (); }
 
-  virtual stack_info_type stack_info (void) const
+  virtual stack_info_type stack_info () const
   {
     return m_stack_info;
   }
@@ -169,11 +169,11 @@
 
   OCTAVE_DEFAULT_COPY_MOVE_DELETE (exit_exception)
 
-  const char * what (void) const noexcept { return "exit exception"; }
+  const char * what () const noexcept { return "exit exception"; }
 
-  int exit_status (void) const { return m_exit_status; }
+  int exit_status () const { return m_exit_status; }
 
-  bool safe_to_return (void) const { return m_safe_to_return; }
+  bool safe_to_return () const { return m_safe_to_return; }
 
 private:
 
@@ -186,15 +186,15 @@
 {
 public:
 
-  interrupt_exception (void) = default;
+  interrupt_exception () = default;
 
   interrupt_exception (const interrupt_exception&) = default;
 
   interrupt_exception& operator = (const interrupt_exception&) = default;
 
-  ~interrupt_exception (void) = default;
+  ~interrupt_exception () = default;
 
-  const char * what (void) const noexcept { return "interrupt exception"; }
+  const char * what () const noexcept { return "interrupt exception"; }
 };
 
 OCTAVE_END_NAMESPACE(octave)
@@ -234,7 +234,7 @@
 
 #if defined (__cplusplus)
 
-inline void octave_quit (void)
+inline void octave_quit ()
 {
   bool expected = true;
 
@@ -286,8 +286,8 @@
 /* These should only be declared for C++ code, and should also be
    outside of any extern "C" block.  */
 
-extern OCTAVE_API void (*octave_signal_hook) (void);
-extern OCTAVE_API void (*octave_interrupt_hook) (void);
+extern OCTAVE_API void (*octave_signal_hook) ();
+extern OCTAVE_API void (*octave_interrupt_hook) ();
 
 #endif