HOME

Mini Shell 1.0
DIR:/proc/self/root/proc/thread-self/root/usr/share/emacs/26.1/lisp/
Current File : //proc/self/root/proc/thread-self/root/usr/share/emacs/26.1/lisp/ielm.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310%\210\311\312\313\314\315DD\316\317\320\307\304&\210\311\321\313\314\322DD\323\317\320\307\304\324\325&	\210\311\326\313\314\327DD\330\317\331\307\304&\207" [require comint pp custom-declare-group ielm nil "Interaction mode for Emacs Lisp." :group lisp custom-declare-variable ielm-noisy funcall function #[0 "\300\207" [t] 1] "If non-nil, IELM will beep on error." :type boolean ielm-prompt-read-only #[0 "\300\207" [t] 1] "If non-nil, the IELM prompt is read only.\nThe read only region includes the newline before the prompt.\nSetting this variable does not affect existing IELM runs.\nThis works by setting the buffer-local value of `comint-prompt-read-only'.\nSetting that value directly affects new prompts in the current buffer.\n\nIf this option is enabled, then the safe way to temporarily\noverride the read-only-ness of IELM prompts is to call\n`comint-kill-whole-line' or `comint-kill-region' with no\nnarrowing in effect.  This way you will be certain that none of\nthe remaining prompts will be accidentally messed up.  You may\nwish to put something like the following in your init file:\n\n(add-hook \\='ielm-mode-hook\n          (lambda ()\n             (define-key ielm-map \"\\C-w\" \\='comint-kill-region)\n             (define-key ielm-map [C-S-backspace]\n               \\='comint-kill-whole-line)))\n\nIf you set `comint-prompt-read-only' to t, you might wish to use\n`comint-mode-hook' and `comint-mode-map' instead of\n`ielm-mode-hook' and `ielm-map'.  That will affect all comint\nbuffers, including IELM buffers.  If you sometimes use IELM on\ntext-only terminals or with `emacs -nw', you might wish to use\nanother binding for `comint-kill-whole-line'." :version "22.1" ielm-prompt #[0 "\300\207" [#1="ELISP> "] 1 #1#] "Prompt used in IELM.\nSetting this variable does not affect existing IELM runs.\n\nInterrupting the IELM process with \\<ielm-map>\\[comint-interrupt-subjob],\nand then restarting it using \\[ielm], makes the then current\ndefault value affect _new_ prompts.  Unless the new prompt\ndiffers only in text properties from the old one, IELM will no\nlonger recognize the old prompts.  However, executing \\[ielm]\ndoes not update the prompt of an *ielm* buffer with a running process.\nFor IELM buffers that are not called `*ielm*', you can execute\n\\[inferior-emacs-lisp-mode] in that IELM buffer to update the value,\nfor new prompts.  This works even if the buffer has a running process." string] 10)
#@213 Stored value of `ielm-prompt' in the current IELM buffer.
This is an internal variable used by IELM.  Its purpose is to
prevent a running IELM process from being messed up when the user
customizes `ielm-prompt'.
(defvar ielm-prompt-internal "ELISP> " (#$ . 2924))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\307\310\311&\210\300\315\302\303\316DD\317\320\321\306\322\310\311&	\210\323\324\315\"\207" [custom-declare-variable ielm-dynamic-return funcall function #[0 "\300\207" [t] 1] "Controls whether \\<ielm-map>\\[ielm-return] has intelligent behavior in IELM.\nIf non-nil, \\[ielm-return] evaluates input for complete sexps, or inserts a newline\nand indents for incomplete sexps.  If nil, always inserts newlines." :type boolean :group ielm ielm-dynamic-multiline-inputs #[0 "\300\207" [t] 1] "Force multiline inputs to start from column zero?\nIf non-nil, after entering the first line of an incomplete sexp, a newline\nwill be inserted after the prompt, moving the input to the next line.\nThis gives more frame width for large indented sexps, and allows functions\nsuch as `edebug-defun' to work with such inputs." ielm-mode-hook #[0 "\300\207" [nil] 1] "Hooks to be run when IELM (`inferior-emacs-lisp-mode') is started." :options (eldoc-mode) hook defvaralias inferior-emacs-lisp-mode-hook] 10)
#@38 Most recent value evaluated in IELM.
(defvar * nil (#$ . 4283))
#@45 Second-most-recent value evaluated in IELM.
(defvar ** nil (#$ . 4353))
#@44 Third-most-recent value evaluated in IELM.
(defvar *** nil (#$ . 4431))
#@46 Match data saved at the end of last command.
(defvar ielm-match-data nil (#$ . 4509))
#@322 During IELM evaluation, most recent value evaluated in IELM.
Normally identical to `*'.  However, if the working buffer is an IELM
buffer, distinct from the process buffer, then `*' gives the value in
the working buffer, `*1' the value in the process buffer.
The intended value is only accessible during IELM evaluation.
(defvar *1 nil (#$ . 4602))
#@331 During IELM evaluation, second-most-recent value evaluated in IELM.
Normally identical to `**'.  However, if the working buffer is an IELM
buffer, distinct from the process buffer, then `**' gives the value in
the working buffer, `*2' the value in the process buffer.
The intended value is only accessible during IELM evaluation.
(defvar *2 nil (#$ . 4958))
#@332 During IELM evaluation, third-most-recent value evaluated in IELM.
Normally identical to `***'.  However, if the working buffer is an IELM
buffer, distinct from the process buffer, then `***' gives the value in
the working buffer, `*3' the value in the process buffer.
The intended value is only accessible during IELM evaluation.
(defvar *3 nil (#$ . 5323))
#@78 Buffer in which IELM sexps will be evaluated.
This variable is buffer-local.
(defvar ielm-working-buffer nil (#$ . 5688))
#@42 Message to display when IELM is started.
(defvar ielm-header "*** Welcome to IELM ***  Type (describe-mode) for help.\n" (#$ . 5816))
#@23 Keymap for IELM mode.
(defvar ielm-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\321#\210\301\322\323#\210\301\324\325#\210\301\326\327#\210\211\207" [make-sparse-keymap define-key "	" ielm-tab "
" ielm-return "
" ielm-return-for-effect "\n" ielm-send-input "" eval-defun "	" completion-at-point "" indent-sexp "" backward-delete-char-untabify "" ielm-change-working-buffer "" ielm-display-working-buffer "" ielm-print-working-buffer] 5) (#$ . 5956))
(defvaralias 'inferior-emacs-lisp-mode-map 'ielm-map)
#@17 IELM mode menu.
(defvar ielm-menu nil (#$ . 6594))
(easy-menu-do-define 'ielm-menu ielm-map "IELM mode menu." '("IELM" ["Change Working Buffer" ielm-change-working-buffer t] ["Display Working Buffer" ielm-display-working-buffer t] ["Print Working Buffer" ielm-print-working-buffer t]))
#@54 Additional expressions to highlight in IELM buffers.
(defvar ielm-font-lock-keywords '(("\\(^\\*\\*\\*[^*]+\\*\\*\\*\\)\\(.*$\\)" (1 font-lock-comment-face) (2 font-lock-constant-face))) (#$ . 6886))
#@21 Indent or complete.
(defalias 'ielm-tab #[0 "h\300=\204
hz\301=\203\302 \207\303 \207" [10 32 ielm-indent-line completion-at-point] 2 (#$ . 7092) nil])
#@61 Dynamically complete filename before point, if in a string.
(defalias 'ielm-complete-filename #[0 "\301\302`\"8\205\303 \207" [comint-last-input-start 3 parse-partial-sexp comint-filename-completion] 4 (#$ . 7253)])
#@66 Indent the current line as Lisp code if it is not a prompt line.
(defalias 'ielm-indent-line #[0 "\212\300\301!\210n)\205\f\302 \207" [comint-bol t lisp-indent-line] 2 (#$ . 7478)])
#@64 Print the current IELM working buffer's name in the echo area.
(defalias 'ielm-print-working-buffer #[0 "\301\302\303!\"\207" [ielm-working-buffer message "The current working buffer is: %s" buffer-name] 4 (#$ . 7667) nil])
#@147 Display the current IELM working buffer.
Don't forget that selecting that buffer will change its value of `point'
to its value of `window-point'!
(defalias 'ielm-display-working-buffer #[0 "\301!\210\302 \207" [ielm-working-buffer display-buffer ielm-print-working-buffer] 2 (#$ . 7899) nil])
#@219 Change the current IELM working buffer to BUF.
This is the buffer in which all sexps entered at the IELM prompt are
evaluated.  You can achieve the same effect with a call to
`set-buffer' at the IELM prompt.

(fn BUF)
(defalias 'ielm-change-working-buffer #[257 "\301!\211\203\302!\203\211\202\303\304\"\210\210\305 \207" [ielm-working-buffer get-buffer buffer-live-p error "No such buffer: %S" ielm-print-working-buffer] 5 (#$ . 8200) "bSet working buffer to: "])
#@250 Newline and indent, or evaluate the sexp before the prompt.
Complete sexps are evaluated; for incomplete sexps inserts a newline
and indents.  If however `ielm-dynamic-return' is nil, this always
simply inserts a newline.

(fn &optional FOR-EFFECT)
(defalias 'ielm-return #[256 "\203C\212\304\210\305\306 `\")\211@\307W\203!\3108\204!\311!\202B	\203@\212\312 \210\n\313\314!)\262)\203@\212\306 b\210\315\307!\210)\316 \207\315 \207" [ielm-dynamic-return ielm-dynamic-multiline-inputs comint-prompt-regexp inhibit-changing-match-data nil parse-partial-sexp ielm-pm 1 3 ielm-send-input beginning-of-line t looking-at newline newline-and-indent] 5 (#$ . 8682) nil])
#@50 Like `ielm-return', but do not print the result.
(defalias 'ielm-return-for-effect #[0 "\300\301!\207" [ielm-return t] 2 (#$ . 9364) nil])
#@19 

(fn PROC INPUT)
(defalias 'ielm-input-sender #[514 "\211\211\207" [ielm-input] 4 (#$ . 9509)])
#@81 Evaluate the Emacs Lisp expression after the prompt.

(fn &optional FOR-EFFECT)
(defalias 'ielm-send-input #[256 "\301\302 \210\303\")\207" [ielm-input nil comint-send-input ielm-eval-input] 4 (#$ . 9613) nil])
#@71 Return non-nil if STRING is all whitespace or a comment.

(fn STRING)
(defalias 'ielm-is-whitespace-or-comment #[257 "\211\301\230\206\302\303\304\305#)\266\203\207" [inhibit-changing-match-data "" "\\`[ 	\n]*\\(?:;.*\\)*\\'" nil t string-match] 8 (#$ . 9833)])
#@307 Return a function to use for `standard-output' while in ielm eval.
The returned function takes one character as input.  Passing nil
to this function instead of a character flushes the output
buffer.  Passing t appends a terminating newline if the buffer is
nonempty, then flushes the buffer.

(fn PROCESS)
(defalias 'ielm-standard-output-impl #[257 "\300C\300C\301\302\303\304\305#\306\"\307$\301\310\311\304\305#\312\"\313\314%\207" [nil make-byte-code 0 "\303\300\304\305\301\242\237\"\"\210\306 \210\301\307\240\210\302\242\205\310\302\242!\210\302\307\240\207" vconcat vector [comint-output-filter apply string redisplay nil cancel-timer] 5 257 "\303\304=\203\300\242\203\300\305\300\242B\240\210\304\262\202&\306!\203&\300\300\242B\240\210\211\203/\302 \202<\301\242?\205<\301\307\310\303\302#\240\207" [nil t 10 characterp run-with-timer 0.1] 7 "\n\n(fn CHAR)"] 12 (#$ . 10109)])
#@113 Evaluate the Lisp expression INPUT-STRING, and pretty-print the result.

(fn INPUT-STRING &optional FOR-EFFECT)
(defalias 'ielm-eval-input #[513 "\306\211\211\211\307\310 \311!\204\201\3121'\313!\211@\262\211A\211\262\2620\2022\314!\262\315\211\262\262\210\204\374\316!\204I\317\262\320\262p\262\202\374\311\306O!\203\366	
:\321 ;\306C\306C\322<!\210\212\323\324!r\211q\210\325\326\327\330\331!\332\"\333$\216\3341\337\3351\320\325\326\336\330\331#\337\"\333$\216\n\f:;\340=\203\256\341!\240\210\242;\342p!\210q\210\343\f=\"\262\np\262\323\344!\240\210\242q,00\202\3500\314!\262\345\211\262\262\202\350\346\262\345\211\262\262\210*\210)\347 <+\266\202\374\350\262\351\262=\204	\352\353\"\210\211b\210\204P\3541G\3551;?\2056\356!\357!\211\2050\360\361\362#\262Q\211\26200\202O0\210\320\262\363\211\262\202O\210\320\262\364\211\262\210\203k>\203\\\365 \210\366\367R\262P\262\202q	\203|\307\232\204\201\370P\262?P\262\371\321 \"\207" [ielm-working-buffer * *1 ** *2 *** nil "" ielm-pm ielm-is-whitespace-or-comment (error) read-from-string error-message-string "Read error" buffer-name "Working buffer has been killed" "IELM Error" ielm-process set-match-data generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 (quit) (error) "\302\242\203\n\304\302\242!\210\301\242=\205$\3051\306!0\202 \210\202!\210\300\211\207" [standard-output kill-buffer (error) t] t ielm-standard-output-impl kill-buffer eval " *ielm-temp*" "Eval error" "Quit during evaluation" match-data "IELM error" "More than one sexp in input" message "current buffer is now: %s" (quit) (error) pp-to-string eval-expression-print-format propertize font-lock-face shadow "Error during pretty-printing (bug in pp)" "Quit during pretty-printing" ding "*** " " ***  " "\n" comint-output-filter *3 standard-output ielm-match-data lexical-binding ielm-noisy ielm-prompt-internal] 23 (#$ . 11029)])
(defalias 'ielm-process #[0 "\300p!\207" [get-buffer-process] 2])
(defalias 'ielm-pm #[0 "\300\301p!!\207" [process-mark get-buffer-process] 3])
#@12 

(fn POS)
(defalias 'ielm-set-pm #[257 "\300\301p!!\302\223\207" [process-mark get-buffer-process nil] 4 (#$ . 13242)])
(defvar inferior-emacs-lisp-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [inferior-emacs-lisp-mode-hook variable-documentation put "Hook run after entering IELM mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp inferior-emacs-lisp-mode-map definition-name inferior-emacs-lisp-mode] 4)
(defvar inferior-emacs-lisp-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\300!\204#\303\300\307\310#\210\311\312\300\313\"\210!\210\300\302N\2041\303\300\302\304\314!#\210\303\310\315\316#\207" [inferior-emacs-lisp-mode-abbrev-table inferior-emacs-lisp-mode-map variable-documentation put purecopy "Keymap for `inferior-emacs-lisp-mode'." boundp definition-name inferior-emacs-lisp-mode (lambda (#1=#:def-tmp-var) (defvar inferior-emacs-lisp-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `inferior-emacs-lisp-mode'." derived-mode-parent comint-mode] 5)
#@2763 Major mode for interactively evaluating Emacs Lisp expressions.
Uses the interface provided by `comint-mode' (which see).

* \<ielm-map>\[ielm-send-input] evaluates the sexp following the prompt.  There must be at most
  one top level sexp per prompt.

* \[ielm-return] inserts a newline and indents, or evaluates a
  complete expression (but see variable `ielm-dynamic-return').
  Inputs longer than one line are moved to the line following the
  prompt (but see variable `ielm-dynamic-multiline-inputs').

* \[ielm-return-for-effect] works like `ielm-return', except
  that it doesn't print the result of evaluating the input.  This
  functionality is useful when forms would generate voluminous
  output.

* \[completion-at-point] completes Lisp symbols (or filenames, within strings),
  or indents the line if there is nothing to complete.

The current working buffer may be changed (with a call to `set-buffer',
or with \[ielm-change-working-buffer]), and its value is preserved between successive
evaluations.  In this way, expressions may be evaluated in a different
buffer than the *ielm* buffer.  By default, its name is shown on the
mode line; you can always display it with \[ielm-print-working-buffer], or the buffer itself
with \[ielm-display-working-buffer].

During evaluations, the values of the variables `*', `**', and `***'
are the results of the previous, second previous and third previous
evaluations respectively.  If the working buffer is another IELM
buffer, then the values in the working buffer are used.  The variables
`*1', `*2' and `*3', yield the process buffer values.

If, at the start of evaluation, `standard-output' is t (the
default), `standard-output' is set to a special function that
causes output to be directed to the ielm buffer.
`standard-output' is restored after evaluation unless explicitly
set to a different value during evaluation.  You can use (princ
VALUE) or (pp VALUE) to write to the ielm buffer.

Expressions evaluated by IELM are not subject to `debug-on-quit' or
`debug-on-error'.

The behavior of IELM may be customized with the following variables:
* To stop beeping on error, set `ielm-noisy' to nil.
* If you don't like the prompt, you can change it by setting `ielm-prompt'.
* If you do not like that the prompt is (by default) read-only, set
  `ielm-prompt-read-only' to nil.
* Set `ielm-dynamic-return' to nil for bindings like `lisp-interaction-mode'.
* Entry to this mode runs `comint-mode-hook' and `ielm-mode-hook'
 (in that order).

Customized bindings may be defined in `ielm-map', which currently contains:
\{ielm-map}

In addition to any hooks its parent mode might have run,
this mode runs the hook `inferior-emacs-lisp-mode-hook', as the final or penultimate step
during initialization.
(defalias 'inferior-emacs-lisp-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f\321\"\204;\f
=\204;\322\f\321
C#\210\323!\210\324@!\210\f\325\326A!PB\306\327!\210\330\306\331!\210B\332C\333D\306\334!\210\335\336\337\340\341B\342\333$\210\306\343!\210A#\306\344!\210E$\345F\306\346!\210\347&\350G\306\351!\210\352)\306\353!\210\307+\306\354!\210\355,\306\356!\210p.\306\357!\210\360/\306\361!\210\3331\306\362!\210\3332\306\363!\210\3333\306\364!\210\3334\306\365!\210\3665\367p!\204<\3701\351\371\372p\373#0\202\357\210\371\372p\374#\210\375\376 \333\"\210db\210\306\377!\210\307?Hc\210\201Ld!\210I\204\307J\201Med\201N#\210)\201O\376 #\"\210K\201P \333\223\210\201Q\201Rp!\201O\"\210)\201S\201T!\207" [delay-mode-hooks major-mode mode-name inferior-emacs-lisp-mode-map inferior-emacs-lisp-mode-abbrev-table local-abbrev-table make-local-variable t comint-mode inferior-emacs-lisp-mode "IELM" mode-class put keymap-parent set-keymap-parent current-local-map abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table "^" regexp-quote paragraph-separate "\\'" paragraph-start ielm-input-sender nil completion-at-point-functions (comint-replace-by-expanded-history ielm-complete-filename elisp-completion-at-point) advice--add-function :before-until #[0 "\300\301!\207" [advice--buffer-local eldoc-documentation-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local eldoc-documentation-function] 4 "\n\n(fn GV--VAL)"] elisp-eldoc-documentation-function ielm-prompt-internal comint-prompt-read-only ielm-get-old-input comint-completion-addsuffix ("/" . "") (":%s on " (:eval (buffer-name ielm-working-buffer))) comment-start ";" comment-use-syntax indent-line-function ielm-indent-line ielm-working-buffer fill-paragraph-function lisp-fill-paragraph * ** *** ielm-match-data font-lock-defaults (ielm-font-lock-keywords nil nil ((58 . "w") (45 . "w") (42 . "w"))) comint-check-proc (file-error) start-process "ielm" "hexl" "cat" set-process-query-on-exit-flag ielm-process comint-inhibit-carriage-motion emacs-lisp-mode-syntax-table ielm-prompt comint-prompt-regexp comint-input-sender comint-process-echoes ielm-prompt-read-only comint-get-old-input mode-line-process ielm-header comint-use-prompt-regexp inhibit-read-only comint-last-input-start ielm-set-pm add-text-properties (rear-nonsticky t field output inhibit-line-move-field-capture t) comint-output-filter ielm-pm set-process-filter get-buffer-process run-mode-hooks inferior-emacs-lisp-mode-hook] 5 (#$ . 14432) nil])
(defalias 'ielm-get-old-input #[0 "\212\302 \210\303\304!)\262\204\305!\210\306 \210`\307\310!\210`{)\207" [comint-prompt-regexp inhibit-changing-match-data beginning-of-line t looking-at re-search-backward comint-skip-prompt forward-sexp 1] 3])
#@161 Interactively evaluate Emacs Lisp expressions.
Switches to the buffer `*ielm*', or creates it if it does not exist.
See `inferior-emacs-lisp-mode' for details.
(defalias 'ielm #[0 "\301\302\303!\204!r\304\303!q\210\305 \306U\204`\262\307 \210\310\300!\210\311)\312\303!\210\211\205,\313!\207" [trusted-content nil comint-check-proc "*ielm*" get-buffer-create buffer-size 0 inferior-emacs-lisp-mode make-local-variable :all pop-to-buffer-same-window push-mark] 3 (#$ . 20082) nil])
(provide 'ielm)