xemacs-beta: lisp/bytecomp-runtime.el comparison

comparison lisp/bytecomp-runtime.el @ 771:943eaba38521

[xemacs-hg @ 2002-03-13 08:51:24 by ben] The big ben-mule-21-5 check-in! Various files were added and deleted. See CHANGES-ben-mule. There are still some test suite failures. No crashes, though. Many of the failures have to do with problems in the test suite itself rather than in the actual code. I'll be addressing these in the next day or so -- none of the test suite failures are at all critical. Meanwhile I'll be trying to address the biggest issues -- i.e. build or run failures, which will almost certainly happen on various platforms. All comments should be sent to ben@xemacs.org -- use a Cc: if necessary when sending to mailing lists. There will be pre- and post- tags, something like pre-ben-mule-21-5-merge-in, and post-ben-mule-21-5-merge-in.

author	ben
date	Wed, 13 Mar 2002 08:54:06 +0000
parents	7039e6323819
children	79940b592197

comparison

equal deleted inserted replaced

-:336a418893b5
+:943eaba38521
 ;;; bytecomp-runtime.el --- byte-compiler support for inlining
 ;; Copyright (C) 1992, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 2002 Ben Wing.
 ;; Author: Jamie Zawinski <jwz@jwz.org>
 ;; Author: Hallvard Furuseth <hbf@ulrik.uio.no>
 ;; Maintainer: XEmacs Development Team
 ;; Keywords: internal, dumped
 ;; arguments, and I find it extremely confusing to deal with cases
 ;; such as `throw' requiring a quoted argument but `block' an unquoted
 ;; one.
 (put 'with-boundp 'lisp-indent-function 1)
-(defmacro with-boundp (symbols &rest body)
+(defmacro with-boundp (variables &rest body)
-"Evaluate BODY, but do not issue bytecomp warnings about SYMBOLS undefined.
+"Evaluate BODY, but do not issue bytecomp warnings about VARIABLES undefined.
-SYMBOLS can be a symbol or a list of symbols and must be quoted.  When
+VARIABLES can be a symbol or a list of symbols and must be quoted.  When
-compiling this file, the warning `reference to free variable SYMBOL'
+compiling this file, the warnings `reference to free variable VARIABLE' and
-will not occur.  This is a clean way to avoid such warnings.  See also
+`assignment to free variable VARIABLE' will not occur anywhere in BODY, for
-`declare-boundp' and `if-boundp'."
+any of the listed variables.  This is a clean way to avoid such warnings.
-(setq symbols (eval symbols))
+See also `declare-boundp', `if-boundp', `when-boundp', and
-(unless (consp symbols)
+`globally-declare-boundp'."
-(setq symbols (list symbols)))
+(setq variables (eval variables))
+(unless (consp variables)
+(setq variables (list variables)))
 `(progn
-(declare (special ,@symbols))
+(declare (special ,@variables))
 ,@body))
 (put 'if-boundp 'lisp-indent-function 2)
-(defmacro if-boundp (symbol then &rest else)
+(defmacro if-boundp (variable then &rest else)
-"Equivalent to (if (boundp SYMBOL) THEN ELSE) but handles bytecomp warnings.
+"Equivalent to (if (boundp VARIABLE) THEN ELSE) but handles bytecomp warnings.
-When compiling this file, the warning `reference to free variable SYMBOL'
+VARIABLE should be a quoted symbol.  When compiling this file, the warnings
-will not occur.  This is a clean way to avoid such warnings.  See also
+`reference to free variable VARIABLE' and `assignment to free variable
-`with-boundp' and `declare-boundp'."
+VARIABLE' will not occur anywhere in the if-statement.  This is a clean way
-`(with-boundp ,symbol
+to avoid such warnings.  See also `when-boundp', `declare-boundp',
-(if (boundp ,symbol) ,then ,@else)))
+`with-boundp' and `globally-declare-boundp'."
+`(with-boundp ,variable
-(defmacro declare-boundp (symbol)
+(if (boundp ,variable) ,then ,@else)))
-"Evaluate SYMBOL without bytecomp warnings about the symbol.
+(put 'when-boundp 'lisp-indent-function 1)
+(defmacro when-boundp (variable &rest body)
+"Equivalent to (when (boundp VARIABLE) BODY) but handles bytecomp warnings.
+VARIABLE should be a quoted symbol.  When compiling this file, the warnings
+`reference to free variable VARIABLE' and `assignment to free variable
+VARIABLE' will not occur anywhere in the when-statement.  This is a clean
+way to avoid such warnings.  See also `if-boundp', `declare-boundp',
+`with-boundp' and `globally-declare-boundp'."
+`(with-boundp ,variable
+(when (boundp ,variable) ,@body)))
+(defmacro declare-boundp (variable)
+"Evaluate VARIABLE without bytecomp warnings about the symbol.
 Sample usage is
 (declare-boundp gpm-minor-mode)
 which is equivalent to
-(with-fboundp 'gpm-minor-mode
+(with-boundp 'gpm-minor-mode
 gpm-minor-mode)"
-`(with-boundp ',symbol ,symbol))
+`(with-boundp ',variable ,variable))
-(defmacro globally-declare-boundp (symbol)
+(defmacro globally-declare-boundp (variables)
-"Declare that all free uses of SYMBOL in this file are valid.
+"Declare that all free uses of VARIABLES in this file are valid.
-SYMBOL can also be a list of symbols.  SYMBOL must be quoted.
+VARIABLES can be a symbol or a list of symbols and must be quoted.
-When compiling this file, the warning `reference to free variable
+When compiling this file, the warnings `reference to free variable
-SYMBOL' will not occur regardless of where calls to SYMBOL occur in
+VARIABLE' and `assignment to free variable VARIABLE' will not occur
-the file.
+regardless of where references to VARIABLE occur in the file.
-In general, you should *NOT* use this; use `declare-boundp',
+In general, you should *NOT* use this; use `declare-boundp', `if-boundp',
-`if-boundp', or `with-boundp' to wrap individual uses, as necessary.
+`when-boundp', or `with-boundp' to wrap individual uses, as necessary.
-That way, you're more likely to remember to put in the explicit checks
+That way, you're more likely to remember to put in the explicit checks for
-for the variable's existence that are usually necessary.  However,
+the variable's existence that are usually necessary.  However,
-`globally-declare-boundp' is better in some circumstances, such as
+`globally-declare-boundp' is better in some circumstances, such as when
-when writing an ELisp package that makes integral use of
+writing an ELisp package that makes integral use of optionally-compiled-in
-optionally-compiled-in functionality (typically, an interface onto a
+functionality (typically, an interface onto a system library) and checks
-system library) and checks for the existence of the functionality at
+for the existence of the functionality at some entry point to the package.
-some entry point to the package.  See `globally-declare-fboundp' for
+See `globally-declare-fboundp' for more information."
-more information."
+(setq variables (eval variables))
-(setq symbol (eval symbol))
+(if (not (consp variables))
-(if (not (consp symbol))
+(setq variables (list variables)))
-(setq symbol (list symbol)))
 `(progn
 ;; (defvar FOO) has no side effects.
-,@(mapcar #'(lambda (sym) `(defvar ,sym)) symbol)))
+,@(mapcar #'(lambda (sym) `(defvar ,sym)) variables)))
 (defun byte-compile-with-fboundp (form)
 (byte-compile-form (cons 'progn (cdr (cdr form))))
 ;; Unfortunately, byte-compile-unresolved-functions is used not only
 ;; for unresolved-function warnings, but also in connection with the
 (put 'with-fboundp-1 'byte-compile 'byte-compile-with-fboundp)
 (defalias 'with-fboundp-1 'progn)
 (put 'with-fboundp 'lisp-indent-function 1)
-(defmacro with-fboundp (symbol &rest body)
+(defmacro with-fboundp (functions &rest body)
-"Evaluate BODY, but do not issue bytecomp warnings about SYMBOL.
+"Evaluate BODY, but do not issue bytecomp warnings about FUNCTIONS undefined.
-SYMBOL must be quoted.  When compiling this file, the warning `the
+FUNCTIONS can be a symbol or a list of symbols and must be quoted.  When
-function SYMBOL is not known to be defined' will not occur.  This is a
+compiling this file, the warning `the function FUNCTION is not known to be
-clean way to avoid such warnings.  See also `declare-fboundp',
+defined' will not occur anywhere in BODY, for any of the listed functions.
-`if-fboundp', and `globally-declare-fboundp'."
+This is a clean way to avoid such warnings.  See also `declare-fboundp',
-`(with-fboundp-1 ,symbol ,@body))
+`if-fboundp', `when-fboundp', and `globally-declare-fboundp'."
+`(with-fboundp-1 ,functions ,@body))
 (put 'if-fboundp 'lisp-indent-function 2)
-(defmacro if-fboundp (symbol then &rest else)
+(defmacro if-fboundp (function then &rest else)
-"Equivalent to (if (fboundp SYMBOL) THEN ELSE) but handles bytecomp warnings.
+"Equivalent to (if (fboundp FUNCTION) THEN ELSE) but handles bytecomp warnings.
-When compiling this file, the warning `the function SYMBOL is not
+FUNCTION should be a quoted symbol.  When compiling this file, the warning
-known to be defined' will not occur.  This is a clean way to avoid
+`the function FUNCTION is not known to be defined' will not occur anywhere
-such warnings.  See also `declare-fboundp', `with-fboundp', and
+in the if-statement.  This is a clean way to avoid such warnings.  See also
+`when-fboundp', `declare-fboundp', `with-fboundp', and
 `globally-declare-fboundp'."
-`(with-fboundp ,symbol
+`(with-fboundp ,function
-(if (fboundp ,symbol) ,then ,@else)))
+(if (fboundp ,function) ,then ,@else)))
+(put 'when-fboundp 'lisp-indent-function 1)
+(defmacro when-fboundp (function &rest body)
+"Equivalent to (when (fboundp FUNCTION) BODY) but handles bytecomp warnings.
+FUNCTION should be a quoted symbol.  When compiling this file, the warning
+`the function FUNCTION is not known to be defined' will not occur anywhere
+in the when-statement.  This is a clean way to avoid such warnings.  See
+also `if-fboundp', `declare-fboundp', `with-fboundp', and
+`globally-declare-fboundp'."
+`(with-fboundp ,function
+(when (fboundp ,function) ,@body)))
 (defmacro declare-fboundp (form)
 "Execute FORM (a function call) without bytecomp warnings about the call.
 Sample usage is
 (with-fboundp 'x-keysym-on-keyboard-sans-modifiers-p
 (x-keysym-on-keyboard-sans-modifiers-p 'backspace))"
 `(with-fboundp ',(car form) ,form))
-(defmacro globally-declare-fboundp (symbol)
+(defmacro globally-declare-fboundp (functions)
-"Declare that all calls to function SYMBOL in this file are valid.
+"Declare that all calls to function FUNCTIONS in this file are valid.
-SYMBOL can also be a list of symbols.  SYMBOL must be quoted.
+FUNCTIONS can be a symbol or a list of symbols and must be quoted.
-When compiling this file, the warning `the function SYMBOL is not
+When compiling this file, the warning `the function FUNCTION is not known
-known to be defined' will not occur regardless of where calls to
+to be defined' will not occur regardless of where calls to FUNCTION occur
-SYMBOL occur in the file.
+in the file.
-In general, you should *NOT* use this; use `declare-fboundp',
+In general, you should *NOT* use this; use `declare-fboundp', `if-fboundp',
-`if-fboundp', or `with-fboundp' to wrap individual uses, as necessary.
+`when-fboundp', or `with-fboundp' to wrap individual uses, as necessary.
-That way, you're more likely to remember to put in the explicit checks
+That way, you're more likely to remember to put in the explicit checks for
-for the function's existence that are usually necessary.  However,
+the function's existence that are usually necessary.  However,
-`globally-declare-fboundp' is better in some circumstances, such as
+`globally-declare-fboundp' is better in some circumstances, such as when
-when writing an ELisp package that makes integral use of
+writing an ELisp package that makes integral use of optionally-compiled-in
-optionally-compiled-in functionality (typically, an interface onto a
+functionality (typically, an interface onto a system library) and checks
-system library) and checks for the existence of the functionality at
+for the existence of the functionality at some entry point to the package.
-some entry point to the package.  The file `ldap.el' is a good
+The file `ldap.el' is a good example: It provides a layer on top of the
-example: It provides a layer on top of the optional LDAP ELisp
+optional LDAP ELisp primitives, makes calls to them throughout its code,
-primitives, makes calls to them throughout its code, and verifies the
+and verifies the presence of LDAP support at load time.  Putting calls to
-presence of LDAP support at load time.  Putting calls to
 `declare-fboundp' throughout the code would be a major annoyance."
 (when (cl-compiling-file)
-(setq symbol (eval symbol))
+(setq functions (eval functions))
-(if (not (consp symbol))
+(if (not (consp functions))
-	(setq symbol (list symbol)))
+	(setq functions (list functions)))
 ;; Another hack.  This works because the autoload environment is
 ;; currently used ONLY to suppress warnings, and the actual
 ;; autoload definition is not used. (NOTE: With this definition,
 ;; we will get spurious "multiple autoloads for %s" warnings if we
-;; have an autoload later in the file for any functions in SYMBOL.
+;; have an autoload later in the file for any functions in FUNCTIONS.
 ;; This is not something that code should ever do, though.)
 (setq byte-compile-autoload-environment
-	  (append (mapcar #'(lambda (sym) (cons sym nil)) symbol)
+	  (append (mapcar #'(lambda (sym) (cons sym nil)) functions)
 		  byte-compile-autoload-environment)))
 nil)
 (defun byte-compile-with-byte-compiler-warnings-suppressed (form)
 (let ((byte-compile-warnings byte-compile-warnings)
 NOTE: You should *NOT* under normal circumstances be using this!
 There are better ways of avoiding most of these warnings.  In particular:
 -- use (declare (special ...)) if you are making use of
 dynamically-scoped variables.
--- use `with-fboundp', `declare-fboundp', `if-fboundp', or
+-- use `if-fboundp', `when-fboundp', `declare-fboundp', `with-fboundp', or
-`globally-declare-fboundp' to avoid warnings about undefined
+`globally-declare-fboundp' to avoid warnings about undefined functions
-functions when you know the function actually exists.
+when you know the function actually exists.
--- use `with-boundp', `declare-boundp', or `if-boundp' to avoid
+-- use `if-boundp', `when-boundp', `declare-boundp', `with-boundp', or
-warnings about undefined variables when you know the variable
+`globally-declare-boundp' to avoid warnings about undefined variables
-actually exists.
+when you know the variable actually exists.
 -- use `with-obsolete-variable' or `with-obsolete-function' if you
 are purposely using such a variable or function."
 `(with-byte-compiler-warnings-suppressed-1 ,type ,@body))
 ;; #### These should be more clever.  You could (e.g.) try fletting

Mercurial > hg > xemacs-beta

comparison lisp/bytecomp-runtime.el @ 771:943eaba38521