❶WARNING: Upgrade Your Mailbox
7 years, 1 month
Mail.Notification
Mail.Notification
Dear User,
You have used 98.64% of the mailbox space, only 6.80MB left available, in
order to prevent delays in receiving mail, please click here to increase space.
Click here to Upgrade
This mail is sent automatically by the system, please do not reply directly
Copyright © 2018 Email Administrator Inc. All Right Reserved
- 1 participants
- 0 comments
❶WARNING: Upgrade Your Mailbox
7 years, 1 month
Mail.Notification
Mail.Notification
Dear User,
You have used 98.64% of the mailbox space, only 6.80MB left available, in
order to prevent delays in receiving mail, please click here to increase space.
Click here to Upgrade
This mail is sent automatically by the system, please do not reply directly
Copyright © 2018 Email Administrator Inc. All Right Reserved
- 1 participants
- 0 comments
❶WARNING: Upgrade Your Mailbox
7 years, 1 month
Mail.Notification
Mail.Notification
Dear User,
You have used 98.64% of the mailbox space, only 6.80MB left available, in
order to prevent delays in receiving mail, please click here to increase space.
Click here to Upgrade
This mail is sent automatically by the system, please do not reply directly
Copyright © 2018 Email Administrator Inc. All Right Reserved
- 1 participants
- 0 comments
❶WARNING: Upgrade Your Mailbox
7 years, 1 month
Mail.Notification
Mail.Notification
Dear User,
You have used 98.64% of the mailbox space, only 6.80MB left available, in
order to prevent delays in receiving mail, please click here to increase space.
Click here to Upgrade
This mail is sent automatically by the system, please do not reply directly
Copyright © 2018 Email Administrator Inc. All Right Reserved
- 1 participants
- 0 comments
❶WARNING: Upgrade Your Mailbox
7 years, 1 month
Mail.Notification
Mail.Notification
Dear User,
You have used 98.64% of the mailbox space, only 6.80MB left available, in
order to prevent delays in receiving mail, please click here to increase space.
Click here to Upgrade
This mail is sent automatically by the system, please do not reply directly
Copyright © 2018 Email Administrator Inc. All Right Reserved
- 1 participants
- 0 comments
[COMMIT] Recognise that keywords are constant symbols too, #'cl-const-expr-p.
7 years, 1 month
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1536172246 -3600
# Wed Sep 05 19:30:46 2018 +0100
# Node ID 38fed6d19a1e9e0f286d37dadb86daeada6e4614
# Parent 9851c4a033df9f2b33ae5cea984efa69ef1f8012
Recognise that keywords are constant symbols too, #'cl-const-expr-p.
lisp/ChangeLog addition:
2018-09-05 Aidan Kehoe <kehoea(a)parhasard.net>
* cl-macs.el (cl-const-expr-p):
Recognise that keywords are constant symbols within this
function.
* byte-optimize.el:
* byte-optimize.el (byte-compile-trueconstp): Removed.
* byte-optimize.el (byte-optimize-car):
* byte-optimize.el (byte-optimize-cdr):
* byte-optimize.el (byte-optimize-or):
* byte-optimize.el (byte-optimize-if):
* byte-optimize.el (byte-optimize-letX):
Use `byte-compile-constp' instead in the places this macro was
used, which recognises that keywords are constant symbols too, and
so reduces the number of places this bug can happen.
diff -r 9851c4a033df -r 38fed6d19a1e lisp/ChangeLog
--- a/lisp/ChangeLog Sun Sep 02 21:03:24 2018 +0100
+++ b/lisp/ChangeLog Wed Sep 05 19:30:46 2018 +0100
＠＠ -1,3 +1,19 ＠＠
+2018-09-05 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * cl-macs.el (cl-const-expr-p):
+ Recognise that keywords are constant symbols within this
+ function.
+ * byte-optimize.el:
+ * byte-optimize.el (byte-compile-trueconstp): Removed.
+ * byte-optimize.el (byte-optimize-car):
+ * byte-optimize.el (byte-optimize-cdr):
+ * byte-optimize.el (byte-optimize-or):
+ * byte-optimize.el (byte-optimize-if):
+ * byte-optimize.el (byte-optimize-letX):
+ Use `byte-compile-constp' instead in the places this macro was
+ used, which recognises that keywords are constant symbols too, and
+ so reduces the number of places this bug can happen.
+
2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
* byte-optimize.el:
diff -r 9851c4a033df -r 38fed6d19a1e lisp/byte-optimize.el
--- a/lisp/byte-optimize.el Sun Sep 02 21:03:24 2018 +0100
+++ b/lisp/byte-optimize.el Wed Sep 05 19:30:46 2018 +0100
＠＠ -656,14 +656,6 ＠＠
;;;
;;; It is now safe to optimize code such that it introduces new bindings.
-;; I'd like this to be a defsubst, but let's not be self-referential...
-(defmacro byte-compile-trueconstp (form)
- ;; Returns non-nil if FORM is a non-nil constant.
- `(cond ((consp ,form) (eq (car ,form) 'quote))
- ((not (symbolp ,form)))
- ((eq ,form t))
- ((keywordp ,form))))
-
;; If the function is being called with constant numeric args,
;; evaluate as much as possible at compile-time. This optimizer
;; assumes that the function is associative, like + or *.
＠＠ -873,13 +865,11 ＠＠
(defun byte-optimize-car (form)
(let ((arg (cadr form)))
(cond
- ((and (byte-compile-trueconstp arg)
- (not (and (consp arg)
- (eq (car arg) 'quote)
- (listp (cadr arg)))))
- (byte-compile-warn
- "taking car of a constant: %s" arg)
- form)
+ ((not arg)) ;; Return nil if called on nil
+ ((and (byte-compile-constp arg)
+ (not (and (eq (car-safe arg) 'quote) (listp (cadr arg)))))
+ (byte-compile-warn "taking car of a non-list constant: %s" arg)
+ form)
((and (eq (car-safe arg) 'cons)
(eq (length arg) 3))
`(prog1 ,(nth 1 arg) ,(nth 2 arg)))
＠＠ -891,14 +881,12 ＠＠
(defun byte-optimize-cdr (form)
(let ((arg (cadr form)))
(cond
- ((and (byte-compile-trueconstp arg)
- (not (and (consp arg)
- (eq (car arg) 'quote)
- (listp (cadr arg)))))
- (byte-compile-warn
- "taking cdr of a constant: %s" arg)
- form)
- ((and (eq (car-safe arg) 'cons)
+ ((not arg)) ;; Return nil if called on nil
+ ((and (byte-compile-constp arg)
+ (not (and (consp arg) (eq (car arg) 'quote) (listp (cadr arg)))))
+ (byte-compile-warn "taking cdr of a non-list constant: %s" arg)
+ form)
+ ((and (eq (car-safe arg) 'cons)
(eq (length arg) 3))
`(progn ,(nth 1 arg) ,(nth 2 arg)))
((eq (car-safe arg) 'list)
＠＠ -1009,9 +997,8 ＠＠
;; constant cannot be multiple.
(let ((rest form))
(while (cdr (setq rest (cdr rest)))
- (if (byte-compile-trueconstp (car rest))
- (setq form (copy-sequence form)
- rest (setcdr (memq (car rest) form) nil))))
+ (if (and (car rest) (byte-compile-constp (car rest)))
+ (setq form (ldiff form (cdr rest)))))
(if (cdr (cdr form))
(byte-optimize-predicate form)
(nth 1 form))))
＠＠ -1042,17 +1029,17 ＠＠
;; BEGIN SYNC WITH 20.7.
(defun byte-optimize-if (form)
+ ;; (if <false-constant> <then> <else...>) ==> (progn <else...>)
;; (if <true-constant> <then> <else...>) ==> <then>
- ;; (if <false-constant> <then> <else...>) ==> (progn <else...>)
;; (if <test> nil <else...>) ==> (if (not <test>) (progn <else...>))
;; (if <test> <then> nil) ==> (if <test> <then>)
(let ((clause (nth 1 form)))
- (cond ((byte-compile-trueconstp clause)
- (nth 2 form))
- ((null clause)
+ (cond ((null clause)
(if (nthcdr 4 form)
(cons 'progn (nthcdr 3 form))
(nth 3 form)))
+ ((byte-compile-constp clause)
+ (nth 2 form))
((nth 2 form)
(if (equal '(nil) (nthcdr 3 form))
(list 'if clause (nth 2 form))
＠＠ -1206,8 +1193,8 ＠＠
most-positive-fixnum)
((null (cadr object))
most-positive-fixnum)
- ((byte-compile-trueconstp
- (cadr object))
+ ((byte-compile-constp
+ (cadr object))
(mod (sxhash (cadr object))
most-positive-fixnum))
(t 0))))))
diff -r 9851c4a033df -r 38fed6d19a1e lisp/cl-macs.el
--- a/lisp/cl-macs.el Sun Sep 02 21:03:24 2018 +0100
+++ b/lisp/cl-macs.el Wed Sep 05 19:30:46 2018 +0100
＠＠ -108,7 +108,7 ＠＠
(and (memq (car x) '(function function*))
(or (symbolp (nth 1 x))
(and (eq (car-safe (nth 1 x)) 'lambda) 'func)))))
- ((symbolp x) (and (memq x '(nil t)) t))
+ ((symbolp x) (or (and (memq x '(nil t)) t) (keywordp x)))
(t t)))
(defun cl-const-exprs-p (xs)
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Use #'eval-when in those places it's clearer than #'eval-when-compile
7 years, 2 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1535918604 -3600
# Sun Sep 02 21:03:24 2018 +0100
# Node ID 9851c4a033df9f2b33ae5cea984efa69ef1f8012
# Parent a771016803ed16b7d614d188f8ae21cc2056e396
Use #'eval-when in those places it's clearer than #'eval-when-compile
lisp/ChangeLog addition:
2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
* byte-optimize.el:
* byte-optimize.el (:execute):
* bytecomp.el (:execute):
* cl-extra.el:
* cl-extra.el (:execute):
* cl-extra.el (streamp):
* cl-macs.el:
* cus-face.el:
* cus-face.el (:compile-toplevel):
* easy-mmode.el:
* help.el:
* help.el (:execute):
* info.el (:compile-toplevel):
* info.el (unless):
* regexp-opt.el (regexp-opt-group):
* syntax-ppss.el (font-lock-beginning-of-syntax-function):
* syntax-ppss.el (syntax-ppss-depth):
* wid-browse.el:
* wid-browse.el (widget-browse):
* x-init.el (:compile-toplevel):
Now #'eval-when is in bytecomp-runtime, use it in those places
where it is clearer than #'eval-when-compile.
Many of the places #'eval-when-compile were used were actually
unnecessary; remove them.
* bytecomp-runtime.el (eval-when):
Document #'eval-when in a little more detail.
diff -r a771016803ed -r 9851c4a033df lisp/ChangeLog
--- a/lisp/ChangeLog Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/ChangeLog Sun Sep 02 21:03:24 2018 +0100
＠＠ -1,3 +1,32 ＠＠
+2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * byte-optimize.el:
+ * byte-optimize.el (:execute):
+ * bytecomp.el (:execute):
+ * cl-extra.el:
+ * cl-extra.el (:execute):
+ * cl-extra.el (streamp):
+ * cl-macs.el:
+ * cus-face.el:
+ * cus-face.el (:compile-toplevel):
+ * easy-mmode.el:
+ * help.el:
+ * help.el (:execute):
+ * info.el (:compile-toplevel):
+ * info.el (unless):
+ * regexp-opt.el (regexp-opt-group):
+ * syntax-ppss.el (font-lock-beginning-of-syntax-function):
+ * syntax-ppss.el (syntax-ppss-depth):
+ * wid-browse.el:
+ * wid-browse.el (widget-browse):
+ * x-init.el (:compile-toplevel):
+ Now #'eval-when is in bytecomp-runtime, use it in those places
+ where it is clearer than #'eval-when-compile.
+ Many of the places #'eval-when-compile were used were actually
+ unnecessary; remove them.
+ * bytecomp-runtime.el (eval-when):
+ Document #'eval-when in a little more detail.
+
2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
* bytecomp.el (byte-compile-initial-macro-environment):
diff -r a771016803ed -r 9851c4a033df lisp/byte-optimize.el
--- a/lisp/byte-optimize.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/byte-optimize.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -2152,24 +2152,22 ＠＠
;; To avoid "lisp nesting exceeds max-lisp-eval-depth" when this file compiles
;; itself, compile some of its most used recursive functions (at load time).
;;
-(eval-when-compile
- (or (compiled-function-p (symbol-function 'byte-optimize-form))
- (assq 'byte-code (symbol-function 'byte-optimize-form))
- (let ((byte-optimize nil)
- (byte-compile-warnings nil))
- (mapcar
- #'(lambda (x)
- (or noninteractive (message "compiling %s..." x))
- (byte-compile x)
- (or noninteractive (message "compiling %s...done" x)))
- '(byte-optimize-form
- byte-optimize-body
- byte-optimize-predicate
- byte-optimize-binary-predicate
- ;; Inserted some more than necessary, to speed it up.
- byte-optimize-form-code-walker
- byte-optimize-lapcode))))
- nil)
+(eval-when (:execute)
+ (let ((byte-optimize nil)
+ (byte-compile-warnings nil))
+ (map nil (if noninteractive
+ #'byte-compile
+ #'(lambda (x)
+ (message "compiling %s..." x)
+ (byte-compile x)
+ (message "compiling %s...done" x)))
+ '(byte-optimize-form
+ byte-optimize-body
+ byte-optimize-predicate
+ byte-optimize-binary-predicate
+ ;; Inserted some more than necessary, to speed it up.
+ byte-optimize-form-code-walker
+ byte-optimize-lapcode))))
;; END SYNC WITH 20.7.
diff -r a771016803ed -r 9851c4a033df lisp/bytecomp-runtime.el
--- a/lisp/bytecomp-runtime.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/bytecomp-runtime.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -221,6 +221,14 ＠＠
The symbols `compile', `load' and `eval' are accepted as synonyms for
:compile-toplevel, :load-toplevel and :execute, respectively.
+A top-level `eval-when' where :compile-toplevel is in WITH, differs from
+`eval-when-compile' in that the latter is also run when
+interpreted. `eval-when-compile' also allows non-top-level code to be run at
+compile time, something the Common Lisp form does not.
+
+A top-level `eval-when' where :execute, and only :execute, is in WITH, is a
+mechanism to have code run when interpreted, and only when interpreted.
+
arguments: ((&rest WHEN) &body BODY)"
(if (set-difference when '(:compile-toplevel :load-toplevel :execute
compile load eval))
diff -r a771016803ed -r 9851c4a033df lisp/bytecomp.el
--- a/lisp/bytecomp.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/bytecomp.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -5180,24 +5180,23 ＠＠
;; To avoid "lisp nesting exceeds max-lisp-eval-depth" when bytecomp compiles
;; itself, compile some of its most used recursive functions (at load time).
;;
-(eval-when-compile
- (or (compiled-function-p (symbol-function 'byte-compile-form))
- (let ((byte-optimize nil) ; do it fast
- (byte-compile-warnings nil))
- (map nil (if noninteractive
- #'byte-compile
- #'(lambda (x)
- (message "compiling %s..." x)
- (byte-compile x)
- (message "compiling %s...done" x)))
- '(byte-compile-normal-call
- byte-compile-form
- byte-compile-body
- ;; Inserted some more than necessary, to speed it up.
- byte-compile-top-level
- byte-compile-out-toplevel
- byte-compile-constant
- byte-compile-variable-ref)))))
+(eval-when (:execute)
+ (let ((byte-optimize nil) ; do it fast
+ (byte-compile-warnings nil))
+ (map nil (if noninteractive
+ #'byte-compile
+ #'(lambda (x)
+ (message "compiling %s..." x)
+ (byte-compile x)
+ (message "compiling %s...done" x)))
+ '(byte-compile-normal-call
+ byte-compile-form
+ byte-compile-body
+ ;; Inserted some more than necessary, to speed it up.
+ byte-compile-top-level
+ byte-compile-out-toplevel
+ byte-compile-constant
+ byte-compile-variable-ref))))
;;; Some packages byte-compile with -no-autoloads, so this is necessary:
(autoload 'cl-compile-time-init "cl-macs")
diff -r a771016803ed -r 9851c4a033df lisp/cl-extra.el
--- a/lisp/cl-extra.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/cl-extra.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -45,8 +45,6 ＠＠
;;; Code:
-;; XEmacs addition
-(eval-when-compile (require 'obsolete))
;;; Type coercion.
＠＠ -646,7 +644,7 ＠＠
;; XEmacs addition; force cl-macs to be available from here on when
;; compiling files to be dumped. This is more reasonable than forcing other
;; files to do the same, multiple times.
-(eval-when-compile (or (cl-compiling-file) (load "cl-macs")))
+(eval-when (:execute) (load "cl-macs"))
;; XEmacs, functions from Common Lisp.
(defun streamp (object)
diff -r a771016803ed -r 9851c4a033df lisp/cl-macs.el
--- a/lisp/cl-macs.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/cl-macs.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -2038,7 +2038,8 ＠＠
call)))))
;;; Some standard place types from Common Lisp.
-(eval-when-compile (defvar ignored-arg)) ; XEmacs: warning suppression
+; XEmacs: warning suppression
+(eval-when (:compile-toplevel) (defvar ignored-arg))
(defsetf aref aset)
(defsetf car setcar)
(defsetf cdr setcdr)
diff -r a771016803ed -r 9851c4a033df lisp/cus-face.el
--- a/lisp/cus-face.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/cus-face.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -39,8 +39,7 ＠＠
(require 'custom)
;; To elude the warnings for font functions.
-(eval-when-compile
- (require 'font))
+(eval-when (:compile-toplevel) (or (featurep 'font) (require 'font)))
;;; Declaring a face.
diff -r a771016803ed -r 9851c4a033df lisp/easy-mmode.el
--- a/lisp/easy-mmode.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/easy-mmode.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -54,8 +54,6 ＠＠
;;; Code:
-(eval-when-compile (require 'cl))
-
;;; This file uses two functions that did not exist in some versions of
;;; XEmacs: propertize and replace-regexp-in-string. We provide these
;;; functions here for such XEmacsen.
diff -r a771016803ed -r 9851c4a033df lisp/help.el
--- a/lisp/help.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/help.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -37,7 +37,7 ＠＠
;; Get the macro make-help-screen when this is compiled,
;; or run interpreted, but not when the compiled code is loaded.
-(eval-when-compile (require 'help-macro))
+(eval-when (:execute :compile-toplevel) (require 'help-macro))
(globally-declare-boundp
(unless (featurep 'menubar) '(last-popup-menu-event)))
diff -r a771016803ed -r 9851c4a033df lisp/info.el
--- a/lisp/info.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/info.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -314,7 +314,7 ＠＠
;; Use the new macro `with-search-caps-disable-folding'
;; Code:
-(eval-when-compile
+(eval-when (:compile-toplevel)
(condition-case nil (require 'browse-url) (error nil)))
(globally-declare-fboundp
diff -r a771016803ed -r 9851c4a033df lisp/regexp-opt.el
--- a/lisp/regexp-opt.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/regexp-opt.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -150,9 +150,6 ＠＠
;;; Workhorse functions.
-(eval-when-compile
- (require 'cl))
-
(defun regexp-opt-group (strings &optional paren lax)
"Return a regexp to match a string in STRINGS.
If PAREN non-nil, output regexp parentheses around returned regexp.
diff -r a771016803ed -r 9851c4a033df lisp/syntax-ppss.el
--- a/lisp/syntax-ppss.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/syntax-ppss.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -45,8 +45,6 ＠＠
;; Note: PPSS stands for `parse-partial-sexp state'
-(eval-when-compile (require 'cl))
-
(defvar font-lock-beginning-of-syntax-function)
(defsubst syntax-ppss-depth (ppss)
diff -r a771016803ed -r 9851c4a033df lisp/wid-browse.el
--- a/lisp/wid-browse.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/wid-browse.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -31,7 +31,6 ＠＠
(require 'easymenu)
(require 'custom)
(require 'wid-edit)
-(eval-when-compile (require 'cl))
(defgroup widget-browse nil
"Customization support for browsing widgets."
diff -r a771016803ed -r 9851c4a033df lisp/x-init.el
--- a/lisp/x-init.el Sun Sep 02 16:37:33 2018 +0100
+++ b/lisp/x-init.el Sun Sep 02 21:03:24 2018 +0100
＠＠ -137,8 +137,8 ＠＠
(x-keysym-hash-table device))
t)))
-(eval-when-compile
- (load "x-win-sun" nil t)
+(eval-when (:compile-toplevel)
+ (load "x-win-sun" nil t)
(load "x-win-xfree86" nil t))
(defun x-initialize-keyboard (device)
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT eudc] Don't require the ldap feature when byte-compiling
7 years, 2 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1535903492 -3600
# Sun Sep 02 16:51:32 2018 +0100
# Node ID af7c95ef33e60cffe3fbcccf784e7507769b6c56
# Parent 78dbcd4ff48226e3e9aa3a959b384f19aa615c68
Don't require the ldap feature when byte-compiling, EUDC
2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
* eudcb-ldap.el:
Only #'require ldap at runtime, there's no need for it when
compiling.
diff -r 78dbcd4ff482 -r af7c95ef33e6 ChangeLog
--- a/ChangeLog Thu May 15 21:02:25 2014 +0200
+++ b/ChangeLog Sun Sep 02 16:51:32 2018 +0100
＠＠ -1,3 +1,9 ＠＠
+2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * eudcb-ldap.el:
+ Only #'require ldap at runtime, there's no need for it when
+ compiling.
+
2014-05-15 Norbert Koch <viteno(a)xemacs.org>
* Makefile (VERSION): XEmacs package 1.43 released.
diff -r 78dbcd4ff482 -r af7c95ef33e6 eudcb-ldap.el
--- a/eudcb-ldap.el Thu May 15 21:02:25 2014 +0200
+++ b/eudcb-ldap.el Sun Sep 02 16:51:32 2018 +0100
＠＠ -35,8 +35,8 ＠＠
;;; Code:
(require 'eudc)
-(require 'ldap)
-
+;; This syntax lets us require the feature at runtime and not compile time:
+(or (featurep 'ldap) (require 'ldap))
;;{{{ Internal cooking
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT edit-utils] Don't quote the WHEN argument to #'eval-when, where-was-i-db.el
7 years, 2 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1535902971 -3600
# Sun Sep 02 16:42:51 2018 +0100
# Node ID 4043f901c9368c4212311ee3f6209ad140bb12b9
# Parent a02f9fb31a055ff7d1b935c76639b50c65434c26
Don't quote the WHEN argument to #'eval-when, where-was-i-db.el
ChangeLog addition:
2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
* where-was-i-db.el (load):
WHEN with #'eval-when can't be quoted, correct this.
diff -r a02f9fb31a05 -r 4043f901c936 ChangeLog
--- a/ChangeLog Sun Jun 10 17:51:56 2018 +0100
+++ b/ChangeLog Sun Sep 02 16:42:51 2018 +0100
＠＠ -1,3 +1,8 ＠＠
+2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * where-was-i-db.el (load):
+ WHEN with #'eval-when can't be quoted, correct this.
+
2018-06-10 Aidan Kehoe <kehoea(a)parhasard.net>
* Makefile (VERSION): XEmacs package 2.58 released.
diff -r a02f9fb31a05 -r 4043f901c936 where-was-i-db.el
--- a/where-was-i-db.el Sun Jun 10 17:51:56 2018 +0100
+++ b/where-was-i-db.el Sun Sep 02 16:42:51 2018 +0100
＠＠ -134,8 +134,7 ＠＠
;;; Code:
-(eval-when 'load
- (require 'berkeley-db))
+(eval-when (load) (require 'berkeley-db))
;;; Utility functions:
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Move #'eval-when to bytecomp.el, where it should have been long ago.
7 years, 2 months
Aidan Kehoe
Aidan Kehoe
This has been sitting on my hard disk three-quarters cooked for a long
time.
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1535899543 -3600
# Sun Sep 02 15:45:43 2018 +0100
# Node ID 9fa700dbfe93f1d05f859fc2d6fdb7377df72f8c
# Parent 8675506fce8a215642369f153edc2c88946ba743
Move #'eval-when to bytecomp.el, where it should have been long ago.
lisp/ChangeLog addition:
2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
* bytecomp-runtime.el:
* bytecomp-runtime.el (eval-when): Move the runtime part of this
here from cl-macs.el.
* bytecomp.el:
* bytecomp.el (byte-compile-eval):
* bytecomp.el (byte-compile-eval-when-seen): New.
* bytecomp.el (byte-compile-initial-macro-environment):
Implement the bulk of #'eval-when in the compiler, where it belongs.
* cl-macs.el:
* cl-macs.el (cl-not-toplevel): Removed.
* cl-macs.el (eval-when): Removed.
* cl-macs.el (arguments): Removed.
* cl-macs.el (cl-compile-time-too): Removed.
* cl-macs.el (define-setf-method):
* cl-macs.el (defstruct):
* cl-macs.el (deftype):
* cl-macs.el (define-compiler-macro):
* cl.el (declaim):
Use the ANSI CL syntax for the stages in WHEN with #'eval-when.
No need to worry about delaying loading cl-macs.el when using that
syntax.
* cl.el (cl-random-time):
* ldap.el (:load-toplevel):
Correct the syntax of this #'eval-when call.
man/ChangeLog addition:
2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
* cl.texi (Time of Evaluation): Use the new-style
:compile-toplevel, :load-toplevel and :execute CL keywords in the
documentation of the WHEN argument to #'eval-when.
diff -r 8675506fce8a -r 9fa700dbfe93 lisp/ChangeLog
--- a/lisp/ChangeLog Sun Aug 26 15:40:56 2018 +0100
+++ b/lisp/ChangeLog Sun Sep 02 15:45:43 2018 +0100
＠＠ -1,3 +1,30 ＠＠
+2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * bytecomp-runtime.el:
+ * bytecomp-runtime.el (eval-when): Move the runtime part of this
+ here from cl-macs.el.
+ * bytecomp.el:
+ * bytecomp.el (byte-compile-eval):
+ * bytecomp.el (byte-compile-eval-when-seen): New.
+ * bytecomp.el (byte-compile-initial-macro-environment):
+ Implement the bulk of #'eval-when in the compiler, where it belongs.
+ * cl-macs.el:
+ * cl-macs.el (cl-not-toplevel): Removed.
+ * cl-macs.el (eval-when): Removed.
+ * cl-macs.el (arguments): Removed.
+ * cl-macs.el (cl-compile-time-too): Removed.
+ * cl-macs.el (define-setf-method):
+ * cl-macs.el (defstruct):
+ * cl-macs.el (deftype):
+ * cl-macs.el (define-compiler-macro):
+ * cl.el (declaim):
+ Use the ANSI CL syntax for the stages in WHEN with #'eval-when.
+ No need to worry about delaying loading cl-macs.el when using that
+ syntax.
+ * cl.el (cl-random-time):
+ * ldap.el (:load-toplevel):
+ Correct the syntax of this #'eval-when call.
+
2018-08-25 Aidan Kehoe <kehoea(a)parhasard.net>
* autoload.el (generate-file-autoloads):
diff -r 8675506fce8a -r 9fa700dbfe93 lisp/bytecomp-runtime.el
--- a/lisp/bytecomp-runtime.el Sun Aug 26 15:40:56 2018 +0100
+++ b/lisp/bytecomp-runtime.el Sun Sep 02 15:45:43 2018 +0100
＠＠ -207,6 +207,27 ＠＠
;; Remember, it's magic.
(cons 'progn body))
+;;; The `eval-when' form. XEmacs; this has been moved from cl-macs.el.
+(defmacro eval-when (when &rest body)
+ "Control when BODY is evaluated.
+
+If :compile-toplevel is in WHEN, BODY is evaluated when compiled at
+top-level (roughly, when it is an outermost form in a file).
+If :load-toplevel is in WHEN, BODY is evaluated when loaded after
+top-level compile.
+If :execute is in WHEN, BODY is evaluated when interpreted or at
+non-top-level.
+
+The symbols `compile', `load' and `eval' are accepted as synonyms for
+:compile-toplevel, :load-toplevel and :execute, respectively.
+
+arguments: ((&rest WHEN) &body BODY)"
+ (if (set-difference when '(:compile-toplevel :load-toplevel :execute
+ compile load eval))
+ (error 'syntax-error "not a valid value for WHEN" when))
+ (if (or (member* :execute when) (member* 'eval when))
+ (cons 'progn body)))
+
;;; From Emacs 20.
(put 'eval-when-feature 'lisp-indent-hook 1)
(defmacro eval-when-feature (feature &rest body)
diff -r 8675506fce8a -r 9fa700dbfe93 lisp/bytecomp.el
--- a/lisp/bytecomp.el Sun Aug 26 15:40:56 2018 +0100
+++ b/lisp/bytecomp.el Sun Sep 02 15:45:43 2018 +0100
＠＠ -166,8 +166,9 ＠＠
;;; o Forms like ((lambda ...) ...) are open-coded.
;;;
;;; o The form `eval-when-compile' is like `progn', except that the body
-;;; is evaluated at compile-time. When it appears at top-level, this
-;;; is analogous to the Common Lisp idiom (eval-when (compile) ...).
+;;; is evaluated at compile-time. When it appears at top-level, this is
+;;; analogous to the Common Lisp idiom (eval-when (:compile-toplevel)
+;;; ...).
;;; When it does not appear at top-level, it is similar to the
;;; Common Lisp #. reader macro (but not in interpreted code).
;;;
＠＠ -460,7 +461,7 ＠＠
;; shouldn't be shadowed when calling #'byte-compile-eval, since
;; such code is interpreted, not compiled.
;; #### Consider giving this a docstring and a top-level value.
- (byte-compile-no-shadow '(load-time-value labels flet)))
+ (byte-compile-no-shadow '(load-time-value labels flet eval-when)))
(unwind-protect
(loop
for (sym . def) in byte-compile-macro-environment
＠＠ -479,6 +480,8 ＠＠
(defvar for-effect) ; ## Kludge! This should be an arg, not a special.
+(defvar byte-compile-eval-when-seen nil)
+
(defconst byte-compile-initial-macro-environment
`((byte-compiler-options
. ,#'(lambda (&rest forms)
＠＠ -490,6 +493,47 ＠＠
. ,#'(lambda (&rest body)
(byte-compile-eval (cons 'progn body))
(cons 'progn body)))
+ (eval-when
+ . ,(symbol-macrolet ((wrapper '#:eval-when-wrapper))
+ (put wrapper 'byte-compile
+ #'(lambda (form)
+ (when (member :execute (cadadr form))
+ (byte-compile-body-do-effect (cddr form)))))
+ (put wrapper 'byte-hunk-handler
+ #'(lambda (form)
+ (let ((when (cadadr form)))
+ (when (member :compile-toplevel when)
+ (let ((byte-compile-macro-environment
+ (acons wrapper
+ #'(lambda (when &rest body)
+ (if (memq :execute (cadr when))
+ (cons 'progn body)))
+ byte-compile-macro-environment)))
+ (byte-compile-eval (cons 'progn (cddr form)))))
+ (when (and (member :load-toplevel when)
+ (not byte-compile-eval-when-seen))
+ (let ((byte-compile-eval-when-seen t))
+ (mapc 'byte-compile-file-form (cddr form))))
+ ;; Do nothing if it is just :execute.
+ nil)))
+ #'(lambda (when &rest body)
+ ;; It's tempting to attempt to implement this purely with a
+ ;; byte-hunk-handler, and leave the non-toplevel expansion to
+ ;; the macro in bytecomp-runtime.el. That chokes on the output
+ ;; of defstruct as used in gnuserv.el, which is likely a bug
+ ;; in defstruct or the defsetf code used by it.
+ (and (set-difference
+ when '(:compile-toplevel :load-toplevel :execute
+ compile load eval))
+ (error 'syntax-error "not a valid value for WHEN" when))
+ (list* wrapper
+ (list 'quote (sublis
+ ;; Make the logic within the byte compile
+ ;; handlers a little simpler:
+ '((load . :load-toplevel)
+ (compile . :compile-toplevel)
+ (eval . :execute))
+ when)) body))))
(the .
,#'(lambda (type form)
(if (cl-const-expr-p form)
diff -r 8675506fce8a -r 9fa700dbfe93 lisp/cl-macs.el
--- a/lisp/cl-macs.el Sun Aug 26 15:40:56 2018 +0100
+++ b/lisp/cl-macs.el Sun Sep 02 15:45:43 2018 +0100
＠＠ -573,41 +573,7 ＠＠
(cl-do-arglist (or args '(&aux)) expr)
(nconc (list 'let* (nreverse bind-lets)) (nreverse bind-forms) body)))
-;;; The `eval-when' form.
-
-(defvar cl-not-toplevel nil)
-
-;;;###autoload
-(defmacro eval-when (when &rest body)
- "Control when BODY is evaluated.
-If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
-If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
-If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
-
-arguments: ((&rest WHEN) &body BODY)"
- (if (and (fboundp 'cl-compiling-file) (cl-compiling-file)
- (not cl-not-toplevel) (not (boundp 'for-effect))) ; horrible kludge
- (let ((comp (or (memq 'compile when) (memq :compile-toplevel when)))
- (cl-not-toplevel t))
- (if (or (memq 'load when) (memq :load-toplevel when))
- (if comp (cons 'progn (mapcar 'cl-compile-time-too body))
- (list* 'if nil nil body))
- (progn (if comp (eval (cons 'progn body))) nil)))
- (and (or (memq 'eval when) (memq :execute when))
- (cons 'progn body))))
-
-(defun cl-compile-time-too (form)
- (or (and (symbolp (car-safe form)) (get (car-safe form) 'byte-hunk-handler))
- (setq form (macroexpand
- form (cons '(eval-when) byte-compile-macro-environment))))
- (cond ((eq (car-safe form) 'progn)
- (cons 'progn (mapcar 'cl-compile-time-too (cdr form))))
- ((eq (car-safe form) 'eval-when)
- (let ((when (nth 1 form)))
- (if (or (memq 'eval when) (memq :execute when))
- (list* 'eval-when (cons 'compile when) (cddr form))
- form)))
- (t (eval form) form)))
+;;; XEmacs; #'eval-when has been moved to bytecomp-runtime.el and bytecomp.el.
;;; Conditional control structures.
＠＠ -1983,7 +1949,7 ＠＠
return a list of five elements: a temporary-variables list, a value-forms
list, a store-variables list (of length one), a store-form, and an access-
form. See `defsetf' for a simpler way to define most setf-methods."
- (append '(eval-when (compile load eval))
+ (append '(eval-when (:compile-toplevel :load-toplevel :execute))
(if (stringp (car body))
(list (list 'put (list 'quote name) '(quote setf-documentation)
(pop body))))
＠＠ -2961,7 +2927,7 ＠＠
(list 'and pred-form print-func)))
'custom-print-functions) forms))
(push (list 'setq tag-symbol (list 'list (list 'quote tag))) forms)
- (push (list* 'eval-when '(compile load eval)
+ (push (list* 'eval-when '(:compile-toplevel :load-toplevel :execute)
(list 'put (list 'quote name) '(quote cl-struct-slots)
(list 'quote descs))
(list 'put (list 'quote name) '(quote cl-struct-type)
＠＠ -3008,7 +2974,7 ＠＠
(defmacro deftype (name arglist &rest body)
"Define NAME as a new data type.
The type name can then be used in `typecase', `check-type', etc."
- (list 'eval-when '(compile load eval)
+ (list 'eval-when '(:compile-toplevel :load-toplevel :execute)
(cl-transform-function-property
name 'cl-deftype-handler (cons (list* '&cl-defs ''('*) arglist) body))))
＠＠ -3131,7 +3097,7 ＠＠
(let ((p (if (listp args) args (list '&rest args))) (res nil))
(while (consp p) (push (pop p) res))
(setq args (nconc (nreverse res) (and p (list '&rest p)))))
- (list 'eval-when '(compile load eval)
+ (list 'eval-when '(:compile-toplevel :load-toplevel :execute)
(cl-transform-function-property
func 'cl-compiler-macro
(cons (if (memq '&whole args) (delete* '&whole args)
diff -r 8675506fce8a -r 9fa700dbfe93 lisp/cl.el
--- a/lisp/cl.el Sun Aug 26 15:40:56 2018 +0100
+++ b/lisp/cl.el Sun Sep 02 15:45:43 2018 +0100
＠＠ -237,10 +237,8 ＠＠
nil)
(defmacro declaim (&rest specs)
- (let ((body (mapcar (function (lambda (x) (list 'proclaim (list 'quote x))))
- specs)))
- (if (cl-compiling-file) (list* 'eval-when '(compile load eval) body)
- (cons 'progn body)))) ; avoid loading cl-macs.el for eval-when
+ (list* 'eval-when '(:compile-toplevel :load-toplevel :execute)
+ (mapcar #'(lambda (x) `(proclaim ',x)) specs)))
;;; Symbols.
diff -r 8675506fce8a -r 9fa700dbfe93 lisp/ldap.el
--- a/lisp/ldap.el Sun Aug 26 15:40:56 2018 +0100
+++ b/lisp/ldap.el Sun Sep 02 15:45:43 2018 +0100
＠＠ -36,7 +36,7 ＠＠
(globally-declare-fboundp '(ldapp ldap-open ldap-close ldap-add ldap-modify
ldap-delete))
-(eval-when '(load)
+(eval-when (:load-toplevel)
(if (not (fboundp 'ldap-open))
(error "No LDAP support compiled in this XEmacs")))
diff -r 8675506fce8a -r 9fa700dbfe93 man/ChangeLog
--- a/man/ChangeLog Sun Aug 26 15:40:56 2018 +0100
+++ b/man/ChangeLog Sun Sep 02 15:45:43 2018 +0100
＠＠ -1,3 +1,9 ＠＠
+2018-09-02 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * cl.texi (Time of Evaluation): Use the new-style
+ :compile-toplevel, :load-toplevel and :execute CL keywords in the
+ documentation of the WHEN argument to #'eval-when.
+
2018-08-15 Aidan Kehoe <kehoea(a)parhasard.net>
* lispref/markers.texi (Information from Markers):
diff -r 8675506fce8a -r 9fa700dbfe93 man/cl.texi
--- a/man/cl.texi Sun Aug 26 15:40:56 2018 +0100
+++ b/man/cl.texi Sun Sep 02 15:45:43 2018 +0100
＠＠ -588,9 +588,9 ＠＠
＠defmac eval-when (situations...) forms...
This form controls when the body ＠var{forms} are evaluated.
The ＠var{situations} list may contain any set of the symbols
-＠code{compile}, ＠code{load}, and ＠code{eval} (or their long-winded
-ANSI equivalents, ＠code{:compile-toplevel}, ＠code{:load-toplevel},
-and ＠code{:execute}).
+＠code{:compile-toplevel}, ＠code{:load-toplevel}, and ＠code{:execute},
+or their shorter, deprecated equivalents, ＠code{compile}, ＠code{load},
+and ＠code{eval}.
The ＠code{eval-when} form is handled differently depending on
whether or not it is being compiled as a top-level form.
＠＠ -600,15 +600,16 ＠＠
top level of the file or inside a top-level ＠code{progn}.
For compiled top-level ＠code{eval-when}s, the body ＠var{forms} are
-executed at compile-time if ＠code{compile} is in the ＠var{situations}
-list, and the ＠var{forms} are written out to the file (to be executed
-at load-time) if ＠code{load} is in the ＠var{situations} list.
-
-For non-compiled-top-level forms, only the ＠code{eval} situation is
+executed at compile-time if ＠code{:compile-toplevel} is in the
+＠var{situations} list, and the ＠var{forms} are written out to the file
+(to be executed at load-time) if ＠code{:load-toplevel} is in the
+＠var{situations} list.
+
+For non-compiled-top-level forms, only the ＠code{:execute} situation is
relevant. (This includes forms executed by the interpreter, forms
compiled with ＠code{byte-compile} rather than ＠code{byte-compile-file},
and non-top-level forms.) The ＠code{eval-when} acts like a
-＠code{progn} if ＠code{eval} is specified, and like ＠code{nil}
+＠code{progn} if ＠code{:execute} is specified, and like ＠code{nil}
(ignoring the body ＠var{forms}) if not.
The rules become more subtle when ＠code{eval-when}s are nested;
＠＠ -619,40 +620,40 ＠＠
＠example
;; Top-level forms in foo.el:
-(eval-when (compile) (setq foo1 'bar))
-(eval-when (load) (setq foo2 'bar))
-(eval-when (compile load) (setq foo3 'bar))
-(eval-when (eval) (setq foo4 'bar))
-(eval-when (eval compile) (setq foo5 'bar))
-(eval-when (eval load) (setq foo6 'bar))
-(eval-when (eval compile load) (setq foo7 'bar))
+(eval-when (:compile-toplevel) (setq foo1 'bar))
+(eval-when (:load-toplevel) (setq foo2 'bar))
+(eval-when (:compile-toplevel :load-toplevel) (setq foo3 'bar))
+(eval-when (:execute) (setq foo4 'bar))
+(eval-when (:execute :compile-toplevel) (setq foo5 'bar))
+(eval-when (:execute :load-toplevel) (setq foo6 'bar))
+(eval-when (:execute :compile-toplevel :load-toplevel) (setq foo7 'bar))
＠end example
When ＠file{foo.el} is compiled, these variables will be set during
the compilation itself:
＠example
-foo1 foo3 foo5 foo7 ; `compile'
+foo1 foo3 foo5 foo7 ; `:compile-toplevel'
＠end example
When ＠file{foo.elc} is loaded, these variables will be set:
＠example
-foo2 foo3 foo6 foo7 ; `load'
+foo2 foo3 foo6 foo7 ; `:load-toplevel'
＠end example
And if ＠file{foo.el} is loaded uncompiled, these variables will
be set:
＠example
-foo4 foo5 foo6 foo7 ; `eval'
+foo4 foo5 foo6 foo7 ; `:execute
＠end example
If these seven ＠code{eval-when}s had been, say, inside a ＠code{defun},
then the first three would have been equivalent to ＠code{nil} and the
last four would have been equivalent to the corresponding ＠code{setq}s.
-Note that ＠code{(eval-when (load eval) ＠dots{})} is equivalent
+Note that ＠code{(eval-when (:load-toplevel :execute) ＠dots{})} is equivalent
to ＠code{(progn ＠dots{})} in all contexts. The compiler treats
certain top-level forms, like ＠code{defmacro} (sort-of) and
＠code{require}, as if they were wrapped in ＠code{(eval-when
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments