Commits

cvs  committed 461c7ba

Import from CVS: tag r19-16-pre1

  • Participants
  • Parent commits 69ce12f
  • Tags r19-16-pre1

Comments (0)

Files changed (19)

File CHANGES-beta

 							-*- indented-text -*-
+to 19.16 pre1 -- "Queens"
+-- Hardcode the version number since this is dead code and the previous
+   kludgy method doesn't work anymore.
+
 to 19.16 beta91
 -- Make all texinfo source work with makeinfo-1.68
 -- Update texinfo stuffs from texinfo-3.11
 
 
 #### Find out which version of XEmacs this is.
-version=`grep 'defconst[	 ]*emacs-version' ${srcdir}/lisp/version.el \
-	 | sed -ne 's/^(defconst emacs-version "\([0-9][0-9]\.[0-9]*\).*/\1/p'`
-beta=`grep '" XEmacs Lucid' ${srcdir}/lisp/version.el \
-      | sed -ne 's/^.*" XEmacs Lucid (beta\([^)]*\)).*/\1/p'`
-alpha=`grep '" XEmacs Lucid' ${srcdir}/lisp/version.el \
-       | sed -ne 's/^.*" XEmacs Lucid (alpha\([^)]*\)).*/\1/p'`
+version="19.16"
+beta=""
+alpha=""
 if [ "X$beta" != "X" ]; then
   version=${version}-b${beta}
 fi

File configure.in

 
 [
 #### Find out which version of XEmacs this is.
-version=`grep 'defconst[	 ]*emacs-version' ${srcdir}/lisp/version.el \
-	 | sed -ne 's/^(defconst emacs-version "\([0-9][0-9]\.[0-9]*\).*/\1/p'`
-beta=`grep '" XEmacs Lucid' ${srcdir}/lisp/version.el \
-      | sed -ne 's/^.*" XEmacs Lucid (beta\([^)]*\)).*/\1/p'`
-alpha=`grep '" XEmacs Lucid' ${srcdir}/lisp/version.el \
-       | sed -ne 's/^.*" XEmacs Lucid (alpha\([^)]*\)).*/\1/p'`
+version="19.16"
+beta=""
+alpha=""
 if [ "X$beta" != "X" ]; then
   version=${version}-b${beta}
 fi

File lisp/emulators/tpu-edt.el

 ;;    ; Repeat the preceding mappings for X-windows.
 ;;    (cond
 ;;     (window-system
-;;      (global-set-key [kp_7] 'tpu-paragraph)                   ; KP7
-;;      (define-key GOLD-map [kp_f1] 'universal-argument)))      ; GOLD-PF1
+;;      (global-set-key [kp-7] 'tpu-paragraph)                   ; KP7
+;;      (define-key GOLD-map [kp-f1] 'universal-argument)))      ; GOLD-PF1
 
 ;;    ; Display the TPU-edt version.
 ;;    (tpu-version)
 
 
 ;;;
-;;;  Minibuffer map additions to make KP_enter = RET
+;;;  Minibuffer map additions to make KP-enter = RET
 ;;;
 (define-key minibuffer-local-map "\eOM" 'exit-minibuffer)
 (define-key minibuffer-local-ns-map "\eOM" 'exit-minibuffer)

File lisp/emulators/tpu-mapper.el

 (cond
  ((not (equal tpu-enter tpu-return))
   (insert "
-;;  Minibuffer map additions to make KP_enter = RET
+;;  Minibuffer map additions to make KP-enter = RET
 ;;
 ")
 

File lisp/games/blackbox.el

   (define-key blackbox-mode-map " " 'bb-romp)
   (define-key blackbox-mode-map [insert] 'bb-romp)
   (define-key blackbox-mode-map "\C-m" 'bb-done)
-  (define-key blackbox-mode-map [kp_enter] 'bb-done))
+  (define-key blackbox-mode-map [kp-enter] 'bb-done))
 
 ;; Blackbox mode is suitable only for specially formatted data.
 (put 'blackbox-mode 'mode-class 'special)

File lisp/packages/icomplete.el

 
 ;;; Author: Ken Manheimer <klm@nist.gov>
 ;;; Maintainer: Ken Manheimer <klm@nist.gov>
-;;; Version: $Id: icomplete.el,v 1.2 1997/03/16 05:55:27 steve Exp $
+;;; Version: $Id: icomplete.el,v 1.3 1997/09/13 00:24:38 steve Exp $
 ;;; Created: Mar 1993 klm@nist.gov - first release to usenet
 ;;; Keywords: help, abbrev
 
 	(concat "<"
 		(if keys
 		    (mapconcat 'key-description
-			       (sort '([next] [kp_next] [(control v)])
+			       (sort '([next] [kp-next] [(control v)])
 				     #'(lambda (x y)
 					 (< (length x) (length y))))
 			       ", ")

File lisp/prim/events.el

 (put 'space	'ascii-character ? )
 
  ;; Do the same voodoo for the keypad keys.  I used to bind these to keyboard
- ;; macros (for instance, kp_0 was bound to "0") so that they would track the
+ ;; macros (for instance, kp-0 was bound to "0") so that they would track the
  ;; bindings of the corresponding keys by default, but that made the display
  ;; of M-x describe-bindings much harder to read, so now we'll just bind them
  ;; to self-insert by default.  Not a big difference...
  
-(put 'kp_0 'ascii-character ?0)
-(put 'kp_1 'ascii-character ?1)
-(put 'kp_2 'ascii-character ?2)
-(put 'kp_3 'ascii-character ?3)
-(put 'kp_4 'ascii-character ?4)
-(put 'kp_5 'ascii-character ?5)
-(put 'kp_6 'ascii-character ?6)
-(put 'kp_7 'ascii-character ?7)
-(put 'kp_8 'ascii-character ?8)
-(put 'kp_9 'ascii-character ?9)
+(put 'kp-0 'ascii-character ?0)
+(put 'kp-1 'ascii-character ?1)
+(put 'kp-2 'ascii-character ?2)
+(put 'kp-3 'ascii-character ?3)
+(put 'kp-4 'ascii-character ?4)
+(put 'kp-5 'ascii-character ?5)
+(put 'kp-6 'ascii-character ?6)
+(put 'kp-7 'ascii-character ?7)
+(put 'kp-8 'ascii-character ?8)
+(put 'kp-9 'ascii-character ?9)
 
-(put 'kp_space     'ascii-character ? )
-(put 'kp_tab       'ascii-character ?\t)
-(put 'kp_enter     'ascii-character ?\r)
-(put 'kp_equal     'ascii-character ?=)
-(put 'kp_multiply  'ascii-character ?*)
-(put 'kp_add       'ascii-character ?+)
-(put 'kp_separator 'ascii-character ?,)
-(put 'kp_subtract  'ascii-character ?-)
-(put 'kp_decimal   'ascii-character ?.)
-(put 'kp_divide    'ascii-character ?/)
+(put 'kp-space     'ascii-character ? )
+(put 'kp-tab       'ascii-character ?\t)
+(put 'kp-enter     'ascii-character ?\r)
+(put 'kp-equal     'ascii-character ?=)
+(put 'kp-multiply  'ascii-character ?*)
+(put 'kp-add       'ascii-character ?+)
+(put 'kp-separator 'ascii-character ?,)
+(put 'kp-subtract  'ascii-character ?-)
+(put 'kp-decimal   'ascii-character ?.)
+(put 'kp-divide    'ascii-character ?/)

File lisp/prim/keydefs.el

 ;; files, but these appear to be the standard Motif and PC bindings.
 
 ;; potential R6isms
-(define-key global-map 'kp_left		'backward-char)
-(define-key global-map 'kp_up		'previous-line)
-(define-key global-map 'kp_right	'forward-char)
-(define-key global-map 'kp_down		'next-line)
+(define-key global-map 'kp-left		'backward-char)
+(define-key global-map 'kp-up		'previous-line)
+(define-key global-map 'kp-right	'forward-char)
+(define-key global-map 'kp-down		'next-line)
 
 
 ;; movement by larger blocks
 (define-key global-map '(control prior)	'scroll-right)
 (define-key global-map '(control next)	'scroll-left)
 ;; potential R6isms
-(define-key global-map 'kp_prior	'scroll-down)
-(define-key global-map 'kp_next		'scroll-up)
-(define-key global-map '(control kp_prior) 'scroll-right)
-(define-key global-map '(control kp_next) 'scroll-left)
+(define-key global-map 'kp-prior	'scroll-down)
+(define-key global-map 'kp-next		'scroll-up)
+(define-key global-map '(control kp-prior) 'scroll-right)
+(define-key global-map '(control kp-next) 'scroll-left)
 
 
 ;; movement to the limits
 (define-key global-map 'begin		'beginning-of-line)
 (define-key global-map '(control begin)	'beginning-of-buffer)
 ;; potential R6isms
-(define-key global-map 'kp_home		'beginning-of-line)
-(define-key global-map '(control kp_home) 'beginning-of-buffer)
-(define-key global-map 'kp_end		'end-of-line)
-(define-key global-map '(control kp_end) 'end-of-buffer)
+(define-key global-map 'kp-home		'beginning-of-line)
+(define-key global-map '(control kp-home) 'beginning-of-buffer)
+(define-key global-map 'kp-end		'end-of-line)
+(define-key global-map '(control kp-end) 'end-of-buffer)
 
 ;; movement between windows
 (define-key global-map '(control tab)	'other-window)
 (define-key global-map '(meta home)	'beginning-of-buffer-other-window)
 (define-key global-map '(meta end)	'end-of-buffer-other-window)
 ;; potential R6isms
-(define-key global-map '(meta kp_next)	'scroll-other-window)
-(define-key global-map '(meta kp_prior)	'scroll-other-window-down)
-(define-key global-map '(meta kp_home)	'beginning-of-buffer-other-window)
-(define-key global-map '(meta kp_end)	'end-of-buffer-other-window)
+(define-key global-map '(meta kp-next)	'scroll-other-window)
+(define-key global-map '(meta kp-prior)	'scroll-other-window-down)
+(define-key global-map '(meta kp-home)	'beginning-of-buffer-other-window)
+(define-key global-map '(meta kp-end)	'end-of-buffer-other-window)
 
 ;; potential R6isms
 (define-key global-map 'redo		'repeat-complex-command)
-(define-key global-map 'kp_insert	'overwrite-mode)
-(define-key global-map 'kp_delete	'backward-delete-char-untabify)
+(define-key global-map 'kp-insert	'overwrite-mode)
+(define-key global-map 'kp-delete	'backward-delete-char-untabify)
 
-(define-key global-map 'kp_enter	[return]) ; do whatever RET does now
-(define-key global-map 'kp_tab		[tab])
+(define-key global-map 'kp-enter	[return]) ; do whatever RET does now
+(define-key global-map 'kp-tab		[tab])
 
 (define-key global-map 'undo		'undo)
 (define-key global-map 'help		'help-for-help)
 
-(define-key global-map 'kp_space	'self-insert-command)
-(define-key global-map 'kp_equal	'self-insert-command)
-(define-key global-map 'kp_multiply	'self-insert-command)
-(define-key global-map 'kp_add		'self-insert-command)
-(define-key global-map 'kp_separator	'self-insert-command)
-(define-key global-map 'kp_subtract	'self-insert-command)
-(define-key global-map 'kp_decimal	'self-insert-command)
-(define-key global-map 'kp_divide	'self-insert-command)
+(define-key global-map 'kp-space	'self-insert-command)
+(define-key global-map 'kp-equal	'self-insert-command)
+(define-key global-map 'kp-multiply	'self-insert-command)
+(define-key global-map 'kp-add		'self-insert-command)
+(define-key global-map 'kp-separator	'self-insert-command)
+(define-key global-map 'kp-subtract	'self-insert-command)
+(define-key global-map 'kp-decimal	'self-insert-command)
+(define-key global-map 'kp-divide	'self-insert-command)
 
-(define-key global-map 'kp_0		'self-insert-command)
-(define-key global-map 'kp_1		'self-insert-command)
-(define-key global-map 'kp_2		'self-insert-command)
-(define-key global-map 'kp_3		'self-insert-command)
-(define-key global-map 'kp_4		'self-insert-command)
-(define-key global-map 'kp_5		'self-insert-command)
-(define-key global-map 'kp_6		'self-insert-command)
-(define-key global-map 'kp_7		'self-insert-command)
-(define-key global-map 'kp_8		'self-insert-command)
-(define-key global-map 'kp_9		'self-insert-command)
+(define-key global-map 'kp-0		'self-insert-command)
+(define-key global-map 'kp-1		'self-insert-command)
+(define-key global-map 'kp-2		'self-insert-command)
+(define-key global-map 'kp-3		'self-insert-command)
+(define-key global-map 'kp-4		'self-insert-command)
+(define-key global-map 'kp-5		'self-insert-command)
+(define-key global-map 'kp-6		'self-insert-command)
+(define-key global-map 'kp-7		'self-insert-command)
+(define-key global-map 'kp-8		'self-insert-command)
+(define-key global-map 'kp-9		'self-insert-command)
 
 (define-key global-map 'select		'function-key-error)
 (define-key global-map 'print		'function-key-error)

File lisp/term/AT386.el

   (define-key AT386-keypad-map "@" [insert])	;; Ins key
 
   ;; These are not normally set up by either
-  (define-key AT386-keypad-map "G" [kp_5])	;; Unlabeled center key
-  (define-key AT386-keypad-map "S" [kp_subtract])
-  (define-key AT386-keypad-map "T" [kp_add])
+  (define-key AT386-keypad-map "G" [kp-5])	;; Unlabeled center key
+  (define-key AT386-keypad-map "S" [kp-subtract])
+  (define-key AT386-keypad-map "T" [kp-add])
 
   ;; Arrange for the ALT key to be equivalent to ESC
   (define-key function-key-map "\eN" [?\e]) ; ALT map

File lisp/term/linux.el

 (define-key function-key-map "\e[4~" [end])
 (define-key function-key-map "\e[5~" [prior])
 (define-key function-key-map "\e[6~" [next])
-(define-key function-key-map "\e[G" [kp_5])
+(define-key function-key-map "\e[G" [kp-5])
 
-(define-key function-key-map "\eOp" [kp_0])
-(define-key function-key-map "\eOq" [kp_1])
-(define-key function-key-map "\eOr" [kp_2])
-(define-key function-key-map "\eOs" [kp_3])
-(define-key function-key-map "\eOt" [kp_4])
-(define-key function-key-map "\eOu" [kp_5])
-(define-key function-key-map "\eOv" [kp_6])
-(define-key function-key-map "\eOw" [kp_7])
-(define-key function-key-map "\eOx" [kp_8])
-(define-key function-key-map "\eOy" [kp_9])
+(define-key function-key-map "\eOp" [kp-0])
+(define-key function-key-map "\eOq" [kp-1])
+(define-key function-key-map "\eOr" [kp-2])
+(define-key function-key-map "\eOs" [kp-3])
+(define-key function-key-map "\eOt" [kp-4])
+(define-key function-key-map "\eOu" [kp-5])
+(define-key function-key-map "\eOv" [kp-6])
+(define-key function-key-map "\eOw" [kp-7])
+(define-key function-key-map "\eOx" [kp-8])
+(define-key function-key-map "\eOy" [kp-9])
 
-(define-key function-key-map "\eOl" [kp_add])
-(define-key function-key-map "\eOS" [kp_subtract])
-(define-key function-key-map "\eOM" [kp_enter])
-(define-key function-key-map "\eOR" [kp_multiply])
-(define-key function-key-map "\eOQ" [kp_divide])
-(define-key function-key-map "\eOn" [kp_decimal])
-(define-key function-key-map "\eOP" [kp_numlock])
+(define-key function-key-map "\eOl" [kp-add])
+(define-key function-key-map "\eOS" [kp-subtract])
+(define-key function-key-map "\eOM" [kp-enter])
+(define-key function-key-map "\eOR" [kp-multiply])
+(define-key function-key-map "\eOQ" [kp-divide])
+(define-key function-key-map "\eOn" [kp-decimal])
+(define-key function-key-map "\eOP" [kp-numlock])
 

File lisp/term/lk201.el

 
 ;; Termcap or terminfo should set these, but doesn't properly.
 ;; Termcap sets these to k1-k4, which get mapped to f1-f4 in term.c
-(define-key function-key-map "\eOP" [kp_f1])
-(define-key function-key-map "\eOQ" [kp_f2])
-(define-key function-key-map "\eOR" [kp_f3])
-(define-key function-key-map "\eOS" [kp_f4])
+(define-key function-key-map "\eOP" [kp-f1])
+(define-key function-key-map "\eOQ" [kp-f2])
+(define-key function-key-map "\eOR" [kp-f3])
+(define-key function-key-map "\eOS" [kp-f4])
 
-(define-key function-key-map "\eOI" [kp_tab])
-(define-key function-key-map "\eOj" [kp_multiply])
-(define-key function-key-map "\eOk" [kp_add])
-(define-key function-key-map "\eOl" [kp_separator])
-(define-key function-key-map "\eOM" [kp_enter])
-(define-key function-key-map "\eOm" [kp_subtract])
-(define-key function-key-map "\eOn" [kp_decimal])
-(define-key function-key-map "\eOo" [kp_divide])
-(define-key function-key-map "\eOp" [kp_0])
-(define-key function-key-map "\eOq" [kp_1])
-(define-key function-key-map "\eOr" [kp_2])
-(define-key function-key-map "\eOs" [kp_3])
-(define-key function-key-map "\eOt" [kp_4])
-(define-key function-key-map "\eOu" [kp_5])
-(define-key function-key-map "\eOv" [kp_6])
-(define-key function-key-map "\eOw" [kp_7])
-(define-key function-key-map "\eOx" [kp_8])
-(define-key function-key-map "\eOy" [kp_9])
+(define-key function-key-map "\eOI" [kp-tab])
+(define-key function-key-map "\eOj" [kp-multiply])
+(define-key function-key-map "\eOk" [kp-add])
+(define-key function-key-map "\eOl" [kp-separator])
+(define-key function-key-map "\eOM" [kp-enter])
+(define-key function-key-map "\eOm" [kp-subtract])
+(define-key function-key-map "\eOn" [kp-decimal])
+(define-key function-key-map "\eOo" [kp-divide])
+(define-key function-key-map "\eOp" [kp-0])
+(define-key function-key-map "\eOq" [kp-1])
+(define-key function-key-map "\eOr" [kp-2])
+(define-key function-key-map "\eOs" [kp-3])
+(define-key function-key-map "\eOt" [kp-4])
+(define-key function-key-map "\eOu" [kp-5])
+(define-key function-key-map "\eOv" [kp-6])
+(define-key function-key-map "\eOw" [kp-7])
+(define-key function-key-map "\eOx" [kp-8])
+(define-key function-key-map "\eOy" [kp-9])

File lisp/term/news.el

   (define-key news-fkey-prefix "a" [execute])
   (define-key news-fkey-prefix "b" [select])
   (define-key news-fkey-prefix "c" [cancel])
-  (define-key news-fkey-prefix "M" [kp_enter])
-  (define-key news-fkey-prefix "q" [kp_1])
-  (define-key news-fkey-prefix "s" [kp_3])
-  (define-key news-fkey-prefix "u" [kp_5])
-  (define-key news-fkey-prefix "w" [kp_7])
-  (define-key news-fkey-prefix "y" [kp_9])
+  (define-key news-fkey-prefix "M" [kp-enter])
+  (define-key news-fkey-prefix "q" [kp-1])
+  (define-key news-fkey-prefix "s" [kp-3])
+  (define-key news-fkey-prefix "u" [kp-5])
+  (define-key news-fkey-prefix "w" [kp-7])
+  (define-key news-fkey-prefix "y" [kp-9])
 
   ;; These aren't in either termcap or terminfo's repertoire
-  (define-key news-fkey-prefix "m" [kp_subtract])
-  (define-key news-fkey-prefix "k" [kp_add])
-  (define-key news-fkey-prefix "l" [kp_separator])
-  (define-key news-fkey-prefix "n" [kp_decimal])
-  (define-key news-fkey-prefix "p" [kp_0])
-  (define-key news-fkey-prefix "r" [kp_2])
-  (define-key news-fkey-prefix "t" [kp_4])
-  (define-key news-fkey-prefix "v" [kp_6])
-  (define-key news-fkey-prefix "x" [kp_8])
+  (define-key news-fkey-prefix "m" [kp-subtract])
+  (define-key news-fkey-prefix "k" [kp-add])
+  (define-key news-fkey-prefix "l" [kp-separator])
+  (define-key news-fkey-prefix "n" [kp-decimal])
+  (define-key news-fkey-prefix "p" [kp-0])
+  (define-key news-fkey-prefix "r" [kp-2])
+  (define-key news-fkey-prefix "t" [kp-4])
+  (define-key news-fkey-prefix "v" [kp-6])
+  (define-key news-fkey-prefix "x" [kp-8])
   )
 
 ;;; news.el ends here

File lisp/term/tvi970.el

 		      (car key-binding) (nth 1 key-binding))))
 	'(
 	  ;; These are set up by termcap or terminfo
-	  ;; ("\eOP"	[kp_f1])
-	  ;; ("\eOQ"	[kp_f2])
-	  ;; ("\eOR"	[kp_f3])
-	  ;; ("\eOS"	[kp_f4])
+	  ;; ("\eOP"	[kp-f1])
+	  ;; ("\eOQ"	[kp-f2])
+	  ;; ("\eOR"	[kp-f3])
+	  ;; ("\eOS"	[kp-f4])
 
 	  ;; These might br set by terminfo
 	  ("\e[H"	[home])
 	  ("\e[U"	[next])		;; actually the `page' key
 
 	  ;; These won't be set up by either
-	  ("\eOm"	[kp_subtract])
-	  ("\eOl"	[kp_separator])
-	  ("\eOn"	[kp_decimal])
-	  ("\eOM"	[kp_enter])
+	  ("\eOm"	[kp-subtract])
+	  ("\eOl"	[kp-separator])
+	  ("\eOn"	[kp-decimal])
+	  ("\eOM"	[kp-enter])
 
 	  ;; These won't be set up by either either
 	  ("\e[K"	[key_eol])	;; Not an X keysym
   (while (< i 10)
     (define-key function-key-map
       (format "\eO%c" (+ i ?p))
-      (vector (intern (format "kp_%d" i))))
+      (vector (intern (format "kp-%d" i))))
     (setq i (1+ i))))
 ;; The numbered function keys.
 (let ((i 0))

File lisp/term/xterm.el

 (define-key function-key-map "\eOC" [right])
 (define-key function-key-map "\eOD" [left])
 
-(define-key function-key-map "\eOp" [kp_0])
-(define-key function-key-map "\eOq" [kp_1])
-(define-key function-key-map "\eOr" [kp_2])
-(define-key function-key-map "\eOs" [kp_3])
-(define-key function-key-map "\eOt" [kp_4])
-(define-key function-key-map "\eOu" [kp_5])
-(define-key function-key-map "\eOv" [kp_6])
-(define-key function-key-map "\eOw" [kp_7])
-(define-key function-key-map "\eOx" [kp_8])
-(define-key function-key-map "\eOy" [kp_9])
+(define-key function-key-map "\eOp" [kp-0])
+(define-key function-key-map "\eOq" [kp-1])
+(define-key function-key-map "\eOr" [kp-2])
+(define-key function-key-map "\eOs" [kp-3])
+(define-key function-key-map "\eOt" [kp-4])
+(define-key function-key-map "\eOu" [kp-5])
+(define-key function-key-map "\eOv" [kp-6])
+(define-key function-key-map "\eOw" [kp-7])
+(define-key function-key-map "\eOx" [kp-8])
+(define-key function-key-map "\eOy" [kp-9])
 
-(define-key function-key-map "\eOk" [kp_add])
-(define-key function-key-map "\eOm" [kp_subtract])
-(define-key function-key-map "\eOM" [kp_enter])
-(define-key function-key-map "\eOj" [kp_multiply])
-(define-key function-key-map "\eOo" [kp_divide])
-(define-key function-key-map "\eOn" [kp_decimal])
+(define-key function-key-map "\eOk" [kp-add])
+(define-key function-key-map "\eOm" [kp-subtract])
+(define-key function-key-map "\eOM" [kp-enter])
+(define-key function-key-map "\eOj" [kp-multiply])
+(define-key function-key-map "\eOo" [kp-divide])
+(define-key function-key-map "\eOn" [kp-decimal])
 
 ;; If you use the X resource -- XTerm*sunFunctionKeys: on -- you may
 ;; need these.

File lisp/version.el

 
 (defconst emacs-build-system (system-name))
 
-(defconst xemacs-betaname "(beta91)"
+(defconst xemacs-betaname nil
   "Non-nil when this is a test (beta) version of XEmacs.
 Warning, this variable did not exist in XEmacs versions prior to 20.3")
 
-(defconst xemacs-codename ""
-  "This only works in XEmacs 20.3 or greater.")
+(defconst xemacs-codename "Queens"
+  "Symbolic name of XEmacs build.
+Warning, this variable did not exist in XEmacs versions prior to 19.16
+and 20.3")
 
 (defconst emacs-version
   (purecopy

File lisp/x11/x-iso8859-1.el

 
 ;; It puts the same property on the keypad keys, so that (read-char) will
 ;; think that they are the same as the digit characters.  However, those
-;; keys are bound to one-character keyboard macros, so that `kp_9' will, by
+;; keys are bound to one-character keyboard macros, so that `kp-9' will, by
 ;; default, do the same thing that `9' does, in whatever the current mode is.
 
 ;; The standard case and syntax tables are set in prim/iso8859-1.el, since

File lisp/x11/x-win-sun.el

 ;;   .emacs files like (global-set-key [(f35)] 'foo) continue to work
 ;;
 ;; - Use keyboard macros to provide indirection for keybindings.
-;;   If we do (global-set-key [(f35)] [(kp_3)]), then the user's keybindings
-;;   work whether he uses `f35' or `kp_3'.
+;;   If we do (global-set-key [(f35)] [(kp-3)]), then the user's keybindings
+;;   work whether he uses `f35' or `kp-3'.
 ;;   This is also compatible with FSF Emacs and other X11 apps.
 ;;   Although this has the disadvantage that these remappings
 ;;   only work with the global key map, we use this as the default.
  ;; up is ok
  ;; left is ok
  ;; right is ok
- ;; kp_add is ok
+ ;; kp-add is ok
  ;; down is ok
  ;; insert is ok
  ;; delete is ok
- ;; kp_enter is ok
+ ;; kp-enter is ok
  (append
   ;; Sun Function keys
   (cond ((x-keysym-on-keyboard-p "F21")
        '((f21 . pause)
          (f22 . prsc)
          (f23 . scroll)
-         (f25 . kp_divide)
-         (f26 . kp_multiply)
-         (f31 . kp_5))
+         (f25 . kp-divide)
+         (f26 . kp-multiply)
+         (f31 . kp-5))
        
-       ;; Map f33 and r13 to end or kp_end
+       ;; Map f33 and r13 to end or kp-end
        (cond
         ((not (x-keysym-on-keyboard-p "End"))
          '((f33 . end)    (r13 . end)))
         ((not (x-keysym-on-keyboard-p "KP_End"))
-         '((f33 . kp_end) (r13 . kp_end))))
+         '((f33 . kp-end) (r13 . kp-end))))
   
        (if (x-keysym-on-keyboard-p "F36")
            '((f36 . stop) (f37 . again)) ; MIT Type 5 name
          '((f11 . stop) (f12 . again)))  ; Sun name or MIT Type 4 name
     
-       ;; Type 4 keyboards have a real kp_subtract  and a f24 labelled `='
+       ;; Type 4 keyboards have a real kp-subtract  and a f24 labelled `='
        ;; Type 5 keyboards have no key labelled `=' and a f24 labelled `-'
        (if (x-keysym-on-keyboard-p "F24")
            (if (x-keysym-on-keyboard-p "KP_Subtract")
-               '((f24 . kp_equal))
-             '((f24 . kp_subtract))))
+               '((f24 . kp-equal))
+             '((f24 . kp-subtract))))
   
-       ;; Map f27 to home or kp_home, as appropriate
+       ;; Map f27 to home or kp-home, as appropriate
        (cond ((not (x-keysym-on-keyboard-p "Home"))    '((f27 . home)))
-             ((not (x-keysym-on-keyboard-p "KP_Home")) '((f27 . kp_home))))
+             ((not (x-keysym-on-keyboard-p "KP_Home")) '((f27 . kp-home))))
 
-       ;; Map f29 to prior or kp_prior, as appropriate
+       ;; Map f29 to prior or kp-prior, as appropriate
        (cond ((not (x-keysym-on-keyboard-p "Prior"))     '((f29 . prior)))
-             ((not (x-keysym-on-keyboard-p "KP_Prior"))  '((f29 . kp_prior))))
+             ((not (x-keysym-on-keyboard-p "KP_Prior"))  '((f29 . kp-prior))))
 
-       ;; Map f35 to next or kp_next, as appropriate
+       ;; Map f35 to next or kp-next, as appropriate
        (cond ((not (x-keysym-on-keyboard-p "Next"))    '((f35 . next)))
-             ((not (x-keysym-on-keyboard-p "KP_Next")) '((f35 . kp_next))))
+             ((not (x-keysym-on-keyboard-p "KP_Next")) '((f35 . kp-next))))
        ))
 
   (cond ((x-keysym-on-keyboard-p "apRead") ; SunOS 4.1.1
 
   ;; !@#$ SunOS 4 with SunOS5 X server
   (if (string-match "sunos4.1" system-configuration)
-      '((unknown_keysym_0xFF9A . kp_prior)
-        (unknown_keysym_0xFF9B . kp_next)
-        (unknown_keysym_0xFF95 . kp_home)
-        (unknown_keysym_0xFF9C . kp_end)
-        (unknown_keysym_0xFF96 . kp_left)
-        (unknown_keysym_0xFF97 . kp_up)
-        (unknown_keysym_0xFF98 . kp_right)
-        (unknown_keysym_0xFF99 . kp_down)
-        (unknown_keysym_0xFF9E . kp_insert)))
+      '((unknown_keysym_0xFF9A . kp-prior)
+        (unknown_keysym_0xFF9B . kp-next)
+        (unknown_keysym_0xFF95 . kp-home)
+        (unknown_keysym_0xFF9C . kp-end)
+        (unknown_keysym_0xFF96 . kp-left)
+        (unknown_keysym_0xFF97 . kp-up)
+        (unknown_keysym_0xFF98 . kp-right)
+        (unknown_keysym_0xFF99 . kp-down)
+        (unknown_keysym_0xFF9E . kp-insert)))
   ))
 
 (fmakunbound 'x11-remap-keysyms-using-function-key-map)
 (defun sun-x11-keyboard-translate ()
   "Remap Sun's X11 keyboard.
 Keys with names like `f35' are remapped, at a low level,
-to more mnemonic ones,like `kp_3'."
+to more mnemonic ones,like `kp-3'."
   (interactive)
   
   (keyboard-translate
    'f22 'prsc
    'f23 'scroll
    ;; num_lock is ok
-   ;;'f24 'kp_equal)			; type4 only!
-   'f25 'kp_divide			;
-   'f26 'kp_multiply			;
-   'f24 'kp_subtract			; type5 only!
-   'f27 'kp_7				;
+   ;;'f24 'kp-equal)			; type4 only!
+   'f25 'kp-divide			;
+   'f26 'kp-multiply			;
+   'f24 'kp-subtract			; type5 only!
+   'f27 'kp-7				;
    ;; up is ok
-   'f29 'kp_9
+   'f29 'kp-9
    ;; left is ok
-   'f31 'kp_5
+   'f31 'kp-5
    ;; right is ok
-   ;; kp_add is ok
-   'f33 'kp_1				; the Sun name
+   ;; kp-add is ok
+   'f33 'kp-1				; the Sun name
    'r13 'end				; the MIT name
    ;; down is ok
-   'f35 'kp_3
+   'f35 'kp-3
    ;; insert is ok
    ;; delete is ok
-   ;; kp_enter is ok
+   ;; kp-enter is ok
    'SunF36 'f11				; Type 5 keyboards
    'SunF37 'f12				; Used to be Stop & Again
    ))

File man/lispref/help.texi

      @result{} "C-x SPC M-y SPC LFD SPC TAB SPC RET SPC C-l 1 2 3"
 @end group
 @group
-(single-key-description 'kp_next)
-     @result{} "kp_next"
+(single-key-description 'kp-next)
+     @result{} "kp-next"
 @end group
 @group
 (single-key-description '(shift button1))