bug-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

bug#33602: 27.0.50; Compiling no file at


From: Eli Zaretskii
Subject: bug#33602: 27.0.50; Compiling no file at
Date: Fri, 07 Dec 2018 21:17:50 +0200

> From: Glenn Morris <address@hidden>
> Date: Fri, 07 Dec 2018 14:01:46 -0500
> Cc: "address@hidden" <address@hidden>, address@hidden,
>       Colin Baxter <address@hidden>
> 
> emacs -Q -l seq
> 
> Now there is a Compile-Log buffer.

Thanks, here's the backtrace for that:

  (and (get-buffer byte-compile-log-buffer) (equal byte-compile-current-file 
byte-compile-last-logged-file))
  (not (and (get-buffer byte-compile-log-buffer) (equal 
byte-compile-current-file byte-compile-last-logged-file)))
  (and (not (and (get-buffer byte-compile-log-buffer) (equal 
byte-compile-current-file byte-compile-last-logged-file))) (not noninteractive) 
(save-current-buffer (set-buffer (get-buffer-create byte-compile-log-buffer)) 
(goto-char (point-max)) (let* ((inhibit-read-only t) (dir (and (stringp 
byte-compile-current-file) (file-name-directory byte-compile-current-file))) 
(was-same (equal default-directory dir)) pt) (if dir (progn (if was-same nil 
(insert (format-message "Leaving directory `%s'\n" default-directory))))) (if 
(bolp) nil (insert "\n")) (setq pt (point-marker)) (if 
byte-compile-current-file (insert "\f\nCompiling " (if (stringp 
byte-compile-current-file) (concat "file " byte-compile-current-file) (concat 
"in buffer " (buffer-name byte-compile-current-file))) " at " 
(current-time-string) "\n") (insert "\f\nCompiling no file at " 
(current-time-string) "\n")) (if dir (progn (setq default-directory dir) (if 
was-same nil (insert (format-message "Entering directory `%s'\n" 
default-directory))))) (setq byte-compile-last-logged-file 
byte-compile-current-file byte-compile-last-warned-form nil) (if 
(derived-mode-p 'compilation-mode) nil (emacs-lisp-compilation-mode)) 
(compilation-forget-errors) pt)))
  byte-compile-log-file()
  (or (byte-compile-log-file) 'byte-compile-warning-series)
  (let ((warning-series (or (byte-compile-log-file) 
'byte-compile-warning-series))) (if byte-compile-debug (funcall 
--displaying-byte-compile-warnings-fn) (condition-case error-info (funcall 
--displaying-byte-compile-warnings-fn) (error (byte-compile-report-error 
error-info)))))
  (if (or (eq warning-series 'byte-compile-warning-series) 
warning-series-started) (let (tem) (setq tem (byte-compile-log-file)) (if 
warning-series-started nil (setq warning-series (or tem 
'byte-compile-warning-series))) (if byte-compile-debug (funcall 
--displaying-byte-compile-warnings-fn) (condition-case error-info (funcall 
--displaying-byte-compile-warnings-fn) (error (byte-compile-report-error 
error-info))))) (let ((warning-series (or (byte-compile-log-file) 
'byte-compile-warning-series))) (if byte-compile-debug (funcall 
--displaying-byte-compile-warnings-fn) (condition-case error-info (funcall 
--displaying-byte-compile-warnings-fn) (error (byte-compile-report-error 
error-info))))))
  (let* ((--displaying-byte-compile-warnings-fn #'(lambda nil (let 
((byte-compile-macro-environment ...) (byte-compile--outbuffer nil) 
(overriding-plist-environment nil) (byte-compile-function-environment nil) 
(byte-compile-bound-variables nil) (byte-compile-lexical-variables nil) 
(byte-compile-const-variables nil) (byte-compile-free-references nil) 
(byte-compile-free-assignments nil) (byte-compile-verbose byte-compile-verbose) 
(byte-optimize byte-optimize) (byte-compile-dynamic byte-compile-dynamic) 
(byte-compile-dynamic-docstrings byte-compile-dynamic-docstrings) 
(byte-compile-warnings byte-compile-warnings)) (let* (... ... ...) (if macro 
...) (cond ... ...))))) (warning-series-started (and (markerp warning-series) 
(eq (marker-buffer warning-series) (get-buffer byte-compile-log-buffer))))) 
(byte-compile-find-cl-functions) (if (or (eq warning-series 
'byte-compile-warning-series) warning-series-started) (let (tem) (setq tem 
(byte-compile-log-file)) (if warning-series-started nil (setq warning-series 
(or tem 'byte-compile-warning-series))) (if byte-compile-debug (funcall 
--displaying-byte-compile-warnings-fn) (condition-case error-info (funcall 
--displaying-byte-compile-warnings-fn) (error (byte-compile-report-error 
error-info))))) (let ((warning-series (or (byte-compile-log-file) 
'byte-compile-warning-series))) (if byte-compile-debug (funcall 
--displaying-byte-compile-warnings-fn) (condition-case error-info (funcall 
--displaying-byte-compile-warnings-fn) (error (byte-compile-report-error 
error-info)))))))
  byte-compile((lambda (generic dispatches-left methods) (let ((method-cache 
(make-hash-table :test #'eql))) (lambda (arg0 arg &rest args) (let nil (apply 
(cl--generic-with-memoization (gethash ... method-cache) 
(cl--generic-cache-miss generic ... dispatches-left methods ...)) arg0 arg 
args))))))
  cl--generic-get-dispatcher((1 #s(cl--generic-generalizer :name 
cl--generic-typeof-generalizer :priority 10 :tagcode-function 
#f(compiled-function (name &rest _) #<bytecode -0x1ffffffffeb95ff0>) 
:specializers-function #f(compiled-function (tag &rest _) #<bytecode 
-0x1ffffffffeb95fc0>)) #s(cl--generic-generalizer :name 
cl--generic-t-generalizer :priority 0 :tagcode-function #f(compiled-function 
(name &rest _) #<bytecode -0x1ffffffffeb99c30>) :specializers-function 
#f(compiled-function (tag &rest _) #<bytecode -0x1ffffffffeb99bf0>))))
  cl--generic-make-next-function(#s(cl--generic :name \(setf\ seq-elt\) 
:dispatches ((2 #s(cl--generic-generalizer :name cl--generic-t-generalizer 
:priority 0 :tagcode-function #f(compiled-function (name &rest _) #<bytecode 
-0x1ffffffffeb99c30>) :specializers-function #f(compiled-function (tag &rest _) 
#<bytecode -0x1ffffffffeb99bf0>))) (1 #s(cl--generic-generalizer :name 
cl--generic-typeof-generalizer :priority 10 :tagcode-function 
#f(compiled-function (name &rest _) #<bytecode -0x1ffffffffeb95ff0>) 
:specializers-function #f(compiled-function (tag &rest _) #<bytecode 
-0x1ffffffffeb95fc0>)) #s(cl--generic-generalizer :name 
cl--generic-t-generalizer :priority 0 :tagcode-function #f(compiled-function 
(name &rest _) #<bytecode -0x1ffffffffeb99c30>) :specializers-function 
#f(compiled-function (tag &rest _) #<bytecode -0x1ffffffffeb99bf0>))) (0 
#s(cl--generic-generalizer :name cl--generic-t-generalizer :priority 0 
:tagcode-function #f(compiled-function (name &rest _) #<bytecode 
-0x1ffffffffeb99c30>) :specializers-function #f(compiled-function (tag &rest _) 
#<bytecode -0x1ffffffffeb99bf0>)))) :method-table (#s(cl--generic-method 
:specializers (t array t) :qualifiers nil :uses-cnm nil :function 
#f(compiled-function (store sequence n) #<bytecode -0x1ffffffffe48d7c0>))) 
:options nil) ((2 #s(cl--generic-generalizer :name cl--generic-t-generalizer 
:priority 0 :tagcode-function #f(compiled-function (name &rest _) #<bytecode 
-0x1ffffffffeb99c30>) :specializers-function #f(compiled-function (tag &rest _) 
#<bytecode -0x1ffffffffeb99bf0>))) (1 #s(cl--generic-generalizer :name 
cl--generic-typeof-generalizer :priority 10 :tagcode-function 
#f(compiled-function (name &rest _) #<bytecode -0x1ffffffffeb95ff0>) 
:specializers-function #f(compiled-function (tag &rest _) #<bytecode 
-0x1ffffffffeb95fc0>)) #s(cl--generic-generalizer :name 
cl--generic-t-generalizer :priority 0 :tagcode-function #f(compiled-function 
(name &rest _) #<bytecode -0x1ffffffffeb99c30>) :specializers-function 
#f(compiled-function (tag &rest _) #<bytecode -0x1ffffffffeb99bf0>))) (0 
#s(cl--generic-generalizer :name cl--generic-t-generalizer :priority 0 
:tagcode-function #f(compiled-function (name &rest _) #<bytecode 
-0x1ffffffffeb99c30>) :specializers-function #f(compiled-function (tag &rest _) 
#<bytecode -0x1ffffffffeb99bf0>)))) (#s(cl--generic-method :specializers (t 
array t) :qualifiers nil :uses-cnm nil :function #f(compiled-function (store 
sequence n) #<bytecode -0x1ffffffffe48d7c0>))))
  cl--generic-make-function(#s(cl--generic :name \(setf\ seq-elt\) :dispatches 
((2 #s(cl--generic-generalizer :name cl--generic-t-generalizer :priority 0 
:tagcode-function #f(compiled-function (name &rest _) #<bytecode 
-0x1ffffffffeb99c30>) :specializers-function #f(compiled-function (tag &rest _) 
#<bytecode -0x1ffffffffeb99bf0>))) (1 #s(cl--generic-generalizer :name 
cl--generic-typeof-generalizer :priority 10 :tagcode-function 
#f(compiled-function (name &rest _) #<bytecode -0x1ffffffffeb95ff0>) 
:specializers-function #f(compiled-function (tag &rest _) #<bytecode 
-0x1ffffffffeb95fc0>)) #s(cl--generic-generalizer :name 
cl--generic-t-generalizer :priority 0 :tagcode-function #f(compiled-function 
(name &rest _) #<bytecode -0x1ffffffffeb99c30>) :specializers-function 
#f(compiled-function (tag &rest _) #<bytecode -0x1ffffffffeb99bf0>))) (0 
#s(cl--generic-generalizer :name cl--generic-t-generalizer :priority 0 
:tagcode-function #f(compiled-function (name &rest _) #<bytecode 
-0x1ffffffffeb99c30>) :specializers-function #f(compiled-function (tag &rest _) 
#<bytecode -0x1ffffffffeb99bf0>)))) :method-table (#s(cl--generic-method 
:specializers (t array t) :qualifiers nil :uses-cnm nil :function 
#f(compiled-function (store sequence n) #<bytecode -0x1ffffffffe48d7c0>))) 
:options nil))
  cl-generic-define-method(\(setf\ seq-elt\) nil (store (sequence array) n) nil 
#f(compiled-function (store sequence n) #<bytecode -0x1ffffffffe48d7c0>))
  
byte-code("\300\301\302\303#\304\301\305\306#\210\307\310\311\310\312\313#\314#\210\315\310\313\312\313\316%\210\315\317\313\320\313\321%\210\315\317\313\322\313\323%\210\307\324\311\324\325..."
 [function-put seq-let lisp-indent-function 2 put edebug-form-spec (sexp form 
body) defalias seq-elt cl-generic-define (sequence n) nil "Return Nth element 
of SEQUENCE.\n\n(fn SEQUENCE N)" cl-generic-define-method #f(compiled-function 
(sequence n) #<bytecode -0x1ffffffffe54c358>) \(setf\ seq-elt\) (store 
(sequence array) n) #f(compiled-function (store sequence n) #<bytecode 
-0x1ffffffffe48d7c0>) (store (sequence cons) n) #f(compiled-function (store 
sequence n) #<bytecode -0x1ffffffffe480810>) seq-length (sequence) "Return the 
number of elements of SEQUENCE.\n\n(fn SE..." #f(compiled-function (sequence) 
#<bytecode -0x1ffffffffe4808d0>) seq-do #'sequence "Apply FUNCTION to each 
element of SEQUENCE, presum..." #f(compiled-function #'sequence #<bytecode 
-0x1ffffffffe47f980>) seq-each] 7)
  load("seq")





reply via email to

[Prev in Thread] Current Thread [Next in Thread]