;;; obsolete.el --- obsoleteness support

;; Copyright (C) 1985-1994, 1997 Free Software Foundation, Inc.
;; Copyright (C) 1994, 1995 Amdahl Corporation.
;; Copyright (C) 1995 Sun Microsystems.
;; Copyright (C) 2002, 2004, 2010 Ben Wing.

;; Maintainer: XEmacs Development Team
;; Keywords: internal, dumped

;; This file is part of XEmacs.

;; XEmacs is free software: you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by the
;; Free Software Foundation, either version 3 of the License, or (at your
;; option) any later version.

;; XEmacs is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
;; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
;; for more details.

;; You should have received a copy of the GNU General Public License
;; along with XEmacs.  If not, see <http://www.gnu.org/licenses/>.

;;; Synched up with: Not in FSF.

;;; Commentary:

;; This file is dumped with XEmacs.

;; The obsoleteness support used to be scattered throughout various
;; source files.  We put the stuff in one place to remove the junkiness
;; from other source files and to facilitate creating/updating things
;; like sysdep.el.

;;; Code:

(defsubst define-obsolete-function-alias (oldfun newfun
					  &optional when docstring)
  "Define OLDFUN as an obsolete alias for function NEWFUN.
This makes calling OLDFUN equivalent to calling NEWFUN and marks OLDFUN
as obsolete.
Optional WHEN is for GNU compatibility.  XEmacs ignores it.  \(In Emacs, WHEN
is a string indicating the version where OLDFUN was first marked obsolete.)
Optional DOCSTRING describes any changes in semantics users should be aware of."
  (declare (special when))
  (define-function oldfun newfun)
  (make-obsolete oldfun (or docstring newfun) when))

(defsubst define-compatible-function-alias (oldfun newfun
					    &optional when docstring)
  "Define OLDFUN as a compatible alias for function NEWFUN.
This makes calling OLDFUN equivalent to calling NEWFUN and marks OLDFUN
as provided for compatibility only.
Optional WHEN is for consistency with `define-obsolete-function-alias'.  XEmacs
ignores it.  \(If present, it is a string indicating the version where OLDFUN
was first marked as a compatibility API.)
Optional DOCSTRING describes any changes in semantics users should be aware of."
  (declare (special when))
  (define-function oldfun newfun)
  (make-compatible oldfun (or docstring newfun)))

(defsubst define-obsolete-variable-alias (oldvar newvar
					  &optional when docstring)
  "Define OLDVAR as an obsolete alias for variable NEWVAR.
This makes referencing or setting OLDVAR equivalent to referencing or
setting NEWVAR and marks OLDVAR as obsolete.
If OLDVAR was bound and NEWVAR was not, set NEWVAR to OLDVAR.
Note: Use this before any other references (defvar/defcustom) to NEWVAR.

Optional WHEN is for GNU compatibility.  XEmacs ignores it.  \(In Emacs, WHEN
is a string indicating the version where OLDVAR was first marked obsolete.)
Optional DOCSTRING describes any changes in semantics users should be aware of."
  (declare (special when))
  (let ((needs-setting (and (boundp oldvar) (not (boundp newvar))))
        (value (and (boundp oldvar) (symbol-value oldvar))))
     (defvaralias oldvar newvar docstring)
     (make-obsolete-variable oldvar newvar when)
     (and needs-setting (set newvar value))))

(defsubst define-compatible-variable-alias (oldvar newvar
					    &optional when docstring)
  "Define OLDVAR as a compatible alias for variable NEWVAR.
This makes referencing or setting OLDVAR equivalent to referencing or
setting NEWVAR and marks OLDVAR as provided for compatibility only.
Optional WHEN is for consistency with `define-obsolete-variable-alias'.  XEmacs
ignores it.  \(If present, it is a string indicating the version where OLDFUN
was first marked as a compatibility API.)
Optional DOCSTRING describes any changes in semantics users should be aware of."
  (declare (special when))
  (defvaralias oldvar newvar docstring)
  (make-compatible-variable oldvar newvar))

;;;;;;;;;;;;;;;;;;;;;;;;;;;; buffers

(define-obsolete-function-alias 'show-buffer 'set-window-buffer)
(define-obsolete-function-alias 'buffer-flush-undo 'buffer-disable-undo)
(make-compatible 'eval-current-buffer 'eval-buffer)

(defun buffer-local-value (variable buffer)
  "Return the value of VARIABLE in BUFFER.
If VARIABLE does not have a buffer-local binding in BUFFER, the value
is the default binding of variable."
  (symbol-value-in-buffer variable buffer))
(make-compatible 'buffer-local-value 'symbol-value-in-buffer)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; device stuff

(make-compatible-variable 'window-system "use (console-type)")

(defun x-display-color-p (&optional device)
  "Return t if DEVICE is a color device."
  (eq 'color (device-class device)))
(make-compatible 'x-display-color-p 'device-class)

(define-function 'x-color-display-p 'x-display-color-p)
(make-compatible 'x-display-color-p 'device-class)

(defun x-display-grayscale-p (&optional device)
  "Return t if DEVICE is a grayscale device."
  (eq 'grayscale (device-class device)))
(make-compatible 'x-display-grayscale-p 'device-class)

(define-function 'x-grayscale-display-p 'x-display-grayscale-p)
(make-compatible 'x-display-grayscale-p 'device-class)

(define-compatible-function-alias 'x-display-pixel-width  'device-pixel-width)
(define-compatible-function-alias 'x-display-pixel-height 'device-pixel-height)
(define-compatible-function-alias 'x-display-planes       'device-bitplanes)
(define-compatible-function-alias 'x-display-color-cells  'device-color-cells)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; events

(define-obsolete-function-alias 'menu-event-p 'misc-user-event-p)
(make-obsolete-variable 'unread-command-char 'unread-command-events)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; extents

(make-obsolete 'set-window-dot 'set-window-point)

(define-obsolete-function-alias 'extent-buffer 'extent-object)
(define-compatible-variable-alias 'parse-sexp-lookup-properties
  'lookup-syntax-properties)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; frames

(defun frame-first-window (frame)
  "Return the topmost, leftmost window of FRAME.
If omitted, FRAME defaults to the currently selected frame."
  (frame-highest-window frame 0))
(make-compatible 'frame-first-window 'frame-highest-window)

(define-obsolete-variable-alias 'initial-frame-alist 'initial-frame-plist)
(define-obsolete-variable-alias 'minibuffer-frame-alist
  'minibuffer-frame-plist)
(define-obsolete-variable-alias 'pop-up-frame-alist 'pop-up-frame-plist)
(define-obsolete-variable-alias 'special-display-frame-alist
  'special-display-frame-plist)

;; Defined in C.

(define-obsolete-variable-alias 'default-frame-alist 'default-frame-plist)
(define-obsolete-variable-alias 'default-x-frame-alist 'default-x-frame-plist)
(define-obsolete-variable-alias 'default-tty-frame-alist
  'default-tty-frame-plist)

(make-compatible 'frame-parameters 'frame-property)
(defun frame-parameters (&optional frame)
  "Return the parameters-alist of frame FRAME.
It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of frame.
If FRAME is omitted, return information on the currently selected frame.

See the variables `default-frame-plist', `default-x-frame-plist', and
`default-tty-frame-plist' for a description of the parameters meaningful
for particular types of frames."
  (or frame (setq frame (selected-frame)))
  ;; #### This relies on a `copy-sequence' of the user properties in
  ;; `frame-properties'.  Removing that would make `frame-properties' more
  ;; efficient but this function less efficient, as we couldn't be
  ;; destructive.  Since most callers now use `frame-parameters', we'll
  ;; do it this way.  Should probably change this at some point in the
  ;; future.
  (destructive-plist-to-alist (frame-properties frame)))

(make-compatible 'frame-parameter 'frame-property)
(defun frame-parameter (frame parameter)
  "Return FRAME's value for parameter PARAMETER.
If FRAME is nil, describe the currently selected frame."
  (cdr (assq parameter (frame-parameters frame))))

(make-compatible 'modify-frame-parameters 'set-frame-properties)
(defun modify-frame-parameters (frame alist)
  "Modify the properties of frame FRAME according to ALIST.
ALIST is an alist of properties to change and their new values.
Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of frame.

See `set-frame-properties' for built-in property names."
  ;; it would be nice to be destructive here but that's not safe.
  (set-frame-properties frame (alist-to-plist alist)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;; faces

(define-obsolete-function-alias 'list-faces-display 'edit-faces)
(define-obsolete-function-alias 'list-faces 'face-list)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; fonts and colors

(defun x-color-values  (color &optional frame)
  "Return a description of the color named COLOR on frame FRAME.
The value is a list of integer RGB values--(RED GREEN BLUE).
These values appear to range from 0 to 65280 or 65535, depending
on the system; white is (65280 65280 65280) or (65535 65535 65535).
If FRAME is omitted or nil, use the selected frame."
  (color-instance-rgb-components (make-color-instance color)))
(make-compatible 'x-color-values 'color-instance-rgb-components)

(make-obsolete 'mswindows-color-list 'color-list)
(make-obsolete 'tty-color-list 'color-list)
(make-compatible 'list-fonts 'font-list)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; hooks

(make-compatible-variable 'lisp-indent-hook 'lisp-indent-function)
(make-compatible-variable 'comment-indent-hook 'comment-indent-function)
(make-obsolete-variable 'temp-buffer-show-hook
			'temp-buffer-show-function)
(make-obsolete-variable 'inhibit-local-variables
			"use `enable-local-variables' (with the reversed sense).")
(make-obsolete-variable 'suspend-hooks 'suspend-hook)
(make-obsolete-variable 'first-change-function 'first-change-hook)
(make-obsolete-variable 'before-change-function
  "Use before-change-functions; which is a list of functions rather than a \
single function.")

(labels
    ((make-local-handler (sym args fun harg handler)
       (error 'protected-field
              (format "Minimal compatibility provided for `%s'; \
use `%ss'" sym sym)
              fun)))

  (dontusethis-set-symbol-value-handler
   'before-change-function
   'set-value
   #'(lambda (sym args fun harg handler)
       (if (car args)
           (unless (function-allows-args (car args) 2)
             (error 'invalid-argument "Not a valid before-change-function"
                    (car args))))
       (setq before-change-functions
             (delete*
              '#22222=#:before-change-function-secret
              before-change-functions :test #'member*
              :key #'(lambda (object)
                       (and (compiled-function-p object)
                            (compiled-function-arglist object))))
             before-change-functions (append before-change-functions
                                             (if (car args)
                                                 (list
                                                  (apply-partially
                                                   #'(lambda (f &rest #22222#)
                                                       (apply f #22222#))
                                                   (car args))))))))

  (dontusethis-set-symbol-value-handler
   'before-change-function
   'make-local #'make-local-handler)

  (make-obsolete-variable 'after-change-function
   "Use after-change-functions; which is a list of functions rather than a \
single function.")

  (dontusethis-set-symbol-value-handler
   'after-change-function
   'set-value
   #'(lambda (sym args fun harg handler)
       (if (car args)
           (unless (function-allows-args (car args) 3)
             (error 'invalid-argument "Not a valid after-change-function"
                    (car args))))
       (setq after-change-functions
             (delete*
              '#44444=#:after-change-function-secret
              after-change-functions :test #'member*
              :key #'(lambda (object)
                       (and (compiled-function-p object)
                            (compiled-function-arglist object))))
             after-change-functions (append after-change-functions
                                            (if (car args)
                                                (list
                                                 (apply-partially
                                                  #'(lambda (f &rest #44444#)
                                                      (apply f #44444#))
                                                  (car args))))))))

  (dontusethis-set-symbol-value-handler
   'after-change-function
   'make-local
   #'make-local-handler))

;;;;;;;;;;;;;;;;;;;;;;;;;;;; insertion, deletion, movement

(define-compatible-function-alias 'insert-and-inherit 'insert)
(define-compatible-function-alias 'insert-before-markers-and-inherit
  'insert-before-markers)

(define-compatible-function-alias 'line-beginning-position 'point-at-bol)
(define-compatible-function-alias 'line-end-position 'point-at-eol)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; Lisp engine, basic Lisp stuff

(make-obsolete 'function-called-at-point 'function-at-point)

;; As of 21.5, #'throw is a special operator. This makes bytecode using it
;; compiled for 21.4 fail; making this function available works around that.
(defun obsolete-throw (tag value)
  "Ugly compatibility hack.

See the implementation of #'funcall in eval.c.  This should be removed once
we no longer encounter bytecode from 21.4."
  (throw tag value))

(make-obsolete
 'obsolete-throw
 "it says `obsolete' in the name, you know you shouldn't be using this.")

(define-compatible-function-alias 'cl-mapc 'mapc)

;; Various non-XEmacs code can call this, because it used not be
;; called automatically at dump time.
(define-function 'cl-float-limits 'ignore)
(make-obsolete 'cl-float-limits "this is called at dump time in 21.5 and \
later, no need to call it in user code.")

;; This occurs because of setf expansion by 21.4, changing the affected
;; packages won't fix that.
(define-obsolete-function-alias 'cl-puthash 'puthash)

; old names
(define-compatible-function-alias 'byte-code-function-p
  'compiled-function-p) ;FSFmacs

(define-compatible-function-alias 'interactive-form 
  'function-interactive) ;GNU 21.1
(define-function 'assq-delete-all 'remassq) ;GNU 21.1
(make-compatible 'assq-delete-all "use (delete* ITEM SEQUENCE :key #'car)")

(defun makehash (&optional test)
  "Create a new hash table.
Optional first argument TEST specifies how to compare keys in the table.  
Predefined tests are `eq', `eql', and `equal'.  Default is `eql'."
  (make-hash-table :test test))
(make-compatible 'makehash 'make-hash-table)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; keys, keymaps

(defun keymap-parent (keymap)
  "Return the first parent of the given keymap."
  (car (keymap-parents keymap)))
(make-compatible 'keymap-parent 'keymap-parents)

(defun set-keymap-parent (keymap parent)
  "Make the given keymap have (only) the given parent."
  (set-keymap-parents keymap (if parent (list parent) '()))
  parent)
(make-compatible 'set-keymap-parent 'set-keymap-parents)

(make-compatible-variable 'suggest-key-bindings 'teach-extended-commands-p)

;; too bad there's not a way to check for aref, assq, and nconc
;; being called on the values of functions known to return keymaps,
;; or known to return vectors of events instead of strings...

;;; Yes there is; make compiler macros for aref, assq, nconc, checking that
;;; the car of the relevant argument is sane.

(make-obsolete-variable 'executing-macro 'executing-kbd-macro)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; menu stuff

(defun add-menu-item (menu-path item-name function enabled-p &optional before)
  "Obsolete.  See the function `add-menu-button'."
  (or item-name (error "must specify an item name"))
  (declare-fboundp (add-menu-button menu-path (vector item-name function enabled-p) before)))
(make-obsolete 'add-menu-item 'add-menu-button)

(defun add-menu (menu-path menu-name menu-items &optional before)
  "See the function `add-submenu'."
  (or menu-name (error "must specify a menu name"))
  (or menu-items (error "must specify some menu items"))
  (declare-fboundp (add-submenu menu-path (cons menu-name menu-items) before)))
;; Can't make this obsolete.  easymenu depends on it.
(make-compatible 'add-menu 'add-submenu)

(define-obsolete-function-alias 'package-get-download-menu 
  'package-ui-download-menu)

(unless (featurep 'menubar)
  ;; Don't provide the last three functions unless the menubar feature is
  ;; available. This approach (with #'unintern) avoids warnings about lost
  ;; docstrings since make-docfile doesn't parse bytecode.
  (mapc #'unintern '(add-menu-item add-menu package-get-download-menu)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;; minibuffer

(define-compatible-function-alias 'read-minibuffer
  'read-expression) ; misleading name
(define-compatible-function-alias 'read-input 'read-string)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; modeline

(define-compatible-function-alias 'redraw-mode-line 'redraw-modeline)
(define-compatible-function-alias 'force-mode-line-update
  'redraw-modeline) ;; FSF compatibility
(define-compatible-variable-alias 'mode-line-map 'modeline-map)
(define-compatible-variable-alias 'mode-line-buffer-identification
  'modeline-buffer-identification)
(define-compatible-variable-alias 'mode-line-process 'modeline-process)
(define-compatible-variable-alias 'mode-line-modified 'modeline-modified)
(make-compatible-variable 'mode-line-inverse-video
			"use set-face-highlight-p and set-face-reverse-p")
(define-compatible-variable-alias 'default-mode-line-format
  'default-modeline-format)
(define-compatible-variable-alias 'mode-line-format 'modeline-format)
(define-compatible-variable-alias 'mode-line-menu 'modeline-menu)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; mouse

;;; (defun mouse-eval-last-sexpr (event)
;;;   (interactive "@e")
;;;   (save-excursion
;;;     (mouse-set-point event)
;;;     (eval-last-sexp nil)))

(define-obsolete-function-alias 'mouse-eval-last-sexpr 'mouse-eval-sexp)

(defun read-mouse-position (frame)
  (cdr (mouse-position (frame-device frame))))
(make-obsolete 'read-mouse-position 'mouse-position)

(define-obsolete-function-alias 'mwheel-scroll 'mouse-wheel-scroll)
(define-obsolete-variable-alias 'mwheel-scroll-amount
    'mouse-wheel-scroll-amount nil "Now a list with modifiers specified")
(define-obsolete-variable-alias 'mwheel-follow-mouse
    'mouse-wheel-follow-mouse)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; paths

(defvar Info-default-directory-list nil
  "This used to be the initial value of Info-directory-list.
If you want to change the locations where XEmacs looks for info files,
set Info-directory-list.")
(make-obsolete-variable 'Info-default-directory-list 'Info-directory-list)

(defvar init-file-user nil
  "This used to be the name of the user whose init file was read at startup.")
(make-obsolete-variable 'init-file-user 'load-user-init-file-p)

(define-obsolete-function-alias 'pui-add-install-directory
  'pui-set-local-package-get-directory) ; misleading name

;;;;;;;;;;;;;;;;;;;;;;;;;;;; redisplay

(defun redraw-display (&optional device)
  (if (eq device t)
      (mapcar 'redisplay-device (device-list))
    (redisplay-device device)))

;; the functionality of column.el has been moved into C
;; Function obsoleted for XEmacs 20.0/February 1997.
(defalias 'display-column-mode 'column-number-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; selections

(define-obsolete-function-alias 'isearch-yank-x-selection
  'isearch-yank-selection)
(define-obsolete-function-alias 'isearch-yank-x-clipboard
  'isearch-yank-clipboard)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; text and strings

(define-obsolete-function-alias 'sref 'aref)

(defun char-bytes (character)
  "Return number of bytes a CHARACTER occupies in a string or buffer.
It always returns 1 in XEmacs, and in recent FSF Emacs versions."
  1)
(make-obsolete 'char-bytes "This function always returns 1")

(defun find-non-ascii-charset-string (string)
  "Return a list of charsets in the STRING except ascii.
It might be available for compatibility with Mule 2.3,
because its `find-charset-string' ignores ASCII charset."
  (delete* 'ascii
           (and-fboundp 'charsets-in-string (charsets-in-string string))))
(make-obsolete 'find-non-ascii-charset-string
	       "use (delq 'ascii (charsets-in-string STRING)) instead.")

(defun find-non-ascii-charset-region (start end)
  "Return a list of charsets except ascii in the region between START and END.
It might be available for compatibility with Mule 2.3,
because its `find-charset-string' ignores ASCII charset."
  (delete* 'ascii (and-fboundp 'charsets-in-region
                    (charsets-in-region start end))))
(make-obsolete 'find-non-ascii-charset-region
	       "use (delq 'ascii (charsets-in-region START END)) instead.")

;; < 21.5 compatibility, eg. https://bugzilla.redhat.com/201524#c2
(define-obsolete-function-alias 'string-to-char-list 'string-to-list)

;; Two loser functions which shouldn't be used.
(defun following-char (&optional buffer)
  "Return the result of calling `char-after' with buffer BUFFER.
If that is nil, return integer zero."
  (or (char-after nil buffer) 0))
(make-obsolete 'following-char 'char-after)

(defun preceding-char (&optional buffer)
  "Return the result of calling `char-before' with buffer BUFFER.
If that is nil, return integer zero."
  (or (char-before nil buffer) 0))
(make-obsolete 'preceding-char 'char-before)

;;;;;;;;;;;;;;;;;;;;;;;;;;;; misc

;; (defun user-original-login-name ()
;;   "Return user's login name from original login.
;; This tries to remain unaffected by `su', by looking in environment variables."
;;   (or (getenv "LOGNAME") (getenv "USER") (user-login-name)))
(define-obsolete-function-alias 'user-original-login-name 'user-login-name)

;; Keywords already do The Right Thing in XEmacs
(make-compatible 'define-widget-keywords "Just use them")

(define-function 'purecopy 'identity)
(make-obsolete 'purecopy "purespace is not available in XEmacs.")

(define-compatible-function-alias 'process-get 'get)
(define-compatible-function-alias 'process-put 'put)
(define-compatible-function-alias 'process-plist 'object-plist)
(define-compatible-function-alias 'set-process-plist 'object-setplist)

(define-function 'memql 'member*)
(make-compatible 'memql "use the more full-featured `member*' instead.")

(define-obsolete-variable-alias 'cl-macro-environment
  'byte-compile-macro-environment)

;; Actual implementations of these functions are in cl-extra.el, after
;; cl-macs is loaded, since those implementations use #'labels and
;; #'symbol-macrolet. These APIs were always XEmacs-specific, were never
;; widely used, and it was always more readable and more compatible to use
;; the CL functions.
(make-obsolete 'remassoc "use delete* with :test #'equal, :key #'car")
(make-obsolete 'remassq "use delete* with :test #'eq, :key #'car")
(make-obsolete 'remrassoc "use delete* with :test #'equal, :key #'cdr")
(make-obsolete 'remrassq "use delete* with :test #'eq, :key #'cdr")

(defun max-char ()
  "Return a fixnum one less than `char-code-limit'.

In contrast with GNU Emacs, this is not necessarily a valid character, but it
is an inclusive upper bound on the possible values returned by `char-int'."
  (1- char-code-limit))
(make-compatible
 'max-char
 "consider `char-code-limit', which gives an exclusive upper bound")

(autoload 'xemacs-intern-in-vector "obarray")
(autoload 'xemacs-intern-soft-in-vector "obarray")
(autoload 'xemacs-unintern-in-vector "obarray")
(autoload 'xemacs-mapatoms-in-vector "obarray")

(labels ((canonicalize-string-equal-argument (string)
           (check-type string (or string symbol))
           (if (symbolp string)
               (symbol-name string)
             string)))

  (defun string-equal (string1 string2)
    "Return t if two strings have identical contents.

Case is significant.  Text properties are ignored.
\(Under XEmacs, `equal' also ignores text properties and extents in
strings, but this is not the case under FSF Emacs 19.  In FSF Emacs 20
`equal' is the same as in XEmacs, in that respect.)
Symbols are also allowed; their print names are used instead.

This function is usually not appropriate, for the following reasons:

-- STRING1 and STRING2 can be strings or symbols, indifferently; but any other
   type provokes an error.
   If you don't want type-based error-checking, you should be using `equal'
   If you do want type-based error-checking, it's very easy to get the calling
   convention of this function wrong and let a symbol slip through when you
   don't intend to.

-- You may be thinking \"ah, a string equal predicate, surely this defaults to
   case-insensitive comparison, or takes account of `case-fold-search'\".
   No, neither is true.  For the former, see `equalp'. For the latter, you're
   stuck with something like:
     `(string-match-p (concat \"\\\\`\" (regexp-quote NEEDLE) \"\\\\'\")
                      HAYSTACK)'.

-- It is rare that you want something like `(string-equal buffer-file-name
   filename)' to give `t' when `filename' is the string \"nil\", if the buffer
   doesn't have an associated file.

-- `equal' has a bytecode and so most of the time will be fast, even if you
   do your own type-checking (since `stringp' and `symbolp' both have
   bytecodes too).

It is included for compatibility with old versions of GNU Emacs, see above."
    (equal (canonicalize-string-equal-argument string1)
           (canonicalize-string-equal-argument string2)))
  (make-compatible 'string-equal
                   "use `equal' with your own type checking, if needed")

  (define-function 'string= 'string-equal)
  (make-compatible 'string=
                   "use `equal' with your own type checking, if needed")

  ;; XEmacs
  (defun string-equal-ignore-case (string1 string2)
    "Return t if two strings have identical contents, ignoring case.

Text properties and extents are ignored. Symbols are also allowed; their print
names are used instead.

This function is usually not appropriate, see the docstring for
`string-equal'. See also `equalp'."
    (equalp (canonicalize-string-equal-argument string1)
            (canonicalize-string-equal-argument string2)))
  (make-compatible 'string-equal-ignore-case
                   "use `equalp' with your own type checking, if needed"))

(defun fetch-bytecode (object) (check-type object compiled-function) object)
(make-obsolete 'fetch-bytecode "Lazy loading of function instructions removed"
               "21.5-b35")

(provide 'obsolete)
;;; obsolete.el ends here
