Anonymous avatar Anonymous committed 507f646

Apply typo patches from Paul Eggert.

Comments (0)

Files changed (151)

 This typically happens on Suns and other systems that use shared
 libraries.  The cause is that the site has installed a version of the
 shared library which uses a name server--but has not installed a
-similiar version of the unshared library which Emacs uses.
+similar version of the unshared library which Emacs uses.
 
 The result is that most programs, using the shared library, work with
 the nameserver, but Emacs does not.
 
 * Trouble using ptys on AIX.
 
-People often instll the pty devices on AIX incorrectly.
+People often install the pty devices on AIX incorrectly.
 Use `smit pty' to reinstall them properly.
 
 * Shell mode on HP/UX gives the message, "`tty`: Ambiguous".
 to map two other input characters (such as C-^ and C-\) into C-s and
 C-q, so that you can still search and quote.
 
-I have no intention of ever redisigning the Emacs command set for
+I have no intention of ever redesigning the Emacs command set for
 the assumption that terminals use C-s/C-q flow control.  This
 flow control technique is a bad design, and terminals that need
 it are bad merchandise and should not be purchased.  If you can
 	  inst_paths='#disabled# '
 	;;
 
-	## Has the user specifiec an installation prefix?
+	## Has the user specified an installation prefix?
 	"prefix" )
 	  ## If the value was omitted, get it from the next argument.
 	  if [ "${valomitted}" = "yes" ]; then
 	  prefix="${val}"
         ;;
 
-	## Has the user specifiec an installation prefix?
+	## Has the user specified an installation prefix?
 	"exec_prefix" )
 	  ## If the value was omitted, get it from the next argument.
 	  if [ "${valomitted}" = "yes" ]; then
   
   The real legal meaning of the GNU General Public Licence (copyleft) is
   however it is interpreted by a judge.  There has never been a copyright
-  infringment case involving the GPL to set any precedents.  Please take any
+  infringement case involving the GPL to set any precedents.  Please take any
   discussion regarding this issue to the newsgroup gnu.misc.discuss, which
   was created to hold the extensive flame wars on the subject.
   
   If you are receiving a GNU mailing list named `XXX', you might be able
   to unsubscribe to it by sending a request to the address
   `XXX-request@prep.ai.mit.edu'.  However, this will not work if you are
-  not listed on the main mailing list, but instead recieve the mail from a
+  not listed on the main mailing list, but instead receive the mail from a
   distribution point.  In that case, you will have to track down at which
   distribution point you are listed.  Inspecting the `Received:' headers
   on the mail messages may help, along with liberal use of the `EXPN' or
     Cliff Stoll in his book `The Cuckoo's Egg' describes this in chapter 4.
     The site at LBL had installed the `etc/movemail' program setuid root.
     Since `movemail' had not been designed for this situation, a security
-    hole was created and users could get root priveleges.
+    hole was created and users could get root privileges.
   
     `movemail' has since been changed so that even if it is installed setuid
     root this security hole will not be a result.
     Emacs accepts synthetic X events generated by the SendEvent request as
     though they were regular events.  As a result, if you are using the
     trivial host-based authentication, other users who can open X
-    connections to your X workstatation can make your Emacs process do
-    anything, including run other processes with your priveleges.
+    connections to your X workstation can make your Emacs process do
+    anything, including run other processes with your privileges.
   
     The only fix for this is to prevent other users from being able to open
     X connections.  The standard way to prevent this is to use a real
     ;; LCD Archive Entry:
     ;; tex-complete|Sebastian Kremer|sk@thp.Uni-Koeln.DE
     ;; |Minibuffer name completion for editing [La]TeX.
-    ;; |91-03-26|$Revision: 20.5 $|~/packages/tex-complete.el.Z              !
+    ;; |91-03-26|$Revision: 1.4 $|~/packages/tex-complete.el.Z              !
   
   Dave Brennan has software which automatically looks for data in this
   format.  The format is fairly flexible.  The entry ends when a line is
 	  X keysyms Up, Left, Right, and Down.)
        Break (the `Alternate' key is given this keysym)
   
-     These keys work like Sun function keys.  When Emacs recieves the
+     These keys work like Sun function keys.  When Emacs receives the
      keysym, it will internally use character sequences that look like "ESC
      [ ### z", where ### is replaced by a number.  The character sequences
      are identical to those generated by Sun's keyboard under SunView.  Any
 
     With these patches, Emacs becomes fully 8-bit operational.  There is
     support for displaying 8-bit characters, as well as for entering such
-    characters from the keyboard.  In addition, upcase/lowcase tranlatsion
+    characters from the keyboard.  In addition, upcase/lowcase translation
     is supported, accented characters are recognized as "letters" (important
     when doing 'forward-word', for example), and text with 8-bit characters
     can be sorted correctly.
 #	Briefly, the settings are for the following modes:
 #	   (values are for bit set/clear with * indicating our preference
 #	    and the value used to test these termcaps)
-#	Note that many of these settings are irelevent to the termcap
+#	Note that many of these settings are irrelevant to the termcap
 #	and are just set to the default mode of the terminal as shipped
 #	by the factory.
 #
 #	transmit all characters/transmit only selected characters*
 #	transmit all selected areas/transmit only 1 selected area*
 #
-#	transmit/do not transmit line seperators to host*
+#	transmit/do not transmit line separators to host*
 #	transmit/do not transmit page tab stops tabs to host*
 #	transmit/do not transmit column tab stop tabs to host*
 #	transmit/do not transmit graphics control (underline,inverse..)*
 #
 # D menu: 0110 1001   1   0
 #	LF is newline/LF is down one line, same column*
-#	wrap to preceeding line if move left from col 1*/don't wrap
+#	wrap to preceding line if move left from col 1*/don't wrap
 #	wrap to next line if move right from col 80*/don't wrap
 #	backspace is/is not destructive*
 #
 	:kl=^H:ku=^K:kr=^L:kd=^J:tc=adm3a:
 # Needs function keys added.  Also can't use 60 line mode because it needs
 # too much nl delay - can fix for nl but not out of vi.
-# The cl delay is sufficent, but a smaller one could do.
+# The cl delay is sufficient, but a smaller one could do.
 # This entry is merged from Mike O'Brien@Rand and Howard Katseff at
 # Bell Labs, and is untested.
 Mb|aaa|ambas|ambassador|ann arbor ambassador/48 lines:\

lib-src/=aixcc.lex

 
 ^([a-z]\ -)?\ *{EC}:	{
     /* 
-     * error message (which we print immediately) preceeded by an
+     * error message (which we print immediately) preceded by an
      * error code (which we ignore)
      */
 
 
 char *pname;      /* programme name for error messages */
 
-/* Accepts a string of two fields seperated by FS.
+/* Accepts a string of two fields separated by FS.
    First field is string for get_date, saying when to wake-up.
    Second field is a token to identify the request.  */
 void

lib-src/emacstool.c

 /* define WANT_CAPS_LOCK to make f-key T1 (aka F1) behave as CapsLock */
 #define WANT_CAPS_LOCK
 #ifdef WANT_CAPS_LOCK
-int caps_lock;		/* toggle indicater for f-key T1 caps lock */
+int caps_lock;		/* toggle indicator for f-key T1 caps lock */
 static char *Caps = "[CAPS] ";		/* Caps Lock prefix string */
 #define CAPS_LEN 7			/* strlen (Caps) */
 #endif
 }
 
 /*
- * This routine sets up the boolean psuedo-functions which work
+ * This routine sets up the boolean pseudo-functions which work
  * by setting boolean flags dependent upon the corresponding character
  * Every char which is NOT in that string is not a white char.  Therefore,
  * all of the array "_wht" is set to FALSE, and then the elements
   register char *pend;
   int newline;			/* 1 if ended with newline, 0 if ended with EOF */
 
-  pend = p + linebuffer->size;	/* Separate to avoind 386/IX compiler bug.  */
+  pend = p + linebuffer->size;	/* Separate to avoid 386/IX compiler bug.  */
 
   while (1)
     {

lib-src/make-docfile.c

  starting in column zero.
  (quote NAME) may appear as 'NAME as well.
  For defun, defmacro, and autoload, we know how to skip over the arglist.
- For defvar, defconst, and fset we skip to the docstring with a klugey 
+ For defvar, defconst, and fset we skip to the docstring with a kludgy 
  formatting convention: all docstrings must appear on the same line as the
  initial open-paren (the one in column zero) and must contain a backslash 
  and a double-quote immediately after the initial double-quote.  No newlines
   }
 
   /* Read until SEP, read next line, print it.
-     (Note that we will never print anything before the first seperator.)
+     (Note that we will never print anything before the first separator.)
      If we hit EOF looking for the first SEP, just recurse. */
   while ((c = getc(fp)) != SEP)
     if (c == EOF) {
 ;;; extract a value with (extract-from-klist KLIST KEY [DEFAULT]).
 
 (defun reduce (function sequence &rest kargs)
-  "Apply FUNCTION (a function of two arguments) to succesive pairs of elements
+  "Apply FUNCTION (a function of two arguments) to successive pairs of elements
 from SEQUENCE.  Some keyword arguments are valid after FUNCTION and SEQUENCE:
 :from-end       If non-nil, process the values backwards
 :initial-value  If given, prefix it to the SEQUENCE.  Suffix, if :from-end
            (do* ((absa (abs (nth 0 integers))) ; better to operate only
                  (absb (abs (nth 1 integers))) ;on positives.
                  (dd (max absa absb))   ; setup correct order for the
-                 (ds (min absa absb))   ;succesive divisions.
+                 (ds (min absa absb))   ;successive divisions.
                  ;; intermediate results
                  (q 0)
                  (r 0)
 
 (defsetf apply
   (lambda (&rest args)
-    ;; dissasemble the calling form
+    ;; disassemble the calling form
     ;; "(((quote fn) x1 x2 ... xn) val)" (function instead of quote, too)
     (let* ((fnform (car args))          ;functional form
            (applyargs (append           ;arguments "to apply fnform"
 list \{:conc-name, :copier, :constructor, :predicate, :include,
 :print-function, :type, :initial-offset\}.  The meanings of these are as in
 CLtL, except that no BOA-constructors are provided, and the options
-\{:print-fuction, :type, :initial-offset\} are ignored quietly.  All these
+\{:print-function, :type, :initial-offset\} are ignored quietly.  All these
 structs are named, in the sense that their names can be used for type
 discrimination.
 
 do the right thing. If you run multiple processes, you can change
 cmulisp-buffer to another process buffer with \\[set-variable].
 
-More sophisticated approaches are, of course, possible. If you find youself
+More sophisticated approaches are, of course, possible. If you find yourself
 needing to switch back and forth between multiple processes frequently,
 you may wish to consider ilisp.el, a larger, more sophisticated package
 for running inferior Lisp processes. The approach taken here is for a
 ;;; GNUS: an NNTP-based News Reader for GNU Emacs
 ;; Copyright (C) 1987, 1988, 1989, 1990, 1993 Free Software Foundation, Inc.
-;; $Header: /home/fsf/rms/e19/lisp/RCS/gnus.el,v 1.17 1993/06/04 05:33:32 rms Exp rms $
+;; $Header: /gd/gnu/emacs/19.0/lisp/RCS/gnus.el,v 1.18 1993/06/05 09:17:34 rms Exp jimb $
 
 ;; This file is part of GNU Emacs.
 
 
 (defvar gnus-use-followup-to t
   "*Specifies what to do with Followup-To: field.
-If nil, ignore followup-to: field.  If t, use its value execpt for
-`poster'.  Otherewise, if not nil nor t, always use its value.")
+If nil, ignore followup-to: field.  If t, use its value except for
+`poster'.  Otherwise, if not nil nor t, always use its value.")
 
 (defvar gnus-large-newsgroup 50
   "*The number of articles which indicates a large newsgroup.
 result must be a string excluding `[' and `]'.")
 
 (defvar gnus-auto-extend-newsgroup t
-  "*Extend visible artciles to forward and backward if non-nil.")
+  "*Extend visible articles to forward and backward if non-nil.")
 
 (defvar gnus-auto-select-first t
   "*Select the first unread article automagically if non-nil.
 
 (defun gnus-summary-next-page (lines)
   "Show next page of selected article.
-If end of artile, select next article.
+If end of article, select next article.
 Argument LINES specifies lines to be scrolled up."
   (interactive "P")
   (let ((article (gnus-summary-article-number))
       (gnus-eval-in-buffer-window gnus-article-buffer
 	;; Look for parent Message-ID.
 	;; We cannot use gnus-current-headers to get references
-	;; because we may be looking at parent or refered article.
+	;; because we may be looking at parent or referred article.
 	(let ((references (gnus-fetch-field "References")))
 	  ;; Get the last message-id in the references.
 	  (and references
 	    (setq message-id (concat message-id ">")))
 	;; Push current message-id on history.
 	;; We cannot use gnus-current-headers to get current
-	;; message-id because we may be looking at parent or refered
+	;; message-id because we may be looking at parent or referred
 	;; article.
 	(let ((current (gnus-fetch-field "Message-ID")))
 	  (or (equal current message-id) ;Nothing to do.
   (let ((newsgroup (substring newsgroup 0)) ;Copy string.
 	(len (length newsgroup))
 	(idx 0))
-    ;; Replace all occurence of `.' with `/'.
+    ;; Replace all occurrences of `.' with `/'.
     (while (< idx len)
       (if (= (aref newsgroup idx) ?.)
 	  (aset newsgroup idx ?/))
 
 (defun gnus-define-access-method (method &optional access-methods)
   "Define access functions for the access METHOD.
-Methods defintion is taken from optional argument ACCESS-METHODS or
+Methods definition is taken from optional argument ACCESS-METHODS or
 the variable gnus-access-methods."
   (let ((bindings
 	 (cdr (assoc method (or access-methods gnus-access-methods)))))
       (setq defs (car overloads))
       (setq overloads (cdr overloads))
       ;; Load file before overloading function if necessary.  Make
-      ;; sure we cannot use `requre' always.
+      ;; sure we cannot use `require' always.
       (and (not (fboundp (car defs)))
 	   (car (cdr (cdr defs)))
 	   (load (car (cdr (cdr defs))) nil 'nomessage))

lisp/=gnusmisc.el

 
 (defun gnus-group-yank-group ()
   "Yank the last newsgroup killed with \\[gnus-group-kill-group],
-inserting it before the newsgroup on the line containging point."
+inserting it before the newsgroup on the line containing point."
   (interactive)
   (gnus-group-insert-group (car gnus-killed-assoc))
   ;; Remove killed newsgroups from the buffer if exists.
 ;;; Modified by James Larus, BBN, July 1984 and UCB, 1984 & 1985.
 ;;; Rewritten for GNU Emacs, James Larus 1985.  larus@ginger.berkeley.edu
 ;;; Modified by Stephen Gildea 1988.  gildea@bbn.com
-(defconst mh-e-RCS-id "$Header: /home/fsf/rms/e19/lisp/RCS/mh-e.el,v 1.10 1993/05/30 22:56:31 rms Exp rms $")
+(defconst mh-e-RCS-id "$Header: /home/gd/gnu/emacs/19.0/lisp/RCS/mh-e.el,v 1.11 1993/06/05 02:51:21 rms Exp jimb $")
 
 ;;; Code:
 
   "String whose first character is used to notate redistributed messages.")
 
 (defvar mh-good-msg-regexp  "^....[^D^]"
-  "Regexp specifiying the scan lines that are 'good' messages.")
+  "Regexp specifying the scan lines that are 'good' messages.")
 
 (defvar mh-deleted-msg-regexp "^....D"
   "Regexp matching scan lines of deleted messages.")
 ;;; The folder data abstraction.
 
 (defvar mh-current-folder nil "Name of current folder, a string.")
-(defvar mh-show-buffer nil "Buffer that displays mesage for this folder.")
+(defvar mh-show-buffer nil "Buffer that displays message for this folder.")
 (defvar mh-folder-filename nil "Full path of directory for this folder.")
 (defvar mh-showing nil "If non-nil, show the message in a separate window.")
 (defvar mh-next-seq-num nil "Index of free sequence id.")
 provided now.  I suppose the later is faster.")
 
 (defvar mhspool-list-directory-switches '("-R")
-  "*Switches for mhspool-list-folders-using-ls to pass to `ls' for gettting file lists.
+  "*Switches for mhspool-list-folders-using-ls to pass to `ls' for getting file lists.
 One entry should appear on one line. You may need to add `-1' option.")
 
 
   (let ((string (substring string 0))	;Copy string.
 	(len (length string))
 	(idx 0))
-    ;; Replace all occurence of FROM with TO.
+    ;; Replace all occurrences of FROM with TO.
     (while (< idx len)
       (if (= (aref string idx) from)
 	  (aset string idx to))

lisp/=mim-mode.el

 <FOO ...> will be indented n spaces from start of form.
 \(put 'FOO 'indent-mim-function 'DEFINE\) is like above but means use
 value of mim-body-indent as offset from start of form.
-\(put 'FOO 'indent-mim-function <cons>\) where <cons> is a list or pointted list
+\(put 'FOO 'indent-mim-function <cons>\) where <cons> is a list or pointed list
 of integers, means indent each form in <FOO ...> by the amount specified
 in <cons>.  When <cons> is exhausted, indent remaining forms by
 `mim-body-indent' unless <cons> is a pointed list, in which case the last
   "Move forward across Mim object.
 With ARG, move forward that many objects."
   (interactive "p")
-  ;; this function is wierd because it emulates the behavior of the old
+  ;; this function is weird because it emulates the behavior of the old
   ;; (gosling) mim-mode - if the arg is 1 and we are `inside' an ADECL,
   ;; more than one character into the ATOM part and not sitting on the
   ;; colon, then we move to the DECL part (just past colon) instead of
   "Move down a level of Mim structure forwards.
 With ARG, move down that many levels forwards (backwards, ARG < 0)."
   (interactive "p")
-  ;; another wierdo - going down `inside' an ADECL or ATOM trailer
+  ;; another weirdo - going down `inside' an ADECL or ATOM trailer
   ;; depends on the value of mim-down-parens-only.  if nil, treat
   ;; ADECLs and trailers as structured objects.
   (let ((direction (sign (or arg (setq arg 1)))))
 		    (+ method start))
 	      (goto-char current-indent)
 	      (if (consp method)
-		  ;; list or pointted list of explicit indentations
+		  ;; list or pointed list of explicit indentations
 		  (indent-mim-offset state indent-point)
 		(if (and (symbolp method) (fboundp method))
 		    ;; luser function - s/he better know what's going on.
 	(last-sexp (car (nthcdr 2 state)))
 	indentation)
     (goto-char (1+ containing-sexp))
-    ;; determine wheich of the indentations to use.
+    ;; determine which of the indentations to use.
     (while (and (< (point) indent-point)
 		(condition-case nil
 		    (progn (forward-sexp 1)
   (setq nntp-server-process nil))
 
 (defun nnspool-find-article-by-message-id (id)
-  "Return full pathname of an artilce identified by message-ID."
+  "Return full pathname of an article identified by message-ID."
   (save-excursion
     (let ((buffer (get-file-buffer nnspool-history-file)))
       (if buffer
   (let ((string (substring string 0))	;Copy string.
 	(len (length string))
 	(idx 0))
-    ;; Replace all occurence of FROM with TO.
+    ;; Replace all occurrences of FROM with TO.
     (while (< idx len)
       (if (= (aref string idx) from)
 	  (aset string idx to))
   "Send list of STRINGS to news server as command and its arguments."
   (let ((cmd (car strings))
 	(strings (cdr strings)))
-    ;; Command and each argument must be separeted by one or more spaces.
+    ;; Command and each argument must be separated by one or more spaces.
     (while strings
       (setq cmd (concat cmd " " (car strings)))
       (setq strings (cdr strings)))
 ;; massages raw reply buffers set up by the reply/forward functions in
 ;; the news/mail subsystems. Therefore, such useful operations as
 ;; yanking and citing portions of the original article (instead of the
-;; whole article) are not within the ability or responsiblity of
+;; whole article) are not within the ability or responsibility of
 ;; supercite.
 
 ;; ========== Disclaimer ==========
 
 
 ;; ======================================================================
-;; global variables, not user accessable
+;; global variables, not user accessible
 
 (defconst sc-version-number "2.3"
   "Supercite's version number.")
   ())
 
 (defun sc-no-blank-line-or-header()
-  "Similar to sc-no-header except it removes the preceeding blank line."
+  "Similar to sc-no-header except it removes the preceding blank line."
   (if (not (bobp))
       (if (and (eolp)
 	       (progn (forward-line -1)
 				   (run-hooks 'sc-fill-paragraph-hook)))
 	       (setq fstart (point)
 		     fend (point)))
-	      ;; not end of line so perhap cite it
+	      ;; not end of line so perhaps cite it
 	      ((not (looking-at sc-cite-regexp))
 	       (insert (aget sc-gal-information "sc-citation")))
 	      (sc-nested-citation-p
 ;;
 (defun sc-describe ()
   "Supercite version 2.3 is now described in a texinfo manual which
-makes the documenation available both for online perusal via emacs'
+makes the documentation available both for online perusal via emacs'
 info system, or for hard-copy printing using the TeX facility.
 
 To view the online document hit \\[info], then \"mSupercite <RET>\"."
 ;;; Commentary:
 
 ;; This package gives you the capability to run Emacs Lisp commands at
-;; specified simes in the future, either as one-shots or periodically.
+;; specified times in the future, either as one-shots or periodically.
 ;; The single entry point is `run-at-time'.
 
 ;;; Code:
 
 ;;;###autoload
 (defun change-log-mode ()
-  "Major mode for editting change logs; like Indented Text Mode.
+  "Major mode for editing change logs; like Indented Text Mode.
 Prevents numeric backups and sets `left-margin' to 8 and `fill-column' to 74.
 New log entries are usually made with \\[add-change-log-entry] or \\[add-change-log-entry-other-window].
 Each entry behaves as a paragraph, and the entries for one day as a page.
 ;;;_  - Author: Ken Manheimer <klm@nist.gov>
 ;;;_  - Maintainer: Ken Manheimer <klm@nist.gov>
 ;;;_  - Created: Dec 1991 - first release to usenet
-;;;_  - Version: $Id: allout.el,v 1.1 1993/06/02 17:53:31 rms Exp rms $||
+;;;_  - Version: $Id: allout.el,v 1.2 1993/06/07 18:48:08 rms Exp jimb $||
 ;;;_  - Keywords: outline mode
 
 ;;;_  - LCD Archive Entry
 ;; LCD Archive Entry:
 ;; allout|Ken Manheimer|klm@nist.gov
 ;; |A more thorough outline-mode
-;; |27-May-1993|$Id: allout.el,v 1.1 1993/06/02 17:53:31 rms Exp rms $||
+;; |27-May-1993|$Id: allout.el,v 1.2 1993/06/07 18:48:08 rms Exp jimb $||
 
 ;;;_  - Description
 ;; A full-fledged outline mode, based on the original rudimentary
 
 ;;;_   = outline-primary-bullet
 (defvar outline-primary-bullet "*") ;; Changing this var disables any
-                                    ;; backwards compatability with
+                                    ;; backwards compatibility with
                                     ;; the original outline mode.
 (make-variable-buffer-local 'outline-primary-bullet)
 
 
 ;;;_   : Key bindings
 ;;;_    = Generic minor keybindings control
-;;;_     ; Stallmans suggestion
+;;;_     ; Stallman's suggestion
 (defvar outline-mode-map nil "")
  
 (if outline-mode-map
 Exposure: Hidden (~closed~) topics are represented by ellipses ('...')
           at the end of the visible SUPERTOPIC which contains them,
           rather than by their actual text.  Hidden topics are still
-          susceptable to editing and regular movement functions, they
+          susceptible to editing and regular movement functions, they
           just are not displayed normally, effectively collapsed into
           the ellipses which represent them.  Outline mode provides
           the means to selectively expose topics based on their
         topic header PREFIX at the beginning of the line, followed by
         text to the end of the EFFECTIVE LINE.
 
-Body: Any subsequent lines of text following a topic header and preceeding
+Body: Any subsequent lines of text following a topic header and preceding
       the next one.  This is also referred to as the entry for a topic.
 
 Prefix: The text which distinguishes topic headers from normal text
         by zero or more spaces and then an outline BULLET.  [Note - you
         can now designate your own, arbitrary HEADER-LEAD string, by
         setting the variable 'outline-header-prefix'.]  The second form
-        is for backwards compatability with the original emacs outline
+        is for backwards compatibility with the original emacs outline
         mode, and consists solely of asterisks.  Both sorts are
         recognized by all outline commands.  The first sort is generated
         by outline topic production commands if the emacs variable
    that the index for the numbered prefix will be derived, by counting
    siblings back to start of level.  If INDEX is a number, then that
    number is used as the index for the numbered prefix (allowing, eg,
-   sequential renumbering to not requre this function counting back the
+   sequential renumbering to not require this function counting back the
    index for each successive sibling)."
 
   ;; The options are ordered in likely frequence of use, most common
    - Creation of sibling or nested topics is with respect to the topic
      you're starting from, even when creating backwards.  This way you
      can easily create a sibling in front of the current topic without
-     having to go to it's preceeding sibling, and then open forward
+     having to go to its preceding sibling, and then open forward
      from there."
 
   (let* ((depth (+ (outline-current-depth) relative-depth))
                 (or (and (not (> relative-depth 0))
                          ;; not descending,
                          (save-excursion
-                           ;; preceeded by a blank line?
+                           ;; preceded by a blank line?
                            (forward-line -1)
                            (looking-at "^\\s-*$")))
                     (and (= ref-depth 1)
   "  Reindent body lines which were indented at old-depth to new-depth.
 
   Note that refill of indented paragraphs is not done, and tabs are
-  not accomodated.  ('untabify' your outline if you want to preserve
+  not accommodated.  ('untabify' your outline if you want to preserve
   hanging body indents.)"
 
   (save-excursion
       (yank arg)
       (exchange-dot-and-mark)
       (if (and established-depth        ; the established stuff qualifies.
-               ;; The yanked stuff also qualfies - is topic(s):
+               ;; The yanked stuff also qualifies - is topic(s):
                (looking-at (concat "\\(" outline-regexp "\\)")))
           ;; Ok, adjust the depth of the yanked stuff.  Note that the
           ;; stuff may have more than a single root, so we have to
       )
     )
   )
-;;;_     > outline-to-entry-end - Unmaintained compatability - ignore this!
+;;;_     > outline-to-entry-end - Unmaintained compatibility - ignore this!
 ;-------------------------------------------------------------------
 ; Something added solely for use by a "smart menu" package someone got
 ; off the net.  I have no idea whether this is appropriate code.
       (if arg (insert-string (format "\t\t\t(%s \"%s\")\n"
                                      "outline-lead-with-comment-string"
                                      arg)))
-                                        ; Insert ammouncement and
+                                        ; Insert announcement and
                                         ; exposure control:
       (insert-string
        (format "\t\t\t%s %s\n\t\t\t%s %s\n\t\t%s %s"
 
 ;;; Gateways:
 ;;;
-;;; Sometimes it is neccessary for the FTP process to be run on a different
+;;; Sometimes it is necessary for the FTP process to be run on a different
 ;;; machine than the machine running GNU Emacs.  This can happen when the
 ;;; local machine has restrictions on what hosts it can access.
 ;;;
 ;;;
 ;;; 3) Using NFS and symlinks, make sure that there is a shared directory with
 ;;;    the *same* name between the local machine and the gateway machine.
-;;;    This directory is neccessary for temporary files created by ange-ftp.
+;;;    This directory is necessary for temporary files created by ange-ftp.
 ;;;
 ;;; 4) Set the variable 'ange-ftp-gateway-tmp-name-template' to the name of
 ;;;    this directory plus an identifying filename prefix.  For example:
 ;;;    there is a chance you might connect to an ULTRIX machine (such as
 ;;;    prep.ai.mit.edu), then set this variable accordingly.  This will have
 ;;;    the side effect that dired will have problems with symlinks whose names
-;;;    end in an @. If you get youself into this situation then editing
+;;;    end in an @.  If you get yourself into this situation then editing
 ;;;    dired's ls-switches to remove "F", will temporarily fix things.
 ;;;
 ;;; 2. If you know that you are connecting to a certain non-UNIX machine
 ;;; 1. Umask problems:
 ;;;    Be warned that files created by using ange-ftp will take account of the
 ;;;    umask of the ftp daemon process rather than the umask of the creating
-;;;    user.  This is particulary important when logging in as the root user.
+;;;    user.  This is particularly important when logging in as the root user.
 ;;;    The way that I tighten up the ftp daemon's umask under HP-UX is to make
 ;;;    sure that the umask is changed to 027 before I spawn /etc/inetd.  I
 ;;;    suspect that there is something similar on other systems.
 ;;;; Internal variables.
 ;;;; ------------------------------------------------------------
 
-(defconst ange-ftp-version "$Revision: 1.23 $")
+(defconst ange-ftp-version "$Revision: 1.24 $")
 
 (defvar ange-ftp-data-buffer-name " *ftp data*"
   "Buffer name to hold directory listing data received from ftp process.")
   "Return the password for specified HOST and USER, asking user if necessary."
   (ange-ftp-parse-netrc)
 
-  ;; look up password in the hash table first; user might have overriden the
+  ;; look up password in the hash table first; user might have overridden the
   ;; defaults.
   (cond ((ange-ftp-lookup-passwd host user))
 	
 ;;;; ------------------------------------------------------------
 
 (defun ange-ftp-process-handle-line (line proc)
-  "Look at the given LINE from the ftp process PROC.  Try to catagorize it
+  "Look at the given LINE from the ftp process PROC.  Try to categorize it
 into one of four categories: good, skip, fatal, or unknown."
   (cond ((string-match ange-ftp-xfer-size-msgs line)
 	 (setq ange-ftp-xfer-size
 ;; 	(kill-buffer (current-buffer))))))
 
 ;; this is the extended version of ange-ftp-copy-file-internal that works
-;; asyncronously if asked nicely.
+;; asynchronously if asked nicely.
 (defun ange-ftp-copy-file-internal (filename newname ok-if-already-exists
 					     keep-date &optional msg cont nowait)
   (setq filename (expand-file-name filename)
 ;; 		      0		;success-count
 ;; 		      (length fn-list) ;total
 ;; 		      )
-;;    ;; normal case... use the interative routine... much cheaper.
+;;    ;; normal case... use the interactive routine... much cheaper.
 ;;    (ange-ftp-real-dired-create-files file-creator operation fn-list
 ;;				      name-constructor marker-char)))
 

lisp/buff-menu.el

 ;;; Commentary:
 
 ;; Edit, delete, or change attributes of all currently active Emacs
-;; buffers from a list summarizing thir state.  A good way to browse
+;; buffers from a list summarizing their state.  A good way to browse
 ;; any special or scratch buffers you have loaded, since you can't find
 ;; them by filename.  The single entry point is `Buffer-menu-mode',
 ;; normally bound to C-x C-b.

lisp/calendar/calendar.el

 ;; calendar, to the Islamic calendar, to the French Revolutionary calendar,
 ;; to the Mayan calendar, and to the astronomical (Julian) day number.
 ;; When floating point is available, times of sunrise/sunset can be displayed,
-;; as can the phases of the moon.  Appointment notication for diary entries
+;; as can the phases of the moon.  Appointment notification for diary entries
 ;; is available.
 
 ;; The following files are part of the calendar/diary code:
     (monthname " *" day ", *" year "[^0-9]")
     (dayname "\\W"))
   "*List of pseudo-patterns describing the American patterns of date used.
-See the documentation of diary-date-forms for an explanantion.")
+See the documentation of diary-date-forms for an explanation.")
 
 ;;;###autoload
 (defvar european-date-diary-pattern
     (day " *" monthname " *" year "[^0-9]")
     (dayname "\\W"))
   "*List of pseudo-patterns describing the European patterns of date used.
-See the documentation of diary-date-forms for an explanantion.")
+See the documentation of diary-date-forms for an explanation.")
 
 ;;;###autoload
 (defvar diary-date-forms
   '((if dayname (concat dayname ", ")) day " " monthname " " year)
   "*The pseudo-pattern that governs the way a Gregorian date is formatted
 in the European style.  See the documentation of calendar-date-display-forms
-for an explanantion.")
+for an explanation.")
 
 ;;;###autoload
 (defvar american-calendar-display-form
   '((if dayname (concat dayname ", ")) monthname " " day ", " year)
   "*The pseudo-pattern that governs the way a Gregorian date is formatted
 in the American style.  See the documentation of calendar-date-display-forms
-for an explanantion.")
+for an explanation.")
 
 ;;;###autoload
 (defvar calendar-date-display-form
 
 To include a holiday conditionally, use the if or the sexp form.  For example,
 to include American presidential elections, which occur on the first Tuesday
-after the first Monday in November of years divisble by 4, add
+after the first Monday in November of years divisible by 4, add
 
      (sexp (if (zerop (% year 4))
                (calendar-gregorian-from-absolute
        \\[calendar-print-french-date]  show equivalent date on the French Revolutionary calendar
        \\[calendar-print-mayan-date]  show equivalent date on the Mayan calendar
 
-The astromonical (Julian) day number of a date is found with
+The astronomical (Julian) day number of a date is found with
 
        \\[calendar-print-astro-day-number]  show equivalent astronomical (Julian) day number
 
   "Move cursor to astronomical (Julian) DAYNUMBER.
 Echo astronomical (Julian) day number unless NOECHO is t."
   (interactive (list (calendar-read
-                      "Astromonical (Julian) day number (>1721425): "
+                      "Astronomical (Julian) day number (>1721425): "
                       '(lambda (x) (> x 1721425)))))
   (calendar-goto-date (calendar-gregorian-from-absolute (- daynumber 1721425)))
   (or noecho (calendar-print-astro-day-number)))

lisp/calendar/solar.el

 ;;; Commentary:
 
 ;; This collection of functions implements the features of calendar.el and
-;; diary.el that deal with sunrise/sunset and eqinoxes/solstices.
+;; diary.el that deal with sunrise/sunset and equinoxes/solstices.
 
 ;; Based on the ``Almanac for Computers 1984,'' prepared by the Nautical
 ;; Almanac Office, United States Naval Observatory, Washington, 1984 and

lisp/cmuscheme.el

 do the right thing. If you run multiple processes, you can change
 scheme-buffer to another process buffer with \\[set-variable].
 
-More sophisticated approaches are, of course, possible. If you find youself
+More sophisticated approaches are, of course, possible. If you find yourself
 needing to switch back and forth between multiple processes frequently,
 you may wish to consider ilisp.el, a larger, more sophisticated package
 for running inferior Lisp and Scheme processes. The approach taken here is
 ;;; 9/5/90 shivers
 ;;; - Changed make-variable-buffer-local's to make-local-variable's.
 ;;;   This leaves non-comint-mode buffers alone. Stephane Payrard
-;;;   reported the sloppy useage.
+;;;   reported the sloppy usage.
 ;;; - You can now go from comint-previous-similar-input to
 ;;;   comint-previous-input with no problem.
 ;;;

lisp/completion.el

 ;;;---------------------
 ;;;
 ;;;   A "word" is any string containing characters with either word or symbol 
-;;; syntax.  [E.G. Any alphanumeric string with hypens, underscores, etc.]
+;;; syntax.  [E.G. Any alphanumeric string with hyphens, underscores, etc.]
 ;;; Unless you change the constants, you must type at least three characters
 ;;; for the word to be recognized.  Only words longer than 6 characters are
 ;;; saved.
 ;;;
 ;;;   When you load this file, completion will be on.  I suggest you use the
-;;; compiled version (because it is noticibly faster).
+;;; compiled version (because it is noticeably faster).
 ;;;
 ;;;  M-X completion-mode toggles whether or not new words are added to the
 ;;; database by changing the value of enable-completion.
 ;;; superior to that of the LISPM version.
 ;;;
 ;;;-----------------------------------------------
-;;; Acknowlegements
+;;; Acknowledgements
 ;;;-----------------------------------------------
 ;;;  Cliff Lasser (cal@think.com), Kevin Herbert (kph@cisco.com),
 ;;;  eero@media-lab, kgk@cs.brown.edu, jla@ai.mit.edu,
 ;;;
 ;;; C diffs ->
 ;;;   Separator chars :: + * / : %
-;;;  A note on the hypen (`-').  Perhaps, the hypen should also be a separator
+;;;  A note on the hyphen (`-').  Perhaps the hyphen should also be a separator
 ;;; char., however, we wanted to have completion symbols include pointer 
 ;;; references.  For example, "foo->bar" is a symbol as far as completion is
 ;;; concerned.
 (defconst cmpl-obarray-length 511)
 
 (defvar cmpl-prefix-obarray (make-vector cmpl-obarray-length 0)
-  "An obarray used to store the downcased completion prefices.
+  "An obarray used to store the downcased completion prefixes.
 Each symbol is bound to a list of completion entries.")
 
 (defvar cmpl-obarray (make-vector cmpl-obarray-length 0)
 (defmacro set-cmpl-prefix-entry-tail (prefix-entry new-tail)
   (list 'setcdr prefix-entry new-tail))
 
-;;; Contructor
+;;; Constructor
 
 (defun make-cmpl-prefix-entry (completion-entry-list)
   "Makes a new prefix entry containing only completion-entry."
 ;;; WRITES
 (defun add-completion-to-tail-if-new (string)
   "If STRING is not in the database add it to appropriate prefix list.
-STRING is added to the end of the approppriate prefix list with
+STRING is added to the end of the appropriate prefix list with
 num-uses = 0.  The database is unchanged if it is there.  STRING must be
 longer than `completion-prefix-min-length'.
 This must be very fast.
 
 (defun add-completion-to-head (string)
   "If STRING is not in the database, add it to prefix list.
-STRING is added to the head of the approppriate prefix list.  Otherwise
+STRING is added to the head of the appropriate prefix list.  Otherwise
 it is moved to the head of the list.
 STRING must be longer than `completion-prefix-min-length'.
 Updates the saved string with the supplied string.
 
 (defun complete (&optional arg)
   "Fill out a completion of the word before point.  
-Point is left at end.  Consective calls rotate through all possibilities.
+Point is left at end.  Consecutive calls rotate through all possibilities.
 Prefix args ::
   control-u :: leave the point at the beginning of the completion rather 
                than at the end.
 ;;; Symbol separator chars (have whitespace syntax) --> , ; * = (
 ;;; Opening char --> [ {
 ;;; Closing char --> ] }
-;;; openning and closing must be skipped over
+;;; opening and closing must be skipped over
 ;;; Whitespace chars (have symbol syntax)
 ;;; Everything else has word syntax
 
 (defun cmpl-make-c-def-completion-syntax-table ()
   (let ((table (make-vector 256 0))
 	(whitespace-chars '(?  ?\n ?\t ?\f  ?\v ?\r))
-	;; unforunately the ?( causes the parens to appear unbalanced
+	;; unfortunately the ?( causes the parens to appear unbalanced
 	(separator-chars '(?, ?* ?= ?\( ?\;
 			   ))
 	)
 ;;; Patches to self-insert-command.
 ;;;-----------------------------------------------
 
-;;; Need 2 versions: generic seperator chars. and space (to get auto fill
+;;; Need 2 versions: generic separator chars. and space (to get auto fill
 ;;; to work)
 
 ;;; All common separators (eg. space "(" ")" """) characters go through a
 ;;; function to add new words to the list of words to complete from:
 ;;;  COMPLETION-SEPARATOR-SELF-INSERT-COMMAND (arg).
 ;;; If the character before this was an alpha-numeric then this adds the 
-;;; symbol befoe point to the completion list (using ADD-COMPLETION).
+;;; symbol before point to the completion list (using ADD-COMPLETION).
 
 (defun completion-separator-self-insert-command (arg)
   (interactive "p")

lisp/dired-aux.el

 (defun dired-shell-quote (filename)
   "Quote a file name for inferior shell (see variable `shell-file-name')."
   ;; Quote everything except POSIX filename characters.
-  ;; This should be safe enough even for really wierd shells.
+  ;; This should be safe enough even for really weird shells.
   (let ((result "") (start 0) end)
     (while (string-match "[^---0-9a-zA-Z_./]" filename start)
       (setq end (match-beginning 0)
 (defun dired-compress-file (file)
   ;; Compress or uncompress FILE.
   ;; Return the name of the compressed or uncompressed file.
-  ;; Rerurn nil if no change in files.
+  ;; Return nil if no change in files.
   (let ((handler (find-file-name-handler file)))
     (cond (handler
 	   (funcall handler 'dired-compress-file file))
 	    nil))
     (if reason				; don't move away on failure
 	(goto-char opoint))
-    (not reason)))			; return t on succes, nil else
+    (not reason)))			; return t on success, nil else
 
 ;; This is a separate function for the sake of nested dired format.
 (defun dired-add-entry-do-indentation (marker-char)
   ;;   the new files.  Target may be a plain file if only one marked
   ;;   file exists.
   ;; OP-SYMBOL is the symbol for the operation.  Function `dired-mark-pop-up'
-  ;;   will determine wether pop-ups are appropriate for this OP-SYMBOL.
+  ;;   will determine whether pop-ups are appropriate for this OP-SYMBOL.
   ;; FILE-CREATOR and OPERATION as in dired-create-files.
   ;; ARG as in dired-get-marked-files.
   ;; Optional arg OP1 is an alternate form for OPERATION if there is
 (defvar dired-chown-program
   (if (memq system-type '(hpux dgux usg-unix-v silicon-graphics-unix))
       "chown" "/etc/chown")
-  "Name of chown command (usully `chown' or `/etc/chown').")
+  "Name of chown command (usually `chown' or `/etc/chown').")
 
 ;;;###autoload
 (defvar dired-ls-F-marks-symlinks nil
   (dired-sort-other dired-actual-switches t)
   (run-hooks 'dired-mode-hook))
 
-;; Ideosyncratic dired commands that don't deal with marks.
+;; Idiosyncratic dired commands that don't deal with marks.
 
 (defun dired-quit ()
   "Bury the current dired buffer."

lisp/emacs-lisp/backquote.el

 
 ;;; Commentary:
 
- ;;; This is a rudimentry backquote package written by D. King,
+ ;;; This is a rudimentary backquote package written by D. King,
  ;;; king@kestrel, on 8/31/85.  (` x) is a macro
  ;;; that expands to a form that produces x.  (` (a b ..)) is
  ;;; a macro that expands into a form that produces a list of what a b
 ;;; These two advertised variables control what characters are used to
  ;;; unquote things.  I have included , and ,@ as the unquote and
  ;;; splice operators, respectively, to give users of MIT CADR machine
- ;;; derivitive machines a warm, cosy feeling.
+ ;;; derivative machines a warm, cosy feeling.
 
 (defconst backquote-unquote '(,)
   "*A list of all objects that stimulate unquoting in `.  Memq test.")
 
 ;;; Given a state/tailmaker pair that already knows how to make a
  ;;; partial tail of the desired form, this function knows how to add
- ;;; yet another element to the burgening list.  There are four cases;
+ ;;; yet another element to the burgeoning list.  There are four cases;
  ;;; the next item is an atom (which will certainly be quoted); a 
  ;;; (, xxx), which will be evaluated and put into the list at the top
  ;;; level; a (,@ xxx), which will be evaluated and spliced in, or

lisp/emacs-lisp/byte-opt.el

 	  
 	  ((memq fn '(and or))  ; remember, and/or are control structures.
 	   ;; take forms off the back until we can't any more.
-	   ;; In the future it could concievably be a problem that the
+	   ;; In the future it could conceivably be a problem that the
 	   ;; subexpressions of these forms are optimized in the reverse
 	   ;; order, but it's ok for now.
 	   (if for-effect
 ;;;
 ;;; It is now safe to optimize code such that it introduces new bindings.
 
-;; I'd like this to be a defsubst, but let's not be self-referental...
+;; I'd like this to be a defsubst, but let's not be self-referential...
 (defmacro byte-compile-trueconstp (form)
   ;; Returns non-nil if FORM is a non-nil constant.
   (` (cond ((consp (, form)) (eq (car (, form)) 'quote))
 ;; I'm not convinced that this is necessary.  Doesn't the optimizer loop 
 ;; take care of this? - Jamie
 ;; I think this may some times be necessary to reduce ie (quote 5) to 5,
-;; so arithmetic optimizers recognize the numerinc constant.  - Hallvard
+;; so arithmetic optimizers recognize the numeric constant.  - Hallvard
 (put 'quote 'byte-optimizer 'byte-optimize-quote)
 (defun byte-optimize-quote (form)
   (if (or (consp (nth 1 form))
 ;;; and by the disassembler.
 ;;;
 (defun byte-decompile-bytecode (bytes constvec)
-  "Turns BYTECODE into lapcode, refering to CONSTVEC."
+  "Turns BYTECODE into lapcode, referring to CONSTVEC."
   (let ((byte-compile-constants nil)
 	(byte-compile-variables nil)
 	(byte-compile-tag-number 0))
 	      ((and (eq (car lap0) 'TAG)
 		    (eq (car lap1) 'TAG))
 	       (and (memq byte-optimize-log '(t byte))
-		    (byte-compile-log "  adjascent tags %d and %d merged"
+		    (byte-compile-log "  adjacent tags %d and %d merged"
 				      (nth 1 lap1) (nth 1 lap0)))
 	       (setq tmp3 lap)
 	       (while (setq tmp2 (rassq lap0 tmp3))

lisp/emacs-lisp/bytecomp.el

 ;;;
 ;;;  o  The form `eval-when-compile' is like progn, except that the body
 ;;;     is evaluated at compile-time.  When it appears at top-level, this
-;;;     is analagous to the Common Lisp idiom (eval-when (compile) ...).
+;;;     is analogous to the Common Lisp idiom (eval-when (compile) ...).
 ;;;     When it does not appear at top-level, it is similar to the
 ;;;     Common Lisp #. reader macro (but not in interpreted code.)
 ;;;
 (byte-defop  24 -1 byte-varbind	"for binding a variable")
 (byte-defop  32  0 byte-call	"for calling a function")
 (byte-defop  40  0 byte-unbind	"for unbinding special bindings")
-;; codes 8-47 are consumed by the preceeding opcodes
+;; codes 8-47 are consumed by the preceding opcodes
 
 ;; unused: 48-55
 
 (defun byte-compile-associative (form)
   (if (cdr form)
       (let ((opcode (get (car form) 'byte-opcode)))
-	;; To compile all the args first may enable some optimizaions.
+	;; To compile all the args first may enable some optimizations.
 	(mapcar 'byte-compile-form (setq form (cdr form)))
 	(while (setq form (cdr form))
 	  (byte-compile-out opcode 0)))
 
 (defun byte-compile-funarg (form)
   ;; (mapcar '(lambda (x) ..) ..) ==> (mapcar (function (lambda (x) ..)) ..)
-  ;; for cases where it's guarenteed that first arg will be used as a lambda.
+  ;; for cases where it's guaranteed that first arg will be used as a lambda.
   (byte-compile-normal-call
    (let ((fn (nth 1 form)))
      (if (and (eq (car-safe fn) 'quote)

lisp/emacs-lisp/cl-indent.el

     ;;  which does special things with subforms.
     (let ((depth 0)
           ;; Path describes the position of point in terms of
-          ;;  list-structure with respect to contining lists.
+          ;;  list-structure with respect to containing lists.
           ;; `foo' has a path of (0 4 1) in `((a b c (d foo) f) g)'
           (path ())
           ;; set non-nil when somebody works out the indentation to use
 		 path state indent-point sexp-column normal-indent))
     (funcall (function lisp-indent-259)
 	     '((&whole nil &rest
- 		;; the following causes wierd indentation
+ 		;; the following causes weird indentation
  		;;(&whole 1 1 2 nil)
 		)
 	       (&whole nil &rest 1))

lisp/emacs-lisp/cust-print.el

 `print-length' and `print-level'.
 
 If non-nil, shared substructures anywhere in the structure are printed
-with `#N=' before the first occurance (in the order of the print
-representation) and `#N#' in place of each subsequent occurance,
+with `#N=' before the first occurrence (in the order of the print
+representation) and `#N#' in place of each subsequent occurrence,
 where N is a positive decimal integer.
 
 Currently, there is no way to read this representation in Emacs.")
 
 (defun custom-message (fmt &rest args)
   "Replacement for standard `message' that works like `custom-format'."
-  ;; It doesnt work to princ the result of custom-format
+  ;; It doesn't work to princ the result of custom-format
   ;; because the echo area requires special handling
   ;; to avoid duplicating the output.  cust-print-internal-message does it right.
   ;; (cust-print-internal-princ (apply 'custom-format fmt args))
 ;; Print the custom OBJECT using the custom type ALIST.
 ;; For the first predicate that matches the object, the corresponding
 ;; converter is evaluated with the object and the string that results is
-;; printed with princ.  Return nil if no predicte matches the object.
+;; printed with princ.  Return nil if no predicate matches the object.
 (defun cust-print-custom-object1 (object alist)
   (while (and alist (not (funcall (car (car alist)) object)))
     (setq alist (cdr alist)))

lisp/emacs-lisp/edebug.el

 ;;; Reset edebug-mode only on
 ;;; 	first entry of any function at each recursive-edit level.
 ;;; Add edebug-backtrace, to generate cleaned up
-;;; 	backtrace.  It doesnt "work" like the debug backtrace, however.
+;;; 	backtrace.  It doesn't "work" like the debug backtrace, however.
 ;;; Require reselecting outside window even if
 ;;; 	quit occurs, otherwise save-excursions may restore
 ;;; 	buffer to the wrong window.
 ;;; Leave point at syntax error, mark at starting position.
 ;;; 
 ;;; Revision 1.2  88/11/28  12:14:15  liberte
-;;; Bug fixes: cond construct didnt execute.
-;;;   () in sexp list didnt parse
-;;;   () as variable in condition-case didnt parse.
+;;; Bug fixes: cond construct didn't execute.
+;;;   () in sexp list didn't parse
+;;;   () as variable in condition-case didn't parse.
 ;;; 
 ;;; Revision 1.1  88/11/28  12:11:27  liberte
 ;;; Initial revision
 
 (defun edebug-window-list ()
   "Return a list of windows, in order of next-window."
-  ;; This doesnt work for epoch.
+  ;; This doesn't work for epoch.
   (let* ((first-window (selected-window))
 	 (window-list (list first-window))
 	 (next (next-window first-window)))
     (nreverse value-value-list)))
 
 
-;; Bug: this doesnt support condition name lists
+;; Bug: this doesn't support condition name lists
 (put 'condition-case 'edebug-form-hook
      '(symbolp
        form
 		   (eq edebug-arg-mode 'error)) 
 	       (progn
 		 (setq edebug-mode 'step)
-		 (edebug-overlay-arrow)	; this doesnt always show up.
+		 (edebug-overlay-arrow)	; this doesn't always show up.
 		 (edebug-recursive-edit));;   <<<<<< Recursive edit
 	     )
 

lisp/emacs-lisp/float.el

   "Number of highest bit")
 
 (defconst mantissa-maxval (1- (ash 1 maxbit))
-  "Maximum permissable value of mantissa")
+  "Maximum permissible value of mantissa")
 
 (defconst mantissa-minval (ash 1 maxbit)
-  "Minimum permissable value of mantissa")
+  "Minimum permissible value of mantissa")
 
 (defconst floating-point-regexp
   "^[ \t]*\\(-?\\)\\([0-9]*\\)\

lisp/emacs-lisp/lisp-mode.el

 		 (parse-partial-sexp (point) last-sexp 0 t)
 		 (backward-prefix-chars)))))
       ;; Point is at the point to indent under unless we are inside a string.
-      ;; Call indentation hook except when overriden by lisp-indent-offset
+      ;; Call indentation hook except when overridden by lisp-indent-offset
       ;; or if the desired indentation has already been computed.
       (let ((normal-indent (current-column)))
         (cond ((elt state 3)

lisp/emacs-lisp/lisp.el

 
 ;;; Commentary:
 
-;; Lisp ediing commands to go with Lisp major mode.
+;; Lisp editing commands to go with Lisp major mode.
 
 ;;; Code:
 
 	default-B	the merge buffer contains the B variant by default,
 			but this difference hasn't been selected yet, so
 			change-default commands can alter it
-	prefer-A	in a three-file merge, the A variant is the prefered
+	prefer-A	in a three-file merge, the A variant is the preferred
 			choice
-	prefer-B	in a three-file merge, the B variant is the prefered
+	prefer-B	in a three-file merge, the B variant is the preferred
 			choice")
 (emerge-defvar-local emerge-current-difference -1
   "The difference that is currently selected.")
 	     (t
 	      (error "Unrecognized entry"))))
 	;; If the match on the entry pattern failed
-	(error "Unparseable entry")))
+	(error "Unparsable entry")))
     ;; Make sure that file-A and file-B are present
     (if (not (or (and file-A file-B) file-out))
 	(error "Must have both `A' and `B' entries"))
 
 (defun emerge-join-differences (arg)
   "Join the selected difference with the following one.
-With a prefix argument, join with the preceeding one."
+With a prefix argument, join with the preceding one."
   (interactive "P")
   (let ((n emerge-current-difference))
     ;; adjust n to be first difference to join
        (if (< index emerge-number-of-differences)
 	   index
 	 (error "No difference contains or follows point")))
-      ;; if the arg is negative, select the preceeding difference
+      ;; if the arg is negative, select the preceding difference
       (t
        (if (> index 0)
 	   (1- index)
-	 (error "No difference contains or preceeds point")))))))
+	 (error "No difference contains or precedes point")))))))
 
 (defun emerge-line-numbers ()
   "Display the current line numbers.

lisp/emulation/edt.el

   (global-set-key "\C-j" edt-mode-old-linefeed))           ;"LineFeed"
 
 (defvar GOLD-map (make-keymap)
-   "`GOLD-map' maps the function keys on the VT100 keyboard preceeded
+   "`GOLD-map' maps the function keys on the VT100 keyboard preceded
 by the PF1 key.  GOLD is the ASCII the 7-bit escape sequence <ESC>OP.")
 
 (defalias 'GOLD-prefix GOLD-map)

lisp/emulation/mlconvert.el

 
 ;;; Commentary:
 
-;; This package conversts Mocklisp code written under a Gosling or UniPress
+;; This package converts Mocklisp code written under a Gosling or UniPress
 ;; Emacs for use with GNU Emacs.  The translated code will require runtime
 ;; support from the mlsupport.el equivalent.
 

lisp/emulation/vi.el

   "Save last direction, char and upto-flag used for char finding.")
 
 (defvar vi-last-change-command nil	; cons cell
-  "Save commmands for redoing last changes.  Each command is in (FUNC . ARGS)
+  "Save commands for redoing last changes.  Each command is in (FUNC . ARGS)
 form that is ready to be 'apply'ed.")
 
 (defvar vi-last-shell-command nil	; last shell op command line
 
 (defun vi-char-argument (arg)
   "Get following character (could be any CHAR) as part of the prefix argument.
-Possible perfix-arg cases are NIL, INTEGER, (NIL . CHAR) or (INTEGER . CHAR)."
+Possible prefix-arg cases are NIL, INTEGER, (NIL . CHAR) or (INTEGER . CHAR)."
   (interactive "P")
   (let ((char (read-char)))
     (cond ((null arg) (setq prefix-arg (cons nil char)))
 	   (vi-ask-for-info char))))
 
 (defun vi-mark-region (arg region)
-  "Mark region approriately.  The next char REGION is d(efun),s(-exp),b(uffer),
+  "Mark region appropriately.  The next char REGION is d(efun),s(-exp),b(uffer),
 p(aragraph), P(age), f(unction in C/Pascal etc.), w(ord), e(nd of sentence),
 l(ines)."
   (interactive "p\nc")

lisp/emulation/vip.el

 
 (defvar vip-d-com nil
   "If non-nil, it's value is a list (M-COM VAL COM), and is used to
-re-execute last destrcutive command")
+re-execute last destructive command")
 
 (defconst vip-shift-width 8
   "*The number of colums shifted by > and < command.")
   "*If t then do regexp replace, if nil then do string replace.")
 
 (defvar vip-d-char nil
-  "The character remenbered by the vi \"r\" command")
+  "The character remembered by the vi \"r\" command")
 
 (defvar vip-f-char nil
   "for use by \";\" command")
   (vip-escape-to-emacs arg '(?\C-h)))
 
 
-;; prefix argmument for vi mode
+;; prefix argument for vi mode
 
 ;; In vi mode, prefix argument is a dotted pair (NUM . COM) where NUM
 ;; represents the numeric value of the prefix argument and COM represents
 	    (setq cont nil))
 	;; if com is nil we set com as char, and read more.  again, if char
 	;; is ", we read the name of register and store it in vip-use-register.
-	;; if char is !, =, or #, a copmlete com is formed so we exit while.
+	;; if char is !, =, or #, a complete com is formed so we exit while.
 	(cond ((or (= char ?!) (= char ?=))
 	       (setq com char)
 	       (setq char (read-char))
 	  com (vip-getcom arg))
     (if (null val)
 	(if (null com)
-	    (message "Value is nil, and commmand is nil.")
+	    (message "Value is nil, and command is nil.")
 	  (message "Value is nil, and command is %c." com))
       (if (null com)
 	  (message "Value is %d, and command is nil." val)
 			  reg))))
 
 (defun vip-repeat (arg)
-  "(ARG)  Re-excute last destructive command.  vip-d-com has the form
+  "(ARG)  Re-execute last destructive command.  vip-d-com has the form
 (COM ARG CH REG), where COM is the command to be re-executed, ARG is the
 argument for COM, CH is a flag for repeat, and REG is optional and if exists
 is the name of the register for COM."
     (if com (vip-execute-com 'vip-goto-line val com))))
 
 (defun vip-find-char (arg char forward offset)
-  "Find ARG's occurence of CHAR on the current line.  If FORWARD then
+  "Find ARG's occurrence of CHAR on the current line.  If FORWARD then
 search is forward, otherwise backward.  OFFSET is used to adjust point
 after search."
   (let ((arg (if forward arg (- arg))) point)
 ;; searching
 
 (defun vip-search-forward (arg)
-  "Search a string forward.  ARG is used to find the ARG's occurence
+  "Search a string forward.  ARG is used to find the ARG's occurrence
 of the string.  Default is vanilla search.  Search mode can be toggled by
 giving null search string."
   (interactive "P")
 	    (vip-execute-com 'vip-search-next val com))))))
 
 (defun vip-search-backward (arg)
-  "Search a string backward.  ARG is used to find the ARG's occurence
+  "Search a string backward.  ARG is used to find the ARG's occurrence
 of the string.  Default is vanilla search.  Search mode can be toggled by
 giving null search string."
   (interactive "P")
   "pattern for global command")
 
 (defvar ex-map (make-sparse-keymap)
-  "save commnads for mapped keys")
+  "save commands for mapped keys")
 
 (defvar ex-tag nil
   "save ex tag")
 	    (forward-line (1- ex-count)))
 	(set-mark end))
       (vip-enlarge-region (point) (mark))
-      (if ex-flag (error "Extra chacters at end of command"))
+      (if ex-flag (error "Extra characters at end of command"))
       (if ex-buffer
 	  (copy-to-register ex-buffer (point) (mark) nil))
       (copy-region-as-kill (point) (mark)))))

lisp/emulation/ws-mode.el

 
 
 (defun ws-indent-block ()
-  "In WordStar mode: Indent block (not yet implemeted)."
+  "In WordStar mode: Indent block (not yet implemented)."
   (interactive)
   (ws-error "Indent block not yet implemented"))
 
 	  ;; would mean that our line of output would not display
 	  ;; FILE's name as given.  To really address the problem that
 	  ;; SunOS 4.1.3 has, we need to find the right switch to get
-	  ;; a descripton of the link itself.
+	  ;; a description of the link itself.
 	  ;; (let (symlink)
 	  ;;   (while (setq symlink (file-symlink-p file))
 	  ;;     (setq file symlink)))
 Pop-up frames are used for completions, help, and the like.
 This variable can be set in your init file, like this:
   (setq pop-up-frame-alist '((width . 80) (height . 20)))
-These supercede the values given in `default-frame-alist'.")
+These supersede the values given in `default-frame-alist'.")
 
 (setq pop-up-frame-function
       (function (lambda ()
 ;;;; Creation of additional frames, and other frame miscellanea
 
 ;;; Return some frame other than the current frame, creating one if
-;;; neccessary.  Note that the minibuffer frame, if separate, is not
+;;; necessary.  Note that the minibuffer frame, if separate, is not
 ;;; considered (see next-frame).
 (defun get-other-frame ()
   (let ((s (if (equal (next-frame (selected-frame)) (selected-frame))
 ;; The job of the marker-filter method is to detect file/line markers in
 ;; strings and set the global gud-last-frame to indicate what display
 ;; action (if any) should be triggered by the marker.  Note that only
-;; whetever the method *returns* is displayed in the buffer; thus, you
+;; whatever the method *returns* is displayed in the buffer; thus, you
 ;; can filter the debugger's output, interpreting some and passing on
 ;; the rest.
 ;;
 
 (defun expr-compound-sep (span-start span-end)
   "Returns '.' for '->' & '.', returns ' ' for white space,
-returns '?' for other puctuation."  
+returns '?' for other punctuation."
   (let ((result ? )
 	(syntax))
     (while (< span-start span-end)
 
 ;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
 
-;; |$Date: 1993/06/04 06:40:45 $|$Revision: 1.40 $
+;; |$Date: 1993/06/06 22:11:22 $|$Revision: 1.41 $
 
 ;; This file is not yet part of GNU Emacs, but it is based almost
 ;; entirely on isearch.el which is part of GNU Emacs.
 ;; the last possible moment.
 
 ;; TODO
-;; - Integrate the emacs 19 generalized commmand history.
+;; - Integrate the emacs 19 generalized command history.
 ;; - Think about incorporating query-replace.
 ;; - Hooks and options for failed search.
 
 
 ;;;=======================================================
 ;;; Switching buffers should first terminate isearch-mode.
-;;; This is done quite differently for each varient of emacs.
+;;; This is done quite differently for each variant of emacs.
 ;;; For lemacs, see Exiting in lemacs below
 
 ;; For Emacs 19, the frame switch event is handled.
 \\[isearch-forward-exit-minibuffer] to resume isearching forward.
 \\[isearch-backward-exit-minibuffer] to resume isearching backward.
 \\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring.
-\\[isearch-ring-retreat-edit] to replace the search string with the previou item in the search ring.
+\\[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring.
 \\[isearch-complete-edit] to complete the search string using the search ring.
 
 If first char entered is \\[isearch-yank-word], then do word search instead."
   ;; Mainly, isearch-mode must be terminated while editing and then restarted.
   ;; If there were a way to catch any change of buffer from the minibuffer,
   ;; this could be simplified greatly.
-  ;; Editing doesnt back up the search point.  Should it?
+  ;; Editing doesn't back up the search point.  Should it?
   (interactive)
   (condition-case err
       (let (isearch-nonincremental	; should search nonincrementally?
 Otherwise, revert to previous successful search and continue searching.
 Use `isearch-exit' to quit without signalling."
   (interactive)
-;;  (ding)  signal instead below, if quiting
+;;  (ding)  signal instead below, if quitting
   (discard-input)
   (if isearch-success
       ;; If search is successful, move back to starting point
 	  (isearch-process-search-string search-whitespace-regexp " ")
 	(isearch-printing-char))
     (progn
-      ;; This way of doing word search doesnt correctly extend current search.
+      ;; This way of doing word search doesn't correctly extend current search.
       ;;      (setq isearch-word t)
       ;;      (setq isearch-adjusted t)
       ;;      (goto-char isearch-barrier)
 ;; system you connect to.  A more serious problem is that some brain-dead
 ;; systems will not recognize a ^J as an end-of-line character.  So LFD is
 ;; bound to a new function which acts just like CR usually does in shell-mode,
-;; but a ^M is sent as an end-of-line.  Funcions are also provied to swap the
+;; but a ^M is sent as an end-of-line.  Functions are also provided to swap the
 ;; bindings of CR and LFD.  I've also included a filter which will clean out
 ;; any ^M's or ^@'s that get typed at you, but I don't really recommend it.
 ;; There doesn't seem to be an acceptably fast way to do this via emacs-lisp.
 ;; thru a fairly stupid terminal switch.  If I want to connect to unix system,
 ;; then I use the LFD key to talk to the switch, and ignore any ^M's in the
 ;; buffer, and do a " stty -echo nl " after I log in.  Then the only real
-;; differnce from being in local shell-mode is that it is you need to to type
+;; difference from being in local shell-mode is that you need to type
 ;; ^C^Q^C to send an interrupt, and ^C^Q^Z for a stop signal, etc.  (since ^C^C
 ;; just generates a local stop signal, which kermit ignores).
 ;; To connect to a VMS system, I use a shell script to invoke kermit thru the
 ;; in order to do a file transfer, you have to think ahead and and add -r
 ;; (receive) to the command line.  This means that you can't use the server
 ;; feature.  The only fix I can see is to muck around with the source code for
-;; kermit, although this problably wouldn't be too hard.  What is needed is an
+;; kermit, although this probably wouldn't be too hard.  What is needed is an
 ;; option to force kermit to be local, to use stdin and stdout for interactive
 ;; speech, and to forget about cbreak mode.
 
 		   (with-output-to-temp-buffer "*Help*"
 		     (princ
 		      (substitute-command-keys
-		       "Specify how to procede with keyboard macro execution.
+		       "Specify how to proceed with keyboard macro execution.
 Possibilities: \\<query-replace-map>
 \\[act]	Finish this iteration normally and continue with the next.
 \\[skip]	Skip the rest of this iteration, and start the next.

lisp/mail/mailabbrev.el

 ;;;     fred, ethyl, larry, curly, moe
 ;;;
 ;;; Aliases may also contain forward references; the alias of "everybody" can
-;;; preceed the aliases of "group1" and "group2".
+;;; precede the aliases of "group1" and "group2".
 ;;;
 ;;; This code also understands the "source" .mailrc command, for reading
 ;;; aliases from some other file as well.
 
 (defvar mail-mode-header-syntax-table
   (let ((tab (copy-syntax-table text-mode-syntax-table)))
-    ;; This makes the characters "@%!._-" be considered symbol-consituents
+    ;; This makes the characters "@%!._-" be considered symbol-constituents
     ;; but not word-constituents, so forward-sexp will move you over an
     ;; entire address, but forward-word will only move you over a sequence
     ;; of alphanumerics.  (Clearly the right thing.)

lisp/mail/rmail.el

       ;; Show the first unseen message, which might be from a previous session
       ;; or might have been just read in by rmail-get-new-mail.  Must
       ;; determine already unseen messages first, as rmail-get-new-mail
-      ;; positions on the first new messsage, thus marking it as seen.
+      ;; positions on the first new message, thus marking it as seen.
       (rmail-show-message existing-unseen))))
 
 ;; Given the value of MAILPATH, return a list of inbox file names.
 ;; Eric Rose <erose@jessica.stanford.edu>, submitted manual.el which
 ;; provided a very nice manual browsing mode.
 
-;; This package was available as `superman.el' from the LCD paackage
+;; This package was available as `superman.el' from the LCD package
 ;; for some time before it was accepted into Emacs 19.  The entry
 ;; point and some other names have been changed to make it a drop-in
 ;; replacement for the old man.el package.
   "*Association list of bogus sections to real section numbers.
 Some manpages (e.g. the Sun C++ 2.1 manpages) have section numbers in
 their references which Un*x man(1) does not recognize.  This
-assocation list is used to translate those sections, when found, to
+association list is used to translate those sections, when found, to
 the associated section number.")
 
 (defvar Man-filter-list

lisp/play/blackbox.el

   (define-key blackbox-mode-map "\C-m" 'bb-done)
   (define-key blackbox-mode-map [kp-enter] 'bb-done)
 
-  ;; This is a kluge.  What we really want is a general
+  ;; This is a kludge.  What we really want is a general
   ;; feature for reminding terminal keys to the functions
   ;; corresponding to them in local maps.
   (mapcar (function

lisp/play/dissociate.el

 
 ;;; Commentary:
 
-;; The single entry point, `dissociatesd-press', applies a travesty
+;; The single entry point, `dissociated-press', applies a travesty
 ;; generator to the current buffer.  The results can be quite amusing.
 
 ;;; Code:

lisp/play/doctor.el

   (setq deathlst
 	'((this is not a healthy way of thinking \.)
 	  (($ bother) you\, too\, may die someday \?)
-	  (i am worried by your obssession with this topic!)
+	  (i am worried by your obsession with this topic!)
 	  (did you watch a lot of crime and violence on television as a child \?))
 	)
   (make-local-variable 'sexlst)
 (doctor-put-meaning elisa 'eliza)
 (doctor-put-meaning weizenbaum 'eliza)
 (doctor-put-meaning doktor 'eliza)
-(doctor-put-meaning atheletics 'sports)
+(doctor-put-meaning athletics 'sports)
 (doctor-put-meaning baseball 'sports)
 (doctor-put-meaning basketball 'sports)
 (doctor-put-meaning football 'sports)
 			     sent))))
 
 (defun doctor-shorten (sent)
-  "Make a sentence managably short using a few hacks."
+  "Make a sentence manageably short using a few hacks."
   (let (foo
 	retval
 	(temp '(because but however besides anyway until
 		applied applies apply are associate
 		associated ate
 		be became become becomes becoming
-		been being believe belived believes
+		been being believe believed believes
 		bit bite bites bore bored bores boring bought buy buys buying
 		call called calling calls came can caught catch come
 		contract contracted contracts control controlled controls
 		dislikes do does drank drink drinks drinking
 		drive drives driving drove dying
 		eat eating eats expand expanded expands
-		expect expected expects expel expels expeled expelled
+		expect expected expects expel expels expelled
 		explain explained explains
 		fart farts feel feels felt fight fights find finds finding
 		forget forgets forgot fought found fuck fucked
 		take takes taking talk talked talking talks tell tells telling
 		think thinks
 		thought told took tooled touch touched touches touching
-		transfer transfered transfers transmit transmits transmitted
+		transfer transferred transfers transmit transmits transmitted
 		type types types typing
 		walk walked walking walks want wanted wants was watch
 		watched watching went were will wish would work worked works
 		hundred thousand million billion
 		half quarter
 		first second third fourth fifth
-		sixth seventh eighth nineth tenth)))
+		sixth seventh eighth ninth tenth)))
 		 
 (defun doctor-colorp (x)
   (memq x '(beige black blue brown crimson

lisp/play/hanoi.el

 	  ;; If we have NRINGS rings, we label them with the numbers 0
 	  ;; through NRINGS-1.  The width of ring i is 2i+3; it pokes
 	  ;; out i spaces on either side of the pole.  Rather than
-	  ;; checking if the window is wide enough to accomodate this,
+	  ;; checking if the window is wide enough to accommodate this,
 	  ;; we make sure pole-spacing is large enough, since that
 	  ;; works even when we have decremented pole-spacing to make
 	  ;; it even.

lisp/play/life.el

 
 ;; A demonstrator for John Horton Conway's "Life" cellular automaton
 ;; in Emacs Lisp.  Picks a random one of a set of interesting Life
-;; patterns and avolves it according to the familiar rules.
+;; patterns and evolves it according to the familiar rules.
 
 ;;; Code:
 
 (defmacro life-not-void-regexp () (concat "[^" (life-void-string) "\n]"))
 
 ;; try to optimize the (goto-char (point-min)) & (goto-char (point-max))
-;; idioms.  This depends on goto-char's not griping if we underrshoot
+;; idioms.  This depends on goto-char's not griping if we undershoot
 ;; or overshoot beginning or end of buffer.
 (defmacro goto-beginning-of-buffer () '(goto-char 1))
 (defmacro maxint () (lsh (lsh (lognot 0) 1) -1))

lisp/play/mpuz.el

       (aset mpuz-letter-to-digit elem index))))
 
 
-;; A puzzle also uses a board displaying a mulplication.
+;; A puzzle also uses a board displaying a multiplication.
 ;; Every digit appears in the board, crypted or not.
 ;;------------------------------------------------------
 (defvar mpuz-board (make-vector 10 nil)
 ;; Game control
 ;;-------------
 (defun mpuz-abort-game ()
-  "Abort any puzzle in progess."
+  "Abort any puzzle in progress."
   (message "Mult Puzzle aborted.")
   (setq mpuz-in-progress nil
 	mpuz-nb-errors 0)