branch: elpa/goto-chg
commit 494cfa10a6fad7e2f5ae316588a6c32962ee9ff1
Author: Vasilij Schneidermann <m...@vasilij.de>
Commit: Vasilij Schneidermann <m...@vasilij.de>
Clean up whitespace
---
goto-chg.el | 196 ++++++++++++++++++++++++++++++------------------------------
1 file changed, 98 insertions(+), 98 deletions(-)
diff --git a/goto-chg.el b/goto-chg.el
index 5091d63..71e5501 100644
--- a/goto-chg.el
+++ b/goto-chg.el
@@ -69,7 +69,7 @@
;;todo: Rename "goto-chg.el" -> "gotochange.el" or "goto-chgs" ?
;;todo: Rename function goto-last-change -> goto-last-edit ?
;;todo: Rename adjective "-last-" -> "-latest-" or "-most-recent-" ?
-;;todo: There are some, maybe useful, funcs for region undo
+;;todo: There are some, maybe useful, funcs for region undo
;; in simple.el in emacs 20. Take a look.
;;todo: Add functionality to visit changed point in text order, not only in
;; chronological order. (Naa, highlight-changes-mode does that).
@@ -100,10 +100,10 @@ Optional third argument is the replacement, which
defaults to \"...\"."
str
;; else
(let* ((lipsis (or ellipsis "..."))
- (i (/ (- maxlen (length lipsis)) 2)))
+ (i (/ (- maxlen (length lipsis)) 2)))
(concat (substring str 0 i)
- lipsis
- (substring str (- i))))))
+ lipsis
+ (substring str (- i))))))
(defun glc-adjust-pos2 (pos p1 p2 adj)
;; Helper function to glc-adjust-pos
@@ -111,13 +111,13 @@ Optional third argument is the replacement, which
defaults to \"...\"."
;; adj: amount of text added (positive) or removed (negativ) by the edit
;; Return pos if well before p1, or pos+adj if well after p2, or nil if too
close
(cond ((<= pos (- p1 glc-current-span))
- pos)
- ((> pos (+ p2 glc-current-span))
- (+ pos adj))
- ((zerop glc-current-span)
- p1)
- (t
- nil)))
+ pos)
+ ((> pos (+ p2 glc-current-span))
+ (+ pos adj))
+ ((zerop glc-current-span)
+ p1)
+ (t
+ nil)))
(defun glc-adjust-pos (pos e)
"Given POS, a buffer position before the edit E, compute and return
@@ -126,16 +126,16 @@ Exception: return nil if POS is closer than
`glc-current-span' to the edit E.
\nInsertion edits before POS returns a larger value.
Deletion edits before POS returns a smaller value.
\nThe edit E is an entry from the `buffer-undo-list'. See for details."
- (cond ((atom e) ; nil==cmd boundary, or, num==changed
pos
- pos)
- ((numberp (car e)) ; (beg . end)==insertion
- (glc-adjust-pos2 pos (car e) (car e) (- (cdr e) (car e))))
- ((stringp (car e)) ; (string . pos)==deletion
- (glc-adjust-pos2 pos (abs (cdr e)) (+ (abs (cdr e)) (length (car e)))
(- (length (car e)))))
- ((null (car e)) ; (nil prop val beg . end)==prop change
- (glc-adjust-pos2 pos (nth 3 e) (nthcdr 4 e) 0))
- (t ; (marker . dist)==marker moved
- pos)))
+ (cond ((atom e) ; nil==cmd boundary, or, num==changed
pos
+ pos)
+ ((numberp (car e)) ; (beg . end)==insertion
+ (glc-adjust-pos2 pos (car e) (car e) (- (cdr e) (car e))))
+ ((stringp (car e)) ; (string . pos)==deletion
+ (glc-adjust-pos2 pos (abs (cdr e)) (+ (abs (cdr e)) (length (car e)))
(- (length (car e)))))
+ ((null (car e)) ; (nil prop val beg . end)==prop change
+ (glc-adjust-pos2 pos (nth 3 e) (nthcdr 4 e) 0))
+ (t ; (marker . dist)==marker moved
+ pos)))
;; If recursive in stead of iterative (while), it tends to fill the call stack.
;; (Isn't it tail optimized?)
@@ -148,12 +148,12 @@ or nil if the point was closer than `glc-current-span' to
some edit in R.
(if r
;; Get pos
(let ((pos (glc-get-pos (car r))))
- (setq r (cdr r))
- ;; Walk back in reverse list
- (while (and r pos)
- (setq pos (glc-adjust-pos pos (car r))
- r (cdr r)))
- pos)
+ (setq r (cdr r))
+ ;; Walk back in reverse list
+ (while (and r pos)
+ (setq pos (glc-adjust-pos pos (car r))
+ r (cdr r)))
+ pos)
;; else
nil))
@@ -161,35 +161,35 @@ or nil if the point was closer than `glc-current-span' to
some edit in R.
"If E represents an edit, return a position value in E, the position
where the edit took place. Return nil if E represents no real change.
\nE is an entry in the buffer-undo-list."
- (cond ((numberp e) e) ; num==changed position
- ((atom e) nil) ; nil==command boundary
- ((numberp (car e)) (cdr e)) ; (beg . end)==insertion
- ((stringp (car e)) (abs (cdr e))) ; (string . pos)==deletion
- ((null (car e)) (nthcdr 4 e)) ; (nil ...)==text property change
- ((atom (car e)) nil) ; (t ...)==file modification time
- (t nil))) ; (marker ...)==marker moved
+ (cond ((numberp e) e) ; num==changed position
+ ((atom e) nil) ; nil==command boundary
+ ((numberp (car e)) (cdr e)) ; (beg . end)==insertion
+ ((stringp (car e)) (abs (cdr e))) ; (string . pos)==deletion
+ ((null (car e)) (nthcdr 4 e)) ; (nil ...)==text property change
+ ((atom (car e)) nil) ; (t ...)==file modification time
+ (t nil))) ; (marker ...)==marker moved
(defun glc-get-descript (e &optional n)
"If E represents an edit, return a short string describing E.
Return nil if E represents no real change.
\nE is an entry in the buffer-undo-list."
(let ((nn (or (format "T-%d: " n) "")))
- (cond ((numberp e) "New position") ; num==changed position
- ((atom e) nil) ; nil==command boundary
- ((numberp (car e)) ; (beg . end)==insertion
- (if (and n (< n 2))
- (format "%sInserted %d chars \"%s\"" nn (- (cdr e) (car e))
- (glc-center-ellipsis (buffer-substring (car e) (cdr e))
60))
- ;; else
- ;; An older insert. The inserted text cannot easily be computed.
- ;; Just show the char count.
- (format "%sInserted %d chars" nn (- (cdr e) (car e)))))
- ((stringp (car e)) ; (string . pos)==deletion
- (format "%sDeleted \"%s\"" nn (glc-center-ellipsis (car e) 60)))
- ((null (car e)) ; (nil ...)==text property change
- (format "%sProperty change" nn))
- ((atom (car e)) nil) ; (t ...)==file modification time
- (t nil)))) ; (marker ...)==marker moved
+ (cond ((numberp e) "New position") ; num==changed position
+ ((atom e) nil) ; nil==command boundary
+ ((numberp (car e)) ; (beg . end)==insertion
+ (if (and n (< n 2))
+ (format "%sInserted %d chars \"%s\"" nn (- (cdr e) (car e))
+ (glc-center-ellipsis (buffer-substring (car e) (cdr e))
60))
+ ;; else
+ ;; An older insert. The inserted text cannot easily be computed.
+ ;; Just show the char count.
+ (format "%sInserted %d chars" nn (- (cdr e) (car e)))))
+ ((stringp (car e)) ; (string . pos)==deletion
+ (format "%sDeleted \"%s\"" nn (glc-center-ellipsis (car e) 60)))
+ ((null (car e)) ; (nil ...)==text property change
+ (format "%sProperty change" nn))
+ ((atom (car e)) nil) ; (t ...)==file modification time
+ (t nil)))) ; (marker ...)==marker moved
(defun glc-is-positionable (e)
"Return non-nil if E is an insertion, deletion or text property change.
@@ -224,72 +224,72 @@ At times, when undo information becomes too large, the
oldest information is
discarded. See variable `undo-limit'."
(interactive "P")
(cond ((not (eq this-command last-command))
- ;; Start a glc sequence
- ;; Don't go to current point if last command was an obvious edit
- ;; (yank or self-insert, but not kill-region). Makes it easier to
- ;; jump back and forth when copying seleced lines.
- (setq glc-probe-depth (if (memq last-command '(yank
self-insert-command)) 1 0)
- glc-direction 1
- glc-current-span glc-default-span)
- (if (< (prefix-numeric-value arg) 0)
- (error "Negative arg: Cannot reverse as the first operation"))))
+ ;; Start a glc sequence
+ ;; Don't go to current point if last command was an obvious edit
+ ;; (yank or self-insert, but not kill-region). Makes it easier to
+ ;; jump back and forth when copying seleced lines.
+ (setq glc-probe-depth (if (memq last-command '(yank
self-insert-command)) 1 0)
+ glc-direction 1
+ glc-current-span glc-default-span)
+ (if (< (prefix-numeric-value arg) 0)
+ (error "Negative arg: Cannot reverse as the first operation"))))
(cond ((null buffer-undo-list)
- (error "Buffer has not been changed"))
- ((eq buffer-undo-list t)
- (error "No change info (undo is disabled)")))
- (cond ((numberp arg) ; Numeric arg sets span
- (setq glc-current-span (abs arg)))
- ((consp arg) ; C-u's multiply previous span by 4
- (setq glc-current-span (* (abs (car arg)) glc-default-span))
- (message "Current span is %d chars" glc-current-span))) ;todo: keep
message with "waiting" and "is saved"
+ (error "Buffer has not been changed"))
+ ((eq buffer-undo-list t)
+ (error "No change info (undo is disabled)")))
+ (cond ((numberp arg) ; Numeric arg sets span
+ (setq glc-current-span (abs arg)))
+ ((consp arg) ; C-u's multiply previous span by 4
+ (setq glc-current-span (* (abs (car arg)) glc-default-span))
+ (message "Current span is %d chars" glc-current-span))) ;todo: keep
message with "waiting" and "is saved"
(cond ((< (prefix-numeric-value arg) 0)
- (setq glc-direction -1))
- (t
- (setq glc-direction 1)))
- (let (rev ; Reversed (and filtered) undo list
- pos ; The pos we look for, nil until found
- (n 0) ; Steps in undo list (length of 'rev')
- (l buffer-undo-list)
- (passed-save-entry (not (buffer-modified-p)))
- (new-probe-depth glc-probe-depth))
+ (setq glc-direction -1))
+ (t
+ (setq glc-direction 1)))
+ (let (rev ; Reversed (and filtered) undo list
+ pos ; The pos we look for, nil until found
+ (n 0) ; Steps in undo list (length of 'rev')
+ (l buffer-undo-list)
+ (passed-save-entry (not (buffer-modified-p)))
+ (new-probe-depth glc-probe-depth))
;; Walk back and forth in the buffer-undo-list, each time one step deeper,
;; until we can walk back the whole list with a 'pos' that is not coming
;; too close to another edit.
(while (null pos)
(setq new-probe-depth (+ new-probe-depth glc-direction))
(if (< glc-direction 0)
- (setq rev ()
- n 0
- l buffer-undo-list
- passed-save-entry (not (buffer-modified-p))))
+ (setq rev ()
+ n 0
+ l buffer-undo-list
+ passed-save-entry (not (buffer-modified-p))))
(if (< new-probe-depth 1)
- (error "No later change info"))
+ (error "No later change info"))
(if (> n 150)
- (message "working..."))
+ (message "working..."))
;; Walk forward in buffer-undo-list, glc-probe-depth steps.
;; Build reverse list along the way
(while (< n new-probe-depth)
- (cond ((null l)
- ;(setq this-command t) ; Disrupt repeat sequence
- (error "No further change info"))
- ((glc-is-positionable (car l))
- (setq n (1+ n)
- rev (cons (car l) rev)))
- ((or passed-save-entry (glc-is-filetime (car l)))
- (setq passed-save-entry t)))
- (setq l (cdr l)))
+ (cond ((null l)
+ ;(setq this-command t) ; Disrupt repeat sequence
+ (error "No further change info"))
+ ((glc-is-positionable (car l))
+ (setq n (1+ n)
+ rev (cons (car l) rev)))
+ ((or passed-save-entry (glc-is-filetime (car l)))
+ (setq passed-save-entry t)))
+ (setq l (cdr l)))
;; Walk back in reverse list, from older to newer edits.
;; Adjusting pos along the way.
(setq pos (glc-adjust-list rev)))
;; Found a place not previously visited, in 'pos'.
;; (An error have been issued if nothing (more) found.)
(if (> n 150)
- (message nil)) ; remove message "working..."
+ (message nil)) ; remove message "working..."
(if (and (= glc-current-span 0) (glc-get-descript (car rev) n))
- (message "%s" (glc-get-descript (car rev) n))
+ (message "%s" (glc-get-descript (car rev) n))
;; else
(if passed-save-entry
- (message "(This change is saved)")))
+ (message "(This change is saved)")))
(setq glc-probe-depth new-probe-depth)
(goto-char pos)))
@@ -300,12 +300,12 @@ See `goto-last-change' for use of prefix argument."
(interactive "P")
;; Negate arg, all kinds
(cond ((eq arg nil) (setq arg '-))
- ((eq arg '-) (setq arg nil))
- ((listp arg) (setq arg (list (- (car arg)))))
- (t (setq arg (- arg))))
+ ((eq arg '-) (setq arg nil))
+ ((listp arg) (setq arg (list (- (car arg)))))
+ (t (setq arg (- arg))))
;; Make 'goto-last-change-reverse' look like 'goto-last-change'
(cond ((eq last-command this-command)
- (setq last-command 'goto-last-change)))
+ (setq last-command 'goto-last-change)))
(setq this-command 'goto-last-change)
;; Call 'goto-last-change' to do the job
(goto-last-change arg))
