American English spelling fix.

7 files changed, 15 insertions, 15 deletions

diff --git a/src/ChangeLog.1 b/src/ChangeLog.1
index 80e3ae98db7..6ba90aa56c9 100644
--- a/src/ChangeLog.1
+++ b/src/ChangeLog.1
@@ -3435,7 +3435,7 @@
         is non-nil it is silently bashed; else if the function was
         called interactively the user is queried as to whether s/he
         wants to bash the file; otherwise (ok-if-exists nil, non-interactive)
-        a  file-already-exists  error is signalled.
+        a  file-already-exists  error is signaled.
 
         * window.c: Made get-window-buffer return nil if get-buffer of
         its arg returns nil, rather than erring.
diff --git a/src/ChangeLog.9 b/src/ChangeLog.9
index d725e50d966..55ada360995 100644
--- a/src/ChangeLog.9
+++ b/src/ChangeLog.9
@@ -12883,7 +12883,7 @@
         * editfns.c (Fchar_after, Fchar_before): Doc fix.
 
         * bytecode.c (Fbyte_code): Use {BEFORE,AFTER}_POTENTIAL_GC where
-        an error may be signalled.
+        an error may be signaled.
 
 2000-01-26  Gerd Moellmann  <gerd@gnu.org>
 
diff --git a/src/lread.c b/src/lread.c
index 3e0bd1ff671..9e543f88fae 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3104,7 +3104,7 @@ substitute_object_recurse (object, placeholder, subtree)
         else
           /* An unknown pseudovector may contain non-Lisp fields, so we
              can't just blindly traverse all its fields.  We used to call
-             `Flength' which signalled `sequencep', so I just preserved this
+             `Flength' which signaled `sequencep', so I just preserved this
              behavior.  */
           wrong_type_argument (Qsequencep, subtree);
 
diff --git a/src/process.c b/src/process.c
index 73bbb34fd01..0ddeb517290 100644
--- a/src/process.c
+++ b/src/process.c
@@ -3511,7 +3511,7 @@ usage: (make-network-process &rest ARGS)  */)
 
       /* Parse network options in the arg list.
          We simply ignore anything which isn't a known option (including other keywords).
-         An error is signalled if setting a known option fails.  */
+         An error is signaled if setting a known option fails.  */
       for (optn = optbits = 0; optn < nargs-1; optn += 2)
         optbits |= set_socket_option (s, args[optn], args[optn+1]);
 
diff --git a/src/w32proc.c b/src/w32proc.c
index 56369e63281..91722df87ae 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -274,7 +274,7 @@ find_child_pid (DWORD pid)
 
 /* Thread proc for child process and socket reader threads. Each thread
    is normally blocked until woken by select() to check for input by
-   reading one char.  When the read completes, char_avail is signalled
+   reading one char.  When the read completes, char_avail is signaled
    to wake up the select emulator and the thread blocks itself again. */
 DWORD WINAPI
 reader_thread (void *arg)
@@ -1088,7 +1088,7 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
 
    To reduce the number of places in which Emacs can be hung such that
    C-g is not able to interrupt it, we always wait on interrupt_handle
-   (which is signalled by the input thread when C-g is detected).  If we
+   (which is signaled by the input thread when C-g is detected).  If we
    detect that we were woken up by C-g, we return -1 with errno set to
    EINTR as on Unix.  */
 
@@ -1185,7 +1185,7 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
                 current_status = cp->status;
                 if (WaitForSingleObject (cp->char_avail, 0) == WAIT_OBJECT_0)
                   {
-                    /* char_avail has been signalled, so status (which may
+                    /* char_avail has been signaled, so status (which may
                        have changed) should indicate read has completed
                        but has not been acknowledged. */
                     current_status = cp->status;
@@ -1196,9 +1196,9 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
                   }
                 else
                   {
-                    /* char_avail has not been signalled, so status should
+                    /* char_avail has not been signaled, so status should
                        indicate that read is in progress; small possibility
-                       that read has completed but event wasn't yet signalled
+                       that read has completed but event wasn't yet signaled
                        when we tested it (because a context switch occurred
                        or if running on separate CPUs). */
                     if (current_status != STATUS_READ_READY
@@ -1264,7 +1264,7 @@ count_children:
 
   start_time = GetTickCount ();
 
-  /* Wait for input or child death to be signalled.  If user input is
+  /* Wait for input or child death to be signaled.  If user input is
      allowed, then also accept window messages.  */
   if (FD_ISSET (0, &orfds))
     active = MsgWaitForMultipleObjects (nh + nc, wait_hnd, FALSE, timeout_ms,
@@ -1301,7 +1301,7 @@ count_children:
     abort ();
 
   /* Loop over all handles after active (now officially documented as
-     being the first signalled handle in the array).  We do this to
+     being the first signaled handle in the array).  We do this to
      ensure fairness, so that all channels with data available will be
      processed - otherwise higher numbered channels could be starved. */
   do
diff --git a/src/w32xfns.c b/src/w32xfns.c
index 115b0363dd8..682876c6b25 100644
--- a/src/w32xfns.c
+++ b/src/w32xfns.c
@@ -46,12 +46,12 @@ init_crit ()
      when the input queue is empty, so make it a manual reset event. */
   keyboard_handle = input_available = CreateEvent (NULL, TRUE, FALSE, NULL);
 
-  /* interrupt_handle is signalled when quit (C-g) is detected, so that
+  /* interrupt_handle is signaled when quit (C-g) is detected, so that
      blocking system calls can be interrupted.  We make it a manual
      reset event, so that if we should ever have multiple threads
      performing system calls, they will all be interrupted (I'm guessing
      that would the right response).  Note that we use PulseEvent to
-     signal this event, so that it never remains signalled.  */
+     signal this event, so that it never remains signaled.  */
   interrupt_handle = CreateEvent (NULL, TRUE, FALSE, NULL);
 }
 
@@ -75,7 +75,7 @@ delete_crit ()
 void
 signal_quit ()
 {
-  /* Make sure this event never remains signalled; if the main thread
+  /* Make sure this event never remains signaled; if the main thread
      isn't in a blocking call, then this should do nothing.  */
   PulseEvent (interrupt_handle);
 }
diff --git a/src/window.c b/src/window.c
index 27db0296dcf..43b96534427 100644
--- a/src/window.c
+++ b/src/window.c
@@ -4173,7 +4173,7 @@ enlarge_window (window, delta, horiz_flag)
 
              The number of children n equals the number of resizable
              children of this window + 1 because we know window itself
-             is resizable (otherwise we would have signalled an error).
+             is resizable (otherwise we would have signaled an error).
 
              This reasoning is not correct when other windows become too
              small and shrink_windows refuses to delete them.  Below we