4 files changed, 41 insertions, 60 deletions

diff --git a/lisp/emacs-lisp/byte-opt.el b/lisp/emacs-lisp/byte-opt.el
index e00bebc91d5..856a31551df 100644
--- a/lisp/emacs-lisp/byte-opt.el
+++ b/lisp/emacs-lisp/byte-opt.el
@@ -1,6 +1,7 @@
 ;;; byte-opt.el --- the optimization passes of the emacs-lisp byte compiler
 
-;; Copyright (c) 1991,1994,2000,01,02,2004  Free Software Foundation, Inc.
+;; Copyright (c) 1991, 1994, 2000, 2001, 2002, 2004
+;;           Free Software Foundation, Inc.
 
 ;; Author: Jamie Zawinski <jwz@lucid.com>
 ;;      Hallvard Furuseth <hbf@ulrik.uio.no>
@@ -266,7 +267,7 @@
                      (cdr (assq name byte-compile-function-environment)))))
       (if (and (consp fn) (eq (car fn) 'autoload))
           (error "File `%s' didn't define `%s'" (nth 1 fn) name))
-      (if (symbolp fn)
+      (if (and (symbolp fn) (not (eq fn t)))
           (byte-compile-inline-expand (cons fn (cdr form)))
         (if (byte-code-function-p fn)
             (let (string)
@@ -2032,5 +2033,5 @@ If FOR-EFFECT is non-nil, the return value is assumed to be of no importance."
                  byte-optimize-lapcode))))
  nil)
 
-;;; arch-tag: 0f14076b-737e-4bef-aae6-908826ec1ff1
+;; arch-tag: 0f14076b-737e-4bef-aae6-908826ec1ff1
 ;;; byte-opt.el ends here
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 2116cc33b34..ee29039e05e 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -1,7 +1,7 @@
 ;;; bytecomp.el --- compilation of Lisp code into byte code
 
-;; Copyright (C) 1985,86,87,92,94,1998,2000,01,02,03,2004
-;;   Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1986, 1987, 1992, 1994, 1998, 2000, 2001, 2002,
+;;   2003, 2004  Free Software Foundation, Inc.
 
 ;; Author: Jamie Zawinski <jwz@lucid.com>
 ;;      Hallvard Furuseth <hbf@ulrik.uio.no>
@@ -447,7 +447,9 @@ Each element looks like (MACRONAME . DEFINITION).  It is
   "Alist of functions defined in the file being compiled.
 This is so we can inline them when necessary.
 Each element looks like (FUNCTIONNAME . DEFINITION).  It is
-\(FUNCTIONNAME . nil) when a function is redefined as a macro.")
+\(FUNCTIONNAME . nil) when a function is redefined as a macro.
+It is \(FUNCTIONNAME . t) when all we know is that it was defined,
+and we don't know the definition.")
 
 (defvar byte-compile-unresolved-functions nil
   "Alist of undefined functions to which calls have been compiled.
@@ -1103,6 +1105,10 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
 
 ;;; sanity-checking arglists
 
+;; If a function has an entry saying (FUNCTION . t).
+;; that means we know it is defined but we don't know how.
+;; If a function has an entry saying (FUNCTION . nil),
+;; that means treat it as not defined.
 (defun byte-compile-fdefinition (name macro-p)
   (let* ((list (if macro-p
                    byte-compile-macro-environment
@@ -1168,7 +1174,7 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
 (defun byte-compile-callargs-warn (form)
   (let* ((def (or (byte-compile-fdefinition (car form) nil)
                   (byte-compile-fdefinition (car form) t)))
-         (sig (if def
+         (sig (if (and def (not (eq def t)))
                   (byte-compile-arglist-signature
                    (if (eq 'lambda (car-safe def))
                        (nth 1 def)
@@ -1198,7 +1204,7 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
     (byte-compile-format-warn form)
     ;; Check to see if the function will be available at runtime
     ;; and/or remember its arity if it's unknown.
-    (or (and (or sig (fboundp (car form))) ; might be a subr or autoload.
+    (or (and (or def (fboundp (car form))) ; might be a subr or autoload.
              (not (memq (car form) byte-compile-noruntime-functions)))
         (eq (car form) byte-compile-current-form) ; ## this doesn't work
                                         ; with recursion.
@@ -1209,9 +1215,8 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
           (if cons
               (or (memq n (cdr cons))
                   (setcdr cons (cons n (cdr cons))))
-            (setq byte-compile-unresolved-functions
-                  (cons (list (car form) n)
-                        byte-compile-unresolved-functions)))))))
+            (push (list (car form) n)
+                  byte-compile-unresolved-functions))))))
 
 (defun byte-compile-format-warn (form)
   "Warn if FORM is `format'-like with inconsistent args.
@@ -1243,7 +1248,7 @@ extra args."
 ;; number of arguments.
 (defun byte-compile-arglist-warn (form macrop)
   (let ((old (byte-compile-fdefinition (nth 1 form) macrop)))
-    (if old
+    (if (and old (not (eq old t)))
         (let ((sig1 (byte-compile-arglist-signature
                       (if (eq 'lambda (car-safe old))
                           (nth 1 old)
@@ -2123,9 +2128,9 @@ list that represents a doc string reference.
            (eq (car (nth 1 form)) 'quote)
            (consp (cdr (nth 1 form)))
            (symbolp (nth 1 (nth 1 form))))
-      (add-to-list 'byte-compile-function-environment
-                   (cons (nth 1 (nth 1 form))
-                         (cons 'autoload (cdr (cdr form))))))
+      (push (cons (nth 1 (nth 1 form))
+                  (cons 'autoload (cdr (cdr form))))
+            byte-compile-function-environment))
   (if (stringp (nth 3 form))
       form
     ;; No doc string, so we can compile this as a normal form.
@@ -3608,7 +3613,6 @@ being undefined will be suppressed."
 (byte-defop-compiler-1 defconst byte-compile-defvar)
 (byte-defop-compiler-1 autoload)
 (byte-defop-compiler-1 lambda byte-compile-lambda-form)
-(byte-defop-compiler-1 defalias)
 
 (defun byte-compile-defun (form)
   ;; This is not used for file-level defuns with doc strings.
@@ -3710,22 +3714,22 @@ being undefined will be suppressed."
   (error "`lambda' used as function name is invalid"))
 
 ;; Compile normally, but deal with warnings for the function being defined.
-(defun byte-compile-defalias (form)
+(put 'defalias 'byte-hunk-handler 'byte-compile-file-form-defalias)
+(defun byte-compile-file-form-defalias (form)
   (if (and (consp (cdr form)) (consp (nth 1 form))
            (eq (car (nth 1 form)) 'quote)
            (consp (cdr (nth 1 form)))
-           (symbolp (nth 1 (nth 1 form)))
-           (consp (nthcdr 2 form))
-           (consp (nth 2 form))
-           (eq (car (nth 2 form)) 'quote)
-           (consp (cdr (nth 2 form)))
-           (symbolp (nth 1 (nth 2 form))))
-      (progn
+           (symbolp (nth 1 (nth 1 form))))
+      (let ((constant
+             (and (consp (nthcdr 2 form))
+                  (consp (nth 2 form))
+                  (eq (car (nth 2 form)) 'quote)
+                  (consp (cdr (nth 2 form)))
+                  (symbolp (nth 1 (nth 2 form))))))
         (byte-compile-defalias-warn (nth 1 (nth 1 form)))
-        (setq byte-compile-function-environment
-              (cons (cons (nth 1 (nth 1 form))
-                          (nth 1 (nth 2 form)))
-                    byte-compile-function-environment))))
+        (push (cons (nth 1 (nth 1 form))
+                    (if constant (nth 1 (nth 2 form)) t))
+              byte-compile-function-environment)))
   (byte-compile-normal-call form))
 
 ;; Turn off warnings about prior calls to the function being defalias'd.
@@ -3928,7 +3932,7 @@ invoked interactively."
         (while rest
           (or (nth 1 (car rest))
               (null (setq f (car (car rest))))
-              (byte-compile-fdefinition f t)
+              (functionp (byte-compile-fdefinition f t))
               (commandp (byte-compile-fdefinition f nil))
               (setq uncalled (cons f uncalled)))
           (setq rest (cdr rest)))
@@ -4110,5 +4114,5 @@ For example, invoke `emacs -batch -f batch-byte-recompile-directory .'."
 
 (run-hooks 'bytecomp-load-hook)
 
-;;; arch-tag: 9c97b0f0-8745-4571-bfc3-8dceb677292a
+;; arch-tag: 9c97b0f0-8745-4571-bfc3-8dceb677292a
 ;;; bytecomp.el ends here
diff --git a/lisp/emacs-lisp/easymenu.el b/lisp/emacs-lisp/easymenu.el
index 7b18756fd7e..b0f3b9b9d3e 100644
--- a/lisp/emacs-lisp/easymenu.el
+++ b/lisp/emacs-lisp/easymenu.el
@@ -42,25 +42,7 @@ menus, turn this variable off, otherwise it is probably better to keep it on."
   :version "20.3")
 
 (defsubst easy-menu-intern (s)
-  (if (stringp s)
-      (let ((copy (copy-sequence s))
-            (pos 0)
-            found)
-        ;; For each letter that starts a word, flip its case.
-        ;; This way, the usual convention for menu strings (capitalized)
-        ;; corresponds to the usual convention for menu item event types
-        ;; (all lower case).  It's a 1-1 mapping so causes no conflicts.
-        (while (setq found (string-match "\\<\\sw" copy pos))
-          (setq pos (match-end 0))
-          (unless (= (upcase (aref copy found))
-                     (downcase (aref copy found)))
-            (aset copy found
-                  (if (= (upcase (aref copy found))
-                         (aref copy found))
-                      (downcase (aref copy found))
-                    (upcase (aref copy found))))))
-         (intern copy))
-    s))
+  (if (stringp s) (intern s) s))
 
 ;;;###autoload
 (put 'easy-menu-define 'lisp-indent-function 'defun)
@@ -396,6 +378,7 @@ otherwise put the new binding last in MENU.
 BEFORE can be either a string (menu item name) or a symbol
 \(the fake function key for the menu item).
 KEY does not have to be a symbol, and comparison is done with equal."
+  (if (symbolp menu) (setq menu (indirect-function menu)))
   (let ((inserted (null item))          ; Fake already inserted.
         tail done)
     (while (not done)
@@ -437,8 +420,7 @@ ITEM should be a keymap binding of the form (KEY . MENU-ITEM)."
                   (error nil))          ;`item' might not be a proper list.
                 ;; Also check the string version of the symbol name,
                 ;; for backwards compatibility.
-                (eq (car-safe item) (intern name))
-                (eq (car-safe item) (easy-menu-intern name)))))))
+                (eq (car-safe item) (intern name)))))))
 
 (defun easy-menu-always-true-p (x)
   "Return true if form X never evaluates to nil."
@@ -541,15 +523,10 @@ earlier by `easy-menu-define' or `easy-menu-create-menu'."
       (easy-menu-define-key map (easy-menu-intern (car item))
                             (cdr item) before)
     (if (or (keymapp item)
-            (and (symbolp item) (keymapp (symbol-value item))))
+            (and (symbolp item) (keymapp (symbol-value item))
+                 (setq item (symbol-value item))))
         ;; Item is a keymap, find the prompt string and use as item name.
-        (let ((tail (easy-menu-get-map item nil)) name)
-          (if (not (keymapp item)) (setq item tail))
-          (while (and (null name) (consp (setq tail (cdr tail)))
-                      (not (keymapp tail)))
-            (if (stringp (car tail)) (setq name (car tail)) ; Got a name.
-              (setq tail (cdr tail))))
-          (setq item (cons name item))))
+        (setq item (cons (keymap-prompt item) item)))
     (easy-menu-do-add-item map item before)))
 
 (defun easy-menu-item-present-p (map path name)
diff --git a/lisp/emacs-lisp/elp.el b/lisp/emacs-lisp/elp.el
index d701db9e9b6..82ce6f404f7 100644
--- a/lisp/emacs-lisp/elp.el
+++ b/lisp/emacs-lisp/elp.el
@@ -564,7 +564,6 @@ displayed."
                       (generate-new-buffer elp-results-buffer))))
     (set-buffer resultsbuf)
     (erase-buffer)
-    (beginning-of-buffer)
     ;; get the length of the longest function name being profiled
     (let* ((longest 0)
            (title "Function Name")