xemacs-beta: lisp/simple.el comparison

comparison lisp/simple.el @ 444:576fb035e263 r21-2-37

Import from CVS: tag r21-2-37

author	cvs
date	Mon, 13 Aug 2007 11:36:19 +0200
parents	abe6d1db359e
children	1ccc32a20af4

comparison

equal deleted inserted replaced

-:a8296e22da4e
+:576fb035e263
 (defun no-upper-case-p (string &optional regexp-flag)
 "Return t if there are no upper case chars in STRING.
 If REGEXP-FLAG is non-nil, disregard letters preceded by `\\' (but not `\\\\')
 since they have special meaning in a regexp."
 (let ((case-fold-search nil))
 (not (string-match (if regexp-flag
 			   "\\(^\\|\\\\\\\\\\|[^\\]\\)[A-Z]"
 			 "[A-Z]")
 		       string))
 ))
 (defmacro with-search-caps-disable-folding (string regexp-flag &rest body) "\
 Eval BODY with `case-fold-search' let to nil if `search-caps-disable-folding'
 is non-nil, and if STRING (either a string or a regular expression according
 to REGEXP-FLAG) contains uppercase letters."
 `(let ((case-fold-search
 (if (and case-fold-search search-caps-disable-folding)
 (no-upper-case-p ,string ,regexp-flag)
 case-fold-search)))
 ,@body))
 (put 'with-search-caps-disable-folding 'lisp-indent-function 2)
 (put 'with-search-caps-disable-folding 'edebug-form-spec
 '(sexp sexp &rest form))
 (defmacro with-interactive-search-caps-disable-folding (string regexp-flag
 							       &rest body)
 "Same as `with-search-caps-disable-folding', but only in the case of a
 function called interactively."
 `(let ((case-fold-search
 	  (if (and (interactive-p)
 		   case-fold-search search-caps-disable-folding)
 (no-upper-case-p ,string ,regexp-flag)
 case-fold-search)))
 ,@body))
 (put 'with-interactive-search-caps-disable-folding 'lisp-indent-function 2)
 (put 'with-interactive-search-caps-disable-folding 'edebug-form-spec
 '(sexp sexp &rest form))
-(defun newline (&optional arg)
+(defun newline (&optional n)
 "Insert a newline, and move to left margin of the new line if it's blank.
 The newline is marked with the text-property `hard'.
-With arg, insert that many newlines.
+With optional arg N, insert that many newlines.
 In Auto Fill mode, if no numeric arg, break the preceding line if it's long."
 (interactive "*P")
 (barf-if-buffer-read-only nil (point))
 ;; Inserting a newline at the end of a line produces better redisplay in
 ;; try_window_id than inserting at the beginning of a line, and the textual
 ;; Set last-command-char to tell self-insert what to insert.
 (let ((last-command-char ?\n)
 	  ;; Don't auto-fill if we have a numeric argument.
 	  ;; Also not if flag is true (it would fill wrong line);
 	  ;; there is no need to since we're at BOL.
-	  (auto-fill-function (if (or arg flag) nil auto-fill-function)))
+	  (auto-fill-function (if (or n flag) nil auto-fill-function)))
 (unwind-protect
-	  (self-insert-command (prefix-numeric-value arg))
+	  (self-insert-command (prefix-numeric-value n))
 	;; If we get an error in self-insert-command, put point at right place.
 	(if flag (forward-char 1))))
 ;; If we did *not* get an error, cancel that forward-char.
 (if flag (backward-char 1))
 ;; Mark the newline(s) `hard'.
 (if use-hard-newlines
-	(let* ((from (- (point) (if arg (prefix-numeric-value arg) 1)))
+	(let* ((from (- (point) (if n (prefix-numeric-value n) 1)))
 	       (sticky (get-text-property from 'end-open))) ; XEmacs
 	  (put-text-property from (point) 'hard 't)
 	  ;; If end-open is not "t", add 'hard to end-open list
 	  (if (and (listp sticky) (not (memq 'hard sticky)))
 	      (put-text-property from (point) 'end-open ; XEmacs
 ;; If rear-nonsticky is not "t", add 'hard to rear-nonsticky list
 (if (and (listp sticky) (not (memq 'hard sticky)))
 	(put-text-property from (point) 'rear-nonsticky
 			   (cons 'hard sticky)))))
-(defun open-line (arg)
+(defun open-line (n)
 "Insert a newline and leave point before it.
 If there is a fill prefix and/or a left-margin, insert them on the new line
 if the line would have been blank.
 With arg N, insert N newlines."
 (interactive "*p")
 (let* ((do-fill-prefix (and fill-prefix (bolp)))
 	 (do-left-margin (and (bolp) (> (current-left-margin) 0)))
 	 (loc (point)))
-(newline arg)
+(newline n)
 (goto-char loc)
-(while (> arg 0)
+(while (> n 0)
 (cond ((bolp)
 	     (if do-left-margin (indent-to (current-left-margin)))
 	     (if do-fill-prefix (insert fill-prefix))))
 (forward-line 1)
-(setq arg (1- arg)))
+(setq n (1- n)))
 (goto-char loc)
 (end-of-line)))
 (defun split-line ()
 "Split current line, moving portion beyond point vertically down."
 (setq values (cons (eval expression) values))
 (prin1 (car values)
 	 (if eval-expression-insert-value (current-buffer) t)))
 ;; XEmacs -- extra parameter (variant, but equivalent logic)
-(defun edit-and-eval-command (prompt command &optional history)
+(defun edit-and-eval-command (prompt form &optional history)
-"Prompting with PROMPT, let user edit COMMAND and eval result.
+"Prompting with PROMPT, let user edit FORM and eval result.
-COMMAND is a Lisp expression.  Let user edit that expression in
+FORM is a Lisp expression.  Let user edit that expression in
 the minibuffer, then read and evaluate the result."
-(let ((command (read-expression prompt
+(let ((form (read-expression prompt
-				  ;; first try to format the thing readably;
+			       ;; first try to format the thing readably;
-				  ;; and if that fails, print it normally.
+			       ;; and if that fails, print it normally.
-				  (condition-case ()
+			       (condition-case ()
-				      (let ((print-readably t))
+				   (let ((print-readably t))
-					(prin1-to-string command))
+				     (prin1-to-string form))
-				    (error (prin1-to-string command)))
+				 (error (prin1-to-string form)))
-				  (or history '(command-history . 1)))))
+			       (or history '(command-history . 1)))))
 (or history (setq history 'command-history))
 (if (consp history)
 	(setq history (car history)))
 (if (eq history t)
 	nil
-;; If command was added to the history as a string,
+;; If form was added to the history as a string,
 ;; get rid of that.  We want only evallable expressions there.
 (if (stringp (car (symbol-value history)))
 	  (set history (cdr (symbol-value history))))
-;; If command to be redone does not match front of history,
+;; If form to be redone does not match front of history,
 ;; add it to the history.
-(or (equal command (car (symbol-value history)))
+(or (equal form (car (symbol-value history)))
-	  (set history (cons command (symbol-value history)))))
+	  (set history (cons form (symbol-value history)))))
-(eval command)))
+(eval form)))
 (defun repeat-complex-command (arg)
 "Edit and re-evaluate last complex command, or ARGth from last.
 A complex command is one which used the minibuffer.
 The command is placed in the minibuffer as a Lisp form for editing.
 ;; next-history-element
 ;; previous-history-element
 ;; next-complete-history-element
 ;; previous-complete-history-element
-(defun goto-line (arg)
+(defun goto-line (line)
-"Goto line ARG, counting from line 1 at beginning of buffer."
+"Goto line LINE, counting from line 1 at beginning of buffer."
 (interactive "NGoto line: ")
-(setq arg (prefix-numeric-value arg))
+(setq line (prefix-numeric-value line))
 (save-restriction
 (widen)
 (goto-char 1)
 (if (eq selective-display t)
-	(re-search-forward "[\n\C-m]" nil 'end (1- arg))
+	(re-search-forward "[\n\C-m]" nil 'end (1- line))
-(forward-line (1- arg)))))
+(forward-line (1- line)))))
 ;Put this on C-x u, so we can force that rather than C-_ into startup msg
 (define-function 'advertised-undo 'undo)
-(defun undo (&optional arg)
+(defun undo (&optional count)
 "Undo some previous changes.
 Repeat this command to undo more changes.
 A numeric argument serves as a repeat count."
 (interactive "*p")
 ;; If we don't get all the way through, make last-command indicate that
 	(display-message 'command "Undo!"))
 (or (and (eq last-command 'undo)
 	     (eq (current-buffer) last-undo-buffer)) ; XEmacs
 	(progn (undo-start)
 	       (undo-more 1)))
-(undo-more (or arg 1))
+(undo-more (or count 1))
 ;; Don't specify a position in the undo record for the undo command.
 ;; Instead, undoing this should move point to where the change is.
 (let ((tail buffer-undo-list)
 	  done)
 (while (and tail (not done) (not (null (car tail))))
 (reset-this-command-lengths)
 (setq overriding-terminal-local-map nil))
 ;; XEmacs -- keep zmacs-region active.
-(defun forward-to-indentation (arg)
+(defun forward-to-indentation (count)
-"Move forward ARG lines and position at first nonblank character."
+"Move forward COUNT lines and position at first nonblank character."
 (interactive "_p")
-(forward-line arg)
+(forward-line count)
 (skip-chars-forward " \t"))
-(defun backward-to-indentation (arg)
+(defun backward-to-indentation (count)
-"Move backward ARG lines and position at first nonblank character."
+"Move backward COUNT lines and position at first nonblank character."
 (interactive "_p")
-(forward-line (- arg))
+(forward-line (- count))
 (skip-chars-forward " \t"))
 (defcustom kill-whole-line nil
 "*Control when and whether `kill-line' removes entire lines.
 Note: This only applies when `kill-line' is called interactively;
 (defvar kill-ring-yank-pointer nil
 "The tail of the kill ring whose car is the last thing yanked.")
 (defun kill-new (string &optional replace)
 "Make STRING the latest kill in the kill ring.
-Set the kill-ring-yank pointer to point to it.
+Set `kill-ring-yank-pointer' to point to it.
 Run `kill-hooks'.
 Optional second argument REPLACE non-nil means that STRING will replace
 the front of the kill ring, rather than being added to the list."
 ;  (and (fboundp 'menu-bar-update-yank-menu)
 ;       (menu-bar-update-yank-menu string (and replace (car kill-ring))))
 ;; is a very bad idea -- see Jamie's comment below.
 ;(defvar kill-read-only-ok nil
 ;  "*Non-nil means don't signal an error for killing read-only text.")
-(defun kill-region (beg end &optional verbose) ; verbose is XEmacs addition
+(defun kill-region (start end &optional verbose) ; verbose is XEmacs addition
 "Kill between point and mark.
 The text is deleted but saved in the kill ring.
 The command \\[yank] can retrieve it from there.
 \(If you want to kill and then yank immediately, use \\[copy-region-as-kill].)
 ;     ;; This lets "^Y^W" work.  I think this is dumb, but zwei did it.
 ;     (if region-hack (zmacs-activate-region))
 ;     (prog1
 ;	 (list (point) (mark) current-prefix-arg)
 ;       (if region-hack (zmacs-deactivate-region)))))
-;; beg and end can be markers but the rest of this function is
+;; start and end can be markers but the rest of this function is
 ;; written as if they are only integers
-(if (markerp beg) (setq beg (marker-position beg)))
+(if (markerp start) (setq start (marker-position start)))
 (if (markerp end) (setq end (marker-position end)))
-(or (and beg end) (if zmacs-regions ;; rewritten for I18N3 snarfing
+(or (and start end) (if zmacs-regions ;; rewritten for I18N3 snarfing
 			(error "The region is not active now")
 		      (error "The mark is not set now")))
 (if verbose (if buffer-read-only
 		  (lmessage 'command "Copying %d characters"
-			    (- (max beg end) (min beg end)))
+			    (- (max start end) (min start end)))
 		(lmessage 'command "Killing %d characters"
-			  (- (max beg end) (min beg end)))))
+			  (- (max start end) (min start end)))))
 (cond
 ;; I don't like this large change in behavior -- jwz
 ;; Read-Only text means it shouldn't be deleted, so I'm restoring
 ;; this code, but only for text-properties and not full extents. -sb
 ;; If the buffer is read-only, we should beep, in case the person
 ;; just isn't aware of this.  However, there's no harm in putting
 ;; the region's text in the kill ring, anyway.
 ((or (and buffer-read-only (not inhibit-read-only))
-	(text-property-not-all (min beg end) (max beg end) 'read-only nil))
+	(text-property-not-all (min start end) (max start end) 'read-only nil))
 ;; This is redundant.
 ;; (if verbose (message "Copying %d characters"
-;;			 (- (max beg end) (min beg end))))
+;;			 (- (max start end) (min start end))))
-(copy-region-as-kill beg end)
+(copy-region-as-kill start end)
 ;; ;; This should always barf, and give us the correct error.
 ;; (if kill-read-only-ok
 ;;	  (message "Read only text copied to kill ring")
 (setq this-command 'kill-region)
 (barf-if-buffer-read-only)
 ;; In certain cases, we can arrange for the undo list and the kill
 ;; ring to share the same string object.  This code does that.
 ((not (or (eq buffer-undo-list t)
 	     (eq last-command 'kill-region)
 	     ;; Use = since positions may be numbers or markers.
-	     (= beg end)))
+	     (= start end)))
 ;; Don't let the undo list be truncated before we can even access it.
 ;; FSF calls this `undo-strong-limit'
-(let ((undo-high-threshold (+ (- end beg) 100))
+(let ((undo-high-threshold (+ (- end start) 100))
 	  ;(old-list buffer-undo-list)
 	  tail)
-(delete-region beg end)
+(delete-region start end)
 ;; Search back in buffer-undo-list for this string,
 ;; in case a change hook made property changes.
 (setq tail buffer-undo-list)
 (while (and tail
 		  (not (stringp (car-safe (car-safe tail))))) ; XEmacs
 	   (kill-new (car (car tail))))))
 (t
 ;; if undo is not kept, grab the string then delete it (which won't
 ;; add another string to the undo list).
-(copy-region-as-kill beg end)
+(copy-region-as-kill start end)
-(delete-region beg end)))
+(delete-region start end)))
 (setq this-command 'kill-region))
 ;; copy-region-as-kill no longer sets this-command, because it's confusing
 ;; to get two copies of the text when the user accidentally types M-w and
 ;; then corrects it with the intended C-w.
-(defun copy-region-as-kill (beg end)
+(defun copy-region-as-kill (start end)
 "Save the region as if killed, but don't kill it.
 Run `kill-hooks'."
 (interactive "r")
 (if (eq last-command 'kill-region)
-(kill-append (buffer-substring beg end) (< end beg))
+(kill-append (buffer-substring start end) (< end start))
-(kill-new (buffer-substring beg end)))
+(kill-new (buffer-substring start end)))
 nil)
-(defun kill-ring-save (beg end)
+(defun kill-ring-save (start end)
 "Save the region as if killed, but don't kill it.
 This command is similar to `copy-region-as-kill', except that it gives
 visual feedback indicating the extent of the region being copied."
 (interactive "r")
-(copy-region-as-kill beg end)
+(copy-region-as-kill start end)
 ;; copy before delay, for xclipboard's benefit
 (if (interactive-p)
-(let ((other-end (if (= (point) beg) end beg))
+(let ((other-end (if (= (point) start) end start))
 	    (opoint (point))
 	    ;; Inhibit quitting so we can make a quit here
 	    ;; look like a C-g typed as a command.
 	    (inhibit-quit t))
 	(if (pos-visible-in-window-p other-end (selected-window))
 	      (and quit-flag (mark)
 (zmacs-deactivate-region)))
 	  ;; too noisy. -- jwz
 ;	  (let* ((killed-text (current-kill 0))
 ;		 (message-len (min (length killed-text) 40)))
-;	    (if (= (point) beg)
+;	    (if (= (point) start)
 ;		;; Don't say "killed"; that is misleading.
 ;		(message "Saved text until \"%s\""
 ;			(substring killed-text (- message-len)))
 ;	      (message "Saved text from \"%s\""
 ;		      (substring killed-text 0 message-len))))
 That is to say, don't use this function unless you want
 the user to see that the mark has moved, and you want the previous
 mark position to be lost.
 Normally, when a new mark is set, the old one should go on the stack.
-This is why most applications should use push-mark, not set-mark.
+This is why most applications should use `push-mark', not `set-mark'.
 Novice Emacs Lisp programmers often try to use the mark for the wrong
 purposes.  The mark saves a location for the user's convenience.
 Most editing commands should not alter the mark.
 To remember a location for internal use in the Lisp program,
 store it in a Lisp variable.  Example:
-(let ((beg (point))) (forward-line 1) (delete-region beg (point)))."
+(let ((start (point))) (forward-line 1) (delete-region start (point)))."
 (setq buffer (decode-buffer buffer))
 (set-marker (mark-marker t buffer) pos buffer))
 ;; FSF
 ;  (if pos
 (and (key-press-event-p last-input-event)
 (memq (event-key last-input-event)
 	'(left right up down home end prior next
 	       kp-left kp-right kp-up kp-down
 	       kp-home kp-end kp-prior kp-next))))
 (defun handle-pre-motion-command ()
 (if
 (and
 (handle-pre-motion-command-current-command-is-motion)
 zmacs-regions
 boundaries do not cause an error to be signaled."
 (interactive "_")
 (scroll-up-command 1))
 (defun scroll-up-command (&optional n)
-"Scroll text of current window upward ARG lines; or near full screen if no ARG.
+"Scroll current window upward N lines; or near full screen if N is nil.
 A near full screen is `next-screen-context-lines' less than a full screen.
-Negative ARG means scroll downward.
+Negative N means scroll downward.
 When calling from a program, supply a number as argument or nil.
 On attempt to scroll past end of buffer, `end-of-buffer' is signaled.
 On attempt to scroll past beginning of buffer, `beginning-of-buffer' is
 signaled.
 boundaries do not cause an error to be signaled."
 (interactive "_")
 (scroll-down-command 1))
 (defun scroll-down-command (&optional n)
-"Scroll text of current window downward ARG lines; or near full screen if no ARG.
+"Scroll current window downward N lines; or near full screen if N is nil.
 A near full screen is `next-screen-context-lines' less than a full screen.
-Negative ARG means scroll upward.
+Negative N means scroll upward.
 When calling from a program, supply a number as argument or nil.
 On attempt to scroll past end of buffer, `end-of-buffer' is signaled.
 On attempt to scroll past beginning of buffer, `beginning-of-buffer' is
 signaled.
 (condition-case nil
 	(scroll-down n)
 (beginning-of-buffer nil)
 (end-of-buffer nil))))
-(defun next-line (arg)
+(defun next-line (count)
-"Move cursor vertically down ARG lines.
+"Move cursor vertically down COUNT lines.
 If there is no character in the target line exactly under the current column,
 the cursor is positioned after the character in that line which spans this
 column, or at the end of the line if it is not long enough.
 If there is no line in the buffer after this one, behavior depends on the
 If you are thinking of using this in a Lisp program, consider
 using `forward-line' instead.  It is usually easier to use
 and more reliable (no dependence on goal column, etc.)."
 (interactive "_p")
-(if (and next-line-add-newlines (= arg 1))
+(if (and next-line-add-newlines (= count 1))
 (let ((opoint (point)))
 	(end-of-line)
 	(if (eobp)
 	    (newline 1)
 	  (goto-char opoint)
-	  (line-move arg)))
+	  (line-move count)))
 (if (interactive-p)
 	;; XEmacs:  Not sure what to do about this.  It's inconsistent. -sb
 	(condition-case nil
-	    (line-move arg)
+	    (line-move count)
 	  ((beginning-of-buffer end-of-buffer)
 	   (when signal-error-on-buffer-boundary
 	     (ding nil 'buffer-bound))))
-(line-move arg)))
+(line-move count)))
 nil)
-(defun previous-line (arg)
+(defun previous-line (count)
-"Move cursor vertically up ARG lines.
+"Move cursor vertically up COUNT lines.
 If there is no character in the target line exactly over the current column,
 the cursor is positioned after the character in that line which spans this
 column, or at the end of the line if it is not long enough.
 The command \\[set-goal-column] can be used to create
 `forward-line' with a negative argument instead.  It is usually easier
 to use and more reliable (no dependence on goal column, etc.)."
 (interactive "_p")
 (if (interactive-p)
 (condition-case nil
-	  (line-move (- arg))
+	  (line-move (- count))
 	((beginning-of-buffer end-of-buffer)
 	 (when signal-error-on-buffer-boundary ; XEmacs
 	   (ding nil 'buffer-bound))))
-(line-move (- arg)))
+(line-move (- count)))
 nil)
 (defcustom block-movement-size 6
 "*Number of lines that \"block movement\" commands (\\[forward-block-of-lines], \\[backward-block-of-lines]) move by."
 :type 'integer
 Use with care, as it slows down movement significantly.  Outline mode sets this."
 :type 'boolean
 :group 'editing-basics)
 ;; This is the guts of next-line and previous-line.
-;; Arg says how many lines to move.
+;; Count says how many lines to move.
-(defun line-move (arg)
+(defun line-move (count)
 ;; Don't run any point-motion hooks, and disregard intangibility,
 ;; for intermediate positions.
 (let ((inhibit-point-motion-hooks t)
 	(opoint (point))
 	new)
 	(progn
 	  (if (not (or (eq last-command 'next-line)
 		       (eq last-command 'previous-line)))
 	      (setq temporary-goal-column
 		    (if (and track-eol (eolp)
-			     ;; Don't count beg of empty line as end of line
+			     ;; Don't count start of empty line as end of line
 			     ;; unless we just did explicit end-of-line.
 			     (or (not (bolp)) (eq last-command 'end-of-line)))
 			9999
 		      (current-column))))
 	  (if (and (not (integerp selective-display))
 		   (not line-move-ignore-invisible))
 	      ;; Use just newline characters.
-	      (or (if (> arg 0)
+	      (or (if (> count 0)
-		      (progn (if (> arg 1) (forward-line (1- arg)))
+		      (progn (if (> count 1) (forward-line (1- count)))
-			     ;; This way of moving forward ARG lines
+			     ;; This way of moving forward COUNT lines
 			     ;; verifies that we have a newline after the last one.
 			     ;; It doesn't get confused by intangible text.
 			     (end-of-line)
 			     (zerop (forward-line 1)))
-		    (and (zerop (forward-line arg))
+		    (and (zerop (forward-line count))
 			 (bolp)))
-		  (signal (if (< arg 0)
+		  (signal (if (< count 0)
 			      'beginning-of-buffer
 			    'end-of-buffer)
 			  nil))
-	    ;; Move by arg lines, but ignore invisible ones.
+	    ;; Move by count lines, but ignore invisible ones.
-	    (while (> arg 0)
+	    (while (> count 0)
 	      (end-of-line)
 	      (and (zerop (vertical-motion 1))
 		   (signal 'end-of-buffer nil))
 	      ;; If the following character is currently invisible,
 	      ;; skip all characters with that same `invisible' property value.
 			      (or (memq prop buffer-invisibility-spec)
 				  (assq prop buffer-invisibility-spec)))))
 		(if (get-text-property (point) 'invisible)
 		    (goto-char (next-single-property-change (point) 'invisible))
 		  (goto-char (next-extent-change (point))))) ; XEmacs
-	      (setq arg (1- arg)))
+	      (setq count (1- count)))
-	    (while (< arg 0)
+	    (while (< count 0)
 	      (beginning-of-line)
 	      (and (zerop (vertical-motion -1))
 		   (signal 'beginning-of-buffer nil))
 	      (while (and (not (bobp))
 			  (let ((prop
 			      (or (memq prop buffer-invisibility-spec)
 				  (assq prop buffer-invisibility-spec)))))
 		(if (get-text-property (1- (point)) 'invisible)
 		    (goto-char (previous-single-property-change (point) 'invisible))
 		  (goto-char (previous-extent-change (point))))) ; XEmacs
-	      (setq arg (1+ arg))))
+	      (setq count (1+ count))))
 	  (move-to-column (or goal-column temporary-goal-column)))
 ;; Remember where we moved to, go back home,
 ;; then do the motion over again
 ;; in just one step, with intangibility and point-motion hooks
 ;; enabled this time.
 ;;; Many people have said they rarely use this feature, and often type
 ;;; it by accident.  Maybe it shouldn't even be on a key.
 ;; It's not on a key, as of 20.2.  So no need for this.
 ;(put 'set-goal-column 'disabled t)
-(defun set-goal-column (arg)
+(defun set-goal-column (column)
 "Set the current horizontal position as a goal for \\[next-line] and \\[previous-line].
 Those commands will move to this position in the line moved to
 rather than trying to keep the same horizontal position.
 With a non-nil argument, clears out the goal column
 so that \\[next-line] and \\[previous-line] resume vertical motion.
 The goal column is stored in the variable `goal-column'."
 (interactive "_P") ; XEmacs
-(if arg
+(if column
 (progn
 (setq goal-column nil)
 (display-message 'command "No goal column"))
 (setq goal-column (current-column))
 (lmessage 'command
-	"Goal column %d (use %s with an arg to unset it)"
+	"Goal column %d (use %s with a prefix arg to unset it)"
 goal-column
 (substitute-command-keys "\\[set-goal-column]")))
 nil)
 ;; deleted FSFmacs terminal randomness hscroll-point-visible stuff.
 		       (forward-line arg)))
 		  arg))
 (defun transpose-line-up (arg)
 "Move current line one line up, leaving point at beginning of that line.
-This can be run repeatedly to move to current line up a number of lines."
+This can be run repeatedly to move the current line up a number of lines."
 (interactive "*p")
 ;; Move forward over a line,
 ;; but create a newline if none exists yet.
 (end-of-line)
 (if (eobp)
 (transpose-lines (- arg))
 (forward-line -1))
 (defun transpose-line-down (arg)
 "Move current line one line down, leaving point at beginning of that line.
-This can be run repeatedly to move to current line down a number of lines."
+This can be run repeatedly to move the current line down a number of lines."
 (interactive "*p")
 ;; Move forward over a line,
 ;; but create a newline if none exists yet.
 (end-of-line)
 (if (eobp)
 	      ;; to catch comments a line beginnings
 	      (indent-according-to-mode))))
 (if arg (forward-line 1))
 (setq count (1- count)))))
-(defun comment-region (beg end &optional arg)
+(defun comment-region (start end &optional arg)
 "Comment or uncomment each line in the region.
 With just C-u prefix arg, uncomment each line in region.
 Numeric prefix arg ARG means use ARG comment characters.
 If ARG is negative, delete that many comment characters instead.
 Comments are terminated on each line, even for syntax in which newline does
 ;; comment-end at the end then typing it, C-x C-x, closing it, C-x C-x
 ;; is easy enough.  No option is made here for other than commenting
 ;; every line.
 (interactive "r\nP")
 (or comment-start (error "No comment syntax is defined"))
-(if (> beg end) (let (mid) (setq mid beg beg end end mid)))
+(if (> start end) (let (mid) (setq mid start start end end mid)))
 (save-excursion
 (save-restriction
 (let ((cs comment-start) (ce comment-end)
 	    numarg)
 (if (consp arg) (setq numarg t)
 	  ;; then insert the replicated strings just once.
 	  (while (> numarg 1)
 	    (setq cs (concat cs comment-start)
 		  ce (concat ce comment-end))
 	    (setq numarg (1- numarg))))
-	;; Loop over all lines from BEG to END.
+	;; Loop over all lines from START to END.
-(narrow-to-region beg end)
+(narrow-to-region start end)
-(goto-char beg)
+(goto-char start)
 (while (not (eobp))
 (if (or (eq numarg t) (< numarg 0))
 	      (progn
 		;; Delete comment start from beginning of line.
 		(if (eq numarg t)
 		  (if (save-excursion
 			(skip-chars-backward " \t")
 			(= (point) fill-point))
 		      ;; 1999-09-17 hniksic: turn off Kinsoku until
 		      ;; it's debugged.
-		      (indent-new-comment-line)
+		      (funcall comment-line-break-function)
 		      ;; 97/3/14 jhod: Kinsoku processing
 ;		      ;(indent-new-comment-line)
 ;		      (let ((spacep (memq (char-before (point)) '(?\  ?\t))))
 ;			(funcall comment-line-break-function)
 ;			;; if user type space explicitly, leave SPC
 "Automatically break line at a previous space, in insertion of text."
 nil)
 (defun turn-on-auto-fill ()
 "Unconditionally turn on Auto Fill mode."
+(interactive)
 (auto-fill-mode 1))
 (defun set-fill-column (arg)
 "Set `fill-column' to specified argument.
 Just \\[universal-argument] as argument means to use the current column
 	     ))))
 (setq selective-display nil))
 (add-hook 'change-major-mode-hook 'nuke-selective-display)
-(defconst overwrite-mode-textual (purecopy " Ovwrt")
+(defconst overwrite-mode-textual " Ovwrt"
 "The string displayed in the mode line when in overwrite mode.")
-(defconst overwrite-mode-binary (purecopy " Bin Ovwrt")
+(defconst overwrite-mode-binary " Bin Ovwrt"
 "The string displayed in the mode line when in binary overwrite mode.")
 (defun overwrite-mode (arg)
 "Toggle overwrite mode.
-With arg, turn overwrite mode on iff arg is positive.
+With arg, enable overwrite mode if arg is positive, else disable.
 In overwrite mode, printing characters typed in replace existing text
 on a one-for-one basis, rather than pushing it to the right.  At the
 end of a line, such characters extend the line.  Before a tab,
 such characters insert until the tab is filled in.
 \\[quoted-insert] still inserts characters in overwrite mode; this
 	    'overwrite-mode-textual))
 (redraw-modeline))
 (defun binary-overwrite-mode (arg)
 "Toggle binary overwrite mode.
-With arg, turn binary overwrite mode on iff arg is positive.
+With arg, enable binary overwrite mode if arg is positive, else disable.
 In binary overwrite mode, printing characters typed in replace
 existing text.  Newlines are not treated specially, so typing at the
 end of a line joins the line to the next, with the typed character
 between them.  Typing before a tab character simply replaces the tab
 with the character typed.
 :type 'boolean
 :group 'editing-basics)
 (defun line-number-mode (arg)
 "Toggle Line Number mode.
-With arg, turn Line Number mode on iff arg is positive.
+With arg, enable Line Number mode if arg is positive, else disable.
 When Line Number mode is enabled, the line number appears
 in the mode line."
 (interactive "P")
 (setq line-number-mode
 	(if (null arg) (not line-number-mode)
 :type 'boolean
 :group 'editing-basics)
 (defun column-number-mode (arg)
 "Toggle Column Number mode.
-With arg, turn Column Number mode on iff arg is positive.
+With arg, enable Column Number mode if arg is positive, else disable.
 When Column Number mode is enabled, the column number appears
 in the mode line."
 (interactive "P")
 (setq column-number-mode
 	(if (null arg) (not column-number-mode)
 (defun debug-print (format &rest args)
 "Send a string to the debugging output.
 The string is formatted using (apply #'format FORMAT ARGS)."
 (princ (apply #'format format args) 'external-debugging-output))
 ;;; simple.el ends here

Mercurial > hg > xemacs-beta

comparison lisp/simple.el @ 444:576fb035e263 r21-2-37