Convert uses of looking-at in viper-ex to following-char

* lisp/emulation/viper-ex.el (viper-get-ex-token): Bind
(following-char) and use it in the subsequent cond's clauses.
(viper-ex, ex-quit, viper-get-ex-file): Use following-char instead.
Convert single branch ifs to when

1 files changed, 47 insertions, 52 deletions

diff --git a/lisp/emulation/viper-ex.el b/lisp/emulation/viper-ex.el
index ca067033e63..185cf990f76 100644
--- a/lisp/emulation/viper-ex.el
+++ b/lisp/emulation/viper-ex.el
@@ -401,13 +401,14 @@ reversed."
     (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
     (set-buffer viper-ex-work-buf)
     (skip-chars-forward " \t|")
-    (let ((case-fold-search t))
-      (cond ((looking-at "#")
+    (let ((case-fold-search t)
+          (char (following-char)))
+      (cond ((= char ?#)
              (setq ex-token-type 'command)
-             (setq ex-token (char-to-string (following-char)))
+             (setq ex-token (char-to-string char))
              (forward-char 1))
             ((looking-at "[a-z]") (viper-get-ex-com-subr))
-            ((looking-at "\\.")
+            ((= char ?.)
              (forward-char 1)
              (setq ex-token-type 'dot))
             ((looking-at "[0-9]")
@@ -419,13 +420,13 @@ reversed."
                          (t 'abs-number)))
              (setq ex-token
                    (string-to-number (buffer-substring (point) (mark t)))))
-            ((looking-at "\\$")
+            ((= char ?$)
              (forward-char 1)
              (setq ex-token-type 'end))
-            ((looking-at "%")
+            ((= char ?%)
              (forward-char 1)
              (setq ex-token-type 'whole))
-            ((looking-at "+")
+            ((= char ?+)
              (cond ((or (looking-at "+[-+]") (looking-at "+[\n|]"))
                     (forward-char 1)
                     (insert "1")
@@ -436,7 +437,7 @@ reversed."
                     (setq ex-token-type 'plus))
                    (t
                     (error viper-BadAddress))))
-            ((looking-at "-")
+            ((= char ?-)
              (cond ((or (looking-at "-[-+]") (looking-at "-[\n|]"))
                     (forward-char 1)
                     (insert "1")
@@ -447,7 +448,7 @@ reversed."
                     (setq ex-token-type 'minus))
                    (t
                     (error viper-BadAddress))))
-            ((looking-at "/")
+            ((= char ?/)
              (forward-char 1)
              (set-mark (point))
              (let ((cont t))
@@ -459,9 +460,9 @@ reversed."
                      (setq cont nil))))
              (backward-char 1)
              (setq ex-token (buffer-substring (point) (mark t)))
-             (if (looking-at "/") (forward-char 1))
+             (when (= (following-char) ?/) (forward-char 1))
              (setq ex-token-type 'search-forward))
-            ((looking-at "\\?")
+            ((= char ??)
              (forward-char 1)
              (set-mark (point))
              (let ((cont t))
@@ -472,27 +473,27 @@ reversed."
                                         (line-beginning-position 0)))
                      (setq cont nil))
                  (backward-char 1)
-                 (if (not (looking-at "\n")) (forward-char 1))))
+                 (when (/= (following-char) ?\n) (forward-char 1))))
              (setq ex-token-type 'search-backward)
              (setq ex-token (buffer-substring (1- (point)) (mark t))))
-            ((looking-at ",")
+            ((= char ?,)
              (forward-char 1)
              (setq ex-token-type 'comma))
-            ((looking-at ";")
+            ((= char ?\;)
              (forward-char 1)
              (setq ex-token-type 'semi-colon))
             ((looking-at "[!=><&~]")
              (setq ex-token-type 'command)
-             (setq ex-token (char-to-string (following-char)))
+             (setq ex-token (char-to-string char))
              (forward-char 1))
-            ((looking-at "'")
+            ((= char ?\')
              (setq ex-token-type 'goto-mark)
              (forward-char 1)
-             (cond ((looking-at "'") (setq ex-token nil))
+             (cond ((= (following-char) ?\') (setq ex-token nil))
                    ((looking-at "[a-z]") (setq ex-token (following-char)))
                    (t (error "%s" "Marks are ' and a-z")))
              (forward-char 1))
-            ((looking-at "\n")
+            ((= char ?\n)
              (setq ex-token-type 'end-mark)
              (setq ex-token "goto"))
             (t
@@ -687,9 +688,9 @@ reversed."
                            (get-buffer-create viper-ex-work-buf-name))
                      (set-buffer viper-ex-work-buf)
                      (skip-chars-forward " \t")
-                     (cond ((looking-at "|")
+                     (cond ((= (following-char) ?|)
                             (forward-char 1))
-                           ((looking-at "\n")
+                           ((= (following-char) ?\n)
                             (setq cont nil))
                            (t (error
                                "`%s': %s" ex-token viper-SpuriousText)))
@@ -994,33 +995,31 @@ reversed."
       (with-current-buffer (setq viper-ex-work-buf
                                  (get-buffer-create viper-ex-work-buf-name))
         (skip-chars-forward " \t")
-        (if (looking-at "!")
-            (if (and (not (looking-back "[ \t]" (1- (point))))
-                     ;; read doesn't have a corresponding :r! form, so ! is
-                     ;; immediately interpreted as a shell command.
-                     (not (string= ex-token "read")))
-                (progn
-                  (setq ex-variant t)
-                  (forward-char 1)
-                  (skip-chars-forward " \t"))
-              (setq ex-cmdfile t)
-              (forward-char 1)
-              (skip-chars-forward " \t")))
-        (if (looking-at ">>")
-            (progn
-              (setq ex-append t
-                    ex-variant t)
-              (forward-char 2)
-              (skip-chars-forward " \t")))
-        (if (looking-at "+")
-            (progn
-              (forward-char 1)
-              (set-mark (point))
-              (re-search-forward "[ \t\n]")
-              (backward-char 1)
-              (setq ex-offset (buffer-substring (point) (mark t)))
-              (forward-char 1)
-              (skip-chars-forward " \t")))
+        (when (= (following-char) ?!)
+          (if (and (not (memq (preceding-char) '(?\s ?\t)))
+                   ;; read doesn't have a corresponding :r! form, so ! is
+                   ;; immediately interpreted as a shell command.
+                   (not (string= ex-token "read")))
+              (progn
+                (setq ex-variant t)
+                (forward-char 1)
+                (skip-chars-forward " \t"))
+            (setq ex-cmdfile t)
+            (forward-char 1)
+            (skip-chars-forward " \t")))
+        (when (looking-at ">>")
+          (setq ex-append t
+                ex-variant t)
+          (forward-char 2)
+          (skip-chars-forward " \t"))
+        (when (= (following-char) ?+)
+          (forward-char 1)
+          (set-mark (point))
+          (re-search-forward "[ \t\n]")
+          (backward-char 1)
+          (setq ex-offset (buffer-substring (point) (mark t)))
+          (forward-char 1)
+          (skip-chars-forward " \t"))
         ;; this takes care of :r, :w, etc., when they get file names
         ;; from the history list
         (if (member ex-token '("read" "write" "edit" "visual" "next"))
@@ -1602,7 +1601,7 @@ reversed."
   ;; skip "!", if it is q!.  In Viper q!, w!, etc., behave as q, w, etc.
   (with-current-buffer (setq viper-ex-work-buf
                              (get-buffer-create viper-ex-work-buf-name))
-    (if (looking-at "!") (forward-char 1)))
+    (when (= (following-char) ?!) (forward-char 1)))
   (if (< viper-expert-level 3)
       (save-buffers-kill-emacs)
     (kill-buffer (current-buffer))))
@@ -2322,8 +2321,4 @@ Type `mak ' (including the space) to run make with no args."
       (with-output-to-temp-buffer " *viper-info*"
         (princ lines))))))
 
-
-
-
-
 ;;; viper-ex.el ends here