; Spelling fixes

6 files changed, 15 insertions, 17 deletions

diff --git a/src/ChangeLog.13 b/src/ChangeLog.13
index 9e998952361..e8ab5e01ea7 100644
--- a/src/ChangeLog.13
+++ b/src/ChangeLog.13
@@ -17073,7 +17073,7 @@
 2013-05-04  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * minibuf.c (Fread_minibuffer, Feval_minibuffer): Move to Elisp.
-        (syms_of_minibuf): Adjust accodingly.
+        (syms_of_minibuf): Adjust accordingly.
         * lread.c (Fread):
         * callint.c (Fcall_interactively): Adjust calls accordingly.
 
diff --git a/src/ChangeLog.3 b/src/ChangeLog.3
index a62aee7517b..256e4b78598 100644
--- a/src/ChangeLog.3
+++ b/src/ChangeLog.3
@@ -11648,7 +11648,7 @@
 
         * fileio.c (Fcopy_file): Always close descriptors.
 
-        * s-sunos4.h: read, write, open and close are interruptable.
+        * s-sunos4.h: read, write, open and close are interruptible.
 
 1991-01-09  Jim Blandy  (jimb@churchy.ai.mit.edu)
 
diff --git a/src/process.c b/src/process.c
index 9139a36d4fd..c5a46f992d7 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4557,23 +4557,22 @@ from PROCESS only, suspending reading output from other processes.
 If JUST-THIS-ONE is an integer, don't run any timers either.
 Return non-nil if we received any output from PROCESS (or, if PROCESS
 is nil, from any process) before the timeout expired.  */)
-  (register Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec, Lisp_Object just_this_one)
+  (Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec,
+   Lisp_Object just_this_one)
 {
   intmax_t secs;
   int nsecs;
 
   if (! NILP (process))
     {
-      struct Lisp_Process *procp;
-
       CHECK_PROCESS (process);
-      procp = XPROCESS (process);
+      struct Lisp_Process *proc = XPROCESS (process);
 
       /* Can't wait for a process that is dedicated to a different
          thread.  */
-      if (!EQ (procp->thread, Qnil) && !EQ (procp->thread, Fcurrent_thread ()))
+      if (!EQ (proc->thread, Qnil) && !EQ (proc->thread, Fcurrent_thread ()))
         error ("Attempt to accept output from process %s locked to thread %s",
-               SDATA (procp->name), SDATA (XTHREAD (procp->thread)->name));
+               SDATA (proc->name), SDATA (XTHREAD (proc->thread)->name));
     }
   else
     just_this_one = Qnil;
diff --git a/src/systhread.c b/src/systhread.c
index 369d8f8b5e5..a2c556fd8e3 100644
--- a/src/systhread.c
+++ b/src/systhread.c
@@ -219,7 +219,7 @@ void
 sys_mutex_lock (sys_mutex_t *mutex)
 {
   /* FIXME: What happens if the owning thread exits without releasing
-     the mutex?  Accoding to MSDN, the result is undefined behavior.  */
+     the mutex?  According to MSDN, the result is undefined behavior.  */
   EnterCriticalSection ((LPCRITICAL_SECTION)mutex);
 }
 
diff --git a/src/thread.c b/src/thread.c
index 6966df31d37..9613d1435f7 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -257,7 +257,7 @@ If the current thread already owns MUTEX, increment the count and
 return.
 Otherwise, if no thread owns MUTEX, make the current thread own it.
 Otherwise, block until MUTEX is available, or until the current thread
-is signalled using `thread-signal'.
+is signaled using `thread-signal'.
 Note that calls to `mutex-lock' and `mutex-unlock' must be paired.  */)
   (Lisp_Object mutex)
 {
@@ -363,8 +363,7 @@ condition_wait_callback (void *arg)
   XSETCONDVAR (cond, cvar);
   self->event_object = cond;
   saved_count = lisp_mutex_unlock_for_wait (&mutex->mutex);
-  /* If we were signalled while unlocking, we skip the wait, but we
-     still must reacquire our lock.  */
+  /* If signaled while unlocking, skip the wait but reacquire the lock.  */
   if (NILP (self->error_symbol))
     {
       self->wait_condvar = &cvar->cond;
@@ -384,7 +383,7 @@ The mutex associated with COND must be held when this is called.
 It is an error if it is not held.
 
 This releases the mutex and waits for COND to be notified or for
-this thread to be signalled with `thread-signal'.  When
+this thread to be signaled with `thread-signal'.  When
 `condition-wait' returns, COND's mutex will again be locked by
 this thread.  */)
   (Lisp_Object cond)
@@ -404,7 +403,7 @@ this thread.  */)
   return Qnil;
 }
 
-/* Used to communicate argumnets to condition_notify_callback.  */
+/* Used to communicate arguments to condition_notify_callback.  */
 struct notify_args
 {
   struct Lisp_CondVar *cvar;
@@ -814,7 +813,7 @@ or `thread-join' in the target thread.  */)
   if (tstate == current_thread)
     Fsignal (error_symbol, data);
 
-  /* What to do if thread is already signalled?  */
+  /* What to do if thread is already signaled?  */
   /* What if error_symbol is Qnil?  */
   tstate->error_symbol = error_symbol;
   tstate->error_data = data;
diff --git a/src/thread.h b/src/thread.h
index 0090652b358..33f8ea70636 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -48,7 +48,7 @@ struct thread_state
   /* The thread's function.  */
   Lisp_Object function;
 
-  /* If non-nil, this thread has been signalled.  */
+  /* If non-nil, this thread has been signaled.  */
   Lisp_Object error_symbol;
   Lisp_Object error_data;
 
@@ -60,7 +60,7 @@ struct thread_state
   /* A list of currently active byte-code execution value stacks.
      Fbyte_code adds an entry to the head of this list before it starts
      processing byte-code, and it removed the entry again when it is
-     done.  Signalling an error truncates the list.  */
+     done.  Signaling an error truncates the list.  */
   struct byte_stack *m_byte_stack_list;
 #define byte_stack_list (current_thread->m_byte_stack_list)