master 93eccb5e040 1/3: Better compilation of char-before, backward-char and backward-word

[Mattias Engdegård]

branch: master
commit 93eccb5e040c8fff4c4527819888e01683df5aaa
Author: Mattias Engdegård <mattiase@acm.org>
Commit: Mattias Engdegård <mattiase@acm.org>

    Better compilation of char-before, backward-char and backward-word
    
    Implement char-before, backward-char and backward-word as compiler
    macros instead of byte-compile handlers so that the source-level
    optimiser gets to simplify the result.  In particular, this removes
    some branches.
    
    * lisp/emacs-lisp/bytecomp.el (byte-compile-char-before)
    (byte-compile-backward-char, byte-compile-backward-word): Remove.
    (bytecomp--char-before, bytecomp--backward-char)
    (bytecomp--backward-word): New.
---
 lisp/emacs-lisp/bytecomp.el | 59 +++++++++++++++++----------------------------
 1 file changed, 22 insertions(+), 37 deletions(-)

diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 489a9724fc4..5b1d958e6c2 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -4306,9 +4306,6 @@ This function is never called when `lexical-binding' is 
nil."
 
 ;; more complicated compiler macros
 
-(byte-defop-compiler char-before)
-(byte-defop-compiler backward-char)
-(byte-defop-compiler backward-word)
 (byte-defop-compiler list)
 (byte-defop-compiler concat)
 (byte-defop-compiler (indent-to-column byte-indent-to) byte-compile-indent-to)
@@ -4319,40 +4316,6 @@ This function is never called when `lexical-binding' is 
nil."
 (byte-defop-compiler (/ byte-quo) byte-compile-quo)
 (byte-defop-compiler nconc)
 
-;; Is this worth it?  Both -before and -after are written in C.
-(defun byte-compile-char-before (form)
-  (cond ((or (= 1 (length form))
-            (and (= 2 (length form)) (not (nth 1 form))))
-        (byte-compile-form '(char-after (1- (point)))))
-       ((= 2 (length form))
-        (byte-compile-form (list 'char-after (if (numberp (nth 1 form))
-                                                 (1- (nth 1 form))
-                                               `(1- (or ,(nth 1 form)
-                                                        (point)))))))
-       (t (byte-compile-subr-wrong-args form "0-1"))))
-
-;; backward-... ==> forward-... with negated argument.
-;; Is this worth it?  Both -backward and -forward are written in C.
-(defun byte-compile-backward-char (form)
-  (cond ((or (= 1 (length form))
-            (and (= 2 (length form)) (not (nth 1 form))))
-        (byte-compile-form '(forward-char -1)))
-       ((= 2 (length form))
-        (byte-compile-form (list 'forward-char (if (numberp (nth 1 form))
-                                                   (- (nth 1 form))
-                                                 `(- (or ,(nth 1 form) 1))))))
-       (t (byte-compile-subr-wrong-args form "0-1"))))
-
-(defun byte-compile-backward-word (form)
-  (cond ((or (= 1 (length form))
-            (and (= 2 (length form)) (not (nth 1 form))))
-        (byte-compile-form '(forward-word -1)))
-       ((= 2 (length form))
-        (byte-compile-form (list 'forward-word (if (numberp (nth 1 form))
-                                                   (- (nth 1 form))
-                                                 `(- (or ,(nth 1 form) 1))))))
-       (t (byte-compile-subr-wrong-args form "0-1"))))
-
 (defun byte-compile-list (form)
   (let ((count (length (cdr form))))
     (cond ((= count 0)
@@ -5797,6 +5760,28 @@ and corresponding effects."
 (put 'remq  'compiler-macro #'bytecomp--check-memq-args)
 (put 'delq  'compiler-macro #'bytecomp--check-memq-args)
 
+;; Implement `char-before', `backward-char' and `backward-word' in
+;; terms of `char-after', `forward-char' and `forward-word' which have
+;; their own byte-ops.
+
+(put 'char-before 'compiler-macro #'bytecomp--char-before)
+(defun bytecomp--char-before (form &optional arg &rest junk-args)
+  (if junk-args
+      form    ; arity error
+    `(char-after (1- (or ,arg (point))))))
+
+(put 'backward-char 'compiler-macro #'bytecomp--backward-char)
+(defun bytecomp--backward-char (form &optional arg &rest junk-args)
+  (if junk-args
+      form    ; arity error
+    `(forward-char (- (or ,arg 1)))))
+
+(put 'backward-word 'compiler-macro #'bytecomp--backward-word)
+(defun bytecomp--backward-word (form &optional arg &rest junk-args)
+  (if junk-args
+      form    ; arity error
+    `(forward-word (- (or ,arg 1)))))
+
 (provide 'byte-compile)
 (provide 'bytecomp)