xemacs-beta: lisp/simple.el comparison

comparison lisp/simple.el @ 446:1ccc32a20af4 r21-2-38

Import from CVS: tag r21-2-38

author	cvs
date	Mon, 13 Aug 2007 11:37:21 +0200
parents	576fb035e263
children	3078fd1074e8

comparison

equal deleted inserted replaced

-:34f3776fcf0e
+:1ccc32a20af4
 Leave one space or none, according to the context."
 (interactive "*")
 (save-excursion
 (delete-horizontal-space)
 (if (or (looking-at "^\\|\\s)")
-	    (save-excursion (forward-char -1)
+	    (save-excursion (backward-char 1)
 			    (looking-at "$\\|\\s(\\|\\s'")))
 	nil
 (insert ?\ ))))
 (defun delete-horizontal-space ()
 (let ((count arg))
 (save-excursion
 (while (and (> count 0) (not (bobp)))
 	(if (eq (char-before (point)) ?\t) ; XEmacs
 	    (let ((col (current-column)))
-	      (forward-char -1)
+	      (backward-char 1)
 	      (setq col (- col (current-column)))
 	      (insert-char ?\ col)
 	      (delete-char 1)))
-	(forward-char -1)
+	(backward-char 1)
 	(setq count (1- count)))))
 (delete-backward-char arg killp)
 ;; XEmacs: In overwrite mode, back over columns while clearing them out,
 ;; unless at end of line.
 (and overwrite-mode (not (eolp))
 "*If non-nil, the DEL key will erase one character forwards.
 If nil, the DEL key will erase one character backwards."
 :type 'boolean
 :group 'editing-basics)
-(defcustom backward-delete-function 'backward-delete-char
+(defcustom backward-delete-function 'delete-backward-char
 "*Function called to delete backwards on a delete keypress.
 If `delete-key-deletes-forward' is nil, `backward-or-forward-delete-char'
 calls this function to erase one character backwards.  Default value
-is 'backward-delete-char, with 'backward-delete-char-untabify being a
+is `delete-backward-char', with `backward-delete-char-untabify' being a
 popular alternate setting."
 :type 'function
 :group 'editing-basics)
 ;; Trash me, baby.
 "Interchange characters around point, moving forward one character.
 With prefix arg ARG, effect is to take character before point
 and drag it forward past ARG other characters (backward if ARG negative).
 If no argument and at end of line, the previous two chars are exchanged."
 (interactive "*P")
-(and (null arg) (eolp) (forward-char -1))
+(and (null arg) (eolp) (backward-char 1))
 (transpose-subr 'forward-char (prefix-numeric-value arg)))
 ;;; A very old implementation of transpose-chars from the old days ...
 (defun transpose-preceding-chars (arg)
 "Interchange characters before point.
 With prefix arg ARG, effect is to take character before point
 and drag it forward past ARG other characters (backward if ARG negative).
 If no argument and not at start of line, the previous two chars are exchanged."
 (interactive "*P")
-(and (null arg) (not (bolp)) (forward-char -1))
+(and (null arg) (not (bolp)) (backward-char 1))
 (transpose-subr 'forward-char (prefix-numeric-value arg)))
 (defun transpose-words (arg)
 "Interchange words around point, leaving point at end of them.
 	  (insert prefix)
 	  (end-of-line 1)
 	  (forward-char 1)))))
-;; XEmacs - extra parameter
+(defun backward-word (&optional count buffer)
-(defun backward-word (arg &optional buffer)
+"Move point backward COUNT words (forward if COUNT is negative).
-"Move backward until encountering the end of a word.
+Normally t is returned, but if an edge of the buffer is reached,
-With argument, do this that many times.
+point is left there and nil is returned.
-In programs, it is faster to call `forward-word' with negative arg."
-(interactive "_p") ; XEmacs
+COUNT defaults to 1, and BUFFER defaults to the current buffer."
-(forward-word (- arg) buffer))
+(interactive "_p")
+(forward-word (- (or count 1)) buffer))
-(defun mark-word (arg)
-"Set mark arg words away from point."
+(defun mark-word (&optional count)
+"Mark the text from point until encountering the end of a word.
+With optional argument COUNT, mark COUNT words."
 (interactive "p")
-(mark-something 'mark-word 'forward-word arg))
+(mark-something 'mark-word 'forward-word count))
-;; XEmacs modified
+(defun kill-word (&optional count)
-(defun kill-word (arg)
 "Kill characters forward until encountering the end of a word.
+With optional argument COUNT, do this that many times."
+(interactive "*p")
+(kill-region (point) (save-excursion (forward-word count) (point))))
+(defun backward-kill-word (&optional count)
+"Kill characters backward until encountering the end of a word.
 With argument, do this that many times."
 (interactive "*p")
-(kill-region (point) (save-excursion (forward-word arg) (point))))
+(kill-word (- (or count 1))))
-(defun backward-kill-word (arg)
-"Kill characters backward until encountering the end of a word.
-With argument, do this that many times."
-(interactive "*p") ; XEmacs
-(kill-word (- arg)))
 (defun current-word (&optional strict)
 "Return the word point is on (or a nearby word) as a string.
 If optional arg STRICT is non-nil, return nil unless point is within
 or adjacent to a word.
 				;; the line there and make it look like a
 				;; sentence end.
 				(and (not (bobp))
 				     (not bounce)
 				     sentence-end-double-space
-				     (save-excursion (forward-char -1)
+				     (save-excursion (backward-char 1)
 						     (and (looking-at "\\. ")
 							  (not (looking-at "\\.  "))))))
 		       (setq first nil)
 		       ;; 97/3/14 jhod: Kinsoku
 		       ; (skip-chars-backward "^ \t\n"))
 ;			      ;; the line there and make it look like a
 ;			      ;; sentence end.
 ;			      (and (not (bobp))
 ;				   (not bounce)
 ;				   sentence-end-double-space
-;				   (save-excursion (forward-char -1)
+;				   (save-excursion (backward-char 1)
 ;						   (and (looking-at "\\. ")
 ;							(not (looking-at "\\.  "))))))
 ;		     (setq first nil)
 ;		     (skip-chars-backward "^ \t\n")
 ;		     ;; If we find nowhere on the line to break it,
 		(block-comment-start comstart)
 		(comment-end comment-end))
 	    (and comment-end (not (equal comment-end ""))
 ;	       (if (not comment-multi-line)
 		     (progn
-		       (forward-char -1)
+		       (backward-char 1)
 		       (insert comment-end)
 		       (forward-char 1))
 ;		 (setq comment-column (+ comment-column (length comment-start))
 ;		       comment-start "")
 ;		   )
 		 )
 	    (if (not (eolp))
 		(setq comment-end ""))
 	    (insert ?\n)
-	    (forward-char -1)
+	    (backward-char 1)
 	    (indent-for-comment)
 	    (save-excursion
 	      ;; Make sure we delete the newline inserted above.
 	      (end-of-line)
 	      (delete-char 1)))
 (and (> (point) (1+ (point-min)))
 blink-matching-paren
 ;; Verify an even number of quoting characters precede the close.
 (= 1 (logand 1 (- (point)
 			 (save-excursion
-			   (forward-char -1)
+			   (backward-char 1)
 			   (skip-syntax-backward "/\\")
 			   (point)))))
 (let* ((oldpos (point))
 	      (blinkpos)
 	      (mismatch))

Mercurial > hg > xemacs-beta

comparison lisp/simple.el @ 446:1ccc32a20af4 r21-2-38