Commits

Anonymous committed 169c044

Import from CVS: tag r20-3b26

Comments (0)

Files changed (47)

 							-*- indented-text -*-
+to 20.3 beta26 "Riga"
+-- Miscellaneous bug fixes
+
 to 20.3 beta25 "Prague"
--- Default use-union-type to YES because it works better when processing errors
-   occurring during garbage collection
 -- Ediff 2.671 Courtesy of Michael Kifer
 -- Viper 3.001 Courtesy of Michael Kifer
 -- OffiX DnD now binds to XEmacs events and doesn't use an external library
+1997-10-02  SL Baur  <steve@altair.xemacs.org>
+
+	* XEmacs 20.3-beta26 is released.
+
 1997-09-30  SL Baur  <steve@altair.xemacs.org>
 
 	* XEmacs 20.3-beta25 is released.
 
 ** Startup file additions.
 
-By default XEmacs now loads the user file ~/.xemacs if it exists.  If
-there is no such file, it reads ~/.emacs as usual.  If both .xemacs
-and .emacs exist, XEmacs will only load .xemacs.
-
-Customizable options are now saved to ~/.xemacs-custom file, which is
-normally loaded after .emacs.
+By default XEmacs now loads the user file "~/.xemacs/init.el" if it
+exists.  If there is no such file, it reads "~/.emacs" as usual.  If
+both "~/.xemacs/init.el" and "~/.emacs" exist, XEmacs will only load
+"~/.xemacs/init.el".
+
+Customizable options are now saved to "~/.xemacs/options.el" file,
+which is normally loaded after "~/.xemacs/init.el".
 
 ** Quail input method is now available.
 

etc/dkindred.xpm.Z

Binary file added.

etc/dkindredm.xpm.Z

Binary file added.
+1997-10-02  Colin Rafferty  <craffert@ml.com>
+
+	* prim/simple.el (set-fill-column): Used format to create the
+		  string for `display-message'.
+
+1997-10-03  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* custom/cus-face.el (custom-set-faces): Make the face, if
+	necessary.
+
+1997-10-02  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* custom/cus-face.el (custom-declare-face): Use `make-face'
+ 	instead of `make-empty-face'.
+	(custom-declare-face): Don't invoke init-face-from-resources
+ 	explicitly.
+
+	* prim/profile.el (pretty-print-profiling-info): When interactive, 
+	use a separate buffer instead of current-buffer.
+	(pretty-print-profiling-info): Prettified output.
+
+1997-10-01  SL Baur  <steve@altair.xemacs.org>
+
+	* custom/cus-dep.el (cus-face): Remove unneeded dependency on
+	cus-edit.
+
+1997-09-30  SL Baur  <steve@altair.xemacs.org>
+
+	* utils/finder.el (finder-known-keywords): Fix typo.
+
 1997-09-30  SL Baur  <steve@altair.xemacs.org>
 
 	* prim/dumped-lisp.el (preloaded-file-list): Load

lisp/bytecomp/custom-load.el

+;;; custom-load.el --- automatically extracted custom dependencies
+
+;; Created by SL Baur on Thu Oct  2 17:05:27 1997
+
+;;; Code:
+
+
+;;; custom-load.el ends here

lisp/cc-mode/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sun Sep 28 14:03:08 1997
+;; Created by SL Baur on Thu Oct  2 17:05:28 1997
 
 ;;; Code:
 

lisp/cl/cl-autoload.el

-;;; cl-autoload.el --- Generate the autoload file cl-defs.el.
-
-;; Copyright (C) 1993 Free Software Foundation, Inc.
-
-;; Author: Dave Gillespie <daveg@synaptics.com>, Ben Wing <wing@666.com>
-;; Version: 2.02
-;; Keywords: extensions, lisp
-
-;; This file is part of XEmacs.
-
-;; XEmacs is free software; you can redistribute it and/or modify it
-;; under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; XEmacs is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with XEmacs; see the file COPYING.  If not, write to the Free
-;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-;; 02111-1307, USA.
-
-;;; Synched up with: FSF 19.34 (cl.el).
-
-;;; Commentary:
-
-;;; Run this file to regenerate cl-defs.el.
-;;; Make sure to first erase the old autoloads from cl-defs.el!
-
-;;; This file was extracted almost directly from cl.el, and the code
-;;; there was replaced with (load "cl-defs.el").  What used to happen
-;;; is that when cl.el was loaded, it set up autoloads for all of the
-;;; functions and macros in the other files. (See the commented-out
-;;; code below.) However, the doc strings didn't get properly inserted,
-;;; so the functions had no documentation, which is bad.  I changed it
-;;; so that you run this only once (to generate cl-defs.el), and then
-;;; cl.el loads cl-defs.el.  Note that this relies on a hacked
-;;; autoload.el (included with XEmacs 19.14 / 20.0). --ben
-
-;;; Autoload the other portions of the package.
-(mapcar (function
-	 (lambda (set)
-;	   The old definition:
-;	   (mapcar (function
-;		    (lambda (func)
-;		      (autoload func (car set) nil nil (nth 1 set))))
-;		   (cddr set))))
-	   (find-file "cl-defs.el")
-	   (goto-char (point-max))
-	   (generate-file-autoloads (car set) (cddr set))))
-	'(("cl-extra.el" nil
-	   coerce equalp maplist mapc mapl mapcan mapcon
-	   cl-map-keymap cl-map-keymap-recursively cl-map-intervals
-	   cl-map-overlays cl-set-frame-visible-p cl-float-limits
-	   gcd lcm isqrt floor* ceiling* truncate* round*
-	   mod* rem* signum random* make-random-state random-state-p
-	   concatenate cl-mapcar-many map some every notany
-	   notevery revappend nreconc list-length tailp get* getf
-	   cl-set-getf cl-do-remf make-hash-table cl-hash-lookup
-	   cl-puthash hash-table-p
-	   hash-table-count cl-progv-before cl-prettyexpand
-	   cl-macroexpand-all
-	   ;; XEmacs: removed the following:
-	   ;; expt copy-tree subseq remprop gethash remhash clrhash maphash
-	   ;; cl-map-keymap appeared twice
-	   )
-	  ("cl-seq.el" nil
-	   reduce fill replace remq remove remove* remove-if remove-if-not
-	   delete* delete-if delete-if-not remove-duplicates
-	   delete-duplicates substitute substitute-if substitute-if-not
-	   nsubstitute nsubstitute-if nsubstitute-if-not find find-if
-	   find-if-not position position-if position-if-not count count-if
-	   count-if-not mismatch search sort* stable-sort merge member*
-	   member-if member-if-not cl-adjoin assoc* assoc-if assoc-if-not
-	   rassoc* rassoc-if rassoc-if-not union nunion intersection
-	   nintersection set-difference nset-difference set-exclusive-or
-	   nset-exclusive-or subsetp subst-if subst-if-not nsubst nsubst-if
-	   nsubst-if-not sublis nsublis tree-equal
-	   ;; XEmacs: removed the following:
-	   ;; delete rassoc
-	   )
-	  ("cl-macs.el" nil
-	   gensym gentemp typep cl-do-pop get-setf-method
-	   cl-struct-setf-expander compiler-macroexpand cl-compile-time-init)
-	  ("cl-macs.el" t
-	   defun* defmacro* function* destructuring-bind eval-when
-	   load-time-value case ecase typecase etypecase
-	   block return return-from loop do do* dolist dotimes do-symbols
-	   do-all-symbols psetq progv flet labels macrolet symbol-macrolet
-	   lexical-let lexical-let* multiple-value-bind multiple-value-setq
-	   locally the declare define-setf-method defsetf define-modify-macro
-	   setf psetf remf shiftf rotatef letf letf* callf callf2 defstruct
-	   check-type assert ignore-errors define-compiler-macro
-	   ;; XEmacs: removed the following:
-	   ;; eval-when-compile
-	   )))

lisp/cl/cl-defs.el

-;;; cl-defs.el --- Manually maintained autoloads for cl
-
-;; Copyright (C) 1993, 1997 Free Software Foundation, Inc.
-
-;; Maintainer: XEmacs Development Team
-;; Keywords: extensions, lisp
-
-;; This file is part of XEmacs.
-
-;; XEmacs is free software; you can redistribute it and/or modify it
-;; under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; XEmacs is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with XEmacs; see the file COPYING.  If not, write to the 
-;; Free Software Foundation, 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
-
-;;; Synched up with: Not synched.
-
-;;; Commentary:
- 
-;; At one time this file appears to have been generated by autoload.el.
-
-;;; Code:
-
-;;;***
-
-;;;### (autoloads (cl-compile-time-init compiler-macroexpand cl-struct-setf-expander get-setf-method cl-do-pop typep gentemp gensym) "cl-macs" "cl/cl-macs.el" (12559 39909))
-;;; Generated autoloads from cl/cl-macs.el
-
-(autoload 'gensym "cl-macs" "\
-Generate a new uninterned symbol.
-The name is made by appending a number to PREFIX, default \"G\"." nil nil)
-
-(autoload 'gentemp "cl-macs" "\
-Generate a new interned symbol with a unique name.
-The name is made by appending a number to PREFIX, default \"G\"." nil nil)
-
-(autoload 'typep "cl-macs" "\
-Check that OBJECT is of type TYPE.
-TYPE is a Common Lisp-style type specifier." nil nil)
-
-(autoload 'cl-do-pop "cl-macs" nil nil nil)
-
-(autoload 'get-setf-method "cl-macs" "\
-Return a list of five values describing the setf-method for PLACE.
-PLACE may be any Lisp form which can appear as the PLACE argument to
-a macro like `setf' or `incf'." nil nil)
-
-(autoload 'cl-struct-setf-expander "cl-macs" nil nil nil)
-
-(autoload 'compiler-macroexpand "cl-macs" nil nil nil)
-
-(autoload 'cl-compile-time-init "cl-macs" nil nil nil)
-
-;;;***
-
-;;;### (autoloads (define-compiler-macro ignore-errors assert check-type defstruct callf2 callf letf* letf rotatef shiftf remf psetf setf define-modify-macro defsetf define-setf-method declare the locally multiple-value-setq multiple-value-bind lexical-let* lexical-let symbol-macrolet macrolet labels flet progv psetq do-all-symbols do-symbols dotimes dolist do* do loop return-from return block etypecase typecase ecase case load-time-value eval-when destructuring-bind function* defmacro* defun*) "cl-macs" "cl/cl-macs.el" (12559 39909))
-;;; Generated autoloads from cl/cl-macs.el
-
-(autoload 'defun* "cl-macs" "\
-(defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
-Like normal `defun', except ARGLIST allows full Common Lisp conventions,
-and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
-
-(autoload 'defmacro* "cl-macs" "\
-(defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
-Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
-and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
-
-(autoload 'function* "cl-macs" "\
-(function* SYMBOL-OR-LAMBDA): introduce a function.
-Like normal `function', except that if argument is a lambda form, its
-ARGLIST allows full Common Lisp conventions." nil 'macro)
-
-(autoload 'destructuring-bind "cl-macs" nil nil 'macro)
-
-(autoload 'eval-when "cl-macs" "\
-(eval-when (WHEN...) BODY...): control when BODY is evaluated.
-If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
-If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
-If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level." nil 'macro)
-
-(autoload 'load-time-value "cl-macs" "\
-Like `progn', but evaluates the body at load time.
-The result of the body appears to the compiler as a quoted constant." nil 'macro)
-
-(autoload 'case "cl-macs" "\
-(case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
-Each clause looks like (KEYLIST BODY...).  EXPR is evaluated and compared
-against each key in each KEYLIST; the corresponding BODY is evaluated.
-If no clause succeeds, case returns nil.  A single atom may be used in
-place of a KEYLIST of one atom.  A KEYLIST of `t' or `otherwise' is
-allowed only in the final clause, and matches if no other keys match.
-Key values are compared by `eql'." nil 'macro)
-
-(autoload 'ecase "cl-macs" "\
-(ecase EXPR CLAUSES...): like `case', but error if no case fits.
-`otherwise'-clauses are not allowed." nil 'macro)
-
-(autoload 'typecase "cl-macs" "\
-(typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
-Each clause looks like (TYPE BODY...).  EXPR is evaluated and, if it
-satisfies TYPE, the corresponding BODY is evaluated.  If no clause succeeds,
-typecase returns nil.  A TYPE of `t' or `otherwise' is allowed only in the
-final clause, and matches if no other keys match." nil 'macro)
-
-(autoload 'etypecase "cl-macs" "\
-(etypecase EXPR CLAUSES...): like `typecase', but error if no case fits.
-`otherwise'-clauses are not allowed." nil 'macro)
-
-(autoload 'block "cl-macs" "\
-(block NAME BODY...): define a lexically-scoped block named NAME.
-NAME may be any symbol.  Code inside the BODY forms can call `return-from'
-to jump prematurely out of the block.  This differs from `catch' and `throw'
-in two respects:  First, the NAME is an unevaluated symbol rather than a
-quoted symbol or other form; and second, NAME is lexically rather than
-dynamically scoped:  Only references to it within BODY will work.  These
-references may appear inside macro expansions, but not inside functions
-called from BODY." nil 'macro)
-
-(autoload 'return "cl-macs" "\
-(return [RESULT]): return from the block named nil.
-This is equivalent to `(return-from nil RESULT)'." nil 'macro)
-
-(autoload 'return-from "cl-macs" "\
-(return-from NAME [RESULT]): return from the block named NAME.
-This jump out to the innermost enclosing `(block NAME ...)' form,
-returning RESULT from that form (or nil if RESULT is omitted).
-This is compatible with Common Lisp, but note that `defun' and
-`defmacro' do not create implicit blocks as they do in Common Lisp." nil 'macro)
-
-(autoload 'loop "cl-macs" "\
-(loop CLAUSE...): The Common Lisp `loop' macro.
-Valid clauses are:
-  for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
-  for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
-  for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
-  always COND, never COND, thereis COND, collect EXPR into VAR,
-  append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
-  count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
-  if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
-  unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
-  do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
-  finally return EXPR, named NAME." nil 'macro)
-
-(autoload 'do "cl-macs" "\
-The Common Lisp `do' loop.
-Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
-
-(autoload 'do* "cl-macs" "\
-The Common Lisp `do*' loop.
-Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
-
-(autoload 'dolist "cl-macs" "\
-(dolist (VAR LIST [RESULT]) BODY...): loop over a list.
-Evaluate BODY with VAR bound to each `car' from LIST, in turn.
-Then evaluate RESULT to get return value, default nil." nil 'macro)
-
-(autoload 'dotimes "cl-macs" "\
-(dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times.
-Evaluate BODY with VAR bound to successive integers from 0, inclusive,
-to COUNT, exclusive.  Then evaluate RESULT to get return value, default
-nil." nil 'macro)
-
-(autoload 'do-symbols "cl-macs" "\
-(dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols.
-Evaluate BODY with VAR bound to each interned symbol, or to each symbol
-from OBARRAY." nil 'macro)
-
-(autoload 'do-all-symbols "cl-macs" nil nil 'macro)
-
-(autoload 'psetq "cl-macs" "\
-(psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel.
-This is like `setq', except that all VAL forms are evaluated (in order)
-before assigning any symbols SYM to the corresponding values." nil 'macro)
-
-(autoload 'progv "cl-macs" "\
-(progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY.
-The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
-Each SYMBOL in the first list is bound to the corresponding VALUE in the
-second list (or made unbound if VALUES is shorter than SYMBOLS); then the
-BODY forms are executed and their result is returned.  This is much like
-a `let' form, except that the list of symbols can be computed at run-time." nil 'macro)
-
-(autoload 'flet "cl-macs" "\
-(flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns.
-This is an analogue of `let' that operates on the function cell of FUNC
-rather than its value cell.  The FORMs are evaluated with the specified
-function definitions in place, then the definitions are undone (the FUNCs
-go back to their previous definitions, or lack thereof)." nil 'macro)
-
-(autoload 'labels "cl-macs" nil nil 'macro)
-
-(autoload 'macrolet "cl-macs" "\
-(macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns.
-This is like `flet', but for macros instead of functions." nil 'macro)
-
-(autoload 'symbol-macrolet "cl-macs" "\
-(symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns.
-Within the body FORMs, references to the variable NAME will be replaced
-by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)." nil 'macro)
-
-(autoload 'lexical-let "cl-macs" "\
-(lexical-let BINDINGS BODY...): like `let', but lexically scoped.
-The main visible difference is that lambdas inside BODY will create
-lexical closures as in Common Lisp." nil 'macro)
-
-(autoload 'lexical-let* "cl-macs" "\
-(lexical-let* BINDINGS BODY...): like `let*', but lexically scoped.
-The main visible difference is that lambdas inside BODY will create
-lexical closures as in Common Lisp." nil 'macro)
-
-(autoload 'multiple-value-bind "cl-macs" "\
-(multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values.
-FORM must return a list; the BODY is then executed with the first N elements
-of this list bound (`let'-style) to each of the symbols SYM in turn.  This
-is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
-simulate true multiple return values.  For compatibility, (values A B C) is
-a synonym for (list A B C)." nil 'macro)
-
-(autoload 'multiple-value-setq "cl-macs" "\
-(multiple-value-setq (SYM SYM...) FORM): collect multiple return values.
-FORM must return a list; the first N elements of this list are stored in
-each of the symbols SYM in turn.  This is analogous to the Common Lisp
-`multiple-value-setq' macro, using lists to simulate true multiple return
-values.  For compatibility, (values A B C) is a synonym for (list A B C)." nil 'macro)
-
-(autoload 'locally "cl-macs" nil nil 'macro)
-
-(autoload 'the "cl-macs" nil nil 'macro)
-
-(autoload 'declare "cl-macs" nil nil 'macro)
-
-(autoload 'define-setf-method "cl-macs" "\
-(define-setf-method NAME ARGLIST BODY...): define a `setf' method.
-This method shows how to handle `setf's to places of the form (NAME ARGS...).
-The argument forms ARGS are bound according to ARGLIST, as if NAME were
-going to be expanded as a macro, then the BODY forms are executed and must
-return a list of five elements: a temporary-variables list, a value-forms
-list, a store-variables list (of length one), a store-form, and an access-
-form.  See `defsetf' for a simpler way to define most setf-methods." nil 'macro)
-
-(autoload 'defsetf "cl-macs" "\
-(defsetf NAME FUNC): define a `setf' method.
-This macro is an easy-to-use substitute for `define-setf-method' that works
-well for simple place forms.  In the simple `defsetf' form, `setf's of
-the form (setf (NAME ARGS...) VAL) are transformed to function or macro
-calls of the form (FUNC ARGS... VAL).  Example: (defsetf aref aset).
-Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
-Here, the above `setf' call is expanded by binding the argument forms ARGS
-according to ARGLIST, binding the value form VAL to STORE, then executing
-BODY, which must return a Lisp form that does the necessary `setf' operation.
-Actually, ARGLIST and STORE may be bound to temporary variables which are
-introduced automatically to preserve proper execution order of the arguments.
-Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))." nil 'macro)
-
-(autoload 'define-modify-macro "cl-macs" "\
-(define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro.
-If NAME is called, it combines its PLACE argument with the other arguments
-from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)" nil 'macro)
-
-(autoload 'setf "cl-macs" "\
-(setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL.
-This is a generalized version of `setq'; the PLACEs may be symbolic
-references such as (car x) or (aref x i), as well as plain symbols.
-For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
-The return value is the last VAL in the list." nil 'macro)
-
-(autoload 'psetf "cl-macs" "\
-(psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel.
-This is like `setf', except that all VAL forms are evaluated (in order)
-before assigning any PLACEs to the corresponding values." nil 'macro)
-
-(autoload 'remf "cl-macs" "\
-(remf PLACE TAG): remove TAG from property list PLACE.
-PLACE may be a symbol, or any generalized variable allowed by `setf'.
-The form returns true if TAG was found and removed, nil otherwise." nil 'macro)
-
-(autoload 'shiftf "cl-macs" "\
-(shiftf PLACE PLACE... VAL): shift left among PLACEs.
-Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
-Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
-
-(autoload 'rotatef "cl-macs" "\
-(rotatef PLACE...): rotate left among PLACEs.
-Example: (rotatef A B C) sets A to B, B to C, and C to A.  It returns nil.
-Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
-
-(autoload 'letf "cl-macs" "\
-(letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
-This is the analogue of `let', but with generalized variables (in the
-sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
-VALUE, then the BODY forms are executed.  On exit, either normally or
-because of a `throw' or error, the PLACEs are set back to their original
-values.  Note that this macro is *not* available in Common Lisp.
-As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
-the PLACE is not modified before executing BODY." nil 'macro)
-
-(autoload 'letf* "cl-macs" "\
-(letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
-This is the analogue of `let*', but with generalized variables (in the
-sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
-VALUE, then the BODY forms are executed.  On exit, either normally or
-because of a `throw' or error, the PLACEs are set back to their original
-values.  Note that this macro is *not* available in Common Lisp.
-As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
-the PLACE is not modified before executing BODY." nil 'macro)
-
-(autoload 'callf "cl-macs" "\
-(callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...).
-FUNC should be an unquoted function name.  PLACE may be a symbol,
-or any generalized variable allowed by `setf'." nil 'macro)
-
-(autoload 'callf2 "cl-macs" "\
-(callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...).
-Like `callf', but PLACE is the second argument of FUNC, not the first." nil 'macro)
-
-(autoload 'defstruct "cl-macs" "\
-(defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type.
-This macro defines a new Lisp data type called NAME, which contains data
-stored in SLOTs.  This defines a `make-NAME' constructor, a `copy-NAME'
-copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors." nil 'macro)
-
-(autoload 'check-type "cl-macs" "\
-Verify that FORM is of type TYPE; signal an error if not.
-STRING is an optional description of the desired type." nil 'macro)
-
-(autoload 'assert "cl-macs" "\
-Verify that FORM returns non-nil; signal an error if not.
-Second arg SHOW-ARGS means to include arguments of FORM in message.
-Other args STRING and ARGS... are arguments to be passed to `error'.
-They are not evaluated unless the assertion fails.  If STRING is
-omitted, a default message listing FORM itself is used." nil 'macro)
-
-(autoload 'ignore-errors "cl-macs" "\
-Execute FORMS; if an error occurs, return nil.
-Otherwise, return result of last FORM." nil 'macro)
-
-(autoload 'define-compiler-macro "cl-macs" "\
-(define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro.
-This is like `defmacro', but macro expansion occurs only if the call to
-FUNC is compiled (i.e., not interpreted).  Compiler macros should be used
-for optimizing the way calls to FUNC are compiled; the form returned by
-BODY should do the same thing as a call to the normal function called
-FUNC, though possibly more efficiently.  Note that, like regular macros,
-compiler macros are expanded repeatedly until no further expansions are
-possible.  Unlike regular macros, BODY can decide to \"punt\" and leave the
-original function call alone by declaring an initial `&whole foo' parameter
-and then returning foo." nil 'macro)
-
-;;;***
-
-;;; cl-defs.el ends here

lisp/comint/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sun Sep 28 14:03:10 1997
+;; Created by SL Baur on Thu Oct  2 17:05:29 1997
 
 ;;; Code:
 

lisp/custom/cus-dep.el

 
 (require 'cl)
 (require 'widget)
-(require 'cus-edit)
 (require 'cus-face)
 
 ;; Don't change this, unless you plan to change the code in

lisp/custom/cus-face.el

 	    (frames (relevant-custom-frames))
 	    frame)
 	;; Create global face.
-	(make-empty-face face)
+	(make-face face)
 	(face-display-set face value)
 	;; Create frame local faces
 	(while frames
 	  (setq frame (car frames)
 		frames (cdr frames))
-	  (face-display-set face value frame))
-	(init-face-from-resources face)))
+	  (face-display-set face value frame))))
     (when (and doc (null (face-doc-string face)))
       (set-face-doc-string face doc))
     (custom-handle-all-keywords face args 'custom-face)
     (:foreground (color :tag "Foreground"
 			:value ""
 			:help-echo "Set foreground color.")
-		 set-face-foreground custom-face-foreground)
+		 set-face-foreground face-foreground-name)
     (:background (color :tag "Background"
 			:value ""
 			:help-echo "Set background color.")
-		 set-face-background custom-face-background)
-;;    (:reverse-video (boolean :tag "Reverse"
+		 set-face-background face-background-name)
+;;    (:inverse-video (boolean :tag "Inverse"
 ;;			     :help-echo "\
 ;;Control whether the text should be inverted.")
-;;		    custom-reverse-face custom-face-reverse)
+;;		    custom-inverse-face custom-face-inverse)
     (:stipple (editable-field :format "Stipple: %v"
 			      :help-echo "Name of background bitmap file.")
 	      set-face-background-pixmap custom-face-stipple)
 	    (when now
 	      (put face 'force-face t))
 	    (when (or now (find-face face))
+	      (unless (find-face face)
+		(make-face face))
 	      (face-spec-set face spec))
 	    (setq args (cdr args)))
 	;; Old format, a plist of FACE SPEC pairs.

lisp/custom/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:08:42 1997
+;; Created by SL Baur on Thu Oct  2 17:05:30 1997
 
 ;;; Code:
 
 (custom-put 'extensions 'custom-loads '("wid-edit"))
 (custom-put 'custom-buffer 'custom-loads '("cus-edit"))
 (custom-put 'custom-faces 'custom-loads '("cus-edit"))
-(custom-put 'widgets 'custom-loads '("wid-edit" "wid-browse"))
+(custom-put 'widgets 'custom-loads '("wid-browse" "wid-edit"))
 (custom-put 'environment 'custom-loads '("cus-edit"))
 (custom-put 'custom-menu 'custom-loads '("cus-edit"))
 (custom-put 'internal 'custom-loads '("cus-edit"))
 (custom-put 'widget-faces 'custom-loads '("wid-edit"))
 (custom-put 'languages 'custom-loads '("cus-edit"))
 (custom-put 'custom-magic-faces 'custom-loads '("cus-edit"))
-(custom-put 'faces 'custom-loads '("auto-autoloads" "wid-edit" "cus-edit"))
+(custom-put 'faces 'custom-loads '("cus-edit" "wid-edit"))
 (custom-put 'emacs 'custom-loads '("cus-edit"))
 (custom-put 'processes 'custom-loads '("cus-edit"))
 (custom-put 'wp 'custom-loads '("cus-edit"))

lisp/ediff/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:08:43 1997
+;; Created by SL Baur on Thu Oct  2 17:05:32 1997
 
 ;;; Code:
 

lisp/efs/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sat Sep 27 08:13:47 1997
+;; Created by SL Baur on Thu Oct  2 17:05:35 1997
 
 ;;; Code:
 
 ;;;    efs|Andy Norman and Sandy Rutherford
 ;;;    |ange@hplb.hpl.hp.com and sandy@ibm550.sissa.it
 ;;;    |transparent FTP Support for GNU Emacs
-;;;    |$Date: 1997/04/27 19:30:06 $|$efs release: 1.15 beta $|
+;;;    |$Date: 1997/10/03 00:11:00 $|$efs release: 1.15 beta $|
 
 ;;; Host and listing type notation:
 ;;;
 	      (if result
 		  (let ((exit-code
 			 (efs-shell-call-process
-			  (concat "chmod " mode " " (file-name-nondirectory file))
+			  (concat "chmod " omode " " (file-name-nondirectory file))
 			  (file-name-directory file))))
 		    (if (not (equal 0 exit-code))
 			(progn

lisp/emulators/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sun Sep 28 14:03:13 1997
+;; Created by SL Baur on Thu Oct  2 17:05:36 1997
 
 ;;; Code:
 

lisp/eterm/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:08:44 1997
+;; Created by SL Baur on Thu Oct  2 17:05:36 1997
 
 ;;; Code:
 
+(custom-put 'shell 'custom-loads '("term"))
 (custom-put 'term 'custom-loads '("term"))
 (custom-put 'processes 'custom-loads '("term"))
 (custom-put 'unix 'custom-loads '("term"))

lisp/games/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sun Sep 28 14:03:16 1997
+;; Created by SL Baur on Thu Oct  2 17:05:37 1997
 
 ;;; Code:
 

lisp/modes/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sun Sep 28 14:03:21 1997
+;; Created by SL Baur on Thu Oct  2 17:05:44 1997
 
 ;;; Code:
 

lisp/mule/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:08:46 1997
+;; Created by SL Baur on Thu Oct  2 17:05:45 1997
 
 ;;; Code:
 

lisp/packages/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:08:53 1997
+;; Created by SL Baur on Thu Oct  2 17:05:51 1997
 
 ;;; Code:
 
     (bw       "Bob Weiner"        "weiner@altrasoft.com")
     (cthomp   "Chuck Thompson"    "cthomp@xemacs.org")
     (dmoore   "David Moore"       "dmoore@ucsd.edu")
+    (dkindred "Darrell Kindred"	  "dkindred@cmu.edu")
+    (dv       "Didier Verna"      "verna@inf.enst.fr")
     (hniksic  "Hrvoje Niksic"     "hniksic@srce.hr")
     (jareth   "Jareth Hein"       "jhod@camelot-soft.com")
     (jens     "Jens Lautenbacher" "jens@lemcbed.lem.uni-karlsruhe.de")
     (altrasoft . "http://www.altrasoft.com/")
     (baw       . "http://www.python.org/~bwarsaw/")
     (cc-mode   . "http://www.python.org/ftp/emacs/")
+    (dkindred  . "http://www.cs.cmu.edu/People/dkindred/me.html")
     (dmoore    . "http://oj.egbt.org/dmoore/")
     (jwz       . "http://www.netscape.com/people/jwz/")
     (kazz      . "http://www.imasy.or.jp/~kazz/")
 See also:")
      (about-url-link 'kazz "Visit Kazz's home page")
      (widget-insert ".\n"))
+    (dkindred
+     (widget-insert "\
+Darrell tends to come out of the woodwork a couple of weeks 
+before a new release with a flurry of fixes for bugs that 
+annoy him.  He hopes he's spared you from a core dump or two.
+
+Darrell is currently a doctoral student in computer science at
+Carnegie Mellon University, but he's trying hard to kick that
+habit.
+
+See ")
+     (about-url-link 'dkindred "Visit Darrell's WWW page")
+     (widget-insert ".\n"))
+    (dv
+     (widget-insert "\
+I'm currently working (Ph.D.) on the cognitive aspects of
+Human-Machine Interaction in Virtual Environments, and especialy on
+the possibility of adding (artificial) intelligence between the system 
+and the operator, in order to detect the intentions of the latter.
+
+Otherwise, I'm, say, 35.82% professional Jazz guitar player,
+which means that's not the way I earn my crust, but things may very
+well reverse in the future ...\n"))
+
 ))
 
 ;; Setup the buffer for a maintainer.
     (about-show-linked-info 'kazz "\
 IENAGA Kazuyuki is the XEmacs technical lead on BSD, particularly
 FreeBSD.\n")
+    (about-show-linked-info 'dkindred "\
+Darrell tends to come out of the woodwork a couple of weeks 
+before a new release with a flurry of fixes for bugs that 
+annoy him.  He hopes he's spared you from a core dump or two.
+
+Darrell is currently a doctoral student in computer science at
+Carnegie Mellon University, but he's trying hard to kick that
+habit.\n")
+    (about-show-linked-info 'dv "\
+I'm currently working (Ph.D.) on the cognitive aspects of
+Human-Machine Interaction in Virtual Environments, and especialy on
+the possibility of adding (artificial) intelligence between the system 
+and the operator, in order to detect the intentions of the latter.
+
+Otherwise, I'm, say, 35.82% professional Jazz guitar player,
+which means that's not the way I earn my crust, but things may very
+well reverse in the future ...\n")
     (flet ((print-short (name addr &optional shortinfo)
 	     (concat (about-with-face name 'italic)
 		     (about-tabs name)
 		     "<" addr ">\n"
 		     (if shortinfo (concat shortinfo "\n") ""))))
       (widget-insert
-       (print-short "Darell Kindred" "Darrell.Kindred@cmu.edu" "\
-Unofficial maintainer of the xemacs-beta list of extant bugs and
-contributor of an extraordinary number of important bug fixes, many of
-them in areas that neither Chuck nor Ben were particularly
-enthusiastic about investigating.\n")
        (print-short "Eduardo Pelegri-Llopart" "pelegri@eng.sun.com" "\
 Author of EOS, a package included in the standard XEmacs distribution
 that integrates XEmacs with the SPARCworks development environment
        (print-short "Hans Muller" "hmuller@eng.sun.com" "\
 Author of the code used to connect XEmacs with ToolTalk, and of an
 early client of the external Emacs widget.\n")
-       (print-short "Didier Verna" "verna@inf.enst.fr" "\
-I'm currently working (Ph.D.) on the cognitive aspects of
-Human-Machine Interaction in Virtual Environments, and especialy on
-the possibility of adding (artificial) intelligence between the system 
-and the operator, in order to detect the intentions of the latter.
-
-Otherwise, I'm, say, 35.82% professional Jazz guitar player,
-which means that's not the way I earn my crust, but things may very
-well reverse in the future ...\n")
        (print-short "David hobley" "david.hobley@usa.net" "\
 I used to do real work, but now I am a Project Manager for one of the
 Telco's in Australia. In my spare time I like to get back to basics and

lisp/prim/auto-autoloads.el

 (autoload 'pretty-print-profiling-info "profile" "\
 Print profiling info INFO to STREAM in a pretty format.
 If INFO is omitted, the current profiling info is retrieved using
-`get-profiling-info'.
-If STREAM is omitted, either current buffer or standard output are used,
- depending on whether the function was called interactively or not." t nil)
+ `get-profiling-info'.
+If STREAM is omitted, either a *Profiling Results* buffer or standard
+ output are used, depending on whether the function was called
+ interactively or not." t nil)
 
 (autoload 'profile "profile" "\
 Turn on profiling, execute FORMS and restore profiling state.

lisp/prim/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:08:56 1997
+;; Created by SL Baur on Thu Oct  2 17:05:53 1997
 
 ;;; Code:
 
 is inserted at point."
   ;; changed this back -- hope it works for CDE ;-) Oliver Graf <ograf@fga.de>
   ;; the OffiX drop stuff has moved to mouse.el (mouse-offix-drop)
-  (if (data)
+  (if data
       (insert data)
     (let ((x pop-up-windows))
       (setq pop-up-windows nil)
 ;;; profile.el --- basic profiling commands for XEmacs
 
-;; Copyright (C) 1996 Ben Wing.
+;; Copyright (C) 1996 Ben Wing, (C) 1997 Free Software Foundation.
 
 ;; Maintainer: XEmacs Development Team
 ;; Keywords: internal
 
 ;;; Commentary:
 
-;; `profile' macro and `profile-key-sequence' added in June 1997 by
-;; hniksic.
+;; In addition to Lisp-based `elp', XEmacs contains a set of
+;; primitives able to profile evaluation of Lisp functions, created by
+;; the illustrious Ben Wing.  The functions in this file can be used
+;; to gain easy access to the internal profiling functions.
+
+;; The profiler works by catching "ticks" (actually SIGPROF signals),
+;; and looking at the current Lisp function, at the time of each tick.
+;; The output of this process is an alist with keys being the
+;; functions, and values being the number of ticks per function.  From
+;; this, `pretty-print-profiling-info' easily extracts the total
+;; number of ticks, and the percentage CPU time of each function.
+
+;; Unless stated otherwise, profiling info is being accumulated (the
+;; current info is returned by `get-profiling-info').  Use
+;; `clear-profiling-info' to break the accumulation chain.
+
+;; Caveats (ELP users should read this):
+;; 1) The time reported is function time, rather than
+;;    function+descendants time;
+;; 2) The Time/ms is CPU time (user+kernel), not the real time;
+;; 3) Only the actuall funcalls are profiled.  If a subr Ffoo calls
+;;    Fbar using Fbar (), only Ffoo will appear in the profile.
+
+;; A typical profiling session consists of using `clear-profiling-info'
+;; followed by `profile' or `profile-key-sequence', followed by
+;; `pretty-print-profiling-info'.
+
+;; For instance, to see where Gnus spends time when generating Summary
+;; buffer, go to the group buffer, and press `M-x clear-profiling-info'
+;; followed by `M-x profile-key-sequence RET SPC'.
 
 
 ;;; Code:
 (defun pretty-print-profiling-info (&optional info stream)
   "Print profiling info INFO to STREAM in a pretty format.
 If INFO is omitted, the current profiling info is retrieved using
-`get-profiling-info'.
-If STREAM is omitted, either current buffer or standard output are used,
- depending on whether the function was called interactively or not."
+ `get-profiling-info'.
+If STREAM is omitted, either a *Profiling Results* buffer or standard
+ output are used, depending on whether the function was called
+ interactively or not."
   (interactive)
-  (if info
-      (setq info (copy-alist info))
-    (setq info (get-profiling-info)))
-  (let ((standard-output (or stream (if (interactive-p)
-					(current-buffer)
-				      standard-output))))
+  (setq info (if info
+		 (copy-alist info)
+	       (get-profiling-info)))
+  (when (and (not stream)
+	     (interactive-p))
+    (pop-to-buffer (get-buffer-create "*Profiling Results*"))
+    (erase-buffer))
+  (let* ((standard-output (or stream (if (interactive-p)
+					 (current-buffer)
+				       standard-output)))
+	 (maxfunlen (max (length "Function Name")
+			 (apply 'max (mapcar (lambda (sym)
+					       (length (symbol-name
+							(car sym))))
+					     info))))
+	 (formatstr (format "%%-%ds" maxfunlen)))
     (setq info (nreverse (sort info #'cdr-less-than-cdr)))
-    (princ "Function                                               Count        %\n")
-    (princ "---------------------------------------------------------------------\n")
+    (princ (format (concat formatstr "    Ticks    %%/Total\n")
+		   "Function Name"))
+    (princ (make-string maxfunlen ?=))
+    (princ "    =====    =======\n")
     (let ((sum 0.0))
       (dolist (info2 info)
 	(incf sum (cdr info2)))
       (while info
 	(let ((f (caar info)))
-	  (princ (format "%-50s%10d   %6.3f\n" f (cdar info)
-			 (* 100 (/ (cdar info) sum)))))
-	(pop info)))))
+	  (princ (format (concat formatstr "    %-5d    %-6.3f\n")
+			 f (cdar info) (* 100 (/ (cdar info) sum)))))
+	(pop info))
+      (princ (make-string maxfunlen ?-))
+      (princ "--------------------\n")
+      (princ (format (concat formatstr "    %-5d    %-6.2f\n")
+		     "Total" sum 100.0))
+      (princ (format "\n\nOne tick = %g ms\n"
+		     (/ default-profiling-interval 1000.0)))))
+  (when (and (not stream)
+	     (interactive-p))
+    (goto-char (point-min))))
 
+;; Is it really necessary for this to be a macro?
 ;;;###autoload
 (defmacro profile (&rest forms)
   "Turn on profiling, execute FORMS and restore profiling state.
 	;; Disallow missing argument; it's probably a typo for C-x C-f.
 	(t
 	 (error "set-fill-column requires an explicit argument")))
-  (display-message 'command "fill-column set to %d" fill-column))
+  (display-message 'command (format "fill-column set to %d" fill-column)))
 
 (defcustom comment-multi-line t ; XEmacs - this works well with adaptive fill
   "*Non-nil means \\[indent-new-comment-line] should continue same comment

lisp/psgml/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sun Sep 28 14:03:33 1997
+;; Created by SL Baur on Thu Oct  2 17:05:55 1997
 
 ;;; Code:
 

lisp/utils/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:08:59 1997
+;; Created by SL Baur on Thu Oct  2 17:05:58 1997
 
 ;;; Code:
 
 ;;; Code:
 
 (require 'lisp-mnt)
-(require 'finder-inf)
+(condition-case nil
+    (require 'finder-inf)
+  (t nil))
 ;; XEmacs addition
 (require 'picture)
 (require 'mode-motion)
     (mail	. "modes for electronic-mail handling")
     (matching	. "various sorts of searching and matching")
     (mouse	. "mouse support")
-    ,@(when (featurep 'mule)
+    ,(when (featurep 'mule)
        (cons 'mule "multi-language extensions"))
     (news	. "support for netnews reading and posting")
     (oop	. "support for object-oriented programming")

lisp/viper/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:09:00 1997
+;; Created by SL Baur on Thu Oct  2 17:05:59 1997
 
 ;;; Code:
 

lisp/w3/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Sun Sep 28 14:03:39 1997
+;; Created by SL Baur on Thu Oct  2 17:06:01 1997
 
 ;;; Code:
 

lisp/x11/custom-load.el

 ;;; custom-load.el --- automatically extracted custom dependencies
 
-;; Created by SL Baur on Tue Sep 30 18:09:01 1997
+;; Created by SL Baur on Thu Oct  2 17:06:02 1997
 
 ;;; Code:
 
 
 #ifdef NEED_MOTIF
 #include <Xm/Xm.h>
+#if XmVersion < 1002 /* 1.1 or ancient */
+#undef XmFONTLIST_DEFAULT_TAG
+#define XmFONTLIST_DEFAULT_TAG XmSTRING_DEFAULT_CHARSET
+#endif /* XmVersion < 1.2 */
 #endif
 #include "xlwmenuP.h"
 
 	    highlighted_pos->x = ws->width;
 	}
 
-      if (hit && !*hit_return && (val->type != SEPARATOR_TYPE))
+      if (hit && !*hit_return)
 	{
-	  if (horizontal_p && hit->x > start.x && hit->x < where.x)
+	  if (horizontal_p && hit->x > start.x && hit->x <= where.x)
 	    *hit_return = val;
-	  else if (!horizontal_p && hit->y > start.y && hit->y < where.y)
+	  else if (!horizontal_p && hit->y > start.y && hit->y <= where.y)
 	    *hit_return = val;
 	}
 
+1997-10-01  Karl M. Hegbloom  <karlheg@inetarena.com>
+
+	* lispref/commands.texi (Keyboard Macros): fixed typo.  Changed
+	reference to (emacs) into a reference to (xemacs).
+
+1997-10-01  Karl M. Hegbloom  <karlheg@inetarena.com>
+
+	* lispref/keymaps.texi (Keymaps): untabified and reformatted menu
+	to prevent line wrap.
+
 1997-09-27  SL Baur  <steve@altair.xemacs.org>
 
 	* gnats/flowchart.eps: New file.

man/lispref/commands.texi

 
 @c Broke paragraph to prevent overfull hbox. --rjc 15mar92
   The commands are described in the user's manual (@pxref{Keyboard
-Macros,,, emacs, The XEmacs Reference Manual}).
+Macros,,, xemacs, The XEmacs Reference Manual}).

man/lispref/keymaps.texi

 is found.  The whole process is called @dfn{key lookup}.
 
 @menu
-* Keymap Terminology::        	Definitions of terms pertaining to keymaps.
-* Format of Keymaps::		What a keymap looks like as a Lisp object.
-* Creating Keymaps:: 		Functions to create and copy keymaps.
-* Inheritance and Keymaps::	How one keymap can inherit the bindings
-				   of another keymap.
-* Key Sequences::               How to specify key sequences.
-* Prefix Keys::                 Defining a key with a keymap as its definition.
-* Active Keymaps::	        Each buffer has a local keymap
-                                   to override the standard (global) bindings.
-				   A minor mode can also override them.
-* Key Lookup::                  How extracting elements from keymaps works.
-* Functions for Key Lookup::    How to request key lookup.
-* Changing Key Bindings::       Redefining a key in a keymap.
-* Key Binding Commands::        Interactive interfaces for redefining keys.
-* Scanning Keymaps::            Looking through all keymaps, for printing help.
-* Other Keymap Functions::      Miscellaneous keymap functions.
+* Keymap Terminology::       Definitions of terms pertaining to keymaps.
+* Format of Keymaps::        What a keymap looks like as a Lisp object.
+* Creating Keymaps::         Functions to create and copy keymaps.
+* Inheritance and Keymaps::  How one keymap can inherit the bindings
+                                of another keymap.
+* Key Sequences::            How to specify key sequences.
+* Prefix Keys::              Defining a key with a keymap as its definition.
+* Active Keymaps::           Each buffer has a local keymap
+                                to override the standard (global) bindings.
+                                A minor mode can also override them.
+* Key Lookup::               How extracting elements from keymaps works.
+* Functions for Key Lookup:: How to request key lookup.
+* Changing Key Bindings::    Redefining a key in a keymap.
+* Key Binding Commands::     Interactive interfaces for redefining keys.
+* Scanning Keymaps::         Looking through all keymaps, for printing help.
+* Other Keymap Functions::   Miscellaneous keymap functions.
 @end menu
 
 @node Keymap Terminology
+1997-08-13  Yves BLUSSEAU  <hk444@cleveland.freenet.edu>
+
+	* efs/efs.el (efs-set-file-modes): Fix a bug that cause an error
+	when using the efs-set-file-modes function on a remote station with
+	a FTP daemon that don't support the QUOTE function.
+
+1997-10-02  Colin Rafferty  <craffert@ml.com>
+
+	* prim/frame.el (default-drag-and-drop-functions): Fixed a typo
+		  that was calling `data' rather than looking at it.
+
+1997-10-02  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* profile.c (Fclear_profiling_info): Made interactive.
+
+1997-10-02  SL Baur  <steve@altair.xemacs.org>
+
+	* glyphs-x.c (USE_TEMP_FILES_FOR_PNG_IMAGES): Move outside of
+	HAVE_JPEG ifdef.
+
+1997-10-01  SL Baur  <steve@altair.xemacs.org>
+
+	* lisp.h (min): Fully parenthize.
+	(max): Ditto.
+
+	* Makefile.in.in (widget.o): Insert dependencies.
+	- Insert HAVE_OFFIX_DND dependencies.
+
+	* casefiddle.c (casify_object): Back out bogus undocumented patch
+	from 20.3-beta18.
+
+1997-09-30  SL Baur  <steve@altair.xemacs.org>
+
+	* events.c (Fevent_type): Add OffiX guard.
+	(command_event_p): Ditto.
+	(mark_event): Ditto.
+	(print_event): Ditto.
+
 1997-09-30  SL Baur  <steve@altair.xemacs.org>
 
 	* mule-canna.c (Fcanna_set_bunsetsu): Return a value.
 xselect.o: mule-charset.h
 #endif /* MULE */
 
+#ifdef HAVE_OFFIX_DND
+device-x.o: offix.h
+event-Xt.o: offix.h
+frame-x.o: offix.h
+offix.o: offix-cursors.h
+offix.o: offix.h
+#endif
+
 EmacsFrame.o: $(LWLIB_SRCDIR)/lwlib.h
 EmacsFrame.o: EmacsFrame.h
 EmacsFrame.o: EmacsFrameP.h
 vm-limit.o: config.h
 vm-limit.o: dynarr.h
 vm-limit.o: mem-limits.h
+widget.o: config.h
+widget.o: lisp.h
+widget.o: buffer.h
+widget.o: insdel.h
 window.o: blocktype.h
 window.o: buffer.h
 window.o: bufslots.h
 	  CHECK_CHAR_COERCE_INT (obj);
 	  c = XCHAR (obj);
 	  if (IN_TRT_TABLE_DOMAIN (c))
-	    obj = make_char (inword ? DOWNCASE (buf, c) : UPCASE1 (buf, c));
+	    {
+	      if (inword)
+		obj = make_char (DOWNCASE (buf, c));
+	      else if (!UPPERCASEP (buf, c))
+		obj = make_char (UPCASE1 (buf, c));
+	    }
 	  return obj;
 	}
       if (STRINGP (obj))
     case magic_event:
     case empty_event:
     case dead_event:
+#ifdef HAVE_OFFIX_DND
     case dnd_drop_event:
+#endif
       break;
     default:
       abort ();
     case dead_event:
 	write_c_string ("#<DEALLOCATED-EVENT", printcharfun);
 	break;
+#ifdef HAVE_OFFIX_DND
     case dnd_drop_event:
       print_event_1 ("#<dnd-drop-event ", obj, printcharfun);
       break;
+#endif
     default:
 	write_c_string ("#<UNKNOWN-EVENT-TYPE", printcharfun);
 	break;
     case button_press_event:
     case button_release_event:
     case misc_user_event:
+#ifdef HAVE_OFFIX_DND
     case dnd_drop_event:
+#endif
       return 1;
     default:
       return 0;
     case process_event:		return Qprocess;
     case timeout_event:		return Qtimeout;
     case eval_event:		return Qeval;
+#ifdef HAVE_OFFIX_DND
     case dnd_drop_event:	return Qdnd_drop;
+#endif
     case magic_event:
     case magic_eval_event:
       return Qmagic;
 }
 
 
+#define USE_TEMP_FILES_FOR_PNG_IMAGES 1
+
 #ifdef HAVE_JPEG
 
 /**********************************************************************
 /* Late-breaking update, we're going to give it a try, I think it's */
 /* fixed now -sb */
 /*#define USE_TEMP_FILES_FOR_JPEG_IMAGES 1*/
-#define USE_TEMP_FILES_FOR_PNG_IMAGES 1
-
 static void
 jpeg_validate (Lisp_Object instantiator)
 {
    as 'macros.h' under Solaris.) */
 
 #ifndef min
-#define min(a,b) ((a) <= (b) ? (a) : (b))
+#define min(a,b) (((a) <= (b)) ? (a) : (b))
 #endif
 #ifndef max
-#define max(a,b) ((a) > (b) ? (a) : (b))
+#define max(a,b) (((a) > (b)) ? (a) : (b))
 #endif
 
 /* Emacs needs to use its own definitions of certain system calls on
     }
 }
 
-DEFUN ("clear-profiling-info", Fclear_profiling_info, 0, 0, 0, /*
+DEFUN ("clear-profiling-info", Fclear_profiling_info, 0, 0, "", /*
 Clear out the recorded profiling info.
 */
        ())
 #!/bin/sh
 emacs_major_version=20
 emacs_minor_version=3
-emacs_beta_version=25
-xemacs_codename="Prague"
+emacs_beta_version=26
+xemacs_codename="Riga"