]> code.delx.au - gnu-emacs/blob - lisp/ielm.el
(inferior-emacs-lisp-mode): Use run-mode-hooks.
[gnu-emacs] / lisp / ielm.el
1 ;;; ielm.el --- interaction mode for Emacs Lisp
2
3 ;; Copyright (C) 1994, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 ;; Author: David Smith <maa036@lancaster.ac.uk>
6 ;; Maintainer: FSF
7 ;; Created: 25 Feb 1994
8 ;; Keywords: lisp
9
10 ;; This file is part of GNU Emacs.
11
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
15 ;; any later version.
16
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
21
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25 ;; Boston, MA 02111-1307, USA.
26
27 ;;; Commentary:
28
29 ;; Provides a nice interface to evaluating Emacs Lisp expressions.
30 ;; Input is handled by the comint package, and output is passed
31 ;; through the pretty-printer.
32
33 ;; To start: M-x ielm. Type C-h m in the *ielm* buffer for more info.
34
35 ;;; Code:
36
37 (require 'comint)
38 (require 'pp)
39
40 ;;; User variables
41
42 (defgroup ielm nil
43 "Interaction mode for Emacs Lisp."
44 :group 'lisp)
45
46
47 (defcustom ielm-noisy t
48 "*If non-nil, IELM will beep on error."
49 :type 'boolean
50 :group 'ielm)
51
52 (defcustom ielm-prompt-read-only t
53 "If non-nil, the IELM prompt is read only.
54 The read only region includes the newline before the prompt.
55 Setting this variable does not affect existing IELM runs.
56 This works by setting the buffer-local value of `comint-prompt-read-only'.
57 Setting that value directly affects new prompts in the current buffer.
58
59 If this option is enabled, then the safe way to temporarily
60 override the read-only-ness of ielm prompts is to call
61 `comint-kill-whole-line' or `comint-kill-region' with no
62 narrowing in effect. This way you will be certain that none of
63 the remaining prompts will be accidentally messed up. You may
64 wish to put something like the following in your `.emacs' file:
65
66 \(add-hook 'ielm-mode-hook
67 '(lambda ()
68 (define-key ielm-map \"\\C-w\" 'comint-kill-region)
69 (define-key ielm-map [C-S-backspace]
70 'comint-kill-whole-line)))
71
72 If you set `comint-prompt-read-only' to t, you might wish to use
73 `comint-mode-hook' and `comint-mode-map' instead of
74 `ielm-mode-hook' and `ielm-map'. That will affect all comint
75 buffers, including ielm buffers. If you sometimes use ielm on
76 text-only terminals or with `emacs -nw', you might wish to use
77 another binding for `comint-kill-whole-line'."
78 :type 'boolean
79 :group 'ielm
80 :version "22.1")
81
82 (defcustom ielm-prompt "ELISP> "
83 "Prompt used in IELM.
84 Setting this variable does not affect existing IELM runs.
85
86 Interrupting the IELM process with \\<ielm-map>\\[comint-interrupt-subjob],
87 and then restarting it using \\[ielm], makes the then current
88 default value affect _new_ prompts. Unless the new prompt
89 differs only in text properties from the old one, IELM will no
90 longer recognize the old prompts. However, executing \\[ielm]
91 does not update the prompt of an *ielm* buffer with a running process.
92 For IELM buffers that are not called `*ielm*', you can execute
93 \\[inferior-emacs-lisp-mode] in that IELM buffer to update the value,
94 for new prompts. This works even if the buffer has a running process."
95 :type 'string
96 :group 'ielm)
97
98 (defvar ielm-prompt-internal "ELISP> "
99 "Stored value of `ielm-prompt' in the current IELM buffer.
100 This is an internal variable used by IELM. Its purpose is to
101 prevent a running IELM process from being messed up when the user
102 customizes `ielm-prompt'.")
103
104 (defcustom ielm-dynamic-return t
105 "*Controls whether \\<ielm-map>\\[ielm-return] has intelligent behaviour in IELM.
106 If non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline
107 and indents for incomplete sexps. If nil, always inserts newlines."
108 :type 'boolean
109 :group 'ielm)
110
111 (defcustom ielm-dynamic-multiline-inputs t
112 "*Force multiline inputs to start from column zero?
113 If non-nil, after entering the first line of an incomplete sexp, a newline
114 will be inserted after the prompt, moving the input to the next line.
115 This gives more frame width for large indented sexps, and allows functions
116 such as `edebug-defun' to work with such inputs."
117 :type 'boolean
118 :group 'ielm)
119
120 (defcustom ielm-mode-hook nil
121 "*Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started."
122 :options '(turn-on-eldoc-mode)
123 :type 'hook
124 :group 'ielm)
125
126 (defvar * nil
127 "Most recent value evaluated in IELM.")
128
129 (defvar ** nil
130 "Second-most-recent value evaluated in IELM.")
131
132 (defvar *** nil
133 "Third-most-recent value evaluated in IELM.")
134
135 (defvar ielm-match-data nil
136 "Match data saved at the end of last command.")
137
138 (defvar *1 nil
139 "During IELM evaluation, most recent value evaluated in IELM.
140 Normally identical to `*'. However, if the working buffer is an IELM
141 buffer, distinct from the process buffer, then `*' gives the value in
142 the working buffer, `*1' the value in the process buffer.
143 The intended value is only accessible during IELM evaluation.")
144
145 (defvar *2 nil
146 "During IELM evaluation, second-most-recent value evaluated in IELM.
147 Normally identical to `**'. However, if the working buffer is an IELM
148 buffer, distinct from the process buffer, then `**' gives the value in
149 the working buffer, `*2' the value in the process buffer.
150 The intended value is only accessible during IELM evaluation.")
151
152 (defvar *3 nil
153 "During IELM evaluation, third-most-recent value evaluated in IELM.
154 Normally identical to `***'. However, if the working buffer is an IELM
155 buffer, distinct from the process buffer, then `***' gives the value in
156 the working buffer, `*3' the value in the process buffer.
157 The intended value is only accessible during IELM evaluation.")
158
159 ;;; System variables
160
161 (defvar ielm-working-buffer nil
162 "Buffer in which IELM sexps will be evaluated.
163 This variable is buffer-local.")
164
165 (defvar ielm-header
166 "*** Welcome to IELM *** Type (describe-mode) for help.\n"
167 "Message to display when IELM is started.")
168
169 (defvar ielm-map nil)
170 (if ielm-map nil
171 (if (string-match "Lucid" emacs-version)
172 ;; Lemacs
173 (progn
174 (setq ielm-map (make-sparse-keymap))
175 (set-keymap-parent ielm-map comint-mode-map))
176 ;; FSF
177 (setq ielm-map (cons 'keymap comint-mode-map)))
178 (define-key ielm-map "\t" 'comint-dynamic-complete)
179 (define-key ielm-map "\C-m" 'ielm-return)
180 (define-key ielm-map "\C-j" 'ielm-send-input)
181 (define-key ielm-map "\e\C-x" 'eval-defun) ; for consistency with
182 (define-key ielm-map "\e\t" 'lisp-complete-symbol) ; lisp-interaction-mode
183 ;; These bindings are from `lisp-mode-shared-map' -- can you inherit
184 ;; from more than one keymap??
185 (define-key ielm-map "\e\C-q" 'indent-sexp)
186 (define-key ielm-map "\177" 'backward-delete-char-untabify)
187 ;; Some convenience bindings for setting the working buffer
188 (define-key ielm-map "\C-c\C-b" 'ielm-change-working-buffer)
189 (define-key ielm-map "\C-c\C-f" 'ielm-display-working-buffer)
190 (define-key ielm-map "\C-c\C-v" 'ielm-print-working-buffer))
191
192 (defvar ielm-font-lock-keywords
193 '(("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)"
194 (1 font-lock-comment-face)
195 (2 font-lock-constant-face)))
196 "Additional expressions to highlight in ielm buffers.")
197
198 ;;; Completion stuff
199
200 (defun ielm-tab nil
201 "Possibly indent the current line as Lisp code."
202 (interactive)
203 (if (or (eq (preceding-char) ?\n)
204 (eq (char-syntax (preceding-char)) ? ))
205 (progn
206 (ielm-indent-line)
207 t)))
208
209 (defun ielm-complete-symbol nil
210 "Complete the Lisp symbol before point."
211 ;; A wrapper for lisp-complete symbol that returns non-nil if
212 ;; completion has occurred
213 (let* ((btick (buffer-modified-tick))
214 (cbuffer (get-buffer "*Completions*"))
215 (ctick (and cbuffer (buffer-modified-tick cbuffer))))
216 (lisp-complete-symbol)
217 ;; completion has occurred if:
218 (or
219 ;; the buffer has been modified
220 (not (= btick (buffer-modified-tick)))
221 ;; a completions buffer has been modified or created
222 (if cbuffer
223 (not (= ctick (buffer-modified-tick cbuffer)))
224 (get-buffer "*Completions*")))))
225
226 (defun ielm-complete-filename nil
227 "Dynamically complete filename before point, if in a string."
228 (if (nth 3 (parse-partial-sexp comint-last-input-start (point)))
229 (comint-dynamic-complete-filename)))
230
231 (defun ielm-indent-line nil
232 "Indent the current line as Lisp code if it is not a prompt line."
233 (when (save-excursion (comint-bol) (bolp))
234 (lisp-indent-line)))
235
236 ;;; Working buffer manipulation
237
238 (defun ielm-print-working-buffer nil
239 "Print the current IELM working buffer's name in the echo area."
240 (interactive)
241 (message "The current working buffer is: %s" (buffer-name ielm-working-buffer)))
242
243 (defun ielm-display-working-buffer nil
244 "Display the current IELM working buffer.
245 Don't forget that selecting that buffer will change its value of `point'
246 to its value of `window-point'!"
247 (interactive)
248 (display-buffer ielm-working-buffer)
249 (ielm-print-working-buffer))
250
251 (defun ielm-change-working-buffer (buf)
252 "Change the current IELM working buffer to BUF.
253 This is the buffer in which all sexps entered at the IELM prompt are
254 evaluated. You can achieve the same effect with a call to
255 `set-buffer' at the IELM prompt."
256 (interactive "bSet working buffer to: ")
257 (setq ielm-working-buffer (or (get-buffer buf) (error "No such buffer")))
258 (ielm-print-working-buffer))
259
260 ;;; Other bindings
261
262 (defun ielm-return nil
263 "Newline and indent, or evaluate the sexp before the prompt.
264 Complete sexps are evaluated; for incomplete sexps inserts a newline
265 and indents. If however `ielm-dynamic-return' is nil, this always
266 simply inserts a newline."
267 (interactive)
268 (if ielm-dynamic-return
269 (let ((state
270 (save-excursion
271 (end-of-line)
272 (parse-partial-sexp (ielm-pm)
273 (point)))))
274 (if (and (< (car state) 1) (not (nth 3 state)))
275 (ielm-send-input)
276 (if (and ielm-dynamic-multiline-inputs
277 (save-excursion
278 (beginning-of-line)
279 (looking-at comint-prompt-regexp)))
280 (save-excursion
281 (goto-char (ielm-pm))
282 (newline 1)))
283 (newline-and-indent)))
284 (newline)))
285
286 (defvar ielm-input)
287
288 (defun ielm-input-sender (proc input)
289 ;; Just sets the variable ielm-input, which is in the scope of
290 ;; `ielm-send-input's call.
291 (setq ielm-input input))
292
293 (defun ielm-send-input nil
294 "Evaluate the Emacs Lisp expression after the prompt."
295 (interactive)
296 (let (ielm-input) ; set by ielm-input-sender
297 (comint-send-input) ; update history, markers etc.
298 (ielm-eval-input ielm-input)))
299
300 ;;; Utility functions
301
302 (defun ielm-is-whitespace (string)
303 "Return non-nil if STRING is all whitespace."
304 (or (string= string "") (string-match "\\`[ \t\n]+\\'" string)))
305
306 ;;; Evaluation
307
308 (defun ielm-eval-input (ielm-string)
309 "Evaluate the Lisp expression IELM-STRING, and pretty-print the result."
310 ;; This is the function that actually `sends' the input to the
311 ;; `inferior Lisp process'. All comint-send-input does is works out
312 ;; what that input is. What this function does is evaluates that
313 ;; input and produces `output' which gets inserted into the buffer,
314 ;; along with a new prompt. A better way of doing this might have
315 ;; been to actually send the output to the `cat' process, and write
316 ;; this as in output filter that converted sexps in the output
317 ;; stream to their evaluated value. But that would have involved
318 ;; more process coordination than I was happy to deal with.
319 ;;
320 ;; NOTE: all temporary variables in this function will be in scope
321 ;; during the eval, and so need to have non-clashing names.
322 (let (ielm-form ; form to evaluate
323 ielm-pos ; End posn of parse in string
324 ielm-result ; Result, or error message
325 ielm-error-type ; string, nil if no error
326 (ielm-output "") ; result to display
327 (ielm-wbuf ielm-working-buffer) ; current buffer after evaluation
328 (ielm-pmark (ielm-pm)))
329 (if (not (ielm-is-whitespace ielm-string))
330 (progn
331 (condition-case err
332 (let (rout)
333 (setq rout (read-from-string ielm-string))
334 (setq ielm-form (car rout))
335 (setq ielm-pos (cdr rout)))
336 (error (setq ielm-result (error-message-string err))
337 (setq ielm-error-type "Read error")))
338 (if ielm-error-type nil
339 ;; Make sure working buffer has not been killed
340 (if (not (buffer-name ielm-working-buffer))
341 (setq ielm-result "Working buffer has been killed"
342 ielm-error-type "IELM Error"
343 ielm-wbuf (current-buffer))
344 (if (ielm-is-whitespace (substring ielm-string ielm-pos))
345 ;; To correctly handle the ielm-local variables *,
346 ;; ** and ***, we need a temporary buffer to be
347 ;; current at entry to the inner of the next two let
348 ;; forms. We need another temporary buffer to exit
349 ;; that same let. To avoid problems, neither of
350 ;; these buffers should be alive during the
351 ;; evaluation of ielm-form.
352 (let ((*1 *)
353 (*2 **)
354 (*3 ***)
355 ielm-temp-buffer)
356 (set-match-data ielm-match-data)
357 (save-excursion
358 (with-temp-buffer
359 (condition-case err
360 (unwind-protect
361 ;; The next let form creates default
362 ;; bindings for *, ** and ***. But
363 ;; these default bindings are
364 ;; identical to the ielm-local
365 ;; bindings. Hence, during the
366 ;; evaluation of ielm-form, the
367 ;; ielm-local values are going to be
368 ;; used in all buffers except for
369 ;; other ielm buffers, which override
370 ;; them. Normally, the variables *1,
371 ;; *2 and *3 also have default
372 ;; bindings, which are not overridden.
373 (let ((* *1)
374 (** *2)
375 (*** *3))
376 (kill-buffer (current-buffer))
377 (set-buffer ielm-wbuf)
378 (setq ielm-result (eval ielm-form))
379 (setq ielm-wbuf (current-buffer))
380 (setq
381 ielm-temp-buffer
382 (generate-new-buffer " *ielm-temp*"))
383 (set-buffer ielm-temp-buffer))
384 (when ielm-temp-buffer
385 (kill-buffer ielm-temp-buffer)))
386 (error (setq ielm-result (error-message-string err))
387 (setq ielm-error-type "Eval error"))
388 (quit (setq ielm-result "Quit during evaluation")
389 (setq ielm-error-type "Eval error")))))
390 (setq ielm-match-data (match-data)))
391 (setq ielm-error-type "IELM error")
392 (setq ielm-result "More than one sexp in input"))))
393
394 ;; If the eval changed the current buffer, mention it here
395 (if (eq ielm-wbuf ielm-working-buffer) nil
396 (message "current buffer is now: %s" ielm-wbuf)
397 (setq ielm-working-buffer ielm-wbuf))
398
399 (goto-char ielm-pmark)
400 (if (not ielm-error-type)
401 (condition-case err
402 ;; Self-referential objects cause loops in the printer, so
403 ;; trap quits here. May as well do errors, too
404 (setq ielm-output (concat ielm-output (pp-to-string ielm-result)))
405 (error (setq ielm-error-type "IELM Error")
406 (setq ielm-result "Error during pretty-printing (bug in pp)"))
407 (quit (setq ielm-error-type "IELM Error")
408 (setq ielm-result "Quit during pretty-printing"))))
409 (if ielm-error-type
410 (progn
411 (if ielm-noisy (ding))
412 (setq ielm-output (concat ielm-output "*** " ielm-error-type " *** "))
413 (setq ielm-output (concat ielm-output ielm-result)))
414 ;; There was no error, so shift the *** values
415 (setq *** **)
416 (setq ** *)
417 (setq * ielm-result))
418 (setq ielm-output (concat ielm-output "\n"))))
419 (setq ielm-output (concat ielm-output ielm-prompt-internal))
420 (comint-output-filter (ielm-process) ielm-output)))
421
422 ;;; Process and marker utilities
423
424 (defun ielm-process nil
425 ;; Return the current buffer's process.
426 (get-buffer-process (current-buffer)))
427
428 (defun ielm-pm nil
429 ;; Return the process mark of the current buffer.
430 (process-mark (get-buffer-process (current-buffer))))
431
432 (defun ielm-set-pm (pos)
433 ;; Set the process mark in the current buffer to POS.
434 (set-marker (process-mark (get-buffer-process (current-buffer))) pos))
435
436 ;;; Major mode
437
438 (put 'inferior-emacs-lisp-mode 'mode-class 'special)
439
440 (defun inferior-emacs-lisp-mode nil
441 "Major mode for interactively evaluating Emacs Lisp expressions.
442 Uses the interface provided by `comint-mode' (which see).
443
444 * \\<ielm-map>\\[ielm-send-input] evaluates the sexp following the prompt. There must be at most
445 one top level sexp per prompt.
446
447 * \\[ielm-return] inserts a newline and indents, or evaluates a
448 complete expression (but see variable `ielm-dynamic-return').
449 Inputs longer than one line are moved to the line following the
450 prompt (but see variable `ielm-dynamic-multiline-inputs').
451
452 * \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
453 or indents the line if there is nothing to complete.
454
455 The current working buffer may be changed (with a call to
456 `set-buffer', or with \\[ielm-change-working-buffer]), and its value
457 is preserved between successive evaluations. In this way, expressions
458 may be evaluated in a different buffer than the *ielm* buffer.
459 By default, its name is shown on the mode line; you can always display
460 it with \\[ielm-print-working-buffer], or the buffer itself with \\[ielm-display-working-buffer].
461
462 During evaluations, the values of the variables `*', `**', and `***'
463 are the results of the previous, second previous and third previous
464 evaluations respectively. If the working buffer is another IELM
465 buffer, then the values in the working buffer are used. The variables
466 `*1', `*2' and `*3', yield the process buffer values.
467
468 Expressions evaluated by IELM are not subject to `debug-on-quit' or
469 `debug-on-error'.
470
471 The behaviour of IELM may be customized with the following variables:
472 * To stop beeping on error, set `ielm-noisy' to nil.
473 * If you don't like the prompt, you can change it by setting `ielm-prompt'.
474 * If you do not like that the prompt is (by default) read-only, set
475 `ielm-prompt-read-only' to nil.
476 * Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'.
477 * Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
478 (in that order).
479
480 Customized bindings may be defined in `ielm-map', which currently contains:
481 \\{ielm-map}"
482 (interactive)
483 (comint-mode)
484 (setq comint-prompt-regexp (concat "^" (regexp-quote ielm-prompt)))
485 (set (make-local-variable 'paragraph-separate) "\\'")
486 (make-local-variable 'paragraph-start)
487 (setq paragraph-start comint-prompt-regexp)
488 (setq comint-input-sender 'ielm-input-sender)
489 (setq comint-process-echoes nil)
490 (make-local-variable 'comint-dynamic-complete-functions)
491 (set (make-local-variable 'ielm-prompt-internal) ielm-prompt)
492 (set (make-local-variable 'comint-prompt-read-only) ielm-prompt-read-only)
493 (setq comint-dynamic-complete-functions
494 '(ielm-tab comint-replace-by-expanded-history ielm-complete-filename ielm-complete-symbol))
495 (setq comint-get-old-input 'ielm-get-old-input)
496 (make-local-variable 'comint-completion-addsuffix)
497 (setq comint-completion-addsuffix '("/" . ""))
498 (setq major-mode 'inferior-emacs-lisp-mode)
499 (setq mode-name "IELM")
500 (setq mode-line-process '(":%s on " (:eval (buffer-name ielm-working-buffer))))
501 (use-local-map ielm-map)
502 (set-syntax-table emacs-lisp-mode-syntax-table)
503
504 (make-local-variable 'indent-line-function)
505 (make-local-variable 'ielm-working-buffer)
506 (setq ielm-working-buffer (current-buffer))
507 (setq indent-line-function 'ielm-indent-line)
508 (make-local-variable 'fill-paragraph-function)
509 (setq fill-paragraph-function 'lisp-fill-paragraph)
510
511 ;; Value holders
512 (make-local-variable '*)
513 (setq * nil)
514 (make-local-variable '**)
515 (setq ** nil)
516 (make-local-variable '***)
517 (setq *** nil)
518 (set (make-local-variable 'ielm-match-data) nil)
519
520 ;; font-lock support
521 (make-local-variable 'font-lock-defaults)
522 (setq font-lock-defaults
523 '(ielm-font-lock-keywords nil nil ((?: . "w") (?- . "w") (?* . "w"))))
524
525 ;; A dummy process to keep comint happy. It will never get any input
526 (unless (comint-check-proc (current-buffer))
527 ;; Was cat, but on non-Unix platforms that might not exist, so
528 ;; use hexl instead, which is part of the Emacs distribution.
529 (condition-case nil
530 (start-process "ielm" (current-buffer) "hexl")
531 (file-error (start-process "ielm" (current-buffer) "cat")))
532 (set-process-query-on-exit-flag (ielm-process) nil)
533 (goto-char (point-max))
534
535 ;; Lisp output can include raw characters that confuse comint's
536 ;; carriage control code.
537 (set (make-local-variable 'comint-inhibit-carriage-motion) t)
538
539 ;; Add a silly header
540 (insert ielm-header)
541 (ielm-set-pm (point-max))
542 (unless comint-use-prompt-regexp
543 (let ((inhibit-read-only t))
544 (add-text-properties
545 (point-min) (point-max)
546 '(rear-nonsticky t field output inhibit-line-move-field-capture t))))
547 (comint-output-filter (ielm-process) ielm-prompt-internal)
548 (set-marker comint-last-input-start (ielm-pm))
549 (set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
550
551 (run-mode-hooks 'ielm-mode-hook))
552
553 (defun ielm-get-old-input nil
554 ;; Return the previous input surrounding point
555 (save-excursion
556 (beginning-of-line)
557 (if (looking-at comint-prompt-regexp) nil
558 (re-search-backward comint-prompt-regexp))
559 (comint-skip-prompt)
560 (buffer-substring (point) (progn (forward-sexp 1) (point)))))
561
562 ;;; User command
563
564 ;;;###autoload (add-hook 'same-window-buffer-names "*ielm*")
565
566 ;;;###autoload
567 (defun ielm nil
568 "Interactively evaluate Emacs Lisp expressions.
569 Switches to the buffer `*ielm*', or creates it if it does not exist."
570 (interactive)
571 (let (old-point)
572 (unless (comint-check-proc "*ielm*")
573 (with-current-buffer (get-buffer-create "*ielm*")
574 (unless (zerop (buffer-size)) (setq old-point (point)))
575 (inferior-emacs-lisp-mode)))
576 (pop-to-buffer "*ielm*")
577 (when old-point (push-mark old-point))))
578
579 (provide 'ielm)
580
581 ;;; arch-tag: ef60e4c0-9c4f-4bdb-8402-271313329790
582 ;;; ielm.el ends here