--- a/libinterp/corefcn/sighandlers.cc	Thu Dec 01 14:23:45 2022 -0800
+++ b/libinterp/corefcn/sighandlers.cc	Thu Dec 01 18:02:15 2022 -0800
@@ -60,436 +60,436 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  // Nonzero means we have already printed a message for this series of
-  // SIGPIPES.  We assume that the writer will eventually give up.
-  int pipe_handler_error_count = 0;
+// Nonzero means we have already printed a message for this series of
+// SIGPIPES.  We assume that the writer will eventually give up.
+int pipe_handler_error_count = 0;
 
-  // TRUE means we can be interrupted.
-  bool can_interrupt = false;
+// TRUE means we can be interrupted.
+bool can_interrupt = false;
 
-  // TRUE means we should try to enter the debugger on SIGINT.
-  bool Vdebug_on_interrupt = false;
+// TRUE means we should try to enter the debugger on SIGINT.
+bool Vdebug_on_interrupt = false;
 
-  // Allow users to avoid writing octave-workspace for SIGHUP (sent by
-  // closing gnome-terminal, for example).  Note that this variable has
-  // no effect if Vcrash_dumps_octave_core is FALSE.
-  static bool Vsighup_dumps_octave_core = true;
+// Allow users to avoid writing octave-workspace for SIGHUP (sent by
+// closing gnome-terminal, for example).  Note that this variable has
+// no effect if Vcrash_dumps_octave_core is FALSE.
+static bool Vsighup_dumps_octave_core = true;
 
-  // Similar to Vsighup_dumps_octave_core, but for SIGQUIT signal.
-  static bool Vsigquit_dumps_octave_core = true;
+// Similar to Vsighup_dumps_octave_core, but for SIGQUIT signal.
+static bool Vsigquit_dumps_octave_core = true;
 
-  // Similar to Vsighup_dumps_octave_core, but for SIGTERM signal.
-  static bool Vsigterm_dumps_octave_core = true;
+// Similar to Vsighup_dumps_octave_core, but for SIGTERM signal.
+static bool Vsigterm_dumps_octave_core = true;
 
-  // List of signals we have caught since last call to signal_handler.
-  static bool *signals_caught = nullptr;
+// List of signals we have caught since last call to signal_handler.
+static bool *signals_caught = nullptr;
 
-  static void
-  my_friendly_exit (int sig, bool save_vars = true)
-  {
-    std::cerr << "fatal: caught signal "
-              << octave_strsignal_wrapper (sig)
-              << " -- stopping myself..." << std::endl;
+static void
+my_friendly_exit (int sig, bool save_vars = true)
+{
+  std::cerr << "fatal: caught signal "
+            << octave_strsignal_wrapper (sig)
+            << " -- stopping myself..." << std::endl;
 
-    if (save_vars)
-      {
-        load_save_system& load_save_sys = __get_load_save_system__ ();
+  if (save_vars)
+    {
+      load_save_system& load_save_sys = __get_load_save_system__ ();
 
-        load_save_sys.dump_octave_core ();
-      }
+      load_save_sys.dump_octave_core ();
+    }
 
-    sysdep_cleanup ();
+  sysdep_cleanup ();
 
-    throw exit_exception (1);
-  }
+  throw exit_exception (1);
+}
 
-  // Called from octave_quit () to actually do something about the signals
-  // we have caught.
+// Called from octave_quit () to actually do something about the signals
+// we have caught.
 
-  void
-  respond_to_pending_signals (void)
-  {
-    // The list of signals is relatively short, so we will just go
-    // linearly through the list.
+void
+respond_to_pending_signals (void)
+{
+  // The list of signals is relatively short, so we will just go
+  // linearly through the list.
 
-    // Interrupt signals are currently handled separately.
+  // Interrupt signals are currently handled separately.
 
-    static int sigint;
-    static const bool have_sigint
-      = octave_get_sig_number ("SIGINT", &sigint);
+  static int sigint;
+  static const bool have_sigint
+    = octave_get_sig_number ("SIGINT", &sigint);
 
-    static int sigbreak;
-    static const bool have_sigbreak
-      = octave_get_sig_number ("SIGBREAK", &sigbreak);
+  static int sigbreak;
+  static const bool have_sigbreak
+    = octave_get_sig_number ("SIGBREAK", &sigbreak);
 
-    // Termination signals.
+  // Termination signals.
 
-    static int sighup;
-    static const bool have_sighup
-      = octave_get_sig_number ("SIGHUP", &sighup);
+  static int sighup;
+  static const bool have_sighup
+    = octave_get_sig_number ("SIGHUP", &sighup);
 
-    static int sigquit;
-    static const bool have_sigquit
-      = octave_get_sig_number ("SIGQUIT", &sigquit);
+  static int sigquit;
+  static const bool have_sigquit
+    = octave_get_sig_number ("SIGQUIT", &sigquit);
 
-    static int sigterm;
-    static const bool have_sigterm
-      = octave_get_sig_number ("SIGTERM", &sigterm);
+  static int sigterm;
+  static const bool have_sigterm
+    = octave_get_sig_number ("SIGTERM", &sigterm);
 
-    // Alarm signals.
+  // Alarm signals.
 
-    static int sigalrm;
-    static const bool have_sigalrm
-      = octave_get_sig_number ("SIGALRM", &sigalrm);
+  static int sigalrm;
+  static const bool have_sigalrm
+    = octave_get_sig_number ("SIGALRM", &sigalrm);
 
-    static int sigvtalrm;
-    static const bool have_sigvtalrm
-      = octave_get_sig_number ("SIGVTALRM", &sigvtalrm);
+  static int sigvtalrm;
+  static const bool have_sigvtalrm
+    = octave_get_sig_number ("SIGVTALRM", &sigvtalrm);
 
-    // I/O signals.
+  // I/O signals.
 
-    static int sigio;
-    static const bool have_sigio
-      = octave_get_sig_number ("SIGIO", &sigio);
+  static int sigio;
+  static const bool have_sigio
+    = octave_get_sig_number ("SIGIO", &sigio);
 
-    static int siglost;
-    static const bool have_siglost
-      = octave_get_sig_number ("SIGLOST", &siglost);
+  static int siglost;
+  static const bool have_siglost
+    = octave_get_sig_number ("SIGLOST", &siglost);
 
-    static int sigpipe;
-    static const bool have_sigpipe
-      = octave_get_sig_number ("SIGPIPE", &sigpipe);
+  static int sigpipe;
+  static const bool have_sigpipe
+    = octave_get_sig_number ("SIGPIPE", &sigpipe);
 
-    // Job control signals.
+  // Job control signals.
 
-    static int sigchld;
-    static const bool have_sigchld
-      = octave_get_sig_number ("SIGCHLD", &sigchld);
+  static int sigchld;
+  static const bool have_sigchld
+    = octave_get_sig_number ("SIGCHLD", &sigchld);
 
-    static int sigcld;
-    static const bool have_sigcld
-      = octave_get_sig_number ("SIGCLD", &sigcld);
+  static int sigcld;
+  static const bool have_sigcld
+    = octave_get_sig_number ("SIGCLD", &sigcld);
 
-    // Resource limit signals.
+  // Resource limit signals.
 
-    static int sigxcpu;
-    static const bool have_sigxcpu
-      = octave_get_sig_number ("SIGXCPU", &sigxcpu);
+  static int sigxcpu;
+  static const bool have_sigxcpu
+    = octave_get_sig_number ("SIGXCPU", &sigxcpu);
 
-    static int sigxfsz;
-    static const bool have_sigxfsz
-      = octave_get_sig_number ("SIGXFSZ", &sigxfsz);
+  static int sigxfsz;
+  static const bool have_sigxfsz
+    = octave_get_sig_number ("SIGXFSZ", &sigxfsz);
 
-    // User signals.
+  // User signals.
 
-    static int sigusr1;
-    static const bool have_sigusr1
-      = octave_get_sig_number ("SIGUSR1", &sigusr1);
+  static int sigusr1;
+  static const bool have_sigusr1
+    = octave_get_sig_number ("SIGUSR1", &sigusr1);
 
-    static int sigusr2;
-    static const bool have_sigusr2
-      = octave_get_sig_number ("SIGUSR2", &sigusr2);
+  static int sigusr2;
+  static const bool have_sigusr2
+    = octave_get_sig_number ("SIGUSR2", &sigusr2);
 
-    child_list& kids = __get_child_list__ ();
+  child_list& kids = __get_child_list__ ();
 
-    for (int sig = 0; sig < octave_num_signals (); sig++)
-      {
-        if (signals_caught[sig])
-          {
-            signals_caught[sig] = false;
+  for (int sig = 0; sig < octave_num_signals (); sig++)
+    {
+      if (signals_caught[sig])
+        {
+          signals_caught[sig] = false;
 
-            if ((have_sigchld && sig == sigchld)
-                || (have_sigcld && sig == sigcld))
-              {
-                // FIXME: should we block or ignore?
-                volatile interrupt_handler saved_interrupt_handler
-                  = ignore_interrupts ();
+          if ((have_sigchld && sig == sigchld)
+              || (have_sigcld && sig == sigcld))
+            {
+              // FIXME: should we block or ignore?
+              volatile interrupt_handler saved_interrupt_handler
+                = ignore_interrupts ();
 
-                void *context = octave_block_child ();
+              void *context = octave_block_child ();
 
-                kids.wait ();
+              kids.wait ();
 
-                set_interrupt_handler (saved_interrupt_handler);
+              set_interrupt_handler (saved_interrupt_handler);
 
-                octave_unblock_child (context);
+              octave_unblock_child (context);
 
-                kids.reap ();
-              }
-            else if (have_sigpipe && sig == sigpipe)
-              {
-                std::cerr << "warning: broken pipe" << std::endl;
+              kids.reap ();
+            }
+          else if (have_sigpipe && sig == sigpipe)
+            {
+              std::cerr << "warning: broken pipe" << std::endl;
 
-                // Don't loop forever on account of this.
-                // FIXME: is this really needed?  Does it do anything
-                // useful now?
+              // Don't loop forever on account of this.
+              // FIXME: is this really needed?  Does it do anything
+              // useful now?
 
-                if (pipe_handler_error_count++ > 100
-                    && octave_interrupt_state >= 0)
-                  octave_interrupt_state++;
-              }
-            else if (have_sighup && sig == sighup)
-              my_friendly_exit (sighup, Vsighup_dumps_octave_core);
-            else if (have_sigquit && sig == sigquit)
-              my_friendly_exit (sigquit, Vsigquit_dumps_octave_core);
-            else if (have_sigterm && sig == sigterm)
-              my_friendly_exit (sigterm, Vsigterm_dumps_octave_core);
-            else if ((have_sigalrm && sig == sigalrm)
-                     || (have_sigvtalrm && sig == sigvtalrm)
-                     || (have_sigio && sig == sigio)
-                     || (have_siglost && sig == siglost)
-                     || (have_sigxcpu && sig == sigxcpu)
-                     || (have_sigxfsz && sig == sigxfsz)
-                     || (have_sigusr1 && sig == sigusr1)
-                     || (have_sigusr2 && sig == sigusr2))
-              std::cerr << "warning: ignoring signal: "
-                        << octave_strsignal_wrapper (sig)
-                        << std::endl;
-            else if ((have_sigint && sig == sigint)
-                     || (have_sigbreak && sig == sigbreak))
-              ; // Handled separately; do nothing.
-            else
-              std::cerr << "warning: ignoring unexpected signal: "
-                        << octave_strsignal_wrapper (sig)
-                        << std::endl;
-          }
-      }
-  }
+              if (pipe_handler_error_count++ > 100
+                  && octave_interrupt_state >= 0)
+                octave_interrupt_state++;
+            }
+          else if (have_sighup && sig == sighup)
+            my_friendly_exit (sighup, Vsighup_dumps_octave_core);
+          else if (have_sigquit && sig == sigquit)
+            my_friendly_exit (sigquit, Vsigquit_dumps_octave_core);
+          else if (have_sigterm && sig == sigterm)
+            my_friendly_exit (sigterm, Vsigterm_dumps_octave_core);
+          else if ((have_sigalrm && sig == sigalrm)
+                   || (have_sigvtalrm && sig == sigvtalrm)
+                   || (have_sigio && sig == sigio)
+                   || (have_siglost && sig == siglost)
+                   || (have_sigxcpu && sig == sigxcpu)
+                   || (have_sigxfsz && sig == sigxfsz)
+                   || (have_sigusr1 && sig == sigusr1)
+                   || (have_sigusr2 && sig == sigusr2))
+            std::cerr << "warning: ignoring signal: "
+                      << octave_strsignal_wrapper (sig)
+                      << std::endl;
+          else if ((have_sigint && sig == sigint)
+                   || (have_sigbreak && sig == sigbreak))
+            ; // Handled separately; do nothing.
+          else
+            std::cerr << "warning: ignoring unexpected signal: "
+                      << octave_strsignal_wrapper (sig)
+                      << std::endl;
+        }
+    }
+}
 
-  sig_handler *
-  set_signal_handler (int sig, sig_handler *handler, bool restart_syscalls)
-  {
-    return octave_set_signal_handler_internal (sig, handler, restart_syscalls);
-  }
+sig_handler *
+set_signal_handler (int sig, sig_handler *handler, bool restart_syscalls)
+{
+  return octave_set_signal_handler_internal (sig, handler, restart_syscalls);
+}
 
-  sig_handler *
-  set_signal_handler (const char *signame, sig_handler *handler,
-                      bool restart_syscalls)
-  {
-    return octave_set_signal_handler_by_name (signame, handler,
-                                              restart_syscalls);
-  }
+sig_handler *
+set_signal_handler (const char *signame, sig_handler *handler,
+                    bool restart_syscalls)
+{
+  return octave_set_signal_handler_by_name (signame, handler,
+         restart_syscalls);
+}
 
-  static void
-  generic_sig_handler (int sig)
-  {
-    // FIXME: this function may execute in a separate signal handler or
-    // signal watcher thread so it should probably be more careful about
-    // how it accesses global objects.
+static void
+generic_sig_handler (int sig)
+{
+  // FIXME: this function may execute in a separate signal handler or
+  // signal watcher thread so it should probably be more careful about
+  // how it accesses global objects.
 
-    octave_signal_caught = 1;
+  octave_signal_caught = 1;
 
-    signals_caught[sig] = true;
+  signals_caught[sig] = true;
 
-    static int sigint;
-    static const bool have_sigint
-      = octave_get_sig_number ("SIGINT", &sigint);
+  static int sigint;
+  static const bool have_sigint
+    = octave_get_sig_number ("SIGINT", &sigint);
 
-    static int sigbreak;
-    static const bool have_sigbreak
-      = octave_get_sig_number ("SIGBREAK", &sigbreak);
+  static int sigbreak;
+  static const bool have_sigbreak
+    = octave_get_sig_number ("SIGBREAK", &sigbreak);
 
-    if ((have_sigint && sig == sigint)
-        || (have_sigbreak && sig == sigbreak))
-      {
-        if (! octave_initialized)
-          exit (1);
+  if ((have_sigint && sig == sigint)
+      || (have_sigbreak && sig == sigbreak))
+    {
+      if (! octave_initialized)
+        exit (1);
 
-        if (can_interrupt)
-          {
-            octave_signal_caught = 1;
-            octave_interrupt_state++;
-          }
-      }
-  }
+      if (can_interrupt)
+        {
+          octave_signal_caught = 1;
+          octave_interrupt_state++;
+        }
+    }
+}
 
-  static void
-  deadly_sig_handler (int sig)
-  {
-    std::cerr << "fatal: caught signal "
-              << octave_strsignal_wrapper (sig)
-              << " -- stopping myself..." << std::endl;
+static void
+deadly_sig_handler (int sig)
+{
+  std::cerr << "fatal: caught signal "
+            << octave_strsignal_wrapper (sig)
+            << " -- stopping myself..." << std::endl;
 
-    octave_set_default_signal_handler (sig);
+  octave_set_default_signal_handler (sig);
 
-    octave_raise_wrapper (sig);
-  }
+  octave_raise_wrapper (sig);
+}
 
-  static void
-  fpe_sig_handler (int)
-  {
-    // FIXME: is there something better we can do?
+static void
+fpe_sig_handler (int)
+{
+  // FIXME: is there something better we can do?
 
-    std::cerr << "warning: floating point exception" << std::endl;
-  }
+  std::cerr << "warning: floating point exception" << std::endl;
+}
 
-  interrupt_handler
-  catch_interrupts (void)
-  {
-    interrupt_handler retval;
+interrupt_handler
+catch_interrupts (void)
+{
+  interrupt_handler retval;
 
-    retval.int_handler = set_signal_handler ("SIGINT", generic_sig_handler);
-    retval.brk_handler = set_signal_handler ("SIGBREAK", generic_sig_handler);
+  retval.int_handler = set_signal_handler ("SIGINT", generic_sig_handler);
+  retval.brk_handler = set_signal_handler ("SIGBREAK", generic_sig_handler);
 
-    return retval;
-  }
+  return retval;
+}
 
-  interrupt_handler
-  ignore_interrupts (void)
-  {
-    interrupt_handler retval;
+interrupt_handler
+ignore_interrupts (void)
+{
+  interrupt_handler retval;
 
-    retval.int_handler = set_signal_handler ("SIGINT", SIG_IGN);
-    retval.brk_handler = set_signal_handler ("SIGBREAK", SIG_IGN);
+  retval.int_handler = set_signal_handler ("SIGINT", SIG_IGN);
+  retval.brk_handler = set_signal_handler ("SIGBREAK", SIG_IGN);
 
-    return retval;
-  }
+  return retval;
+}
 
-  interrupt_handler
-  set_interrupt_handler (const volatile interrupt_handler& h,
-                         bool restart_syscalls)
-  {
-    interrupt_handler retval;
+interrupt_handler
+set_interrupt_handler (const volatile interrupt_handler& h,
+                       bool restart_syscalls)
+{
+  interrupt_handler retval;
 
-    retval.int_handler = set_signal_handler ("SIGINT", h.int_handler,
-                                             restart_syscalls);
+  retval.int_handler = set_signal_handler ("SIGINT", h.int_handler,
+                       restart_syscalls);
 
-    retval.brk_handler = set_signal_handler ("SIGBREAK", h.brk_handler,
-                                             restart_syscalls);
+  retval.brk_handler = set_signal_handler ("SIGBREAK", h.brk_handler,
+                       restart_syscalls);
 
-    return retval;
-  }
+  return retval;
+}
 
-  // Install all the handlers for the signals we might care about.
+// Install all the handlers for the signals we might care about.
 
-  void
-  install_signal_handlers (void)
-  {
-    if (! signals_caught)
-      signals_caught = new bool [octave_num_signals ()];
+void
+install_signal_handlers (void)
+{
+  if (! signals_caught)
+    signals_caught = new bool [octave_num_signals ()];
 
-    for (int i = 0; i < octave_num_signals (); i++)
-      signals_caught[i] = false;
+  for (int i = 0; i < octave_num_signals (); i++)
+    signals_caught[i] = false;
 
-    // Interrupt signals.
+  // Interrupt signals.
 
-    catch_interrupts ();
+  catch_interrupts ();
 
-    // Program Error signals.  These are most likely unrecoverable for
-    // us.
+  // Program Error signals.  These are most likely unrecoverable for
+  // us.
 
-    set_signal_handler ("SIGABRT", deadly_sig_handler);
-    set_signal_handler ("SIGBUS", deadly_sig_handler);
-    set_signal_handler ("SIGEMT", deadly_sig_handler);
-    set_signal_handler ("SIGILL", deadly_sig_handler);
-    // SIGIOT is normally another name for SIGABRT.
-    set_signal_handler ("SIGIOT", deadly_sig_handler);
-    set_signal_handler ("SIGSEGV", deadly_sig_handler);
-    set_signal_handler ("SIGSYS", deadly_sig_handler);
-    set_signal_handler ("SIGTRAP", deadly_sig_handler);
+  set_signal_handler ("SIGABRT", deadly_sig_handler);
+  set_signal_handler ("SIGBUS", deadly_sig_handler);
+  set_signal_handler ("SIGEMT", deadly_sig_handler);
+  set_signal_handler ("SIGILL", deadly_sig_handler);
+  // SIGIOT is normally another name for SIGABRT.
+  set_signal_handler ("SIGIOT", deadly_sig_handler);
+  set_signal_handler ("SIGSEGV", deadly_sig_handler);
+  set_signal_handler ("SIGSYS", deadly_sig_handler);
+  set_signal_handler ("SIGTRAP", deadly_sig_handler);
 
-    // Handle SIGFPE separately.
+  // Handle SIGFPE separately.
 
-    set_signal_handler ("SIGFPE", fpe_sig_handler);
+  set_signal_handler ("SIGFPE", fpe_sig_handler);
 
-    // Handle other signals for which the default action is to terminate
-    // the program.
+  // Handle other signals for which the default action is to terminate
+  // the program.
 
-    // Termination signals.
+  // Termination signals.
 
-    set_signal_handler ("SIGHUP", generic_sig_handler);
-    set_signal_handler ("SIGQUIT", generic_sig_handler);
-    set_signal_handler ("SIGTERM", generic_sig_handler);
+  set_signal_handler ("SIGHUP", generic_sig_handler);
+  set_signal_handler ("SIGQUIT", generic_sig_handler);
+  set_signal_handler ("SIGTERM", generic_sig_handler);
 
-    // Alarm signals.
+  // Alarm signals.
 
-    set_signal_handler ("SIGALRM", generic_sig_handler);
-    set_signal_handler ("SIGVTALRM", generic_sig_handler);
+  set_signal_handler ("SIGALRM", generic_sig_handler);
+  set_signal_handler ("SIGVTALRM", generic_sig_handler);
 
-    // I/O signals.
+  // I/O signals.
 
-    set_signal_handler ("SIGLOST", generic_sig_handler);
-    set_signal_handler ("SIGPIPE", generic_sig_handler);
+  set_signal_handler ("SIGLOST", generic_sig_handler);
+  set_signal_handler ("SIGPIPE", generic_sig_handler);
 
-    // Job control signals.  We only recognize signals about child
-    // processes.
+  // Job control signals.  We only recognize signals about child
+  // processes.
 
-    set_signal_handler ("SIGCHLD", generic_sig_handler);
-    set_signal_handler ("SIGCLD", generic_sig_handler);
+  set_signal_handler ("SIGCHLD", generic_sig_handler);
+  set_signal_handler ("SIGCLD", generic_sig_handler);
 
-    // Resource limit signals.
+  // Resource limit signals.
 
-    // FIXME: does it really make sense to try to handle the CPU limit
-    // signal?
+  // FIXME: does it really make sense to try to handle the CPU limit
+  // signal?
 
-    set_signal_handler ("SIGXCPU", generic_sig_handler);
-    set_signal_handler ("SIGXFSZ", generic_sig_handler);
+  set_signal_handler ("SIGXCPU", generic_sig_handler);
+  set_signal_handler ("SIGXFSZ", generic_sig_handler);
 
-    // User signals.
+  // User signals.
 
-    set_signal_handler ("SIGUSR1", generic_sig_handler);
-    set_signal_handler ("SIGUSR2", generic_sig_handler);
+  set_signal_handler ("SIGUSR1", generic_sig_handler);
+  set_signal_handler ("SIGUSR2", generic_sig_handler);
 
-    // This does nothing on Windows systems.
-    octave_create_interrupt_watcher_thread (generic_sig_handler);
-  }
+  // This does nothing on Windows systems.
+  octave_create_interrupt_watcher_thread (generic_sig_handler);
+}
 
-  static void
-  set_sig_struct_field (octave_scalar_map& m, const char *signame)
-  {
-    int signum;
+static void
+set_sig_struct_field (octave_scalar_map& m, const char *signame)
+{
+  int signum;
 
-    // The names in the struct do not include the leading "SIG" prefix.
+  // The names in the struct do not include the leading "SIG" prefix.
 
-    if (octave_get_sig_number (signame, &signum))
-      m.assign (&signame[3], signum);
-  }
+  if (octave_get_sig_number (signame, &signum))
+    m.assign (&signame[3], signum);
+}
 
-  static octave_scalar_map
-  make_sig_struct (void)
-  {
-    octave_scalar_map m;
+static octave_scalar_map
+make_sig_struct (void)
+{
+  octave_scalar_map m;
 
-    set_sig_struct_field (m, "SIGABRT");
-    set_sig_struct_field (m, "SIGALRM");
-    set_sig_struct_field (m, "SIGBUS");
-    set_sig_struct_field (m, "SIGCHLD");
-    set_sig_struct_field (m, "SIGCLD");
-    set_sig_struct_field (m, "SIGCONT");
-    set_sig_struct_field (m, "SIGEMT");
-    set_sig_struct_field (m, "SIGFPE");
-    set_sig_struct_field (m, "SIGHUP");
-    set_sig_struct_field (m, "SIGILL");
-    set_sig_struct_field (m, "SIGINFO");
-    set_sig_struct_field (m, "SIGINT");
-    set_sig_struct_field (m, "SIGIO");
-    set_sig_struct_field (m, "SIGIOT");
-    set_sig_struct_field (m, "SIGKILL");
-    set_sig_struct_field (m, "SIGLOST");
-    set_sig_struct_field (m, "SIGPIPE");
-    set_sig_struct_field (m, "SIGPOLL");
-    set_sig_struct_field (m, "SIGPROF");
-    set_sig_struct_field (m, "SIGPWR");
-    set_sig_struct_field (m, "SIGQUIT");
-    set_sig_struct_field (m, "SIGSEGV");
-    set_sig_struct_field (m, "SIGSTKFLT");
-    set_sig_struct_field (m, "SIGSTOP");
-    set_sig_struct_field (m, "SIGSYS");
-    set_sig_struct_field (m, "SIGTERM");
-    set_sig_struct_field (m, "SIGTRAP");
-    set_sig_struct_field (m, "SIGTSTP");
-    set_sig_struct_field (m, "SIGTTIN");
-    set_sig_struct_field (m, "SIGTTOU");
-    set_sig_struct_field (m, "SIGUNUSED");
-    set_sig_struct_field (m, "SIGURG");
-    set_sig_struct_field (m, "SIGUSR1");
-    set_sig_struct_field (m, "SIGUSR2");
-    set_sig_struct_field (m, "SIGVTALRM");
-    set_sig_struct_field (m, "SIGWINCH");
-    set_sig_struct_field (m, "SIGXCPU");
-    set_sig_struct_field (m, "SIGXFSZ");
+  set_sig_struct_field (m, "SIGABRT");
+  set_sig_struct_field (m, "SIGALRM");
+  set_sig_struct_field (m, "SIGBUS");
+  set_sig_struct_field (m, "SIGCHLD");
+  set_sig_struct_field (m, "SIGCLD");
+  set_sig_struct_field (m, "SIGCONT");
+  set_sig_struct_field (m, "SIGEMT");
+  set_sig_struct_field (m, "SIGFPE");
+  set_sig_struct_field (m, "SIGHUP");
+  set_sig_struct_field (m, "SIGILL");
+  set_sig_struct_field (m, "SIGINFO");
+  set_sig_struct_field (m, "SIGINT");
+  set_sig_struct_field (m, "SIGIO");
+  set_sig_struct_field (m, "SIGIOT");
+  set_sig_struct_field (m, "SIGKILL");
+  set_sig_struct_field (m, "SIGLOST");
+  set_sig_struct_field (m, "SIGPIPE");
+  set_sig_struct_field (m, "SIGPOLL");
+  set_sig_struct_field (m, "SIGPROF");
+  set_sig_struct_field (m, "SIGPWR");
+  set_sig_struct_field (m, "SIGQUIT");
+  set_sig_struct_field (m, "SIGSEGV");
+  set_sig_struct_field (m, "SIGSTKFLT");
+  set_sig_struct_field (m, "SIGSTOP");
+  set_sig_struct_field (m, "SIGSYS");
+  set_sig_struct_field (m, "SIGTERM");
+  set_sig_struct_field (m, "SIGTRAP");
+  set_sig_struct_field (m, "SIGTSTP");
+  set_sig_struct_field (m, "SIGTTIN");
+  set_sig_struct_field (m, "SIGTTOU");
+  set_sig_struct_field (m, "SIGUNUSED");
+  set_sig_struct_field (m, "SIGURG");
+  set_sig_struct_field (m, "SIGUSR1");
+  set_sig_struct_field (m, "SIGUSR2");
+  set_sig_struct_field (m, "SIGVTALRM");
+  set_sig_struct_field (m, "SIGWINCH");
+  set_sig_struct_field (m, "SIGXCPU");
+  set_sig_struct_field (m, "SIGXFSZ");
 
-    return m;
-  }
+  return m;
+}
 
 DEFUN (SIG, args, ,
        doc: /* -*- texinfo -*-