xemacs-beta: lisp/bytecomp.el comparison

comparison lisp/bytecomp.el @ 5473:ac37a5f7e5be

Merge with trunk.

author	Mats Lidell <matsl@xemacs.org>
date	Thu, 17 Mar 2011 23:42:59 +0100
parents	e79980ee5efe d967d96ca043
children	4dee0387b9de

comparison

equal deleted inserted replaced

-:e79980ee5efe
+:ac37a5f7e5be
 (byte-defop-compiler numberp		1)
 (byte-defop-compiler fixnump		1)
 (byte-defop-compiler skip-chars-forward     1-2+1)
 (byte-defop-compiler skip-chars-backward    1-2+1)
 (byte-defop-compiler eq			2)
-(byte-defop-compiler20 old-eq 	 	2)
+; (byte-defop-compiler20 old-eq 	 	2)
-(byte-defop-compiler20 old-memq		2)
+; (byte-defop-compiler20 old-memq		2)
 (byte-defop-compiler cons		2)
 (byte-defop-compiler aref		2)
 (byte-defop-compiler get		2+1)
 (byte-defop-compiler nth		2)
 (byte-defop-compiler subseq byte-compile-subseq)
 (byte-defop-compiler downcase		1+1)
 (byte-defop-compiler string=		2)
 (byte-defop-compiler string<		2)
 (byte-defop-compiler (string-equal byte-string=) 2)
 (byte-defop-compiler (string-lessp byte-string<) 2)
-(byte-defop-compiler20 old-equal	2)
+; (byte-defop-compiler20 old-equal	2)
 (byte-defop-compiler nthcdr		2)
 (byte-defop-compiler elt		2)
 (byte-defop-compiler20 old-member	2)
 (byte-defop-compiler20 old-assq		2)
 (byte-defop-compiler (rplaca byte-setcar) 2)
 (defun byte-compile-warn-wrong-args (form n)
 (when (memq 'subr-callargs byte-compile-warnings)
 (byte-compile-warn "%s called with %d arg%s, but requires %s"
 		       (car form) (length (cdr form))
-		       (if (= 1 (length (cdr form))) "" "s") n)))
+		       (if (eql 1 (length (cdr form))) "" "s") n)))
 (defun byte-compile-subr-wrong-args (form n)
 (byte-compile-warn-wrong-args form n)
 ;; get run-time wrong-number-of-args error.
 (byte-compile-normal-call form))
 (t     (byte-compile-subr-wrong-args form "1-3"))))
 ;; XEmacs: used for functions that have a different opcode in v19 than v20.
 ;; this includes `eq', `equal', and other old-ified functions.
 (defun byte-compile-two-args-19->20 (form)
-(if (not (= (length form) 3))
+(if (not (eql (length form) 3))
 (byte-compile-subr-wrong-args form 2)
 (byte-compile-form (car (cdr form)))  ;; Push the arguments
 (byte-compile-form (nth 2 form))
 (if (byte-compile-version-cond byte-compile-emacs19-compatibility)
 	(byte-compile-out (get (car form) 'byte-opcode19) 0)
 (defun byte-compile-list (form)
 (let* ((args (cdr form))
 	 (nargs (length args)))
 (cond
-((= nargs 0)
+((eql nargs 0)
 (byte-compile-constant nil))
 ((< nargs 5)
 (mapc 'byte-compile-form args)
 (byte-compile-out
 (aref [byte-list1 byte-list2 byte-list3 byte-list4] (1- nargs))
 (defun byte-compile-beginning-of-line (form)
 (let ((len (length form)))
 (cond ((> len 3)
 	   (byte-compile-subr-wrong-args form "0-2"))
-	  ((or (= len 3) (not (byte-compile-constp (nth 1 form))))
+	  ((or (eql len 3) (not (byte-compile-constp (nth 1 form))))
 	   (byte-compile-normal-call form))
 	  (t
 	   (byte-compile-form
 	    (list 'forward-line
 		  (if (integerp (setq form (or (eval (nth 1 form)) 1)))
 (defun byte-compile-set-default (form)
 (let* ((args (cdr form))
 	 (nargs (length args))
 	 (var (car args)))
-(when (and (= (safe-length var) 2)
+(when (and (eql (safe-length var) 2) (eq (car var) 'quote))
-	       (eq (car var) 'quote))
 (let ((sym (nth 1 var)))
 	(cond
 	 ((not (symbolp sym))
 	  (byte-compile-warn "Attempt to set-globally non-symbol %s" sym))
 	 ((byte-compile-constant-symbol-p sym)
 	 ((not (memq 'free-vars byte-compile-warnings))) ; warnings suppressed?
 	 ((memq sym byte-compile-free-assignments)) ; already warned about sym
 	 (t
 	  (byte-compile-warn "assignment to free variable %s" sym)
 	  (push sym byte-compile-free-assignments)))))
-(if (= nargs 2)
+(if (eql nargs 2)
 	;; now emit a normal call to set-default
 	(byte-compile-normal-call form)
 (byte-compile-subr-wrong-args form 2))))
 (setq form (cdr form))
 (byte-compile-form-do-effect (pop form))
 (byte-compile-body form t))
 (defun byte-compile-values (form)
-(if (= 2 (length form))
+(if (eql 2 (length form))
 (if (byte-compile-constp (second form))
 	  (byte-compile-form-do-effect (second form))
 	;; #'or compiles to bytecode, #'values doesn't:
 	(byte-compile-form-do-effect `(or ,(second form) nil)))
 (byte-compile-normal-call form)))
 (defun byte-compile-values-list (form)
-(if (and (= 2 (length form))
+(if (and (eql 2 (length form))
 (or (null (second form))
 (and (consp (second form))
 (eq (car (second form))
 'quote)
 (not (symbolp (car-safe (cdr (second form))))))))
 ;; (except that earlier 21.5 with bignum support will confuse Bfixnump and
 ;; Bintegerp; which it did in dealing with byte-compiled code from 21.4
 ;; anyway).
 (defun byte-compile-integerp (form)
-(if (/= 2 (length form))
+(if (not (eql (length form) 2))
 (byte-compile-subr-wrong-args form 1)
 (let ((donetag (byte-compile-make-tag))
 	  (wintag (byte-compile-make-tag))
 	  (failtag (byte-compile-make-tag)))
 (byte-compile-constant 'integerp)
 (pushnew '(subrp (symbol-function 'multiple-value-call))
 byte-compile-checks-on-load
 :test #'equal)))
 (defun byte-compile-multiple-value-list-internal (form)
-(if (/= 4 (length form))
+(if (not (eql 4 (length form)))
 (progn
 (byte-compile-warn-wrong-args form 3)
 (byte-compile-normal-call
 `(signal 'wrong-number-of-arguments '(,(car form)
 ,(length (cdr form))))))
 ;; the form does not have two args, it tries to #'funcall it expecting a
 ;; runtime wrong-number-of-arguments error. Now that #'throw is a special
 ;; form, it provokes an invalid-function error instead (or at least it
 ;; should; there's a kludge around for the moment in eval.c that avoids
 ;; that, but this file should not assume that that will always be there).
-(if (/= 2 (length (cdr form)))
+(if (not (eql 2 (length (cdr form))))
 (progn
 (byte-compile-warn-wrong-args form 2)
 (byte-compile-normal-call
 `(signal 'wrong-number-of-arguments '(,(car form)
 ,(length (cdr form))))))

Mercurial > hg > xemacs-beta

comparison lisp/bytecomp.el @ 5473:ac37a5f7e5be