xemacs-beta: lisp/prim/help.el comparison

comparison lisp/prim/help.el @ 203:850242ba4a81 r20-3b28

Import from CVS: tag r20-3b28

author	cvs
date	Mon, 13 Aug 2007 10:02:21 +0200
parents	acd284d43ca1
children	e45d5e7c476e

comparison

equal deleted inserted replaced

-:61eefc8fc970
+:850242ba4a81
 (setq default-directory (expand-file-name "~/"))
 (setq buffer-auto-save-file-name nil)
 (insert-file-contents (expand-file-name tutorial data-directory))
 (goto-char (point-min))
 (search-forward "\n<<")
-(beginning-of-line)
+(delete-region (point-at-bol) (point-at-eol))
-(delete-region (point) (progn (end-of-line) (point)))
 (let ((n (- (window-height (selected-window))
 		  (count-lines (point-min) (point))
 		  6)))
 	(if (< n 12)
 	    (newline n)
 		  "Text continues below]")
 	  (newline (- n (/ n 2)))))
 (goto-char (point-min))
 (set-buffer-modified-p nil))))
-;; used by describe-key and describe-key-briefly
+;; used by describe-key, describe-key-briefly, insert-key-binding, etc.
 (defun key-or-menu-binding (key &optional menu-flag)
-;; KEY          is any value returned by next-command-event
+"Return the command invoked by KEY.
-;; MENU-FLAG    is a symbol that should be set to T if KEY is a menu event,
+Like `key-binding', but handles menu events and toolbar presses correctly.
-;;		  or NIL otherwise
+KEY is any value returned by `next-command-event'.
+MENU-FLAG is a symbol that should be set to T if KEY is a menu event,
+or NIL otherwise"
 (let (defn)
 (and menu-flag (set menu-flag nil))
 ;; If the key typed was really a menu selection, grab the form out
 ;; of the event object and intuit the function that would be called,
 ;; and describe that instead.
 	(let ((event (aref key 0)))
 	  (setq defn (if (eventp event)
 			 (list (event-function event) (event-object event))
 		       (cdr event)))
 	  (and menu-flag (set menu-flag t))
-	  (if (eq (car defn) 'eval)
+	  (when (eq (car defn) 'eval)
-	      (setq defn (car (cdr defn))))
+	    (setq defn (car (cdr defn))))
-	  (if (eq (car-safe defn) 'call-interactively)
+	  (when (eq (car-safe defn) 'call-interactively)
-	      (setq defn (car (cdr defn))))
+	    (setq defn (car (cdr defn))))
-	  (if (and (consp defn) (null (cdr defn)))
+	  (when (and (consp defn) (null (cdr defn)))
-	      (setq defn (car defn))))
+	    (setq defn (car defn))))
 ;; else
 (setq defn (key-binding key)))
 ;; kludge: if a toolbar button was pressed on, try to find the
 ;; binding of the toolbar button.
 (if (and (eq defn 'press-toolbar-button)
 (prog1 (funcall thunk)
 (save-excursion
 (set-buffer standard-output)
 (help-mode))))
 (let ((helpwin (get-buffer-window "*Help*")))
-(if helpwin
+(when helpwin
-(progn
+	  (with-current-buffer (window-buffer helpwin)
-(save-excursion
+	    ;; If the *Help* buffer is already displayed on this
-(set-buffer (window-buffer helpwin))
+	    ;; frame, don't override the previous configuration
-		;;If the *Help* buffer is already displayed on this
+	    (when help-not-visible
-		;; frame, don't override the previous configuration
+	      (set-frame-property (selected-frame)
-		(if help-not-visible
+				  'help-window-config winconfig)))
-		    (set-frame-property (selected-frame)
+	  (when help-selects-help-window
-					'help-window-config winconfig)))
+	    (select-window helpwin))
-(if help-selects-help-window
+	  (cond ((eq helpwin (selected-window))
-(select-window helpwin))
+		 (display-message 'command
-(cond ((eq helpwin (selected-window))
+		   (substitute-command-keys "Type \\[help-mode-quit] to remove help window, \\[scroll-up] to scroll the help.")))
-(display-message 'command
+		(was-one-window
-(substitute-command-keys "Type \\[help-mode-quit] to remove help window, \\[scroll-up] to scroll the help.")))
+		 (display-message 'command
-(was-one-window
+		   (substitute-command-keys "Type \\[delete-other-windows] to remove help window, \\[scroll-other-window] to scroll the help.")))
-(display-message 'command
+		(t
-(substitute-command-keys "Type \\[delete-other-windows] to remove help window, \\[scroll-other-window] to scroll the help.")))
+		 (display-message 'command
-(t
+		   (substitute-command-keys "Type \\[switch-to-buffer-other-window] to restore the other window, \\[scroll-other-window] to scroll the help.")))))))))
-(display-message 'command
-(substitute-command-keys "Type \\[switch-to-buffer-other-window] to restore the other window, \\[scroll-other-window] to scroll the help."))))))))))
 (defun describe-key (key)
 "Display documentation of the function invoked by KEY.
 KEY is a string, or vector of events.
 When called interactively, KEY may also be a menu selection."
 	    (insert (documentation 'help-for-help)))
 	  (goto-char (point-min))
 	  (while (or (equal event help-key)
 		     (eq char ??)
 		     (eq 'help-command (key-binding event))
-		     (eq char ? )
+		     (eq char ?\ )
 		     (eq 'scroll-up (key-binding event))
 		     (eq char ?\177)
 		     (and (not (eq char ?b))
 			  (eq 'scroll-down (key-binding event))))
-	    (if (or (eq char ? )
+	    (if (or (eq char ?\ )
 		    (eq 'scroll-up (key-binding event)))
 		(scroll-up))
 	    (if (or (eq char ?\177)
 		    (and (not (eq char ?b))
 			 (eq 'scroll-down (key-binding event))))
 (message nil)
 (if defn
 	  (call-interactively defn)
 	(ding)))))
-;; Return a function which is called by the list containing point.
-;; If that gives no function, return a function whose name is around point.
-;; If that doesn't give a function, return nil.
 (defun function-called-at-point ()
+"Return the function which is called by the list containing point.
+If that gives no function, return the function whose name is around point.
+If that doesn't give a function, return nil."
 (or (condition-case ()
 	  (save-excursion
 	    (save-restriction
 	      (narrow-to-region (max (point-min) (- (point) 1000)) (point-max))
 	      (backward-up-list 1)
 		  (let ((obj (read (current-buffer))))
 		    (and (symbolp obj) (fboundp obj) obj)))
 	      (set-syntax-table stab)))
 	(error nil))))
-;; default to nil for the non-hackers?
+(defun function-at-point ()
+"Return the function whose name is around point.
+If that gives no function, return the function which is called by the
+list containing point.  If that doesn't give a function, return nil."
+(or (condition-case ()
+	  (let ((stab (syntax-table)))
+	    (unwind-protect
+		(save-excursion
+		  (set-syntax-table emacs-lisp-mode-syntax-table)
+		  (or (not (zerop (skip-syntax-backward "_w")))
+		      (eq (char-syntax (char-after (point))) ?w)
+		      (eq (char-syntax (char-after (point))) ?_)
+		      (forward-sexp -1))
+		  (skip-chars-forward "`'")
+		  (let ((obj (read (current-buffer))))
+		    (and (symbolp obj) (fboundp obj) obj)))
+	      (set-syntax-table stab)))
+	(error nil))
+(condition-case ()
+	  (save-excursion
+	    (save-restriction
+	      (narrow-to-region (max (point-min) (- (point) 1000)) (point-max))
+	      (backward-up-list 1)
+	      (forward-char 1)
+	      (let (obj)
+		(setq obj (read (current-buffer)))
+		(and (symbolp obj) (fboundp obj) obj))))
+	(error nil))))
+;; Default to nil for the non-hackers?  Not until we find a way to
+;; distinguish hackers from non-hackers automatically!
 (defcustom describe-function-show-arglist t
 "*If non-nil, describe-function will show its arglist,
 unless the function is autoloaded."
 :type 'boolean
 :group 'help-appearance)
+(defcustom find-function-function 'function-at-point
+"*The function used by `describe-function', `where-is' and
+`find-function' to select the function near point.
+For example `function-at-point' or `function-called-at-point'."
+:type 'function
+:group 'help)
 (defun describe-function-find-file (function)
 (let ((files load-history)
-	     file)
+	file)
-	 (while files
+(while files
-	   (if (memq function (cdr (car files)))
+(if (memq function (cdr (car files)))
-	       (setq file (car (car files))
+	  (setq file (car (car files))
-		     files nil))
+		files nil))
-	   (setq files (cdr files)))
+(setq files (cdr files)))
-	 file))
+file))
 (defun describe-function (function)
 "Display the full documentation of FUNCTION (a symbol).
 When run interactively, it defaults to any function found by the
 value of `find-function-function'."
 obarray 'fboundp t nil 'function-history))))
 (list (if (equal val "") fn (intern val)))))
 (with-displaying-help-buffer
 (lambda ()
 (describe-function-1 function standard-output)
-(save-excursion
+;; Return the text we displayed.
-(set-buffer standard-output)
+(buffer-string nil nil standard-output))))
-;; Return the text we displayed.
-(buffer-string)))))
 (defun function-obsolete-p (function)
 "Return non-nil if FUNCTION is obsolete."
 (not (null (get function 'byte-obsolete-info))))
 (setq def (symbol-function def)))
 (if (compiled-function-p def)
 	(setq file-name (compiled-function-annotation def)))
 (if (eq 'macro (car-safe def))
 	(setq fndef (cdr def)
-	      home (and (compiled-function-p (cdr def))
+	      file-name (and (compiled-function-p (cdr def))
-			(compiled-function-annotation (cdr def)))
+			     (compiled-function-annotation (cdr def)))
 	      macrop t)
 (setq fndef def))
 (if aliases (princ aliases stream))
 (let ((int #'(lambda (string an-p macro-p)
 		   (princ (format
 	       (unless (or (equal doc "")
 			   (eq ?\n (aref doc (1- (length doc)))))
 		 (terpri stream))))))))
-(defun describe-function-arglist (function)
+;;; ## this doesn't seem to be used for anything
-(interactive (list (or (function-called-at-point)
+;; (defun describe-function-arglist (function)
-			 (error "no function call at point"))))
+;;   (interactive (list (or (function-called-at-point)
-(let ((b nil))
+;; 			 (error "no function call at point"))))
-(unwind-protect
+;;   (let ((b nil))
-	(save-excursion
+;;     (unwind-protect
-	  (set-buffer (setq b (get-buffer-create " *arglist*")))
+;; 	(save-excursion
-	  (buffer-disable-undo b)
+;; 	  (set-buffer (setq b (get-buffer-create " *arglist*")))
-	  (erase-buffer)
+;; 	  (buffer-disable-undo b)
-	  (describe-function-1 function b t)
+;; 	  (erase-buffer)
-	  (goto-char (point-min))
+;; 	  (describe-function-1 function b t)
-	  (end-of-line)
+;; 	  (goto-char (point-min))
-	  (or (eobp) (delete-char 1))
+;; 	  (end-of-line)
-	  (just-one-space)
+;; 	  (or (eobp) (delete-char 1))
-	  (end-of-line)
+;; 	  (just-one-space)
-	  (message (buffer-substring (point-min) (point))))
+;; 	  (end-of-line)
-(and b (kill-buffer b)))))
+;; 	  (message (buffer-substring (point-min) (point))))
+;;       (and b (kill-buffer b)))))
 (defun variable-at-point ()
 (ignore-errors
 (let ((stab (syntax-table)))
 		  (format "use `%s' instead." compatible))))))
 (defun built-in-variable-doc (variable)
 "Return a string describing whether VARIABLE is built-in."
 (let ((type (built-in-variable-type variable)))
-(cond ((eq type 'integer) "a built-in integer variable")
+(case type
-	  ((eq type 'const-integer) "a built-in constant integer variable")
+(integer "a built-in integer variable")
-	  ((eq type 'boolean) "a built-in boolean variable")
+(const-integer "a built-in constant integer variable")
-	  ((eq type 'const-boolean) "a built-in constant boolean variable")
+(boolean "a built-in boolean variable")
-	  ((eq type 'object) "a simple built-in variable")
+(const-boolean "a built-in constant boolean variable")
-	  ((eq type 'const-object) "a simple built-in constant variable")
+(object "a simple built-in variable")
-	  ((eq type 'const-specifier) "a built-in constant specifier variable")
+(const-object "a simple built-in constant variable")
-	  ((eq type 'current-buffer) "a built-in buffer-local variable")
+(const-specifier "a built-in constant specifier variable")
-	  ((eq type 'const-current-buffer)
+(current-buffer "a built-in buffer-local variable")
-	   "a built-in constant buffer-local variable")
+(const-current-buffer "a built-in constant buffer-local variable")
-	  ((eq type 'default-buffer)
+(default-buffer "a built-in default buffer-local variable")
-	   "a built-in default buffer-local variable")
+(selected-console "a built-in console-local variable")
-	  ((eq type 'selected-console) "a built-in console-local variable")
+(const-selected-console "a built-in constant console-local variable")
-	  ((eq type 'const-selected-console)
+(default-console "a built-in default console-local variable")
-	   "a built-in constant console-local variable")
+(t
-	  ((eq type 'default-console)
+(if type "an unknown type of built-in variable?"
-	   "a built-in default console-local variable")
+	 "a variable declared in Lisp")))))
-	  (type "an unknown type of built-in variable?")
-	  (t "a variable declared in Lisp"))))
 (defun describe-variable (variable)
 "Display the full documentation of VARIABLE (a symbol)."
 (interactive
 (let* ((v (variable-at-point))
 (princ "Documentation:")
 (terpri)
 (let ((doc (documentation-property variable 'variable-documentation))
 	     (obsolete (variable-obsoleteness-doc origvar))
 	     (compatible (variable-compatibility-doc origvar)))
-	 (if obsolete
+	 (when obsolete
-	     (progn
+	   (princ obsolete)
-	       (princ obsolete)
+	   (terpri)
-	       (terpri)
+	   (terpri))
-	       (terpri)))
+	 (when compatible
-	 (if compatible
+	   (princ compatible)
-	     (progn
+	   (terpri)
-	       (princ compatible)
+	   (terpri))
-	       (terpri)
-	       (terpri)))
 	 ;; don't bother to print anything if variable is obsolete and aliased.
 	 (when (or (not obsolete) (not aliases))
 	   (if doc
 	       ;; note: documentation-property calls substitute-command-keys.
 	       (princ doc)
 	     (princ "not documented as a variable."))
 	   (terpri)))
-(save-excursion
+;; Return the text we displayed.
-	 (set-buffer standard-output)
+(buffer-string nil nil standard-output)))))
-	 ;; Return the text we displayed.
-	 (buffer-string))))))
 (defun sorted-key-descriptions (keys &optional separator)
 "Sort and separate the key descriptions for KEYS.
 The sorting is done by length (shortest bindings first), and the bindings
-are separated with SEPARATOR (`, ' by default)."
+are separated with SEPARATOR (\", \" by default)."
 (mapconcat 'key-description
 	     (sort keys #'(lambda (x y)
 			    (< (length x) (length y))))
 	     (or separator ", ")))
 (if keys
 	(message "%s is on %s" definition (sorted-key-descriptions keys))
 (message "%s is not on any keys" definition)))
 nil)
-;; Synched with Emacs 19.35
+;; `locate-library' moved to "packages.el"
-;; Moved to packages.el
-;(defun locate-library (library &optional nosuffix path interactive-call)
-;  "Show the precise file name of Emacs library LIBRARY.
-;This command searches the directories in `load-path' like `M-x load-library'
-;to find the file that `M-x load-library RET LIBRARY RET' would load.
-;Optional second arg NOSUFFIX non-nil means don't add suffixes `.elc' or `.el'
-;to the specified name LIBRARY.
-;If the optional third arg PATH is specified, that list of directories
-;is used instead of `load-path'."
-;  (interactive (list (read-string "Locate library: ")
-;                     nil nil
-;                     t))
-;  (let (result)
-;    (catch 'answer
-;      (mapcar
-;       (lambda (dir)
-;         (mapcar
-;          (lambda (suf)
-;            (let ((try (expand-file-name (concat library suf) dir)))
-;              (and (file-readable-p try)
-;                   (null (file-directory-p try))
-;                   (progn
-;                     (setq result try)
-;                     (throw 'answer try)))))
-;          (if nosuffix
-;              '("")
-;            (let ((basic '(".elc" ".el" ""))
-;                  (compressed '(".Z" ".gz" "")))
-;              ;; If autocompression mode is on,
-;              ;; consider all combinations of library suffixes
-;              ;; and compression suffixes.
-;              (if (rassq 'jka-compr-handler file-name-handler-alist)
-;                  (apply 'nconc
-;                         (mapcar (lambda (compelt)
-;                                   (mapcar (lambda (baselt)
-;                                             (concat baselt compelt))
-;                                           basic))
-;                                 compressed))
-;                basic)))))
-;       (or path load-path)))
-;    (and interactive-call
-;         (if result
-;             (message "Library is file %s" result)
-;           (message "No library %s in search path" library)))
-;    result))
 ;; Functions ported from C into Lisp in XEmacs
 (defun describe-syntax ()
 "Describe the syntax specifications in the syntax table.
 (progn
 (princ "network stream connection " stream)
 (princ (car pid) stream)
 (princ "@" stream)
 (princ (cdr pid) stream))
-(let ((cmd (process-command p)))
+	      (let ((cmd (process-command p)))
-(while cmd
+		(while cmd
-(princ (car cmd) stream)
+		  (princ (car cmd) stream)
-(setq cmd (cdr cmd))
+		  (setq cmd (cdr cmd))
-(if cmd (princ " " stream)))))
+		  (if cmd (princ " " stream)))))
 (terpri stream)))))))
+;; `find-function' et al moved to "find-func.el"
-;; find-function stuff
-(defvar find-function-function 'function-at-point
-"*The function used by `describe-function', `where-is' and
-`find-function' to select the function near point.
-For example `function-at-point' or `function-called-at-point'.")
-(defvar find-function-source-path nil
-"The default list of directories where find-function searches.
-If this variable is `nil' then find-function searches `load-path' by
-default.")
-(defun find-function-noselect (function)
-"Returns a pair `(buffer . point)' pointing to the definition of FUNCTION.
-Finds the Emacs Lisp library containing the definition of FUNCTION
-in a buffer and the point of the definition.  The buffer is
-not selected.
-The library where FUNCTION is defined is searched for in
-`find-function-source-path', if non `nil', otherwise in `load-path'."
-(and (subrp (symbol-function function))
-(error "%s is a primitive function" function))
-(if (not function)
-(error "You didn't specify a function"))
-(let ((def (symbol-function function))
-	library aliases)
-(while (symbolp def)
-(or (eq def function)
-	  (if aliases
-	      (setq aliases (concat aliases
-				    (format ", which is an alias for %s"
-					    (symbol-name def))))
-	    (setq aliases (format "an alias for %s" (symbol-name def)))))
-(setq function (symbol-function function)
-	    def (symbol-function function)))
-(if aliases
-	(message aliases))
-(setq library
-	  (cond ((eq (car-safe def) 'autoload)
-		 (nth 1 def))
-		((describe-function-find-file function))
-		((compiled-function-p def)
-		 (substring (compiled-function-annotation def) 0 -4))))
-(if (null library)
-	(error (format "Don't know where `%s' is defined" function)))
-(if (string-match "\\.el\\(c\\)\\'" library)
-	(setq library (substring library 0 (match-beginning 1))))
-(let* ((path find-function-source-path)
-	   (filename (if (file-exists-p library)
-			 library
-		       (if (string-match "\\(\\.el\\)\\'" library)
-			   (setq library (substring library 0
-						    (match-beginning
-						     1))))
-		       (or (locate-library (concat library ".el") t path)
-			   (locate-library library t path)))))
-(if (not filename)
-	  (error "The library \"%s\" is not in the path." library))
-(with-current-buffer (find-file-noselect filename)
-	(save-match-data
-	  (let (;; avoid defconst, defgroup, defvar (any others?)
-		(regexp
-		 (format "^\\s-*(def[^cgv\W]\\w+\\*?\\s-+%s\\s-" function))
-		(syntable (syntax-table)))
-	    (set-syntax-table emacs-lisp-mode-syntax-table)
-	    (goto-char (point-min))
-	    (if (prog1
-		    (re-search-forward regexp nil t)
-		  (set-syntax-table syntable))
-		(progn
-		  (beginning-of-line)
-		  (cons (current-buffer) (point)))
-	      (error "Cannot find definition of `%s'" function))))))))
-(defun function-at-point ()
-(or (condition-case ()
-	  (let ((stab (syntax-table)))
-	    (unwind-protect
-		(save-excursion
-		  (set-syntax-table emacs-lisp-mode-syntax-table)
-		  (or (not (zerop (skip-syntax-backward "_w")))
-		      (eq (char-syntax (char-after (point))) ?w)
-		      (eq (char-syntax (char-after (point))) ?_)
-		      (forward-sexp -1))
-		  (skip-chars-forward "`'")
-		  (let ((obj (read (current-buffer))))
-		    (and (symbolp obj) (fboundp obj) obj)))
-	      (set-syntax-table stab)))
-	(error nil))
-(condition-case ()
-	  (save-excursion
-	    (save-restriction
-	      (narrow-to-region (max (point-min) (- (point) 1000)) (point-max))
-	      (backward-up-list 1)
-	      (forward-char 1)
-	      (let (obj)
-		(setq obj (read (current-buffer)))
-		(and (symbolp obj) (fboundp obj) obj))))
-	(error nil))))
-(defun find-function-read-function ()
-"Read and return a function, defaulting to the one near point.
-The function named by `find-function-function' is used to select the
-default function."
-(let ((fn (funcall find-function-function))
-	(enable-recursive-minibuffers t)
-	val)
-(setq val (completing-read
-	       (if fn
-		   (format "Find function (default %s): " fn)
-		 "Find function: ")
-	       obarray 'fboundp t nil 'function-history))
-(list (if (equal val "")
-	      fn (intern val)))))
-(defun find-function-do-it (function switch-fn)
-"find elisp FUNCTION in a buffer and display it with SWITCH-FN.
-Point is saved in the buffer if it is one of the current buffers."
-(let ((orig-point (point))
-	(orig-buffers (buffer-list))
-	(buffer-point (find-function-noselect function)))
-(if buffer-point
-	(progn
-	  (funcall switch-fn (car buffer-point))
-	  (if (memq (car buffer-point) orig-buffers)
-	      (push-mark orig-point))
-	  (goto-char (cdr buffer-point))
-	  (recenter 0)))))
-(defun find-function (function)
-"Find the definition of the function near point in the current window.
-Finds the Emacs Lisp library containing the definition of the function
-near point (selected by `find-function-function') in a buffer and
-places point before the definition.  Point is saved in the buffer if
-it is one of the current buffers.
-The library where FUNCTION is defined is searched for in
-`find-function-source-path', if non `nil', otherwise in `load-path'."
-(interactive (find-function-read-function))
-(find-function-do-it function 'switch-to-buffer))
-(defun find-function-other-window (function)
-"Find the definition of the function near point in the other window.
-Finds the Emacs Lisp library containing the definition of the function
-near point (selected by `find-function-function') in a buffer and
-places point before the definition.  Point is saved in the buffer if
-it is one of the current buffers.
-The library where FUNCTION is defined is searched for in
-`find-function-source-path', if non `nil', otherwise in `load-path'."
-(interactive (find-function-read-function))
-(find-function-do-it function 'switch-to-buffer-other-window))
-(defun find-function-other-frame (function)
-"Find the definition of the function near point in the another frame.
-Finds the Emacs Lisp library containing the definition of the function
-near point (selected by `find-function-function') in a buffer and
-places point before the definition.  Point is saved in the buffer if
-it is one of the current buffers.
-The library where FUNCTION is defined is searched for in
-`find-function-source-path', if non `nil', otherwise in `load-path'."
-(interactive (find-function-read-function))
-(find-function-do-it function 'switch-to-buffer-other-frame))
-(defun find-function-on-key (key)
-"Find the function that KEY invokes.  KEY is a string.
-Point is saved if FUNCTION is in the current buffer."
-(interactive "kFind function on key: ")
-(let ((defn (key-or-menu-binding key)))
-(if (or (null defn) (integerp defn))
-(message "%s is undefined" (key-description key))
-(if (and (consp defn) (not (eq 'lambda (car-safe defn))))
-	  (message "runs %s" (prin1-to-string defn))
-	(find-function-other-window defn)))))
-(defun find-function-at-point ()
-"Find directly the function at point in the other window."
-(interactive)
-(let ((symb (function-at-point)))
-(when symb
-(find-function-other-window symb))))
-(define-key ctl-x-map "F" 'find-function)
-(define-key ctl-x-4-map "F" 'find-function-other-window)
-(define-key ctl-x-5-map "F" 'find-function-other-frame)
 ;;; help.el ends here

Mercurial > hg > xemacs-beta

comparison lisp/prim/help.el @ 203:850242ba4a81 r20-3b28