[nongnu] elpa/goto-chg 494cfa1 02/27: Clean up whitespace

[Philip Kaludercic]

branch: elpa/goto-chg
commit 494cfa10a6fad7e2f5ae316588a6c32962ee9ff1
Author: Vasilij Schneidermann <mail@vasilij.de>
Commit: Vasilij Schneidermann <mail@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))