poe-18.el

   1 ;;; poe-18.el --- poe API implementation for Emacs 18.*
   2
   3 ;; Copyright (C) 1995,1996,1997,1998,1999 Free Software Foundation, Inc.
   4 ;; Copyright (C) 1999 Yuuichi Teranishi
   5
   6 ;; Author: MORIOKA Tomohiko <tomo@m17n.org>
   7 ;;      Shuhei KOBAYASHI <shuhei@aqua.ocn.ne.jp>
   8 ;;      Yuuichi Teranishi <teranisi@gohome.org>
   9 ;; Keywords: emulation, compatibility
  10
  11 ;; This file is part of APEL (A Portable Emacs Library).
  12
  13 ;; This program is free software; you can redistribute it and/or
  14 ;; modify it under the terms of the GNU General Public License as
  15 ;; published by the Free Software Foundation; either version 2, or (at
  16 ;; your option) any later version.
  17
  18 ;; This program is distributed in the hope that it will be useful, but
  19 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 ;; General Public License for more details.
  22
  23 ;; You should have received a copy of the GNU General Public License
  24 ;; along with this program; see the file COPYING.  If not, write to the
  25 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  26 ;; Boston, MA 02111-1307, USA.
  27
  28 ;;; Commentary:
  29
  30 ;; Note to APEL developers and APEL programmers:
  31 ;;
  32 ;; If old (v18) compiler is used, top-level macros are expanded at
  33 ;; *load-time*, not compile-time. Therefore,
  34 ;;
  35 ;; (1) Definitions with `*-maybe' won't be compiled.
  36 ;;
  37 ;; (2) you cannot use macros defined with `defmacro-maybe' within function
  38 ;;     definitions in the same file.
  39 ;;     (`defmacro-maybe' is evaluated at load-time, therefore byte-compiler
  40 ;;      treats such use of macros as (unknown) functions and compiles them
  41 ;;      into function calls, which will cause errors at run-time.)
  42 ;;
  43 ;; (3) `eval-when-compile' and `eval-and-compile' are evaluated at
  44 ;;     load-time if used at top-level.
  45
  46 ;;; Code:
  47
  48 (require 'pym)
  49
  50
  51 ;;; @ Compilation.
  52 ;;;
  53
  54 (defun defalias (sym newdef)
  55   "Set SYMBOL's function definition to NEWVAL, and return NEWVAL."
  56   (fset sym newdef))
  57
  58 (defun byte-code-function-p (object)
  59   "Return t if OBJECT is a byte-compiled function object."
  60   (and (consp object) (consp (cdr object))
  61        (let ((rest (cdr (cdr object)))
  62              elt)
  63          (if (stringp (car rest))
  64              (setq rest (cdr rest)))
  65          (catch 'tag
  66            (while rest
  67              (setq elt (car rest))
  68              (if (and (consp elt)
  69                       (eq (car elt) 'byte-code))
  70                  (throw 'tag t))
  71              (setq rest (cdr rest)))))))
  72
  73 ;; (symbol-plist 'cyclic-function-indirection)
  74 (put 'cyclic-function-indirection
  75      'error-conditions
  76      '(cyclic-function-indirection error))
  77 (put 'cyclic-function-indirection
  78      'error-message
  79      "Symbol's chain of function indirections contains a loop")
  80
  81 ;; The following function definition is a direct translation of its
  82 ;; C definition in emacs-20.4/src/data.c.
  83 (defun indirect-function (object)
  84   "Return the function at the end of OBJECT's function chain.
  85 If OBJECT is a symbol, follow all function indirections and return the final
  86 function binding.
  87 If OBJECT is not a symbol, just return it.
  88 Signal a void-function error if the final symbol is unbound.
  89 Signal a cyclic-function-indirection error if there is a loop in the
  90 function chain of symbols."
  91   (let* ((hare object)
  92          (tortoise hare))
  93     (catch 'found
  94       (while t
  95         (or (symbolp hare) (throw 'found hare))
  96         (or (fboundp hare) (signal 'void-function (cons object nil)))
  97         (setq hare (symbol-function hare))
  98         (or (symbolp hare) (throw 'found hare))
  99         (or (fboundp hare) (signal 'void-function (cons object nil)))
 100         (setq hare (symbol-function hare))
 101
 102         (setq tortoise (symbol-function tortoise))
 103
 104         (if (eq hare tortoise)
 105             (signal 'cyclic-function-indirection (cons object nil)))))
 106     hare))
 107
 108 ;;; Emulate all functions and macros of emacs-20.3/lisp/byte-run.el.
 109 ;;; (note: jwz's original compiler and XEmacs compiler have some more
 110 ;;;  macros; they are "nuked" by rms in FSF version.)
 111
 112 ;; Use `*-maybe' here because new byte-compiler may be installed.
 113 (put 'inline 'lisp-indent-hook 0)
 114 (defmacro-maybe inline (&rest body)
 115   "Eval BODY forms sequentially and return value of last one.
 116
 117 This emulating macro does not support function inlining because old \(v18\)
 118 compiler does not support inlining feature."
 119   (cons 'progn body))
 120
 121 (put 'defsubst 'lisp-indent-hook 'defun)
 122 (put 'defsubst 'edebug-form-spec 'defun)
 123 (defmacro-maybe defsubst (name arglist &rest body)
 124   "Define an inline function.  The syntax is just like that of `defun'.
 125
 126 This emulating macro does not support function inlining because old \(v18\)
 127 compiler does not support inlining feature."
 128   (cons 'defun (cons name (cons arglist body))))
 129
 130 (defun-maybe make-obsolete (fn new)
 131   "Make the byte-compiler warn that FUNCTION is obsolete.
 132 The warning will say that NEW should be used instead.
 133 If NEW is a string, that is the `use instead' message.
 134
 135 This emulating function does nothing because old \(v18\) compiler does not
 136 support this feature."
 137   (interactive "aMake function obsolete: \nxObsoletion replacement: ")
 138   fn)
 139
 140 (defun-maybe make-obsolete-variable (var new)
 141   "Make the byte-compiler warn that VARIABLE is obsolete,
 142 and NEW should be used instead.  If NEW is a string, then that is the
 143 `use instead' message.
 144
 145 This emulating function does nothing because old \(v18\) compiler does not
 146 support this feature."
 147   (interactive "vMake variable obsolete: \nxObsoletion replacement: ")
 148   var)
 149
 150 (put 'dont-compile 'lisp-indent-hook 0)
 151 (defmacro-maybe dont-compile (&rest body)
 152   "Like `progn', but the body always runs interpreted \(not compiled\).
 153 If you think you need this, you're probably making a mistake somewhere."
 154   (list 'eval (list 'quote (if (cdr body) (cons 'progn body) (car body)))))
 155
 156 (put 'eval-when-compile 'lisp-indent-hook 0)
 157 (defmacro-maybe eval-when-compile (&rest body)
 158   "Like progn, but evaluates the body at compile-time.
 159
 160 This emulating macro does not do compile-time evaluation at all because
 161 of the limitation of old \(v18\) compiler."
 162   (cons 'progn body))
 163
 164 (put 'eval-and-compile 'lisp-indent-hook 0)
 165 (defmacro-maybe eval-and-compile (&rest body)
 166   "Like progn, but evaluates the body at compile-time as well as at load-time.
 167
 168 This emulating macro does not do compile-time evaluation at all because
 169 of the limitation of old \(v18\) compiler."
 170   (cons 'progn body))
 171
 172
 173 ;;; @ C primitives emulation.
 174 ;;;
 175
 176 (defun member (elt list)
 177   "Return non-nil if ELT is an element of LIST.  Comparison done with EQUAL.
 178 The value is actually the tail of LIST whose car is ELT."
 179   (while (and list (not (equal elt (car list))))
 180     (setq list (cdr list)))
 181   list)
 182
 183 (defun delete (elt list)
 184   "Delete by side effect any occurrences of ELT as a member of LIST.
 185 The modified LIST is returned.  Comparison is done with `equal'.
 186 If the first member of LIST is ELT, deleting it is not a side effect;
 187 it is simply using a different list.
 188 Therefore, write `(setq foo (delete element foo))'
 189 to be sure of changing the value of `foo'."
 190   (if list
 191       (if (equal elt (car list))
 192           (cdr list)
 193         (let ((rest list)
 194               (rrest (cdr list)))
 195           (while (and rrest (not (equal elt (car rrest))))
 196             (setq rest rrest
 197                   rrest (cdr rrest)))
 198           (setcdr rest (cdr rrest))
 199           list))))
 200
 201 (defun default-boundp (symbol)
 202   "Return t if SYMBOL has a non-void default value.
 203 This is the value that is seen in buffers that do not have their own values
 204 for this variable."
 205   (condition-case error
 206       (progn
 207         (default-value symbol)
 208         t)
 209     (void-variable nil)))
 210
 211 ;;; @@ current-time.
 212 ;;;
 213
 214 (defvar current-time-world-timezones
 215   '(("PST" .  -800)("PDT" .  -700)("MST" .  -700)
 216     ("MDT" .  -600)("CST" .  -600)("CDT" .  -500)
 217     ("EST" .  -500)("EDT" .  -400)("AST" .  -400)
 218     ("NST" .  -330)("UT"  .  +000)("GMT" .  +000)
 219     ("BST" .  +100)("MET" .  +100)("EET" .  +200)
 220     ("JST" .  +900)("GMT+1"  .  +100)("GMT+2"  .  +200)
 221     ("GMT+3"  .  +300)("GMT+4"  .  +400)("GMT+5"  .  +500)
 222     ("GMT+6"  .  +600)("GMT+7"  .  +700)("GMT+8"  .  +800)
 223     ("GMT+9"  .  +900)("GMT+10" . +1000)("GMT+11" . +1100)
 224     ("GMT+12" . +1200)("GMT+13" . +1300)("GMT-1"  .  -100)
 225     ("GMT-2"  .  -200)("GMT-3"  .  -300)("GMT-4"  .  -400)
 226     ("GMT-5"  .  -500)("GMT-6"  .  -600)("GMT-7"  .  -700)
 227     ("GMT-8"  .  -800)("GMT-9"  .  -900)("GMT-10" . -1000)
 228     ("GMT-11" . -1100) ("GMT-12" . -1200))
 229   "Time differentials of timezone from GMT in +-HHMM form.
 230 Used in `current-time-zone'.")
 231
 232 (defvar current-time-local-timezone nil
 233   "*Local timezone name.
 234 Used in `current-time-zone'.")
 235
 236 (defun set-time-zone-rule (tz)
 237   "Set the local time zone using TZ, a string specifying a time zone rule.
 238 If TZ is nil, use implementation-defined default time zone information.
 239 If TZ is t, use Universal Time."
 240   (cond
 241    ((stringp tz)
 242     (setq current-time-local-timezone tz))
 243    (tz
 244     (setq current-time-local-timezone "GMT"))
 245    (t
 246     (setq current-time-local-timezone
 247           (with-temp-buffer
 248             ;; We use `date' command to get timezone information.
 249             (call-process "date" nil (current-buffer) t)
 250             (goto-char (point-min))
 251             (if (looking-at
 252                  "^.*\\([A-Z][A-Z][A-Z]\\([^ \n\t]*\\)\\).*$")
 253                 (buffer-substring (match-beginning 1)
 254                                   (match-end 1))))))))
 255
 256 (defun current-time-zone (&optional specified-time)
 257   "Return the offset and name for the local time zone.
 258 This returns a list of the form (OFFSET NAME).
 259 OFFSET is an integer number of seconds ahead of UTC (east of Greenwich).
 260     A negative value means west of Greenwich.
 261 NAME is a string giving the name of the time zone.
 262 Optional argument SPECIFIED-TIME is ignored in this implementation.
 263 Some operating systems cannot provide all this information to Emacs;
 264 in this case, `current-time-zone' returns a list containing nil for
 265 the data it can't find."
 266   (let ((local-timezone (or current-time-local-timezone
 267                             (progn
 268                               (set-time-zone-rule nil)
 269                               current-time-local-timezone)))
 270         timezone abszone seconds)
 271     (setq timezone
 272           (or (cdr (assoc (upcase local-timezone)
 273                           current-time-world-timezones))
 274               ;; "+900" style or nil.
 275               local-timezone))
 276     (when timezone
 277       (if (stringp timezone)
 278           (setq timezone (string-to-int timezone)))
 279       ;; Taking account of minute in timezone.
 280       ;; HHMM -> MM
 281       (setq abszone (abs timezone))
 282       (setq seconds (* 60 (+ (* 60 (/ abszone 100)) (% abszone 100))))
 283       (list (if (< timezone 0) (- seconds) seconds)
 284             local-timezone))))
 285
 286 (or (fboundp 'si:current-time-string)
 287     (fset 'si:current-time-string (symbol-function 'current-time-string)))
 288 (defun current-time-string (&optional specified-time)
 289   "Return the current time, as a human-readable string.
 290 Programs can use this function to decode a time,
 291 since the number of columns in each field is fixed.
 292 The format is `Sun Sep 16 01:03:52 1973'.
 293 If an argument SPECIFIED-TIME is given, it specifies a time to format
 294 instead of the current time.  The argument should have the form:
 295   (HIGH . LOW)
 296 or the form:
 297   (HIGH LOW . IGNORED).
 298 Thus, you can use times obtained from `current-time'
 299 and from `file-attributes'."
 300   (if (null specified-time)
 301       (si:current-time-string)
 302     (or (consp specified-time)
 303         (error "Wrong type argument %s" specified-time))
 304     (let ((high (car specified-time))
 305           (low  (cdr specified-time))
 306           (offset (or (car (current-time-zone)) 0))
 307           (mdays '(31 28 31 30 31 30 31 31 30 31 30 31))
 308           (mnames '("Jan" "Feb" "Mar" "Apr" "May" "Jun"
 309                     "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"))
 310           (wnames '("Sun" "Mon" "Tue" "Wed" "Thu" "Fri" "Sat"))
 311           days dd yyyy lyear mm HH MM SS)
 312       (if (consp low)
 313           (setq low (car low)))
 314       (or (integerp high)
 315           (error "Wrong type argument %s" high))
 316       (or (integerp low)
 317           (error "Wrong type argument %s" low))
 318       (setq low (+ low offset))
 319       (while (> low 65535)
 320         (setq high (1+ high)
 321               low (- low 65536)))
 322       (setq yyyy 1970)
 323       (while (or (> high 481)
 324                  (and (= high 481)
 325                       (>= low 13184)))
 326         (if (and (> high 0)
 327                  (< low 13184))
 328             (setq high (1- high)
 329                   low  (+ 65536 low)))
 330         (setq high (- high 481)
 331               low  (- low 13184))
 332         (if (and (zerop (% yyyy 4))
 333                  (or (not (zerop (% yyyy 100)))
 334                      (zerop (% yyyy 400))))
 335             (progn
 336               (if (and (> high 0)
 337                        (< low 20864))
 338                   (setq high (1- high)
 339                         low  (+ 65536 low)))
 340               (setq high (- high 1)
 341                     low (- low 20864))))
 342         (setq yyyy (1+ yyyy)))
 343       (setq dd 1)
 344       (while (or (> high 1)
 345                  (and (= high 1)
 346                       (>= low 20864)))
 347         (if (and (> high 0)
 348                  (< low 20864))
 349             (setq high (1- high)
 350                   low  (+ 65536 low)))
 351         (setq high (- high 1)
 352               low  (- low 20864)
 353               dd (1+ dd)))
 354       (setq days dd)
 355       (if (= high 1)
 356           (setq low (+ 65536 low)))
 357       (setq mm 0)
 358       (setq lyear (and (zerop (% yyyy 4))
 359                        (or (not (zerop (% yyyy 100)))
 360                            (zerop (% yyyy 400)))))
 361       (while (> (- dd  (if (and lyear (= mm 1)) 29 (nth mm mdays))) 0)
 362         (setq dd (- dd (if (and lyear (= mm 1)) 29 (nth mm mdays))))
 363         (setq mm (1+ mm)))
 364       (setq HH (/ low 3600)
 365             low (% low 3600)
 366             MM (/ low 60)
 367             SS (% low 60))
 368       (format "%s %s %2d %02d:%02d:%02d %4d"
 369               (nth (% (+ days
 370                          (- (+ (* (1- yyyy) 365) (/ (1- yyyy) 400)
 371                                (/ (1- yyyy) 4)) (/ (1- yyyy) 100))) 7)
 372                    wnames)
 373               (nth mm mnames)
 374               dd HH MM SS yyyy))))
 375
 376 (defun current-time ()
 377   "Return the current time, as the number of seconds since 1970-01-01 00:00:00.
 378 The time is returned as a list of three integers.  The first has the
 379 most significant 16 bits of the seconds, while the second has the
 380 least significant 16 bits.  The third integer gives the microsecond
 381 count.
 382
 383 The microsecond count is zero on systems that do not provide
 384 resolution finer than a second."
 385   (let* ((str (current-time-string))
 386          (yyyy (string-to-int (substring str 20 24)))
 387          (mm (length (member (substring str 4 7)
 388                              '("Dec" "Nov" "Oct" "Sep" "Aug" "Jul"
 389                                "Jun" "May" "Apr" "Mar" "Feb" "Jan"))))
 390          (dd (string-to-int (substring str 8 10)))
 391          (HH (string-to-int (substring str 11 13)))
 392          (MM (string-to-int (substring str 14 16)))
 393          (SS (string-to-int (substring str 17 19)))
 394          (offset (or (car (current-time-zone)) 0))
 395          dn ct1 ct2 i1 i2
 396          year uru)
 397     (setq ct1 0 ct2 0 i1 0 i2 0)
 398     (setq year (- yyyy 1970))
 399     (while (> year 0)
 400       (setq year (1- year)
 401             ct1 (+ ct1 481)
 402             ct2 (+ ct2 13184))
 403       (while (> ct2 65535)
 404         (setq ct1 (1+ ct1)
 405               ct2 (- ct2 65536))))
 406     (setq year (- yyyy 1))
 407     (setq uru (- (+ (- (/ year 4) (/ year 100))
 408                     (/ year 400)) 477))
 409     (while (> uru 0)
 410       (setq uru (1- uru)
 411             i1 (1+ i1)
 412             i2 (+ i2 20864))
 413       (if (> i2 65535)
 414           (setq i1 (1+ i1)
 415                 i2 (- i2 65536))))
 416     (setq ct1 (+ ct1 i1)
 417           ct2 (+ ct2 i2))
 418     (while (> ct2 65535)
 419       (setq ct1 (1+ ct1)
 420             ct2 (- ct2 65536)))
 421     (setq dn (+ dd (* 31 (1- mm))))
 422     (if (> mm 2)
 423         (setq dn (+ (- dn (/ (+ 23 (* 4 mm)) 10))
 424                     (if (and (zerop (% yyyy 4))
 425                              (or (not (zerop (% yyyy 100)))
 426                                  (zerop (% yyyy 400))))
 427                         1 0))))
 428     (setq dn (1- dn)
 429           i1 0
 430           i2 0)
 431     (while (> dn 0)
 432       (setq dn (1- dn)
 433             i1 (1+ i1)
 434             i2 (+ i2 20864))
 435       (if (> i2 65535)
 436           (setq i1 (1+ i1)
 437                 i2 (- i2 65536))))
 438     (setq ct1 (+ (+ (+ ct1 i1) (/ ct2 65536))
 439                  (/ (+ (* HH 3600) (* MM 60) SS)
 440                     65536))
 441           ct2 (+ (+ i2 (% ct2 65536))
 442                  (% (+ (* HH 3600) (* MM 60) SS)
 443                     65536)))
 444     (while (< (- ct2 offset) 0)
 445       (setq ct1 (1- ct1)
 446             ct2 (+ ct2 65536)))
 447     (setq ct2 (- ct2 offset))
 448     (while (> ct2 65535)
 449       (setq ct1 (1+ ct1)
 450             ct2 (- ct2 65536)))
 451     (list ct1 ct2 0)))
 452
 453 ;;; @@ Floating point numbers.
 454 ;;;
 455
 456 (defalias 'numberp 'integerp)
 457
 458 (defun abs (arg)
 459   "Return the absolute value of ARG."
 460   (if (< arg 0) (- arg) arg))
 461
 462 (defun floor (arg &optional divisor)
 463   "Return the largest integer no grater than ARG.
 464 With optional DIVISOR, return the largest integer no greater than ARG/DIVISOR."
 465   (if (null divisor)
 466       (setq divisor 1))
 467   (if (< arg 0)
 468       (- (/ (- divisor 1 arg) divisor))
 469     (/ arg divisor)))
 470
 471 (defalias 'mod '%)
 472
 473 ;;; @ Basic lisp subroutines.
 474 ;;;
 475
 476 (defmacro lambda (&rest cdr)
 477   "Return a lambda expression.
 478 A call of the form (lambda ARGS DOCSTRING INTERACTIVE BODY) is
 479 self-quoting; the result of evaluating the lambda expression is the
 480 expression itself.  The lambda expression may then be treated as a
 481 function, i.e., stored as the function value of a symbol, passed to
 482 funcall or mapcar, etc.
 483
 484 ARGS should take the same form as an argument list for a `defun'.
 485 DOCSTRING is an optional documentation string.
 486  If present, it should describe how to call the function.
 487  But documentation strings are usually not useful in nameless functions.
 488 INTERACTIVE should be a call to the function `interactive', which see.
 489 It may also be omitted.
 490 BODY should be a list of lisp expressions."
 491   ;; Note that this definition should not use backquotes; subr.el should not
 492   ;; depend on backquote.el.
 493   (list 'function (cons 'lambda cdr)))
 494
 495 (defun force-mode-line-update (&optional all)
 496   "Force the mode-line of the current buffer to be redisplayed.
 497 With optional non-nil ALL, force redisplay of all mode-lines."
 498   (if all (save-excursion (set-buffer (other-buffer))))
 499   (set-buffer-modified-p (buffer-modified-p)))
 500
 501 (defalias 'set-match-data 'store-match-data)
 502
 503 (defvar save-match-data-internal)
 504
 505 ;; We use save-match-data-internal as the local variable because
 506 ;; that works ok in practice (people should not use that variable elsewhere).
 507 (defmacro save-match-data (&rest body)
 508   "Execute the BODY forms, restoring the global value of the match data."
 509   (` (let ((save-match-data-internal (match-data)))
 510        (unwind-protect (progn (,@ body))
 511          (set-match-data save-match-data-internal)))))
 512
 513
 514 ;;; @ Basic editing commands.
 515 ;;;
 516
 517 ;; 18.55 does not have these variables.
 518 (defvar buffer-undo-list nil)
 519 (defvar auto-fill-function nil)
 520 (defvar unread-command-event nil)
 521 (defvar unread-command-events nil)
 522
 523 (defalias 'buffer-disable-undo 'buffer-flush-undo)
 524 (defalias 'insert-and-inherit 'insert)
 525 (defalias 'insert-before-markers-and-inherit 'insert-before-markers)
 526 (defalias 'number-to-string 'int-to-string)
 527
 528 (defun generate-new-buffer-name (name &optional ignore)
 529   "Return a string that is the name of no existing buffer based on NAME.
 530 If there is no live buffer named NAME, then return NAME.
 531 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
 532 until an unused name is found, and then return that name.
 533 Optional second argument IGNORE specifies a name that is okay to use
 534 \(if it is in the sequence to be tried\)
 535 even if a buffer with that name exists."
 536   (if (get-buffer name)
 537       (let ((n 2) new)
 538         (while (get-buffer (setq new (format "%s<%d>" name n)))
 539           (setq n (1+ n)))
 540         new)
 541     name))
 542
 543 (or (fboundp 'si:mark)
 544     (fset 'si:mark (symbol-function 'mark)))
 545 (defun mark (&optional force)
 546   (si:mark))
 547
 548 (defun window-minibuffer-p (&optional window)
 549 "Return non-nil if WINDOW is a minibuffer window."
 550   (eq (or window (selected-window)) (minibuffer-window)))
 551
 552 (defun window-live-p (object)
 553   "Returns t if OBJECT is a window which is currently visible."
 554   (and (windowp object)
 555        (or (eq object (minibuffer-window))
 556            (eq object (get-buffer-window (window-buffer object))))))
 557
 558 ;; Add optinal argument `hist'
 559 (or (fboundp 'si:read-from-minibuffer)
 560     (progn
 561       (fset 'si:read-from-minibuffer (symbol-function 'read-from-minibuffer))
 562       (defun read-from-minibuffer (prompt &optional
 563                                           initial-contents keymap read hist)
 564
 565         "Read a string from the minibuffer, prompting with string PROMPT.
 566 If optional second arg INITIAL-CONTENTS is non-nil, it is a string
 567 to be inserted into the minibuffer before reading input.
 568 If INITIAL-CONTENTS is (STRING . POSITION), the initial input
 569 is STRING, but point is placed at position POSITION in the minibuffer.
 570 Third arg KEYMAP is a keymap to use whilst reading;
 571 if omitted or nil, the default is `minibuffer-local-map'.
 572 If fourth arg READ is non-nil, then interpret the result as a lisp object
 573 and return that object:
 574 in other words, do `(car (read-from-string INPUT-STRING))'
 575 Fifth arg HIST is ignored in this implementatin."
 576         (si:read-from-minibuffer prompt initial-contents keymap read))))
 577
 578 ;; Add optional argument `frame'.
 579 (or (fboundp 'si:get-buffer-window)
 580     (progn
 581       (fset 'si:get-buffer-window (symbol-function 'get-buffer-window))
 582       (defun get-buffer-window (buffer &optional frame)
 583         "Return a window currently displaying BUFFER, or nil if none.
 584 Optional argunemt FRAME is ignored in this implementation."
 585         (si:get-buffer-window buffer))))
 586
 587 (defun-maybe walk-windows (proc &optional minibuf all-frames)
 588   "Cycle through all visible windows, calling PROC for each one.
 589 PROC is called with a window as argument.
 590
 591 Optional second arg MINIBUF t means count the minibuffer window even
 592 if not active.  MINIBUF nil or omitted means count the minibuffer iff
 593 it is active.  MINIBUF neither t nor nil means not to count the
 594 minibuffer even if it is active.
 595 Optional third argunemt ALL-FRAMES is ignored in this implementation."
 596   (if (window-minibuffer-p (selected-window))
 597       (setq minibuf t))
 598   (let* ((walk-windows-start (selected-window))
 599          (walk-windows-current walk-windows-start))
 600     (unwind-protect
 601         (while (progn
 602                  (setq walk-windows-current
 603                        (next-window walk-windows-current minibuf))
 604                  (funcall proc walk-windows-current)
 605                  (not (eq walk-windows-current walk-windows-start))))
 606       (select-window walk-windows-start))))
 607
 608 ;;; @@ Environment variables.
 609 ;;;
 610
 611 (autoload 'setenv "env"
 612   "Set the value of the environment variable named VARIABLE to VALUE.
 613 VARIABLE should be a string.  VALUE is optional; if not provided or is
 614 `nil', the environment variable VARIABLE will be removed.
 615 This function works by modifying `process-environment'."
 616   t)
 617
 618
 619 ;;; @ File input and output commands.
 620 ;;;
 621
 622 (defvar data-directory exec-directory)
 623
 624 ;; In 18.55, `call-process' does not return exit status.
 625 (defun file-executable-p (filename)
 626   "Return t if FILENAME can be executed by you.
 627 For a directory, this means you can access files in that directory."
 628   (if (file-exists-p filename)
 629       (let ((process (start-process "test" nil "test" "-x" filename)))
 630         (while (eq 'run (process-status process)))
 631         (zerop (process-exit-status process)))))
 632
 633 (defun make-directory-internal (dirname)
 634   "Create a directory. One argument, a file name string."
 635  (let ((dir (expand-file-name dirname)))
 636    (if (file-exists-p dir)
 637        (error "Creating directory: %s is already exist" dir)
 638      (call-process "mkdir" nil nil nil dir))))
 639
 640 (defun make-directory (dir &optional parents)
 641   "Create the directory DIR and any nonexistent parent dirs.
 642 The second (optional) argument PARENTS says whether
 643 to create parent directories if they don't exist."
 644   (let ((len (length dir))
 645         (p 0) p1 path)
 646     (catch 'tag
 647       (while (and (< p len) (string-match "[^/]*/?" dir p))
 648         (setq p1 (match-end 0))
 649         (if (= p1 len)
 650             (throw 'tag nil))
 651         (setq path (substring dir 0 p1))
 652         (if (not (file-directory-p path))
 653             (cond ((file-exists-p path)
 654                    (error "Creating directory: %s is not directory" path))
 655                   ((null parents)
 656                    (error "Creating directory: %s is not exist" path))
 657                   (t
 658                    (make-directory-internal path))))
 659         (setq p p1)))
 660     (make-directory-internal dir)))
 661
 662 (defun parse-colon-path (cd-path)
 663   "Explode a colon-separated list of paths into a string list."
 664   (and cd-path
 665        (let (cd-prefix cd-list (cd-start 0) cd-colon)
 666          (setq cd-path (concat cd-path path-separator))
 667          (while (setq cd-colon (string-match path-separator cd-path cd-start))
 668            (setq cd-list
 669                  (nconc cd-list
 670                         (list (if (= cd-start cd-colon)
 671                                   nil
 672                                 (substitute-in-file-name
 673                                  (file-name-as-directory
 674                                   (substring cd-path cd-start cd-colon)))))))
 675            (setq cd-start (+ cd-colon 1)))
 676          cd-list)))
 677
 678 (defun file-relative-name (filename &optional directory)
 679   "Convert FILENAME to be relative to DIRECTORY (default: default-directory)."
 680   (setq filename (expand-file-name filename)
 681         directory (file-name-as-directory (expand-file-name
 682                                            (or directory default-directory))))
 683   (let ((ancestor ""))
 684     (while (not (string-match (concat "^" (regexp-quote directory)) filename))
 685       (setq directory (file-name-directory (substring directory 0 -1))
 686             ancestor (concat "../" ancestor)))
 687     (concat ancestor (substring filename (match-end 0)))))
 688
 689 (or (fboundp 'si:directory-files)
 690     (fset 'si:directory-files (symbol-function 'directory-files)))
 691 (defun directory-files (directory &optional full match nosort)
 692   "Return a list of names of files in DIRECTORY.
 693 There are three optional arguments:
 694 If FULL is non-nil, return absolute file names.  Otherwise return names
 695  that are relative to the specified directory.
 696 If MATCH is non-nil, mention only file names that match the regexp MATCH.
 697 If NOSORT is dummy for compatibility."
 698   (si:directory-files directory full match))
 699
 700 ;;; @ Process.
 701 ;;;
 702 (or (fboundp 'si:accept-process-output)
 703     (progn
 704       (fset 'si:accept-process-output (symbol-function 'accept-process-output))
 705       (defun accept-process-output (&optional process timeout timeout-msecs)
 706         "Allow any pending output from subprocesses to be read by Emacs.
 707 It is read into the process' buffers or given to their filter functions.
 708 Non-nil arg PROCESS means do not return until some output has been received
 709  from PROCESS. Nil arg PROCESS means do not return until some output has
 710  been received from any process.
 711 TIMEOUT and TIMEOUT-MSECS are ignored in this implementation."
 712         (si:accept-process-output process))))
 713
 714 ;;; @ Text property.
 715 ;;;
 716
 717 ;; In Emacs 20.4, these functions are defined in src/textprop.c.
 718 (defun text-properties-at (position &optional object))
 719 (defun get-text-property (position prop &optional object))
 720 (defun get-char-property (position prop &optional object))
 721 (defun next-property-change (position &optional object limit))
 722 (defun next-single-property-change (position prop &optional object limit))
 723 (defun previous-property-change (position &optional object limit))
 724 (defun previous-single-property-change (position prop &optional object limit))
 725 (defun add-text-properties (start end properties &optional object))
 726 (defun put-text-property (start end property value &optional object))
 727 (defun set-text-properties (start end properties &optional object))
 728 (defun remove-text-properties (start end properties &optional object))
 729 (defun text-property-any (start end property value &optional object))
 730 (defun text-property-not-all (start end property value &optional object))
 731 ;; the following two functions are new in v20.
 732 (defun next-char-property-change (position &optional object))
 733 (defun previous-char-property-change (position &optional object))
 734 ;; the following two functions are obsolete.
 735 ;; (defun erase-text-properties (start end &optional object)
 736 ;; (defun copy-text-properties (start end src pos dest &optional prop)
 737
 738
 739 ;;; @ Overlay.
 740 ;;;
 741
 742 (defun overlayp (object))
 743 (defun make-overlay (beg end &optional buffer front-advance rear-advance))
 744 (defun move-overlay (overlay beg end &optional buffer))
 745 (defun delete-overlay (overlay))
 746 (defun overlay-start (overlay))
 747 (defun overlay-end (overlay))
 748 (defun overlay-buffer (overlay))
 749 (defun overlay-properties (overlay))
 750 (defun overlays-at (pos))
 751 (defun overlays-in (beg end))
 752 (defun next-overlay-change (pos))
 753 (defun previous-overlay-change (pos))
 754 (defun overlay-lists ())
 755 (defun overlay-recenter (pos))
 756 (defun overlay-get (overlay prop))
 757 (defun overlay-put (overlay prop value))
 758
 759 ;;; @ End.
 760 ;;;
 761
 762 (require 'product)
 763 (product-provide (provide 'poe-18) (require 'apel-ver))
 764
 765 ;;; poe-18.el ends here