poe.el

   1 ;;; poe.el --- Portable Outfit for Emacsen
   2
   3 ;; Copyright (C) 1995,1996,1997,1998,1999 Free Software Foundation, Inc.
   4
   5 ;; Author: MORIOKA Tomohiko <tomo@m17n.org>
   6 ;;      Shuhei KOBAYASHI <shuhei@aqua.ocn.ne.jp>
   7 ;; Keywords: emulation, compatibility, Nemacs, MULE, Emacs/mule, XEmacs
   8
   9 ;; This file is part of APEL (A Portable Emacs Library).
  10
  11 ;; This program is free software; you can redistribute it and/or
  12 ;; modify it under the terms of the GNU General Public License as
  13 ;; published by the Free Software Foundation; either version 2, or (at
  14 ;; your option) any later version.
  15
  16 ;; This program is distributed in the hope that it will be useful, but
  17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19 ;; General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24 ;; Boston, MA 02111-1307, USA.
  25
  26 ;;; Commentary:
  27
  28 ;;; Code:
  29
  30 (require 'product)
  31 (product-provide (provide 'poe) (require 'apel-ver))
  32
  33 (require 'pym)
  34
  35
  36 ;;; @ Version information.
  37 ;;;
  38
  39 (static-when (= emacs-major-version 18)
  40   (require 'poe-18))
  41
  42 ;; Some ancient version of XEmacs did not provide 'xemacs.
  43 (static-when (string-match "XEmacs" emacs-version)
  44   (provide 'xemacs))
  45
  46 ;; `file-coding' was appeared in the spring of 1998, just before XEmacs
  47 ;; 21.0. Therefore it is not provided in XEmacs with MULE versions 20.4
  48 ;; or earlier.
  49 (static-when (featurep 'xemacs)
  50   ;; must be load-time check to share .elc between w/ MULE and w/o MULE.
  51   (when (featurep 'mule)
  52     (provide 'file-coding)))
  53
  54 (static-when (featurep 'xemacs)
  55   (require 'poe-xemacs))
  56
  57 ;; must be load-time check to share .elc between different systems.
  58 (or (fboundp 'open-network-stream)
  59     (require 'tcp))
  60 \f
  61
  62 ;;; @ C primitives emulation.
  63 ;;;
  64
  65 ;; Emacs 20.3 and earlier: (require FEATURE &optional FILENAME)
  66 ;; Emacs 20.4 and later: (require FEATURE &optional FILENAME NOERROR)
  67 (static-condition-case nil
  68     ;; compile-time check.
  69     (progn
  70       (require 'nofeature "nofile" 'noerror)
  71       (if (get 'require 'defun-maybe)
  72           (error "`require' is already redefined")))
  73   (error
  74    ;; load-time check.
  75    (or (fboundp 'si:require)
  76        (progn
  77          (fset 'si:require (symbol-function 'require))
  78          (put 'require 'defun-maybe t)
  79          (defun require (feature &optional filename noerror)
  80            "\
  81 If feature FEATURE is not loaded, load it from FILENAME.
  82 If FEATURE is not a member of the list `features', then the feature
  83 is not loaded; so load the file FILENAME.
  84 If FILENAME is omitted, the printname of FEATURE is used as the file name,
  85 but in this case `load' insists on adding the suffix `.el' or `.elc'.
  86 If the optional third argument NOERROR is non-nil,
  87 then return nil if the file is not found.
  88 Normally the return value is FEATURE."
  89            (if noerror
  90                (condition-case nil
  91                    (si:require feature filename)
  92                  (file-error))
  93              (si:require feature filename)))))))
  94
  95 ;; Emacs 19.29 and later: (plist-get PLIST PROP)
  96 ;; (defun-maybe plist-get (plist prop)
  97 ;;   (while (and plist
  98 ;;               (not (eq (car plist) prop)))
  99 ;;     (setq plist (cdr (cdr plist))))
 100 ;;   (car (cdr plist)))
 101 (static-unless (and (fboundp 'plist-get)
 102                     (not (get 'plist-get 'defun-maybe)))
 103   (or (fboundp 'plist-get)
 104       (progn
 105         (defvar plist-get-internal-symbol)
 106         (defun plist-get (plist prop)
 107           "\
 108 Extract a value from a property list.
 109 PLIST is a property list, which is a list of the form
 110 \(PROP1 VALUE1 PROP2 VALUE2...\).  This function returns the value
 111 corresponding to the given PROP, or nil if PROP is not
 112 one of the properties on the list."
 113           (setplist 'plist-get-internal-symbol plist)
 114           (get 'plist-get-internal-symbol prop))
 115         ;; for `load-history'.
 116         (setq current-load-list (cons 'plist-get current-load-list))
 117         (put 'plist-get 'defun-maybe t))))
 118
 119 ;; Emacs 19.29 and later: (plist-put PLIST PROP VAL)
 120 ;; (defun-maybe plist-put (plist prop val)
 121 ;;   (catch 'found
 122 ;;     (let ((tail plist)
 123 ;;           (prev nil))
 124 ;;       (while (and tail (cdr tail))
 125 ;;         (if (eq (car tail) prop)
 126 ;;             (progn
 127 ;;               (setcar (cdr tail) val)
 128 ;;               (throw 'found plist))
 129 ;;           (setq prev tail
 130 ;;                 tail (cdr (cdr tail)))))
 131 ;;       (if prev
 132 ;;           (progn
 133 ;;             (setcdr (cdr prev) (list prop val))
 134 ;;             plist)
 135 ;;         (list prop val)))))
 136 (static-unless (and (fboundp 'plist-put)
 137                     (not (get 'plist-put 'defun-maybe)))
 138   (or (fboundp 'plist-put)
 139       (progn
 140         (defvar plist-put-internal-symbol)
 141         (defun plist-put (plist prop val)
 142           "\
 143 Change value in PLIST of PROP to VAL.
 144 PLIST is a property list, which is a list of the form
 145 \(PROP1 VALUE1 PROP2 VALUE2 ...\).  PROP is a symbol and VAL is any object.
 146 If PROP is already a property on the list, its value is set to VAL,
 147 otherwise the new PROP VAL pair is added.  The new plist is returned;
 148 use `\(setq x \(plist-put x prop val\)\)' to be sure to use the new value.
 149 The PLIST is modified by side effects."
 150           (setplist 'plist-put-internal-symbol plist)
 151           (put 'plist-put-internal-symbol prop val)
 152           (symbol-plist 'plist-put-internal-symbol))
 153         ;; for `load-history'.
 154         (setq current-load-list (cons 'plist-put current-load-list))
 155         (put 'plist-put 'defun-maybe t))))
 156
 157 ;; Emacs 19.23 and later: (minibuffer-prompt-width)
 158 (defun-maybe minibuffer-prompt-width ()
 159   "Return the display width of the minibuffer prompt."
 160   (save-excursion
 161     (set-buffer (window-buffer (minibuffer-window)))
 162     (current-column)))
 163
 164 ;; (read-string PROMPT &optional INITIAL-INPUT HISTORY)
 165 ;; Emacs 19.29/XEmacs 19.14(?) and later takes optional 3rd arg HISTORY.
 166 (static-unless (or (featurep 'xemacs)
 167                    (>= emacs-major-version 20)
 168                    (and (= emacs-major-version 19)
 169                         (>= emacs-minor-version 29)))
 170   (or (fboundp 'si:read-string)
 171       (progn
 172         (fset 'si:read-string (symbol-function 'read-string))
 173         (defun read-string (prompt &optional initial-input history)
 174           "\
 175 Read a string from the minibuffer, prompting with string PROMPT.
 176 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
 177 The third arg HISTORY, is dummy for compatibility.
 178 See `read-from-minibuffer' for details of HISTORY argument."
 179           (si:read-string prompt initial-input)))))
 180
 181 ;; (completing-read prompt table &optional
 182 ;; FSF Emacs
 183 ;;      --19.7  : predicate require-match init
 184 ;; 19.7 --19.34 : predicate require-match init hist
 185 ;; 20.1 --      : predicate require-match init hist def inherit-input-method
 186 ;; XEmacs
 187 ;;      --19.(?): predicate require-match init
 188 ;;      --21.2  : predicate require-match init hist
 189 ;; 21.2 --      : predicate require-match init hist def
 190 ;; )
 191
 192 ;; We support following API.
 193 ;; (completing-read prompt table
 194 ;;                  &optional predicate require-match init hist def)
 195 (static-cond
 196  ;; add 'hist' and 'def' argument.
 197  ((< emacs-major-version 19)
 198   (or (fboundp 'si:completing-read)
 199       (progn
 200         (fset 'si:completing-read (symbol-function 'completing-read))
 201         (defun completing-read
 202           (prompt table &optional predicate require-match init
 203                                   hist def)
 204         "Read a string in the minibuffer, with completion.
 205 PROMPT is a string to prompt with; normally it ends in a colon and a space.
 206 TABLE is an alist whose elements' cars are strings, or an obarray.
 207 PREDICATE limits completion to a subset of TABLE.
 208 See `try-completion' and `all-completions' for more details
 209  on completion, TABLE, and PREDICATE.
 210
 211 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
 212  the input is (or completes to) an element of TABLE or is null.
 213  If it is also not t, Return does not exit if it does non-null completion.
 214 If the input is null, `completing-read' returns an empty string,
 215  regardless of the value of REQUIRE-MATCH.
 216
 217 If INIT is non-nil, insert it in the minibuffer initially.
 218   If it is (STRING . POSITION), the initial input
 219   is STRING, but point is placed POSITION characters into the string.
 220 HIST is ignored in this implementation.
 221 DEF, if non-nil, is the default value.
 222
 223 Completion ignores case if the ambient value of
 224   `completion-ignore-case' is non-nil."
 225         (let ((string (si:completing-read prompt table predicate
 226                                           require-match init)))
 227           (if (and (string= string "") def)
 228               def string))))))
 229  ;; add 'def' argument.
 230  ((or (and (featurep 'xemacs)
 231            (or (and (eq emacs-major-version 21)
 232                     (< emacs-minor-version 2))
 233                (< emacs-major-version 21)))
 234       (< emacs-major-version 20))
 235   (or (fboundp 'si:completing-read)
 236       (progn
 237         (fset 'si:completing-read (symbol-function 'completing-read))
 238         (defun completing-read
 239           (prompt table &optional predicate require-match init
 240                                   hist def)
 241         "Read a string in the minibuffer, with completion.
 242 PROMPT is a string to prompt with; normally it ends in a colon and a space.
 243 TABLE is an alist whose elements' cars are strings, or an obarray.
 244 PREDICATE limits completion to a subset of TABLE.
 245 See `try-completion' and `all-completions' for more details
 246  on completion, TABLE, and PREDICATE.
 247
 248 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
 249  the input is (or completes to) an element of TABLE or is null.
 250  If it is also not t, Return does not exit if it does non-null completion.
 251 If the input is null, `completing-read' returns an empty string,
 252  regardless of the value of REQUIRE-MATCH.
 253
 254 If INIT is non-nil, insert it in the minibuffer initially.
 255   If it is (STRING . POSITION), the initial input
 256   is STRING, but point is placed POSITION characters into the string.
 257 HIST, if non-nil, specifies a history list
 258   and optionally the initial position in the list.
 259   It can be a symbol, which is the history list variable to use,
 260   or it can be a cons cell (HISTVAR . HISTPOS).
 261   In that case, HISTVAR is the history list variable to use,
 262   and HISTPOS is the initial position (the position in the list
 263   which INIT corresponds to).
 264   Positions are counted starting from 1 at the beginning of the list.
 265 DEF, if non-nil, is the default value.
 266
 267 Completion ignores case if the ambient value of
 268   `completion-ignore-case' is non-nil."
 269         (let ((string (si:completing-read prompt table predicate
 270                                           require-match init hist)))
 271           (if (and (string= string "") def)
 272               def string)))))))
 273
 274 ;; v18: (string-to-int STRING)
 275 ;; v19: (string-to-number STRING)
 276 ;; v20: (string-to-number STRING &optional BASE)
 277 ;;
 278 ;; XXX: `string-to-number' of Emacs 20.3 and earlier is broken.
 279 ;;      (string-to-number "1e1" 16) => 10.0, should be 481.
 280 (static-condition-case nil
 281     ;; compile-time check.
 282     (if (= (string-to-number "1e1" 16) 481)
 283         (if (get 'string-to-number 'defun-maybe)
 284             (error "`string-to-number' is already redefined"))
 285       (error "`string-to-number' is broken"))
 286   (error
 287    ;; load-time check.
 288    (or (fboundp 'si:string-to-number)
 289        (progn
 290          (if (fboundp 'string-to-number)
 291              (fset 'si:string-to-number (symbol-function 'string-to-number))
 292            (fset 'si:string-to-number (symbol-function 'string-to-int))
 293            ;; XXX: In v18, this causes infinite loop while bytecompiling.
 294            ;; (defalias 'string-to-int 'string-to-number)
 295            )
 296          (put 'string-to-number 'defun-maybe t)
 297          (defun string-to-number (string &optional base)
 298            "\
 299 Convert STRING to a number by parsing it as a decimal number.
 300 This parses both integers and floating point numbers.
 301 It ignores leading spaces and tabs.
 302
 303 If BASE, interpret STRING as a number in that base.  If BASE isn't
 304 present, base 10 is used.  BASE must be between 2 and 16 (inclusive).
 305 If the base used is not 10, floating point is not recognized."
 306            (if (or (null base) (= base 10))
 307                (si:string-to-number string)
 308              (if (or (< base 2)(> base 16))
 309                  (signal 'args-out-of-range (cons base nil)))
 310              (let ((len (length string))
 311                    (pos 0))
 312                ;; skip leading whitespace.
 313                (while (and (< pos len)
 314                            (memq (aref string pos) '(?\  ?\t)))
 315                  (setq pos (1+ pos)))
 316                (if (= pos len)
 317                    0
 318                  (let ((number 0)(negative 1)
 319                        chr num)
 320                    (if (eq (aref string pos) ?-)
 321                        (setq negative -1
 322                              pos (1+ pos))
 323                      (if (eq (aref string pos) ?+)
 324                          (setq pos (1+ pos))))
 325                    (while (and (< pos len)
 326                                (setq chr (aref string pos)
 327                                      num (cond
 328                                           ((and (<= ?0 chr)(<= chr ?9))
 329                                            (- chr ?0))
 330                                           ((and (<= ?A chr)(<= chr ?F))
 331                                            (+ (- chr ?A) 10))
 332                                           ((and (<= ?a chr)(<= chr ?f))
 333                                            (+ (- chr ?a) 10))
 334                                           (t nil)))
 335                                (< num base))
 336                      (setq number (+ (* number base) num)
 337                            pos (1+ pos)))
 338                    (* negative number))))))))))
 339
 340 ;; Emacs 20.1 and 20.2: (concat-chars &rest CHARS)
 341 ;; Emacs 20.3/XEmacs 21.0 and later: (string &rest CHARS)
 342 (static-cond
 343  ((and (fboundp 'string)
 344        (subrp (symbol-function 'string)))
 345   ;; Emacs 20.3/XEmacs 21.0 and later.
 346   )
 347  ((and (fboundp 'concat-chars)
 348        (subrp (symbol-function 'concat-chars)))
 349   ;; Emacs 20.1 and 20.2.
 350   (defalias 'string 'concat-chars))
 351  (t
 352   ;; Use `defun-maybe' to update `load-history'.
 353   (defun-maybe string (&rest chars)
 354     "Concatenate all the argument characters and make the result a string."
 355     ;; We cannot use (apply 'concat chars) here because `concat' does not
 356     ;; work with multibyte chars on Mule 1.* and 2.*.
 357     (mapconcat (function char-to-string) chars ""))))
 358
 359 ;; Mule: (char-before POS)
 360 ;; v20: (char-before &optional POS)
 361 (static-condition-case nil
 362     ;; compile-time check.
 363     (progn
 364       (char-before)
 365       (if (get 'char-before 'defun-maybe)
 366           (error "`char-before' is already defined")))
 367   (wrong-number-of-arguments            ; Mule.
 368    ;; load-time check.
 369    (or (fboundp 'si:char-before)
 370        (progn
 371          (fset 'si:char-before (symbol-function 'char-before))
 372          (put 'char-before 'defun-maybe t)
 373          ;; takes IGNORED for backward compatibility.
 374          (defun char-before (&optional pos ignored)
 375            "\
 376 Return character in current buffer preceding position POS.
 377 POS is an integer or a buffer pointer.
 378 If POS is out of range, the value is nil."
 379            (si:char-before (or pos (point)))))))
 380   (void-function                        ; non-Mule.
 381    ;; load-time check.
 382    (defun-maybe char-before (&optional pos)
 383      "\
 384 Return character in current buffer preceding position POS.
 385 POS is an integer or a buffer pointer.
 386 If POS is out of range, the value is nil."
 387      (if pos
 388          (save-excursion
 389            (and (= (goto-char pos) (point))
 390                 (not (bobp))
 391                 (preceding-char)))
 392        (and (not (bobp))
 393             (preceding-char)))))
 394   (error                                ; found our definition at compile-time.
 395    ;; load-time check.
 396    (condition-case nil
 397        (char-before)
 398      (wrong-number-of-arguments         ; Mule.
 399       (or (fboundp 'si:char-before)
 400           (progn
 401             (fset 'si:char-before (symbol-function 'char-before))
 402             (put 'char-before 'defun-maybe t)
 403             ;; takes IGNORED for backward compatibility.
 404             (defun char-before (&optional pos ignored)
 405               "\
 406 Return character in current buffer preceding position POS.
 407 POS is an integer or a buffer pointer.
 408 If POS is out of range, the value is nil."
 409               (si:char-before (or pos (point)))))))
 410      (void-function                     ; non-Mule.
 411       (defun-maybe char-before (&optional pos)
 412         "\
 413 Return character in current buffer preceding position POS.
 414 POS is an integer or a buffer pointer.
 415 If POS is out of range, the value is nil."
 416         (if pos
 417             (save-excursion
 418               (and (= (goto-char pos) (point))
 419                    (not (bobp))
 420                    (preceding-char)))
 421           (and (not (bobp))
 422                (preceding-char))))))))
 423
 424 ;; v18, v19: (char-after POS)
 425 ;; v20: (char-after &optional POS)
 426 (static-condition-case nil
 427     ;; compile-time check.
 428     (progn
 429       (char-after)
 430       (if (get 'char-after 'defun-maybe)
 431           (error "`char-after' is already redefined")))
 432   (wrong-number-of-arguments            ; v18, v19
 433    ;; load-time check.
 434    (or (fboundp 'si:char-after)
 435        (progn
 436          (fset 'si:char-after (symbol-function 'char-after))
 437          (put 'char-after 'defun-maybe t)
 438          (defun char-after (&optional pos)
 439            "\
 440 Return character in current buffer at position POS.
 441 POS is an integer or a buffer pointer.
 442 If POS is out of range, the value is nil."
 443            (si:char-after (or pos (point)))))))
 444   (void-function                        ; NEVER happen?
 445    ;; load-time check.
 446    (defun-maybe char-after (&optional pos)
 447      "\
 448 Return character in current buffer at position POS.
 449 POS is an integer or a buffer pointer.
 450 If POS is out of range, the value is nil."
 451      (if pos
 452          (save-excursion
 453            (and (= (goto-char pos) (point))
 454                 (not (eobp))
 455                 (following-char)))
 456        (and (not (eobp))
 457             (following-char)))))
 458   (error                                ; found our definition at compile-time.
 459    ;; load-time check.
 460    (condition-case nil
 461        (char-after)
 462      (wrong-number-of-arguments         ; v18, v19
 463       (or (fboundp 'si:char-after)
 464           (progn
 465             (fset 'si:char-after (symbol-function 'char-after))
 466             (put 'char-after 'defun-maybe t)
 467             (defun char-after (&optional pos)
 468               "\
 469 Return character in current buffer at position POS.
 470 POS is an integer or a buffer pointer.
 471 If POS is out of range, the value is nil."
 472               (si:char-after (or pos (point)))))))
 473      (void-function                     ; NEVER happen?
 474       (defun-maybe char-after (&optional pos)
 475         "\
 476 Return character in current buffer at position POS.
 477 POS is an integer or a buffer pointer.
 478 If POS is out of range, the value is nil."
 479         (if pos
 480             (save-excursion
 481               (and (= (goto-char pos) (point))
 482                    (not (eobp))
 483                    (following-char)))
 484           (and (not (eobp))
 485                (following-char))))))))
 486
 487 ;; Emacs 19.29 and later: (buffer-substring-no-properties START END)
 488 (defun-maybe buffer-substring-no-properties (start end)
 489   "Return the characters of part of the buffer, without the text properties.
 490 The two arguments START and END are character positions;
 491 they can be in either order."
 492   (let ((string (buffer-substring start end)))
 493     (set-text-properties 0 (length string) nil string)
 494     string))
 495
 496 ;; Emacs 19.31 and later: (buffer-live-p OBJECT)
 497 (defun-maybe buffer-live-p (object)
 498   "Return non-nil if OBJECT is a buffer which has not been killed.
 499 Value is nil if OBJECT is not a buffer or if it has been killed."
 500   (and object
 501        (get-buffer object)
 502        (buffer-name (get-buffer object))
 503        t))
 504
 505 ;; Emacs 20: (line-beginning-position &optional N)
 506 (defun-maybe line-beginning-position (&optional n)
 507   "Return the character position of the first character on the current line.
 508 With argument N not nil or 1, move forward N - 1 lines first.
 509 If scan reaches end of buffer, return that position.
 510 This function does not move point."
 511   (save-excursion
 512     (forward-line (1- (or n 1)))
 513     (point)))
 514
 515 ;; Emacs 20: (line-end-position &optional N)
 516 (defun-maybe line-end-position (&optional n)
 517   "Return the character position of the last character on the current line.
 518 With argument N not nil or 1, move forward N - 1 lines first.
 519 If scan reaches end of buffer, return that position.
 520 This function does not move point."
 521   (save-excursion
 522     (end-of-line (or n 1))
 523     (point)))
 524
 525 ;; FSF Emacs 19.29 and later
 526 ;; (read-file-name PROMPT &optional DIR DEFAULT-FILENAME MUSTMATCH INITIAL)
 527 ;; XEmacs 19.14 and later:
 528 ;; (read-file-name (PROMPT &optional DIR DEFAULT MUST-MATCH INITIAL-CONTENTS
 529 ;;                         HISTORY)
 530
 531 ;; In FSF Emacs 19.28 and earlier (except for v18) or XEmacs 19.13 and
 532 ;; earlier, this function is incompatible with the other Emacsen.
 533 ;; For instance, if DEFAULT-FILENAME is nil, INITIAL is not and user
 534 ;; enters a null string, it returns the visited file name of the current
 535 ;; buffer if it is non-nil.
 536
 537 ;; It does not assimilate the different numbers of the optional arguments
 538 ;; on various Emacsen (yet).
 539 (static-cond
 540  ((and (not (featurep 'xemacs))
 541        (eq emacs-major-version 19)
 542        (< emacs-minor-version 29))
 543   (if (fboundp 'si:read-file-name)
 544       nil
 545     (fset 'si:read-file-name (symbol-function 'read-file-name))
 546     (defun read-file-name (prompt &optional dir default-filename mustmatch
 547                                   initial)
 548       "Read file name, prompting with PROMPT and completing in directory DIR.
 549 Value is not expanded---you must call `expand-file-name' yourself.
 550 Default name to DEFAULT-FILENAME if user enters a null string.
 551  (If DEFAULT-FILENAME is omitted, the visited file name is used,
 552   except that if INITIAL is specified, that combined with DIR is used.)
 553 Fourth arg MUSTMATCH non-nil means require existing file's name.
 554  Non-nil and non-t means also require confirmation after completion.
 555 Fifth arg INITIAL specifies text to start with.
 556 DIR defaults to current buffer's directory default."
 557       (si:read-file-name prompt dir
 558                          (or default-filename
 559                              (if initial
 560                                  (expand-file-name initial dir)))
 561                          mustmatch initial))))
 562  ((and (featurep 'xemacs)
 563        (eq emacs-major-version 19)
 564        (< emacs-minor-version 14))
 565   (if (fboundp 'si:read-file-name)
 566       nil
 567     (fset 'si:read-file-name (symbol-function 'read-file-name))
 568     (defun read-file-name (prompt &optional dir default must-match
 569                                   initial-contents history)
 570       "Read file name, prompting with PROMPT and completing in directory DIR.
 571 This will prompt with a dialog box if appropriate, according to
 572  `should-use-dialog-box-p'.
 573 Value is not expanded---you must call `expand-file-name' yourself.
 574 Value is subject to interpreted by substitute-in-file-name however.
 575 Default name to DEFAULT if user enters a null string.
 576  (If DEFAULT is omitted, the visited file name is used,
 577   except that if INITIAL-CONTENTS is specified, that combined with DIR is
 578   used.)
 579 Fourth arg MUST-MATCH non-nil means require existing file's name.
 580  Non-nil and non-t means also require confirmation after completion.
 581 Fifth arg INITIAL-CONTENTS specifies text to start with.
 582 Sixth arg HISTORY specifies the history list to use.  Default is
 583  `file-name-history'.
 584 DIR defaults to current buffer's directory default."
 585       (si:read-file-name prompt dir
 586                          (or default
 587                              (if initial-contents
 588                                  (expand-file-name initial-contents dir)))
 589                          must-match initial-contents history)))))
 590 \f
 591
 592 ;;; @ Basic lisp subroutines emulation. (lisp/subr.el)
 593 ;;;
 594
 595 ;;; @@ Lisp language features.
 596
 597 (defmacro-maybe push (newelt listname)
 598   "Add NEWELT to the list stored in the symbol LISTNAME.
 599 This is equivalent to (setq LISTNAME (cons NEWELT LISTNAME)).
 600 LISTNAME must be a symbol."
 601   (list 'setq listname
 602         (list 'cons newelt listname)))
 603
 604 (defmacro-maybe pop (listname)
 605   "Return the first element of LISTNAME's value, and remove it from the list.
 606 LISTNAME must be a symbol whose value is a list.
 607 If the value is nil, `pop' returns nil but does not actually
 608 change the list."
 609   (list 'prog1 (list 'car listname)
 610         (list 'setq listname (list 'cdr listname))))
 611
 612 (defmacro-maybe when (cond &rest body)
 613   "If COND yields non-nil, do BODY, else return nil."
 614   (list 'if cond (cons 'progn body)))
 615 ;; (def-edebug-spec when (&rest form))
 616
 617 (defmacro-maybe unless (cond &rest body)
 618   "If COND yields nil, do BODY, else return nil."
 619   (cons 'if (cons cond (cons nil body))))
 620 ;; (def-edebug-spec unless (&rest form))
 621
 622 (defsubst-maybe caar (x)
 623   "Return the car of the car of X."
 624   (car (car x)))
 625
 626 (defsubst-maybe cadr (x)
 627   "Return the car of the cdr of X."
 628   (car (cdr x)))
 629
 630 (defsubst-maybe cdar (x)
 631   "Return the cdr of the car of X."
 632   (cdr (car x)))
 633
 634 (defsubst-maybe cddr (x)
 635   "Return the cdr of the cdr of X."
 636   (cdr (cdr x)))
 637
 638 (defun-maybe last (x &optional n)
 639   "Return the last link of the list X.  Its car is the last element.
 640 If X is nil, return nil.
 641 If N is non-nil, return the Nth-to-last link of X.
 642 If N is bigger than the length of X, return X."
 643   (if n
 644       (let ((m 0) (p x))
 645         (while (consp p)
 646           (setq m (1+ m) p (cdr p)))
 647         (if (<= n 0) p
 648           (if (< n m) (nthcdr (- m n) x) x)))
 649     (while (cdr x)
 650       (setq x (cdr x)))
 651     x))
 652
 653 ;; Actually, `butlast' and `nbutlast' are defined in lisp/cl.el.
 654 (defun-maybe butlast (x &optional n)
 655   "Returns a copy of LIST with the last N elements removed."
 656   (if (and n (<= n 0)) x
 657     (nbutlast (copy-sequence x) n)))
 658
 659 (defun-maybe nbutlast (x &optional n)
 660   "Modifies LIST to remove the last N elements."
 661   (let ((m (length x)))
 662     (or n (setq n 1))
 663     (and (< n m)
 664          (progn
 665            (if (> n 0) (setcdr (nthcdr (- (1- m) n) x) nil))
 666            x))))
 667
 668 ;; Emacs 20.3 and later: (assoc-default KEY ALIST &optional TEST DEFAULT)
 669 (defun-maybe assoc-default (key alist &optional test default)
 670   "Find object KEY in a pseudo-alist ALIST.
 671 ALIST is a list of conses or objects.  Each element (or the element's car,
 672 if it is a cons) is compared with KEY by evaluating (TEST (car elt) KEY).
 673 If that is non-nil, the element matches;
 674 then `assoc-default' returns the element's cdr, if it is a cons,
 675 or DEFAULT if the element is not a cons.
 676
 677 If no element matches, the value is nil.
 678 If TEST is omitted or nil, `equal' is used."
 679   (let (found (tail alist) value)
 680     (while (and tail (not found))
 681       (let ((elt (car tail)))
 682         (when (funcall (or test 'equal) (if (consp elt) (car elt) elt) key)
 683           (setq found t value (if (consp elt) (cdr elt) default))))
 684       (setq tail (cdr tail)))
 685     value))
 686
 687 ;; The following two function use `compare-strings', which we don't
 688 ;; support yet.
 689 ;; (defun assoc-ignore-case (key alist))
 690 ;; (defun assoc-ignore-representation (key alist))
 691
 692 ;; Emacs 19.29/XEmacs 19.13 and later: (rassoc KEY LIST)
 693 ;; Actually, `rassoc' is defined in src/fns.c.
 694 (defun-maybe rassoc (key list)
 695   "Return non-nil if KEY is `equal' to the cdr of an element of LIST.
 696 The value is actually the element of LIST whose cdr equals KEY.
 697 Elements of LIST that are not conses are ignored."
 698   (catch 'found
 699     (while list
 700       (cond ((not (consp (car list))))
 701             ((equal (cdr (car list)) key)
 702              (throw 'found (car list))))
 703       (setq list (cdr list)))))
 704
 705 ;; XEmacs 19.13 and later: (remassq KEY LIST)
 706 (defun-maybe remassq (key list)
 707   "Delete by side effect any elements of LIST whose car is `eq' to KEY.
 708 The modified LIST is returned.  If the first member of LIST has a car
 709 that is `eq' to KEY, there is no way to remove it by side effect;
 710 therefore, write `(setq foo (remassq key foo))' to be sure of changing
 711 the value of `foo'."
 712   (if (setq key (assq key list))
 713       (delq key list)
 714     list))
 715
 716 ;; XEmacs 19.13 and later: (remassoc KEY LIST)
 717 (defun-maybe remassoc (key list)
 718   "Delete by side effect any elements of LIST whose car is `equal' to KEY.
 719 The modified LIST is returned.  If the first member of LIST has a car
 720 that is `equal' to KEY, there is no way to remove it by side effect;
 721 therefore, write `(setq foo (remassoc key foo))' to be sure of changing
 722 the value of `foo'."
 723   (if (setq key (assoc key list))
 724       (delq key list)
 725     list))
 726
 727 ;; XEmacs 19.13 and later: (remrassq VALUE LIST)
 728 (defun-maybe remrassq (value list)
 729   "Delete by side effect any elements of LIST whose cdr is `eq' to VALUE.
 730 The modified LIST is returned.  If the first member of LIST has a car
 731 that is `eq' to VALUE, there is no way to remove it by side effect;
 732 therefore, write `(setq foo (remrassq value foo))' to be sure of changing
 733 the value of `foo'."
 734   (if (setq value (rassq value list))
 735       (delq value list)
 736     list))
 737
 738 ;; XEmacs 19.13 and later: (remrassoc VALUE LIST)
 739 (defun-maybe remrassoc (value list)
 740   "Delete by side effect any elements of LIST whose cdr is `equal' to VALUE.
 741 The modified LIST is returned.  If the first member of LIST has a car
 742 that is `equal' to VALUE, there is no way to remove it by side effect;
 743 therefore, write `(setq foo (remrassoc value foo))' to be sure of changing
 744 the value of `foo'."
 745   (if (setq value (rassoc value list))
 746       (delq value list)
 747     list))
 748
 749 ;;; Define `functionp' here because "localhook" uses it.
 750
 751 ;; Emacs 20.1/XEmacs 20.3 (but first appeared in Epoch?): (functionp OBJECT)
 752 (defun-maybe functionp (object)
 753   "Non-nil if OBJECT is a type of object that can be called as a function."
 754   (or (subrp object) (byte-code-function-p object)
 755       (eq (car-safe object) 'lambda)
 756       (and (symbolp object) (fboundp object))))
 757
 758 ;;; @@ Hook manipulation functions.
 759
 760 ;; "localhook" package is written for Emacs 19.28 and earlier.
 761 ;; `run-hooks' was a lisp function in Emacs 19.29 and earlier.
 762 ;; So, in Emacs 19.29, `run-hooks' and others will be overrided.
 763 ;; But, who cares it?
 764 (static-unless (subrp (symbol-function 'run-hooks))
 765   (require 'localhook))
 766
 767 ;; Emacs 19.29/XEmacs 19.14(?) and later: (add-to-list LIST-VAR ELEMENT)
 768 (defun-maybe add-to-list (list-var element)
 769   "Add to the value of LIST-VAR the element ELEMENT if it isn't there yet.
 770 The test for presence of ELEMENT is done with `equal'.
 771 If you want to use `add-to-list' on a variable that is not defined
 772 until a certain package is loaded, you should put the call to `add-to-list'
 773 into a hook function that will be run only after loading the package.
 774 `eval-after-load' provides one way to do this.  In some cases
 775 other hooks, such as major mode hooks, can do the job."
 776   (or (member element (symbol-value list-var))
 777       (set list-var (cons element (symbol-value list-var)))))
 778
 779 ;; (eval-after-load FILE FORM)
 780 ;; Emacs 19.28 and earlier do not evaluate FORM if FILE is already loaded.
 781 ;; XEmacs 20.2 and earlier have `after-load-alist', but refuse to support
 782 ;; `eval-after-load'. (see comments in XEmacs/lisp/subr.el.)
 783 (static-cond
 784  ((featurep 'xemacs)
 785   ;; for XEmacs 20.2 and earlier.
 786   (defun-maybe eval-after-load (file form)
 787     "Arrange that, if FILE is ever loaded, FORM will be run at that time.
 788 This makes or adds to an entry on `after-load-alist'.
 789 If FILE is already loaded, evaluate FORM right now.
 790 It does nothing if FORM is already on the list for FILE.
 791 FILE should be the name of a library, with no directory name."
 792     ;; Make sure there is an element for FILE.
 793     (or (assoc file after-load-alist)
 794         (setq after-load-alist (cons (list file) after-load-alist)))
 795     ;; Add FORM to the element if it isn't there.
 796     (let ((elt (assoc file after-load-alist)))
 797       (or (member form (cdr elt))
 798           (progn
 799             (nconc elt (list form))
 800             ;; If the file has been loaded already, run FORM right away.
 801             (and (assoc file load-history)
 802                  (eval form)))))
 803     form))
 804  ((>= emacs-major-version 20))
 805  ((and (= emacs-major-version 19)
 806        (< emacs-minor-version 29))
 807   ;; for Emacs 19.28 and earlier.
 808   (defun eval-after-load (file form)
 809     "Arrange that, if FILE is ever loaded, FORM will be run at that time.
 810 This makes or adds to an entry on `after-load-alist'.
 811 If FILE is already loaded, evaluate FORM right now.
 812 It does nothing if FORM is already on the list for FILE.
 813 FILE should be the name of a library, with no directory name."
 814     ;; Make sure there is an element for FILE.
 815     (or (assoc file after-load-alist)
 816         (setq after-load-alist (cons (list file) after-load-alist)))
 817     ;; Add FORM to the element if it isn't there.
 818     (let ((elt (assoc file after-load-alist)))
 819       (or (member form (cdr elt))
 820           (progn
 821             (nconc elt (list form))
 822             ;; If the file has been loaded already, run FORM right away.
 823             (and (assoc file load-history)
 824                  (eval form)))))
 825     form))
 826  (t
 827   ;; should emulate for v18?
 828   ))
 829
 830 (defun-maybe eval-next-after-load (file)
 831   "Read the following input sexp, and run it whenever FILE is loaded.
 832 This makes or adds to an entry on `after-load-alist'.
 833 FILE should be the name of a library, with no directory name."
 834   (eval-after-load file (read)))
 835
 836 ;;; @@ Input and display facilities.
 837
 838 ;; XXX: (defun read-passwd (prompt &optional confirm default))
 839
 840 ;;; @@ Miscellanea.
 841
 842 ;; Avoid compiler warnings about this variable,
 843 ;; which has a special meaning on certain system types.
 844 (defvar-maybe buffer-file-type nil
 845   "Non-nil if the visited file is a binary file.
 846 This variable is meaningful on MS-DOG and Windows NT.
 847 On those systems, it is automatically local in every buffer.
 848 On other systems, this variable is normally always nil.")
 849
 850 ;; Emacs 20.1/XEmacs 20.3(?) and later: (save-current-buffer &rest BODY)
 851 ;;
 852 ;; v20 defines `save-current-buffer' as a C primitive (in src/editfns.c)
 853 ;; and introduces a new bytecode Bsave_current_buffer(_1), replacing an
 854 ;; obsolete bytecode Bread_char.  To make things worse, Emacs 20.1 and
 855 ;; 20.2 have a bug that it will restore the current buffer without
 856 ;; confirming that it is alive.
 857 ;;
 858 ;; This is a source of incompatibility of .elc between v18/v19 and v20.
 859 ;; (XEmacs compiler takes care of it if compatibility mode is enabled.)
 860 (defmacro-maybe save-current-buffer (&rest body)
 861   "Save the current buffer; execute BODY; restore the current buffer.
 862 Executes BODY just like `progn'."
 863   (` (let ((orig-buffer (current-buffer)))
 864        (unwind-protect
 865            (progn (,@ body))
 866          (if (buffer-live-p orig-buffer)
 867              (set-buffer orig-buffer))))))
 868
 869 ;; Emacs 20.1/XEmacs 20.3(?) and later: (with-current-buffer BUFFER &rest BODY)
 870 (defmacro-maybe with-current-buffer (buffer &rest body)
 871   "Execute the forms in BODY with BUFFER as the current buffer.
 872 The value returned is the value of the last form in BODY.
 873 See also `with-temp-buffer'."
 874   (` (save-current-buffer
 875        (set-buffer (, buffer))
 876        (,@ body))))
 877
 878 ;; Emacs 20.1/XEmacs 20.3(?) and later: (with-temp-file FILE &rest FORMS)
 879 (defmacro-maybe with-temp-file (file &rest forms)
 880   "Create a new buffer, evaluate FORMS there, and write the buffer to FILE.
 881 The value of the last form in FORMS is returned, like `progn'.
 882 See also `with-temp-buffer'."
 883   (let ((temp-file (make-symbol "temp-file"))
 884         (temp-buffer (make-symbol "temp-buffer")))
 885     (` (let (((, temp-file) (, file))
 886              ((, temp-buffer)
 887               (get-buffer-create (generate-new-buffer-name " *temp file*"))))
 888          (unwind-protect
 889              (prog1
 890                  (with-current-buffer (, temp-buffer)
 891                    (,@ forms))
 892                (with-current-buffer (, temp-buffer)
 893                  (widen)
 894                  (write-region (point-min) (point-max) (, temp-file) nil 0)))
 895            (and (buffer-name (, temp-buffer))
 896                 (kill-buffer (, temp-buffer))))))))
 897
 898 ;; Emacs 20.4 and later: (with-temp-message MESSAGE &rest BODY)
 899 ;; This macro uses `current-message', which appears in v20.
 900 (static-when (and (fboundp 'current-message)
 901                   (subrp (symbol-function 'current-message)))
 902   (defmacro-maybe with-temp-message (message &rest body)
 903     "\
 904 Display MESSAGE temporarily if non-nil while BODY is evaluated.
 905 The original message is restored to the echo area after BODY has finished.
 906 The value returned is the value of the last form in BODY.
 907 MESSAGE is written to the message log buffer if `message-log-max' is non-nil.
 908 If MESSAGE is nil, the echo area and message log buffer are unchanged.
 909 Use a MESSAGE of \"\" to temporarily clear the echo area."
 910     (let ((current-message (make-symbol "current-message"))
 911           (temp-message (make-symbol "with-temp-message")))
 912       (` (let (((, temp-message) (, message))
 913                ((, current-message)))
 914            (unwind-protect
 915                (progn
 916                  (when (, temp-message)
 917                    (setq (, current-message) (current-message))
 918                    (message "%s" (, temp-message))
 919                    (,@ body))
 920                  (and (, temp-message) (, current-message)
 921                       (message "%s" (, current-message))))))))))
 922
 923 ;; Emacs 20.1/XEmacs 20.3(?) and later: (with-temp-buffer &rest FORMS)
 924 (defmacro-maybe with-temp-buffer (&rest forms)
 925   "Create a temporary buffer, and evaluate FORMS there like `progn'.
 926 See also `with-temp-file' and `with-output-to-string'."
 927   (let ((temp-buffer (make-symbol "temp-buffer")))
 928     (` (let (((, temp-buffer)
 929               (get-buffer-create (generate-new-buffer-name " *temp*"))))
 930          (unwind-protect
 931              (with-current-buffer (, temp-buffer)
 932                (,@ forms))
 933            (and (buffer-name (, temp-buffer))
 934                 (kill-buffer (, temp-buffer))))))))
 935
 936 ;; Emacs 20.1/XEmacs 20.3(?) and later: (with-output-to-string &rest BODY)
 937 (defmacro-maybe with-output-to-string (&rest body)
 938   "Execute BODY, return the text it sent to `standard-output', as a string."
 939   (` (let ((standard-output
 940             (get-buffer-create (generate-new-buffer-name " *string-output*"))))
 941        (let ((standard-output standard-output))
 942          (,@ body))
 943        (with-current-buffer standard-output
 944          (prog1
 945              (buffer-string)
 946            (kill-buffer nil))))))
 947
 948 ;; Emacs 20.1 and later: (combine-after-change-calls &rest BODY)
 949 (defmacro-maybe combine-after-change-calls (&rest body)
 950   "Execute BODY, but don't call the after-change functions till the end.
 951 If BODY makes changes in the buffer, they are recorded
 952 and the functions on `after-change-functions' are called several times
 953 when BODY is finished.
 954 The return value is the value of the last form in BODY.
 955
 956 If `before-change-functions' is non-nil, then calls to the after-change
 957 functions can't be deferred, so in that case this macro has no effect.
 958
 959 Do not alter `after-change-functions' or `before-change-functions'
 960 in BODY.
 961
 962 This emulating macro does not support after-change functions at all,
 963 just execute BODY."
 964   (cons 'progn body))
 965
 966 ;; Emacs 19.29/XEmacs 19.14(?) and later: (match-string NUM &optional STRING)
 967 (defun-maybe match-string (num &optional string)
 968   "Return string of text matched by last search.
 969 NUM specifies which parenthesized expression in the last regexp.
 970  Value is nil if NUMth pair didn't match, or there were less than NUM pairs.
 971 Zero means the entire text matched by the whole regexp or whole string.
 972 STRING should be given if the last search was by `string-match' on STRING."
 973   (if (match-beginning num)
 974       (if string
 975           (substring string (match-beginning num) (match-end num))
 976         (buffer-substring (match-beginning num) (match-end num)))))
 977
 978 ;; Emacs 20.3 and later: (match-string-no-properties NUM &optional STRING)
 979 (defun-maybe match-string-no-properties (num &optional string)
 980   "Return string of text matched by last search, without text properties.
 981 NUM specifies which parenthesized expression in the last regexp.
 982  Value is nil if NUMth pair didn't match, or there were less than NUM pairs.
 983 Zero means the entire text matched by the whole regexp or whole string.
 984 STRING should be given if the last search was by `string-match' on STRING."
 985   (if (match-beginning num)
 986       (if string
 987           (let ((result
 988                  (substring string (match-beginning num) (match-end num))))
 989             (set-text-properties 0 (length result) nil result)
 990             result)
 991         (buffer-substring-no-properties (match-beginning num)
 992                                         (match-end num)))))
 993
 994 ;; Emacs 19.28 and earlier
 995 ;;  (replace-match NEWTEXT &optional FIXEDCASE LITERAL)
 996 ;; Emacs 20.x (?) and later
 997 ;;  (replace-match NEWTEXT &optional FIXEDCASE LITERAL STRING SUBEXP)
 998 ;; XEmacs 21:
 999 ;;  (replace-match NEWTEXT &optional FIXEDCASE LITERAL STRING STRBUFFER)
1000 ;; We support following API.
1001 ;;  (replace-match NEWTEXT &optional FIXEDCASE LITERAL STRING)
1002 (static-condition-case nil
1003     ;; compile-time check
1004     (progn
1005       (string-match "" "")
1006       (replace-match "" nil nil "")
1007       (if (get 'replace-match 'defun-maybe)
1008           (error "`replace-match' is already defined")))
1009   (wrong-number-of-arguments ; Emacs 19.28 and earlier
1010    ;; load-time check.
1011    (or (fboundp 'si:replace-match)
1012        (progn
1013          (fset 'si:replace-match (symbol-function 'replace-match))
1014          (put 'replace-match 'defun-maybe t)
1015          (defun replace-match (newtext &optional fixedcase literal string)
1016            "Replace text matched by last search with NEWTEXT.
1017 If second arg FIXEDCASE is non-nil, do not alter case of replacement text.
1018 Otherwise maybe capitalize the whole text, or maybe just word initials,
1019 based on the replaced text.
1020 If the replaced text has only capital letters
1021 and has at least one multiletter word, convert NEWTEXT to all caps.
1022 If the replaced text has at least one word starting with a capital letter,
1023 then capitalize each word in NEWTEXT.
1024
1025 If third arg LITERAL is non-nil, insert NEWTEXT literally.
1026 Otherwise treat `\' as special:
1027   `\&' in NEWTEXT means substitute original matched text.
1028   `\N' means substitute what matched the Nth `\(...\)'.
1029        If Nth parens didn't match, substitute nothing.
1030   `\\' means insert one `\'.
1031 FIXEDCASE and LITERAL are optional arguments.
1032 Leaves point at end of replacement text.
1033
1034 The optional fourth argument STRING can be a string to modify.
1035 In that case, this function creates and returns a new string
1036 which is made by replacing the part of STRING that was matched."
1037            (if string
1038                (with-temp-buffer
1039                 (save-match-data
1040                   (insert string)
1041                   (let* ((matched (match-data))
1042                          (beg (nth 0 matched))
1043                          (end (nth 1 matched)))
1044                     (store-match-data
1045                      (list
1046                       (if (markerp beg)
1047                           (move-marker beg (1+ (match-beginning 0)))
1048                         (1+ (match-beginning 0)))
1049                       (if (markerp end)
1050                           (move-marker end (1+ (match-end 0)))
1051                         (1+ (match-end 0))))))
1052                   (si:replace-match newtext fixedcase literal)
1053                   (buffer-string)))
1054              (si:replace-match newtext fixedcase literal))))))
1055   (error ; found our definition at compile-time.
1056    ;; load-time check.
1057    (condition-case nil
1058     (progn
1059       (string-match "" "")
1060       (replace-match "" nil nil ""))
1061     (wrong-number-of-arguments ; Emacs 19.28 and earlier
1062      ;; load-time check.
1063      (or (fboundp 'si:replace-match)
1064          (progn
1065            (fset 'si:replace-match (symbol-function 'replace-match))
1066            (put 'replace-match 'defun-maybe t)
1067            (defun replace-match (newtext &optional fixedcase literal string)
1068              "Replace text matched by last search with NEWTEXT.
1069 If second arg FIXEDCASE is non-nil, do not alter case of replacement text.
1070 Otherwise maybe capitalize the whole text, or maybe just word initials,
1071 based on the replaced text.
1072 If the replaced text has only capital letters
1073 and has at least one multiletter word, convert NEWTEXT to all caps.
1074 If the replaced text has at least one word starting with a capital letter,
1075 then capitalize each word in NEWTEXT.
1076
1077 If third arg LITERAL is non-nil, insert NEWTEXT literally.
1078 Otherwise treat `\' as special:
1079   `\&' in NEWTEXT means substitute original matched text.
1080   `\N' means substitute what matched the Nth `\(...\)'.
1081        If Nth parens didn't match, substitute nothing.
1082   `\\' means insert one `\'.
1083 FIXEDCASE and LITERAL are optional arguments.
1084 Leaves point at end of replacement text.
1085
1086 The optional fourth argument STRING can be a string to modify.
1087 In that case, this function creates and returns a new string
1088 which is made by replacing the part of STRING that was matched."
1089              (if string
1090                  (with-temp-buffer
1091                   (save-match-data
1092                     (insert string)
1093                     (let* ((matched (match-data))
1094                            (beg (nth 0 matched))
1095                            (end (nth 1 matched)))
1096                       (store-match-data
1097                        (list
1098                         (if (markerp beg)
1099                             (move-marker beg (1+ (match-beginning 0)))
1100                           (1+ (match-beginning 0)))
1101                         (if (markerp end)
1102                             (move-marker end (1+ (match-end 0)))
1103                           (1+ (match-end 0))))))
1104                     (si:replace-match newtext fixedcase literal)
1105                     (buffer-string)))
1106                (si:replace-match newtext fixedcase literal)))))))))
1107
1108 ;; Emacs 20: (format-time-string)
1109 ;; The the third optional argument universal is yet to be implemented.
1110 ;; Those format constructs are yet to be implemented.
1111 ;;   %c, %C, %j, %U, %W, %x, %X
1112 ;; Not fully compatible especially when invalid format is specified.
1113 (static-unless (and (fboundp 'format-time-string)
1114                     (not (get 'format-time-string 'defun-maybe)))
1115   (or (fboundp 'format-time-string)
1116   (progn
1117   (defconst format-time-month-list
1118     '(( "Zero" . ("Zero" . 0))
1119       ("Jan" . ("January" . 1)) ("Feb" . ("February" . 2))
1120       ("Mar" . ("March" . 3)) ("Apr" . ("April" . 4)) ("May" . ("May" . 5))
1121       ("Jun" . ("June" . 6))("Jul" . ("July" . 7)) ("Aug" . ("August" . 8))
1122       ("Sep" . ("September" . 9)) ("Oct" . ("October" . 10))
1123       ("Nov" . ("November" . 11)) ("Dec" . ("December" . 12)))
1124     "Alist of months and their number.")
1125
1126   (defconst format-time-week-list
1127     '(("Sun" . ("Sunday" . 0)) ("Mon" . ("Monday" . 1))
1128       ("Tue" . ("Tuesday" . 2)) ("Wed" . ("Wednesday" . 3))
1129       ("Thu" . ("Thursday" . 4)) ("Fri" . ("Friday" . 5))
1130       ("Sat" . ("Saturday" . 6)))
1131     "Alist of weeks and their number.")
1132
1133   (defun format-time-string (format &optional time universal)
1134     "Use FORMAT-STRING to format the time TIME, or now if omitted.
1135 TIME is specified as (HIGH LOW . IGNORED) or (HIGH . LOW), as returned by
1136 `current-time' or `file-attributes'.
1137 The third, optional, argument UNIVERSAL, if non-nil, means describe TIME
1138 as Universal Time; nil means describe TIME in the local time zone.
1139 The value is a copy of FORMAT-STRING, but with certain constructs replaced
1140 by text that describes the specified date and time in TIME:
1141
1142 %Y is the year, %y within the century, %C the century.
1143 %G is the year corresponding to the ISO week, %g within the century.
1144 %m is the numeric month.
1145 %b and %h are the locale's abbreviated month name, %B the full name.
1146 %d is the day of the month, zero-padded, %e is blank-padded.
1147 %u is the numeric day of week from 1 (Monday) to 7, %w from 0 (Sunday) to 6.
1148 %a is the locale's abbreviated name of the day of week, %A the full name.
1149 %U is the week number starting on Sunday, %W starting on Monday,
1150  %V according to ISO 8601.
1151 %j is the day of the year.
1152
1153 %H is the hour on a 24-hour clock, %I is on a 12-hour clock, %k is like %H
1154  only blank-padded, %l is like %I blank-padded.
1155 %p is the locale's equivalent of either AM or PM.
1156 %M is the minute.
1157 %S is the second.
1158 %Z is the time zone name, %z is the numeric form.
1159 %s is the number of seconds since 1970-01-01 00:00:00 +0000.
1160
1161 %c is the locale's date and time format.
1162 %x is the locale's \"preferred\" date format.
1163 %D is like \"%m/%d/%y\".
1164
1165 %R is like \"%H:%M\", %T is like \"%H:%M:%S\", %r is like \"%I:%M:%S %p\".
1166 %X is the locale's \"preferred\" time format.
1167
1168 Finally, %n is a newline, %t is a tab, %% is a literal %.
1169
1170 Certain flags and modifiers are available with some format controls.
1171 The flags are `_' and `-'.  For certain characters X, %_X is like %X,
1172 but padded with blanks; %-X is like %X, but without padding.
1173 %NX (where N stands for an integer) is like %X,
1174 but takes up at least N (a number) positions.
1175 The modifiers are `E' and `O'.  For certain characters X,
1176 %EX is a locale's alternative version of %X;
1177 %OX is like %X, but uses the locale's number symbols.
1178
1179 For example, to produce full ISO 8601 format, use \"%Y-%m-%dT%T%z\".
1180
1181 Compatibility Note.
1182
1183 The the third optional argument universal is yet to be implemented.
1184 Those format constructs are yet to be implemented.
1185   %c, %C, %j, %U, %W, %x, %X
1186 Not fully compatible especially when invalid format is specified."
1187     (let ((fmt-len (length format))
1188           (ind 0)
1189           prev-ind
1190           cur-char
1191           (prev-char nil)
1192           strings-so-far
1193           (result "")
1194           field-width
1195           field-result
1196           pad-left change-case
1197           (paren-level 0)
1198           hour
1199           (time-string (current-time-string time)))
1200       (setq hour (string-to-int (substring time-string 11 13)))
1201       (while (< ind fmt-len)
1202         (setq cur-char (aref format ind))
1203         (setq
1204          result
1205          (concat result
1206         (cond
1207          ((eq cur-char ?%)
1208           ;; eat any additional args to allow for future expansion, not!!
1209           (setq pad-left nil change-case nil field-width "" prev-ind ind
1210                 strings-so-far "")
1211 ;         (catch 'invalid
1212           (while (progn
1213                    (setq ind (1+ ind))
1214                    (setq cur-char (if (< ind fmt-len)
1215                                       (aref format ind)
1216                                     ?\0))
1217                    (or (eq ?- cur-char) ; pad on left
1218                        (eq ?# cur-char) ; case change
1219                        (if (and (string-equal field-width "")
1220                                 (<= ?0 cur-char) (>= ?9 cur-char))
1221                            ;; get format width
1222                            (let ((field-index ind))
1223                              (while (progn
1224                                       (setq ind (1+ ind))
1225                                       (setq cur-char (if (< ind fmt-len)
1226                                                          (aref format ind)
1227                                                        ?\0))
1228                                       (and (<= ?0 cur-char) (>= ?9 cur-char))))
1229                              (setq field-width
1230                                    (substring format field-index ind))
1231                              (setq ind (1- ind)
1232                                    cur-char nil)
1233                              t))))
1234             (setq prev-char cur-char
1235                   strings-so-far (concat strings-so-far
1236                                          (if cur-char
1237                                              (char-to-string cur-char)
1238                                            field-width)))
1239             ;; characters we actually use
1240             (cond ((eq cur-char ?-)
1241                    ;; padding to left must be specified before field-width
1242                    (setq pad-left (string-equal field-width "")))
1243                   ((eq cur-char ?#)
1244                    (setq change-case t))))
1245           (setq field-result
1246                 (cond
1247                  ((eq cur-char ?%)
1248                   "%")
1249                  ;; the abbreviated name of the day of week.
1250                  ((eq cur-char ?a)
1251                   (substring time-string 0 3))
1252                  ;; the full name of the day of week
1253                  ((eq cur-char ?A)
1254                   (cadr (assoc (substring time-string 0 3)
1255                                format-time-week-list)))
1256                  ;; the abbreviated name of the month
1257                  ((eq cur-char ?b)
1258                   (substring time-string 4 7))
1259                  ;; the full name of the month
1260                  ((eq cur-char ?B)
1261                   (cadr (assoc (substring time-string 4 7)
1262                                format-time-month-list)))
1263                  ;; a synonym for `%x %X' (yet to come)
1264                  ((eq cur-char ?c)
1265                   "")
1266                  ;; locale specific (yet to come)
1267                  ((eq cur-char ?C)
1268                   "")
1269                  ;; the day of month, zero-padded
1270                  ((eq cur-char ?d)
1271                   (format "%02d" (string-to-int (substring time-string 8 10))))
1272                  ;; a synonym for `%m/%d/%y'
1273                  ((eq cur-char ?D)
1274                   (format "%02d/%02d/%s"
1275                           (cddr (assoc (substring time-string 4 7)
1276                                        format-time-month-list))
1277                           (string-to-int (substring time-string 8 10))
1278                           (substring time-string -2)))
1279                  ;; the day of month, blank-padded
1280                  ((eq cur-char ?e)
1281                   (format "%2d" (string-to-int (substring time-string 8 10))))
1282                  ;; a synonym for `%b'
1283                  ((eq cur-char ?h)
1284                   (substring time-string 4 7))
1285                  ;; the hour (00-23)
1286                  ((eq cur-char ?H)
1287                   (substring time-string 11 13))
1288                  ;; the hour (00-12)
1289                  ((eq cur-char ?I)
1290                   (format "%02d" (if (> hour 12) (- hour 12) hour)))
1291                  ;; the day of the year (001-366) (yet to come)
1292                  ((eq cur-char ?j)
1293                   "")
1294                  ;; the hour (0-23), blank padded
1295                  ((eq cur-char ?k)
1296                   (format "%2d" hour))
1297                  ;; the hour (1-12), blank padded
1298                  ((eq cur-char ?l)
1299                   (format "%2d" (if (> hour 12) (- hour 12) hour)))
1300                  ;; the month (01-12)
1301                  ((eq cur-char ?m)
1302                   (format "%02d" (cddr (assoc (substring time-string 4 7)
1303                                               format-time-month-list))))
1304                  ;; the minute (00-59)
1305                  ((eq cur-char ?M)
1306                   (substring time-string 14 16))
1307                  ;; a newline
1308                  ((eq cur-char ?n)
1309                   "\n")
1310                  ;; `AM' or `PM', as appropriate
1311                  ((eq cur-char ?p)
1312                   (setq change-case (not change-case))
1313                   (if (> hour 12) "pm" "am"))
1314                  ;; a synonym for `%I:%M:%S %p'
1315                  ((eq cur-char ?r)
1316                   (format "%02d:%s:%s %s"
1317                           (if (> hour 12) (- hour 12) hour)
1318                           (substring time-string 14 16)
1319                           (substring time-string 17 19)
1320                           (if (> hour 12) "PM" "AM")))
1321                  ;; a synonym for `%H:%M'
1322                  ((eq cur-char ?R)
1323                   (format "%s:%s"
1324                           (substring time-string 11 13)
1325                           (substring time-string 14 16)))
1326                  ;; the seconds (00-60)
1327                  ((eq cur-char ?S)
1328                   (substring time-string 17 19))
1329                  ;; a tab character
1330                  ((eq cur-char ?t)
1331                   "\t")
1332                  ;; a synonym for `%H:%M:%S'
1333                  ((eq cur-char ?T)
1334                   (format "%s:%s:%s"
1335                           (substring time-string 11 13)
1336                           (substring time-string 14 16)
1337                           (substring time-string 17 19)))
1338                  ;; the week of the year (01-52), assuming that weeks
1339                  ;; start on Sunday (yet to come)
1340                  ((eq cur-char ?U)
1341                   "")
1342                  ;; the numeric day of week (0-6).  Sunday is day 0
1343                  ((eq cur-char ?w)
1344                   (format "%d" (cddr (assoc (substring time-string 0 3)
1345                                             format-time-week-list))))
1346                  ;; the week of the year (01-52), assuming that weeks
1347                  ;; start on Monday (yet to come)
1348                  ((eq cur-char ?W)
1349                   "")
1350                  ;; locale specific (yet to come)
1351                  ((eq cur-char ?x)
1352                   "")
1353                  ;; locale specific (yet to come)
1354                  ((eq cur-char ?X)
1355                   "")
1356                  ;; the year without century (00-99)
1357                  ((eq cur-char ?y)
1358                   (substring time-string -2))
1359                  ;; the year with century
1360                  ((eq cur-char ?Y)
1361                   (substring time-string -4))
1362                  ;; the time zone abbreviation
1363                  ((eq cur-char ?Z)
1364                   (setq change-case (not change-case))
1365                   (downcase (cadr (current-time-zone))))
1366                  (t
1367                   (concat
1368                    "%"
1369                    strings-so-far
1370                    (char-to-string cur-char)))))
1371 ;                 (setq ind prev-ind)
1372 ;                 (throw 'invalid "%"))))
1373           (if (string-equal field-width "")
1374               (if change-case (upcase field-result) field-result)
1375             (let ((padded-result
1376                    (format (format "%%%s%s%c"
1377                                    ""   ; pad on left is ignored
1378 ;                                  (if pad-left "-" "")
1379                                    field-width
1380                                    ?s)
1381                            (or field-result ""))))
1382               (let ((initial-length (length padded-result))
1383                     (desired-length (string-to-int field-width)))
1384                 (when (and (string-match "^0" field-width)
1385                            (string-match "^ +" padded-result))
1386                   (setq padded-result
1387                         (replace-match
1388                          (make-string
1389                           (length (match-string 0 padded-result)) ?0)
1390                          nil nil padded-result)))
1391                 (if (> initial-length desired-length)
1392                     ;; truncate strings on right, years on left
1393                     (if (stringp field-result)
1394                         (substring padded-result 0 desired-length)
1395                       (if (eq cur-char ?y)
1396                           (substring padded-result (- desired-length))
1397                         padded-result))) ;non-year numbers don't truncate
1398                 (if change-case (upcase padded-result) padded-result))))) ;)
1399          (t
1400           (char-to-string cur-char)))))
1401         (setq ind (1+ ind)))
1402       result))
1403   ;; for `load-history'.
1404   (setq current-load-list (cons 'format-time-string current-load-list))
1405   (put 'format-time-string 'defun-maybe t))))
1406
1407 ;; Emacs 20.1/XEmacs 20.3(?) and later: (split-string STRING &optional PATTERN)
1408 ;; Here is a XEmacs version.
1409 (defun-maybe split-string (string &optional pattern)
1410   "Return a list of substrings of STRING which are separated by PATTERN.
1411 If PATTERN is omitted, it defaults to \"[ \\f\\t\\n\\r\\v]+\"."
1412   (or pattern
1413       (setq pattern "[ \f\t\n\r\v]+"))
1414   ;; The FSF version of this function takes care not to cons in case
1415   ;; of infloop.  Maybe we should synch?
1416   (let (parts (start 0))
1417     (while (string-match pattern string start)
1418       (setq parts (cons (substring string start (match-beginning 0)) parts)
1419             start (match-end 0)))
1420     (nreverse (cons (substring string start) parts))))
1421 \f
1422
1423 ;;; @ Window commands emulation. (lisp/window.el)
1424 ;;;
1425
1426 (defmacro-maybe save-selected-window (&rest body)
1427   "Execute BODY, then select the window that was selected before BODY."
1428   (list 'let
1429         '((save-selected-window-window (selected-window)))
1430         (list 'unwind-protect
1431               (cons 'progn body)
1432               (list 'select-window 'save-selected-window-window))))
1433
1434 ;; Emacs 19.31 and later:
1435 ;;  (get-buffer-window-list &optional BUFFER MINIBUF FRAME)
1436 (defun-maybe get-buffer-window-list (buffer &optional minibuf frame)
1437   "Return windows currently displaying BUFFER, or nil if none.
1438 See `walk-windows' for the meaning of MINIBUF and FRAME."
1439   (let ((buffer (if (bufferp buffer) buffer (get-buffer buffer))) windows)
1440     (walk-windows
1441      (function (lambda (window)
1442                  (if (eq (window-buffer window) buffer)
1443                      (setq windows (cons window windows)))))
1444      minibuf frame)
1445     windows))
1446 \f
1447
1448 ;;; @ Frame commands emulation. (lisp/frame.el)
1449 ;;;
1450
1451 ;; XEmacs 21.0 and later:
1452 ;;  (save-selected-frame &rest BODY)
1453 (defmacro-maybe save-selected-frame (&rest body)
1454   "Execute forms in BODY, then restore the selected frame."
1455   (list 'let
1456         '((save-selected-frame-frame (selected-frame)))
1457         (list 'unwind-protect
1458               (cons 'progn body)
1459               (list 'select-frame 'save-selected-frame-frame))))
1460 \f
1461
1462 ;;; @ Basic editing commands emulation. (lisp/simple.el)
1463 ;;;
1464 \f
1465
1466 ;;; @ File input and output commands emulation. (lisp/files.el)
1467 ;;;
1468
1469 (defvar-maybe temporary-file-directory
1470   (file-name-as-directory
1471    (cond ((memq system-type '(ms-dos windows-nt))
1472           (or (getenv "TEMP") (getenv "TMPDIR") (getenv "TMP") "c:/temp"))
1473          ((memq system-type '(vax-vms axp-vms))
1474           (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "SYS$SCRATCH:"))
1475          (t
1476           (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "/tmp"))))
1477   "The directory for writing temporary files.")
1478
1479 ;; Actually, `path-separator' is defined in src/emacs.c and overrided
1480 ;; in dos-w32.el.
1481 (defvar-maybe path-separator ":"
1482   "The directory separator in search paths, as a string.")
1483
1484 ;; `convert-standard-filename' is defined in lisp/files.el and overrided
1485 ;; in lisp/dos-fns.el and lisp/w32-fns.el for each environment.
1486 (cond
1487  ;; must be load-time check to share .elc between different systems.
1488  ((fboundp 'convert-standard-filename))
1489  ((memq system-type '(windows-nt ms-dos))
1490   ;; should we do (require 'filename) at load-time ?
1491   ;; (require 'filename)
1492   ;; filename.el requires many modules, so we do not want to load it
1493   ;; at compile-time. Instead, suppress warnings by these autoloads.
1494   (eval-when-compile
1495     (autoload 'filename-maybe-truncate-by-size "filename")
1496     (autoload 'filename-special-filter "filename"))
1497   (defun convert-standard-filename (filename)
1498     "Convert a standard file's name to something suitable for the current OS.
1499 This function's standard definition is trivial; it just returns the argument.
1500 However, on some systems, the function is redefined
1501 with a definition that really does change some file names.
1502 Under `windows-nt' or `ms-dos', it refers `filename-replacement-alist' and
1503 `filename-limit-length' for the basic filename and each parent directory name."
1504     (require 'filename)
1505     (let* ((names (split-string filename "/"))
1506            (drive-name (car names))
1507            (filter (function
1508                     (lambda (string)
1509                       (filename-maybe-truncate-by-size
1510                        (filename-special-filter string))))))
1511       (cond
1512        ((eq 1 (length names))
1513         (funcall filter drive-name))
1514        ((string-match "^[^/]:$" drive-name)
1515         (concat drive-name "/" (mapconcat filter (cdr names) "/")))
1516        (t
1517         (mapconcat filter names "/"))))))
1518  (t
1519   (defun convert-standard-filename (filename)
1520     "Convert a standard file's name to something suitable for the current OS.
1521 This function's standard definition is trivial; it just returns the argument.
1522 However, on some systems, the function is redefined
1523 with a definition that really does change some file names.
1524 Under `windows-nt' or `ms-dos', it refers `filename-replacement-alist' and
1525 `filename-limit-length' for the basic filename and each parent directory name."
1526     filename)))
1527
1528 (static-cond
1529  ((fboundp 'insert-file-contents-literally))
1530  ((boundp 'file-name-handler-alist)
1531   ;; Use `defun-maybe' to update `load-history'.
1532   (defun-maybe insert-file-contents-literally (filename &optional visit
1533                                                         beg end replace)
1534     "Like `insert-file-contents', q.v., but only reads in the file.
1535 A buffer may be modified in several ways after reading into the buffer due
1536 to advanced Emacs features, such as file-name-handlers, format decoding,
1537 find-file-hooks, etc.
1538   This function ensures that none of these modifications will take place."
1539     (let (file-name-handler-alist)
1540       (insert-file-contents filename visit beg end replace))))
1541  (t
1542   (defalias 'insert-file-contents-literally 'insert-file-contents)))
1543
1544 (defun-maybe file-name-sans-extension (filename)
1545   "Return FILENAME sans final \"extension\".
1546 The extension, in a file name, is the part that follows the last `.'."
1547   (save-match-data
1548     (let ((file (file-name-sans-versions (file-name-nondirectory filename)))
1549           directory)
1550       (if (string-match "\\.[^.]*\\'" file)
1551           (if (setq directory (file-name-directory filename))
1552               (expand-file-name (substring file 0 (match-beginning 0))
1553                                 directory)
1554             (substring file 0 (match-beginning 0)))
1555         filename))))
1556 \f
1557
1558 ;;; @ XEmacs emulation.
1559 ;;;
1560
1561 (defun-maybe find-face (face-or-name)
1562   "Retrieve the face of the given name.
1563 If FACE-OR-NAME is a face object, it is simply returned.
1564 Otherwise, FACE-OR-NAME should be a symbol.  If there is no such face,
1565 nil is returned.  Otherwise the associated face object is returned."
1566   (car (memq face-or-name (face-list))))
1567
1568 ;; Emacs 21.1 defines this as an alias for `line-beginning-position'.
1569 ;; Therefore, optional 2nd arg BUFFER is not portable.
1570 (defun-maybe point-at-bol (&optional n buffer)
1571   "Return the character position of the first character on the current line.
1572 With argument N not nil or 1, move forward N - 1 lines first.
1573 If scan reaches end of buffer, return that position.
1574 This function does not move point."
1575   (save-excursion
1576     (if buffer (set-buffer buffer))
1577     (forward-line (1- (or n 1)))
1578     (point)))
1579
1580 ;; Emacs 21.1 defines this as an alias for `line-end-position'.
1581 ;; Therefore, optional 2nd arg BUFFER is not portable.
1582 (defun-maybe point-at-eol (&optional n buffer)
1583   "Return the character position of the last character on the current line.
1584 With argument N not nil or 1, move forward N - 1 lines first.
1585 If scan reaches end of buffer, return that position.
1586 This function does not move point."
1587   (save-excursion
1588     (if buffer (set-buffer buffer))
1589     (end-of-line (or n 1))
1590     (point)))
1591
1592 (defsubst-maybe define-obsolete-function-alias (oldfun newfun)
1593   "Define OLDFUN as an obsolete alias for function NEWFUN.
1594 This makes calling OLDFUN equivalent to calling NEWFUN and marks OLDFUN
1595 as obsolete."
1596   (defalias oldfun newfun)
1597   (make-obsolete oldfun newfun))
1598
1599 ;; XEmacs 21: (character-to-event CH &optional EVENT DEVICE)
1600 (defun-maybe character-to-event (ch)
1601   "Convert keystroke CH into an event structure, replete with bucky bits.
1602 Note that CH (the keystroke specifier) can be an integer, a character
1603 or a symbol such as 'clear."
1604   ch)
1605
1606 ;; XEmacs 21: (event-to-character EVENT
1607 ;;             &optional ALLOW-EXTRA-MODIFIERS ALLOW-META ALLOW-NON-ASCII)
1608 (defun-maybe-cond event-to-character (event)
1609   "Return the character approximation to the given event object.
1610 If the event isn't a keypress, this returns nil."
1611   ((and (fboundp 'read-event)
1612         (subrp (symbol-function 'read-event)))
1613    ;; Emacs 19 and later.
1614    (cond
1615     ((symbolp event)
1616      ;; mask is (BASE-TYPE MODIFIER-BITS) or nil.
1617      (let ((mask (get event 'event-symbol-element-mask)))
1618        (if mask
1619            (let ((base (get (car mask) 'ascii-character)))
1620              (if base
1621                  (logior base (car (cdr mask))))))))
1622     ((integerp event) event)))
1623   (t
1624    ;; v18. Is this correct?
1625    event))
1626
1627 ;; v18: no event; (read-char)
1628 ;; Emacs 19, 20.1 and 20.2: (read-event)
1629 ;; Emacs 20.3: (read-event &optional PROMPT SUPPRESS-INPUT-METHOD)
1630 ;; Emacs 20.4: (read-event &optional PROMPT INHERIT-INPUT-METHOD)
1631 ;; XEmacs: (next-event &optional EVENT PROMPT),
1632 ;;         (next-command-event &optional EVENT PROMPT)
1633 (defun-maybe-cond next-command-event (&optional event prompt)
1634   "Read an event object from the input stream.
1635 If EVENT is non-nil, it should be an event object and will be filled
1636 in and returned; otherwise a new event object will be created and
1637 returned.
1638 If PROMPT is non-nil, it should be a string and will be displayed in
1639 the echo area while this function is waiting for an event."
1640   ((and (>= emacs-major-version 20)
1641         (>= emacs-minor-version 4))
1642    ;; Emacs 20.4 and later.
1643    (read-event prompt))                 ; should specify 2nd arg?
1644   ((and (= emacs-major-version 20)
1645         (= emacs-minor-version 3))
1646    ;; Emacs 20.3.
1647    (read-event prompt))                 ; should specify 2nd arg?
1648   ((and (fboundp 'read-event)
1649         (subrp (symbol-function 'read-event)))
1650    ;; Emacs 19, 20.1 and 20.2.
1651    (if prompt (message prompt))
1652    (read-event))
1653   (t
1654    (if prompt (message prompt))
1655    (read-char)))
1656 \f
1657
1658 ;;; @ MULE 2 emulation.
1659 ;;;
1660
1661 (defun-maybe-cond cancel-undo-boundary ()
1662   "Cancel undo boundary."
1663   ((boundp 'buffer-undo-list)
1664    ;; for Emacs 19 and later.
1665    (if (and (consp buffer-undo-list)
1666             (null (car buffer-undo-list)))
1667        (setq buffer-undo-list (cdr buffer-undo-list)))))
1668 \f
1669
1670 ;;; @ End.
1671 ;;;
1672
1673 ;;; poe.el ends here