|
8
|
1 \input texinfo @c -*-texinfo-*- Last modified: October 25, 1996
|
|
|
2 @setfilename ilisp.info
|
|
0
|
3 @settitle The ILISP Inferior LISP Interface
|
|
|
4
|
|
|
5 @c NOTE: KEYBINDING DESCRIPTIONS IN THIS FILE
|
|
|
6 @c
|
|
|
7 @c Texinfo doesn't support the functionality of substitute-command-keys,
|
|
|
8 @c which kind of makes things tough when the bindings change.
|
|
|
9 @c
|
|
|
10 @c Note that all the keys here which use the ILISP prefix have
|
|
|
11 @c @key{C-z} before them, so a global replace can be used to put in a
|
|
|
12 @c specific value for this (if wanted). The whole string should be
|
|
|
13 @c rpelaced, as in (replace-string "@key{C-z}" "@key{C-c}"). Any occurrances
|
|
|
14 @c of this should be in the proper @kbd{} construct, or in a table.
|
|
|
15 @c
|
|
|
16 @c Key command descriptions in tables have the function listed after
|
|
|
17 @c them, as in "@item RET (return-ilisp)" so it should be poosible
|
|
|
18 @c to update these descriptions with a little elisp code.
|
|
|
19 @c
|
|
|
20 @c Todd Kaufmann 17-Mar-91
|
|
|
21 @c toad@cs.cmu.edu
|
|
|
22
|
|
|
23
|
|
|
24 @c ================================================================
|
|
|
25 @c THIS file has the new style title page commands.
|
|
|
26
|
|
|
27 @c Run using special version of `texinfo.tex'.
|
|
|
28 @c Version 2.13 or higher is recommended.
|
|
|
29
|
|
|
30 @c Also, run `makeinfo' rather than `texinfo-format-buffer'.
|
|
|
31 @c (Get the texinfo2 package.)
|
|
|
32 @c ================================================================
|
|
|
33
|
|
|
34 @c Use this if you want small book size like the GNU Emacs bound book.
|
|
|
35 @c smallbook
|
|
|
36
|
|
|
37 @c tex
|
|
|
38 @c \overfullrule=0pt
|
|
|
39 @c end tex
|
|
|
40
|
|
|
41 @comment INDEX USAGE:
|
|
|
42 @c
|
|
|
43 @c @cindex concept
|
|
|
44 @c @findex function
|
|
|
45 @c @vindex variable
|
|
|
46 @c @kindex key
|
|
|
47 @c @pindex command (normally program)
|
|
|
48 @c
|
|
|
49 @c not used:
|
|
|
50 @c @tindex (data)type
|
|
|
51
|
|
|
52
|
|
|
53 @c
|
|
|
54 @c Combine indices.
|
|
|
55 @c @synindex cp fn
|
|
|
56 @c @syncodeindex vr fn
|
|
|
57 @c @syncodeindex ky fn
|
|
|
58 @c @syncodeindex pg fn
|
|
|
59 @c @syncodeindex tp fn
|
|
|
60 @c oops: texinfo-format-buffer ignores synindex
|
|
|
61 @c So, use makeinfo.c. Get texinfo2.tar.Z off of prep.ai.mit.edu
|
|
|
62 @c
|
|
|
63
|
|
|
64 @c TODO:
|
|
|
65 @c - Add doc for rlogin lisps.
|
|
|
66 @c - Add doc for trace-defun-break
|
|
|
67
|
|
|
68
|
|
|
69 @ifinfo
|
|
|
70 This file documents ILISP.
|
|
|
71
|
|
8
|
72 This is edition 0.12 of the ILISP manual
|
|
|
73 for ILISP Version 5.8.
|
|
0
|
74
|
|
|
75 Copyright (C) 1991,1992,1993 Todd Kaufmann
|
|
8
|
76 1993,1994 Ivan Vasquez
|
|
|
77 1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
|
|
|
78 1996 Marco Antoniotti and Rick Campbell
|
|
0
|
79
|
|
|
80 Permission is granted to make and distribute verbatim copies of
|
|
|
81 this manual provided the copyright notice and this permission notice
|
|
|
82 are preserved on all copies.
|
|
|
83
|
|
|
84 Permission is granted to copy and distribute modified versions of this
|
|
|
85 manual under the conditions for verbatim copying, provided that the entire
|
|
|
86 resulting derived work is distributed under the terms of a permission
|
|
|
87 notice identical to this one.
|
|
|
88
|
|
|
89 Permission is granted to copy and distribute translations of this manual
|
|
|
90 into another language, under the above conditions for modified versions,
|
|
|
91 except that this permission notice may be stated in a translation approved
|
|
|
92 by the Foundation.
|
|
|
93 @end ifinfo
|
|
|
94 @c
|
|
|
95
|
|
|
96 @c
|
|
|
97 @setchapternewpage odd
|
|
|
98
|
|
|
99 @titlepage
|
|
|
100 @title ILISP User Manual
|
|
|
101 @subtitle A GNU Emacs Interface for Interacting with Lisp
|
|
8
|
102 @subtitle Edition 0.13, October 1996
|
|
|
103 @subtitle For ILISP Version 5.8
|
|
0
|
104 @c
|
|
|
105 @c the following comment string is removed by the ctrl-c-doc.sh script,
|
|
|
106 @c which can be used to change all ilisp-prefix bindings to C-c (or
|
|
|
107 @c other).
|
|
|
108 @c
|
|
|
109 @comment ctrl-C version: @subtitle This is the ``@key{C-z}'' version of the manual.
|
|
|
110
|
|
8
|
111 @author by Todd Kaufmann, Chris McConnell, Ivan Vazquez, Marco Antoniotti, and Rick Campbell
|
|
0
|
112
|
|
|
113 @page
|
|
|
114 @vskip 0pt plus 1filll
|
|
|
115 Copyright @copyright{} 1991, 1992, 1993 Todd Kaufmann
|
|
8
|
116 1993, 1994 Ivan Vasquez
|
|
|
117 1994, 1995, 1996 Marco Antoniotti and Rick Busdiecker
|
|
|
118 1996 Marco Antoniotti and Rick Campbell
|
|
0
|
119
|
|
|
120 @sp 2
|
|
8
|
121 This is edition 0.12 of the @cite{ILISP User Manual}
|
|
|
122 for ILISP Version 5.8,
|
|
|
123 July 1996.
|
|
0
|
124
|
|
|
125 @sp 2
|
|
|
126
|
|
|
127 Permission is granted to make and distribute verbatim copies of
|
|
|
128 this manual provided the copyright notice and this permission notice
|
|
|
129 are preserved on all copies.
|
|
|
130
|
|
|
131 Permission is granted to copy and distribute modified versions of this
|
|
|
132 manual under the conditions for verbatim copying, provided that the entire
|
|
|
133 resulting derived work is distributed under the terms of a permission
|
|
|
134 notice identical to this one.
|
|
|
135
|
|
|
136 Permission is granted to copy and distribute translations of this manual
|
|
|
137 into another language, under the above conditions for modified versions,
|
|
|
138 except that this permission notice may be stated in a translation approved
|
|
|
139 by this author.
|
|
|
140 @end titlepage
|
|
|
141 @page
|
|
|
142
|
|
|
143
|
|
|
144 @node Top, Distribution, (dir), (dir)
|
|
|
145 @comment node-name, next, previous, up
|
|
|
146
|
|
|
147
|
|
|
148 @ifinfo
|
|
|
149 This Info file documents ILISP, a GNU Emacs interface for a lisp
|
|
|
150 running in a buffer.
|
|
|
151 @comment ctrl-C version: @sp
|
|
|
152 @comment ctrl-C version: This is the ``@key{C-z}'' version of the manual.
|
|
|
153 @end ifinfo
|
|
|
154
|
|
|
155 @menu
|
|
|
156 * Distribution:: How to get the latest ILISP distribution.
|
|
|
157
|
|
|
158 * Acknowledgements:: Acknowledgements
|
|
|
159 * Introduction:: An introduction to ILISP and its features.
|
|
|
160 * Installation:: How to install ILISP.
|
|
|
161 * Starting up:: How to run a Lisp process using ILISP.
|
|
|
162
|
|
|
163 * Buffers of ILISP:: Buffers used by ILISP, and their commands.
|
|
|
164 * ILISP Commands::
|
|
|
165 * Customization:: Description of ILISP variables and hooks.
|
|
|
166 * Dialects:: How ILISP knows how to communicate with Lisp,
|
|
|
167 and how to define new dialects.
|
|
|
168
|
|
|
169 Indices:
|
|
|
170 * Concept index:: General concepts.
|
|
|
171 * Key index:: ILISP key sequences.
|
|
|
172 * Command index:: Commands by name.
|
|
|
173 * Variable index:: Variables and hooks that influence ILISP's
|
|
|
174 behavior.
|
|
|
175
|
|
|
176 * Function index:: Internal Emacs Lisp functions.
|
|
|
177 @end menu
|
|
|
178
|
|
|
179 @node Distribution, Acknowledgements, Top, Top
|
|
|
180 @unnumbered How to get the latest ILISP distribution.
|
|
|
181
|
|
|
182 ILISP is "free"; this means that everyone is free to use it and free
|
|
|
183 to redistribute it on a free basis. ILISP is not in the public domain;
|
|
|
184 it is copyrighted and there are restrictions on its distribution, but
|
|
|
185 these restrictions are designed to permit everything that a good
|
|
|
186 cooperating citizen would want to do. What is not allowed is to try to
|
|
|
187 prevent others from further sharing any version of ILISP that they might
|
|
|
188 get from you. The precise conditions appears following this section.
|
|
|
189
|
|
|
190 The easiest way to get a copy of ILISP is from someone else who has it.
|
|
|
191 You need not ask for permission to do so, or tell any one else; just
|
|
|
192 copy it.
|
|
|
193
|
|
|
194 If you do start using the package, please send mail to
|
|
8
|
195 @code{ilisp-request@@naggum.no} to subscribe to the ILISP mailing
|
|
|
196 list.
|
|
0
|
197
|
|
8
|
198 Please send bugs, questions or suggestions for discussion to
|
|
|
199 @code{ilisp@@naggum.no}. Message sent there will be distributed to
|
|
|
200 all subscribers.
|
|
0
|
201
|
|
|
202 @menu
|
|
|
203 * FTP directions:: FTP directions
|
|
8
|
204 * WWW directions:: WWW directions
|
|
0
|
205 @end menu
|
|
|
206
|
|
8
|
207 @node FTP directions, WWW directions, , Distribution
|
|
0
|
208 @unnumberedsec FTP directions
|
|
|
209 @cindex FTP site
|
|
|
210 @cindex Anonymous FTP
|
|
|
211 @cindex How to get
|
|
|
212 @cindex Getting ILISP
|
|
|
213 @noindent
|
|
8
|
214 You can get the distribution file, @code{ilisp-5.8.tar.gz} via
|
|
|
215 anonymous FTP from @code{FTP.CS.CMU.EDU} (128.2.206.173) in
|
|
|
216 @code{/afs/cs/user/campbell/http/ilisp/}.
|
|
0
|
217
|
|
8
|
218 @format
|
|
|
219 % @dfn{ftp ftp.cs.cmu.edu}
|
|
|
220 Name (ftp.cs.cmu.edu:rickc): @dfn{anonymous}
|
|
|
221 331 Guest login ok, send username@@node as password.
|
|
|
222 Password: @dfn{@var{your-user-id@@your-hostname}}
|
|
|
223 ftp> @dfn{cd /afs/cs/user/campbell/http/ilisp}
|
|
|
224 250 Directory path set to /afs/cs/user/campbell/http/ilisp.
|
|
|
225 ftp> @dfn{type binary}
|
|
|
226 200 Type set to I.
|
|
|
227 ftp> @dfn{get ilisp-5.8.tar.gz}
|
|
|
228 200 PORT command successful.
|
|
|
229 150 Opening data connection for ilisp-5.8.tar.gz.
|
|
|
230 226 Transfer complete.
|
|
|
231 local: ilisp-5.8.tar.gz remote: ilisp-5.8.tar.gz
|
|
|
232 168801 bytes received.
|
|
|
233 ftp> @dfn{quit}
|
|
|
234 221 Goodbye.
|
|
|
235 @end format
|
|
0
|
236
|
|
|
237 @noindent
|
|
8
|
238 Or get whatever single files you need from the @code{untarred}
|
|
|
239 subdirectory.
|
|
|
240
|
|
|
241 @noindent
|
|
|
242 You can also get @code{ilisp-5.8.tar.gz} via
|
|
|
243 anonymous FTP from @code{FTP.ICSI.BERKELEY.EDU} in either
|
|
|
244 @code{/pub/software/elisp/} or @code{/pub/theory/marcoxa/elisp/}.
|
|
0
|
245
|
|
|
246 @noindent
|
|
|
247 Unpack and install:
|
|
|
248
|
|
8
|
249 @code{% @dfn{gzip -dc ilisp-5.8.tar.gz | tar xf -}}
|
|
0
|
250
|
|
|
251 @xref{Installation}.
|
|
|
252
|
|
8
|
253 @node WWW directions, , FTP directions, Distribution
|
|
|
254 @unnumberedsec WWW directions
|
|
|
255 @cindex WWW site
|
|
|
256 @cindex How to get
|
|
|
257 @cindex Getting ILISP
|
|
|
258 @noindent
|
|
|
259 You can use the World Wide Web (WWW) to get the distribution file from
|
|
|
260 the anonymous FTP locations using one of the following URLs:
|
|
|
261 @itemize @bullet
|
|
|
262 @item
|
|
|
263 @code{ftp://ftp.cs.cmu.edu/afs/cs/user/campbell/http/ilisp/ilisp-5.8.tar.gz}
|
|
|
264 @item
|
|
|
265 @code{ftp://ftp.icsi.berkeley.edu/pub/software/elisp/ilisp-5.8.tar.gz}
|
|
|
266 @item
|
|
|
267 @code{ftp://ftp.icsi.berkeley.edu/pub/theory/marcoxa/ilisp-5.8.tar.gz}
|
|
|
268 @end itemize
|
|
|
269
|
|
|
270 You can also use the CMU Artificial Intelligence Repository:
|
|
|
271
|
|
|
272 @code{http://www.cs.cmu.edu/Web/Groups/AI/html/repository.html}
|
|
0
|
273
|
|
8
|
274 @noindent
|
|
|
275 From there follow: @code{LISP}, @code{UTIL}, @code{EMACS} and finally
|
|
|
276 @code{ILISP}. Use your browser capabilities to download what you
|
|
|
277 need.
|
|
|
278
|
|
|
279 @noindent
|
|
|
280 The complete URL for the distribution file in the CMU AI Repository is
|
|
|
281 @code{http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/util/emacs/ilisp/v57/ilisp57.tgz}
|
|
|
282
|
|
|
283 @noindent
|
|
|
284 Other URLs for the distribution file include:
|
|
|
285 @itemize @bullet
|
|
|
286 @item
|
|
|
287 @code{http://www.c2.net/~campbell/ilisp/ilisp-5.8.tar.gz}
|
|
|
288 @item
|
|
|
289 @code{http://www.cs.cmu.edu/~campbell/ilisp/ilisp-5.8.tar.gz}
|
|
|
290 @end itemize
|
|
|
291
|
|
|
292 @noindent
|
|
|
293 Unpack and install:
|
|
|
294
|
|
|
295 @code{% @dfn{gzip -dc ilisp-5.8.tar.gz | tar xf -}}
|
|
|
296
|
|
|
297 @xref{Installation}.
|
|
0
|
298
|
|
|
299 @node Acknowledgements, Introduction, Distribution, Top
|
|
|
300 @unnumbered Acknowledgements
|
|
|
301
|
|
|
302 ILISP replaces the standard inferior LISP mode. ILISP is based on
|
|
|
303 comint mode and derived from a number of different interfaces including
|
|
8
|
304 Symbolics, CMU Common Lisp, and Thinking Machines.
|
|
0
|
305
|
|
|
306 There are many people that have taken the time to report bugs, make
|
|
|
307 suggestions and even better send code to fix bugs or implement new
|
|
|
308 features.
|
|
|
309
|
|
8
|
310 Thanks to Guido Bosch, David Braunegg, Tim Bradshaw, Thomas M. Breuel,
|
|
|
311 Hans Chalupsky, Kimball Collins, Brian Dennis, David Duff, Tom
|
|
|
312 Emerson, Michael Ernst, Scott Fahlman, David Gadbois, Robert
|
|
|
313 P. Goldman, Marty Hall, Richard Harris, Jim Healy, Christopher Hoover,
|
|
|
314 Larry Hunter, Ben Hyde, Chuck Irvine, Michael Kashket, Mark
|
|
|
315 Kantrowitz, Qiegang Long, Erik Naggum, Dan Pierson, Yusuf Pisan, Frank
|
|
|
316 Ritter, Jeffrey Mark Siskind, Neil Smithline, Richard Stallman, Larry
|
|
|
317 Stead, Jason Trenouth, Christof Ullwer, Bjorn Victor, Fred White, Ben
|
|
|
318 Wing, Matsuo Yoshihiro, Jamie Zawinski, Paul Fuqua (for the CMU-CL GC
|
|
|
319 display code) and Marco Antoniotti for bug reports, suggestions and
|
|
|
320 code. Our apologies to anyone we may have forgotten.
|
|
0
|
321
|
|
|
322 Special thanks to Todd Kaufmann for the texinfo file, work on bridge,
|
|
8
|
323 epoch-pop and for really exercising everything.
|
|
0
|
324
|
|
|
325 Please send bug reports, fixes and extensions to
|
|
8
|
326 @code{ilisp@@naggum.no} so that they can be merged into the master
|
|
0
|
327 source.
|
|
|
328 @noindent
|
|
|
329 @example
|
|
8
|
330 --Chris McConnell 18-Mar-91
|
|
|
331 --Ivan Vazquez 27-Jun-93
|
|
|
332 --Marco Antoniotti and Rick Campbell 25-Oct-96
|
|
0
|
333 @end example
|
|
|
334
|
|
|
335
|
|
|
336 @node Introduction, Installation, Acknowledgements, Top
|
|
|
337 @unnumbered Introduction
|
|
|
338 @cindex features
|
|
|
339
|
|
|
340 ILISP is an interface from GNU Emacs to an inferior LISP. It has the
|
|
|
341 following features:
|
|
|
342
|
|
|
343 @itemize @bullet
|
|
|
344 @item
|
|
8
|
345 Runs under Emacs-18, Emacs-19, and XEmacs-19.
|
|
0
|
346
|
|
|
347 @item
|
|
|
348 Support for multiple LISP dialects including Lucid, Allegro and CMU
|
|
|
349 on multiple machines even at the same time.
|
|
|
350
|
|
|
351 @item
|
|
|
352 Dynamically sized pop-up windows that can be buried and scrolled from
|
|
|
353 any window.
|
|
|
354
|
|
|
355 @item
|
|
|
356 Packages are properly handled including the distinction between
|
|
|
357 exported and internal symbols.
|
|
|
358
|
|
|
359 @item
|
|
|
360 Synchronous, asynchronous or batch eval and compile of files, regions,
|
|
|
361 definitions and sexps with optional switching and automatic calling.
|
|
|
362
|
|
|
363 @item
|
|
|
364 Arglist, documentation, describe, inspect and macroexpand.
|
|
|
365
|
|
|
366 @item
|
|
|
367 Completion of filename components and LISP symbols including partial matches.
|
|
|
368
|
|
|
369 @item
|
|
|
370 Find source both with and without help from the inferior LISP,
|
|
|
371 including CLOS methods, multiple definitions and multiple files.
|
|
|
372
|
|
|
373
|
|
|
374 @item
|
|
|
375 Edit the callers of a function with and without help from the
|
|
|
376 inferior LISP.
|
|
|
377
|
|
|
378 @item
|
|
|
379 Trace/untrace a function.
|
|
|
380
|
|
|
381 @item
|
|
|
382 @kbd{M-q} (``Fill-paragraph'') works properly on paragraphs in comments,
|
|
|
383 strings and code.
|
|
|
384
|
|
|
385 @item
|
|
|
386 Find unbalanced parentheses.
|
|
|
387
|
|
|
388 @item
|
|
|
389 Super brackets.
|
|
|
390
|
|
|
391 @item
|
|
|
392 Handles editing, entering and indenting full LISP expressions.
|
|
|
393
|
|
|
394 @item
|
|
|
395 Next, previous, and similar history mechanism compatible with comint.
|
|
|
396
|
|
|
397 @item
|
|
|
398 Handles LISP errors.
|
|
|
399
|
|
|
400 @item
|
|
|
401 Result histories are maintained in the inferior LISP.
|
|
|
402
|
|
|
403 @item
|
|
|
404 Does not create spurious symbols and handles case issues.
|
|
|
405
|
|
|
406 @item
|
|
|
407 Online manuals for ILISP and Common LISP.
|
|
|
408
|
|
|
409 @end itemize
|
|
|
410
|
|
|
411 @node Installation, Starting up, Introduction, Top
|
|
|
412 @chapter How to install ILISP
|
|
|
413 @cindex Installation
|
|
|
414 Installation of ILISP and some initialization of your computing
|
|
|
415 environment are described in this chapter. Please read the following
|
|
|
416 sections carefully before getting started with ILISP.
|
|
|
417
|
|
|
418 If ILISP has already been installed at your location, you can probably
|
|
|
419 skip ahead to ``Autoloading.''
|
|
|
420
|
|
8
|
421 Note that Jamie Zawinki's byte-compiler is required when compiling
|
|
|
422 ILISP. If you don't have it, get it from
|
|
|
423 @code{ftp://archive.cis.ohio-state.edu/pub/gnu/emacs/elisp-archive/bytecomp2.tar.Z}
|
|
0
|
424
|
|
8
|
425 You don't need it if you are running emacs version 19 as both the FSF
|
|
|
426 and XEmacs releases include this in their distributions.
|
|
0
|
427
|
|
|
428 @menu
|
|
|
429 * Makefile configuration::
|
|
|
430 * Files of ILISP::
|
|
|
431 * Autoloading:: How to define autoload entries.
|
|
|
432 @end menu
|
|
|
433
|
|
|
434 @node Makefile configuration, Files of ILISP, , Installation
|
|
|
435 @comment node-name, next, previous, up
|
|
|
436 @section Makefile configuration
|
|
|
437
|
|
|
438 Some configuration needs to be done before compiling the emacs-lisp
|
|
|
439 files that comprise ILISP. This should be done in the
|
|
8
|
440 @code{Makefile} file in the section of the file marked
|
|
0
|
441 CONFIGURATION SECTION.
|
|
|
442
|
|
|
443 First, set the @code{YOUR_EMACS} variable to be the pathname of the
|
|
|
444 emacs you will be using ILISP with. This is the emacs that will be used
|
|
|
445 to compile ILISP with.
|
|
|
446
|
|
8
|
447 If you don't have Jamie Zawinski's byte compiler in your standard load
|
|
|
448 path ( both FSF's 19 and XEmacs 19 do have enhaced versions of it )
|
|
|
449 then you will have to uncomment the @code{BYTECOMP} line and set it to
|
|
|
450 point to the correct location of the bytecomp files.
|
|
0
|
451
|
|
8
|
452 If you do not have comint already in your emacs ( both FSF 19 and XEmacs
|
|
0
|
453 19 do ) then uncomment the @code{USE_BUNDLED_COMINT} line. This will
|
|
|
454 cause the copy of @code{comint.el} to be moved from the @code{Extras}
|
|
|
455 directory into the main ILISP directory.
|
|
|
456
|
|
|
457 The advice section is left uncommented out in the distributed
|
|
8
|
458 @code{Makefile} because most people will not have
|
|
|
459 @code{advice.elc} in their load path. Only XEmacs will have
|
|
0
|
460 this in the standard distribution. If you do have it in your load path,
|
|
|
461 then to avoid having two copies in your load-path and avoiding future
|
|
|
462 confusion then comment out both the @code{ADVICE} and
|
|
|
463 @code{USE_BUNDLED_ADVICE} lines.
|
|
|
464
|
|
|
465 @cindex Compiling ILISP files
|
|
|
466 @cindex Byte-compiling ILISP files
|
|
|
467 @findex ilisp-compile-inits
|
|
|
468 @vindex ilisp-load-inits
|
|
|
469 @vindex ilisp-site-hook
|
|
|
470 @vindex ilisp-program
|
|
|
471 @vindex ilisp-init-binary-command
|
|
|
472 @vindex ilisp-init-binary-extension
|
|
|
473
|
|
|
474 You can then compile everything with the shell command
|
|
|
475
|
|
8
|
476 @code{% @dfn{make -f Makefile-ilisp }}@dfn{@var{<your target here>}}
|
|
0
|
477
|
|
|
478 Where the possible targets are @code{emacs_18}, @code{emacs_18_epoch},
|
|
|
479 @code{emacs_18_menu}, and @code{emacs_19}.
|
|
|
480
|
|
|
481 Ignore any compilation warnings unless they result in ILISP not
|
|
|
482 compiling completely.
|
|
|
483
|
|
|
484 You should then copy relevant sections of @code{ilisp.emacs} to your
|
|
|
485 @code{.emacs} or to the system-wide @code{default.el} file, depending on
|
|
|
486 who will be using ILISP.
|
|
|
487
|
|
|
488 You should add the directory where all of the ILISP emacs-lisp files
|
|
|
489 reside to your @code{load-path}. There is an example of this in
|
|
|
490 @code{ilisp.emacs}
|
|
|
491
|
|
8
|
492 As an alternative you could set up a @code{.ilisp} which contains the
|
|
|
493 appropriate portions of @code{ilisp.emacs}, in order to avoid cluttering
|
|
|
494 too much @code{.emacs} or @code{default.el}
|
|
|
495
|
|
0
|
496 The first time a dialect is started, the interface files will complain
|
|
|
497 about not being compiled, just hit @kbd{i} to ignore the message. Once
|
|
|
498 a lisp dialect is started up, you should execute the command
|
|
|
499 @code{ilisp-compile-inits} which will compile the @samp{*.lisp} files
|
|
|
500 and write them to the same directory as the ilisp files.@refill
|
|
|
501
|
|
|
502 The binary files should have a unique
|
|
|
503 extension for each different combination of architecture and
|
|
|
504 LISP dialect. You will need to change
|
|
|
505 @code{ilisp-init-binary-extension} and
|
|
|
506 @code{ilisp-init-binary-command} to get additional
|
|
|
507 extensions. The binary for each different architecture
|
|
|
508 should be different. If you want to build the interface
|
|
|
509 files into a LISP world, you will also need to set
|
|
|
510 @code{ilisp-load-inits} to @code{nil} in the same place that
|
|
|
511 you change @code{ilisp-program} to load the LISP
|
|
|
512 world.@refill
|
|
|
513
|
|
|
514
|
|
|
515 There is an @code{ilisp-site-hook} for initializing site specific stuff
|
|
|
516 like program locations when ILISP is first loaded. You may want to
|
|
|
517 define appropriate autoloads in your system Emacs start up file.
|
|
|
518
|
|
|
519 Example site init:
|
|
|
520 @example
|
|
|
521 ;;; CMU site
|
|
|
522 (setq ilisp-site-hook
|
|
|
523 '(lambda ()
|
|
|
524 (setq ilisp-motd "CMU ILISP V%s")
|
|
|
525 (setq expand-symlinks-rfs-exists t)
|
|
|
526 (setq allegro-program "/usr/misc/.allegro/bin/cl")
|
|
|
527 (setq lucid-program "/usr/misc/.lucid/bin/lisp")))
|
|
|
528 @end example
|
|
|
529
|
|
|
530
|
|
|
531
|
|
|
532 @node Files of ILISP, Autoloading, Makefile configuration, Installation
|
|
|
533 @section Files of ILISP
|
|
|
534 @cindex Files of ILISP
|
|
|
535 The files you need to use ilisp are:
|
|
|
536
|
|
|
537 @table @file
|
|
|
538
|
|
|
539 @item ilisp.emacs
|
|
|
540 File with sample @file{.emacs} code for ILISP.
|
|
|
541 @cindex @file{ilisp.emacs}
|
|
|
542
|
|
|
543 @item symlink-fix.el
|
|
|
544 Expand pathnames resolving links.
|
|
|
545 @cindex @file{symlink-fix.el}
|
|
|
546
|
|
|
547 @item completer.el
|
|
|
548 Partial completion code.
|
|
|
549 @cindex @file{completer.el}
|
|
|
550
|
|
|
551 @item bridge.el
|
|
|
552 Process to process communication.
|
|
|
553 @cindex @file{bridge.el}
|
|
|
554
|
|
|
555 @item comint.el
|
|
|
556 The basic comint abstraction. You only need this if running emacs-18.
|
|
|
557 @cindex @file{comint.el}
|
|
|
558
|
|
|
559 @item comint-ipc.el
|
|
|
560 Extensions for sending commands and getting results.
|
|
|
561 @cindex @file{comint-ipc.el}
|
|
|
562
|
|
|
563 @item ilisp-ext.el
|
|
|
564 Standalone lisp-mode extensions.
|
|
|
565 @cindex @file{ilisp-ext.el}
|
|
|
566
|
|
|
567 @item ilisp-bug.el
|
|
|
568 ILISP bug submittal code.
|
|
|
569 @cindex @file{ilisp-bug.el}
|
|
|
570
|
|
|
571 @item compat.el
|
|
|
572 Compatibility code between fsf-18, fsf-19 and lemacs-19.
|
|
|
573 @cindex @file{compat.el}
|
|
|
574
|
|
|
575 @item ilisp-inp.el
|
|
|
576 Buffer input module.
|
|
|
577 @cindex @file{ilisp-inp.el}
|
|
|
578
|
|
|
579 @item ilisp-def.el
|
|
|
580 Variable definitions.
|
|
|
581 @cindex @file{ilisp-def.el}
|
|
|
582
|
|
|
583 @item ilisp-ind.el
|
|
|
584 Indentation code.
|
|
|
585 @cindex @file{ilisp-ind.el}
|
|
|
586
|
|
|
587 @item ilisp-mov.el
|
|
|
588 Buffer-point movement code.
|
|
|
589 @cindex @file{ilisp-mov.el}
|
|
|
590
|
|
|
591 @item ilisp-key.el
|
|
|
592 Keymap setups, including @code{ilisp-lispm-bindings}.
|
|
|
593 @cindex @file{ilisp-key.el}
|
|
|
594
|
|
|
595 @item ilisp-doc.el
|
|
|
596 ILISP mode documenation.
|
|
|
597 @cindex @file{ilisp-doc.el}
|
|
|
598
|
|
|
599 @item ilisp-mod.el
|
|
|
600 ILISP mode definition.
|
|
|
601 @cindex @file{ilisp-mod.el}
|
|
|
602
|
|
|
603 @item ilisp-prn.el
|
|
|
604 Parenthesis handling.
|
|
|
605 @cindex @file{ilisp-prn.el}
|
|
|
606
|
|
|
607 @item ilisp-el.el
|
|
|
608 Emacs-lisp additions.
|
|
|
609 @cindex @file{ilisp-el.el}
|
|
|
610
|
|
|
611 @item ilisp-sym.el
|
|
|
612 ILISP symbol handling.
|
|
|
613 @cindex @file{ilisp-sym.el}
|
|
|
614
|
|
|
615 @item ilisp-low.el
|
|
|
616 Low level interface code.
|
|
|
617 @cindex @file{ilisp-low.el}
|
|
|
618
|
|
|
619 @item ilisp-hi.el
|
|
|
620 High level interface code.
|
|
|
621 @cindex @file{ilisp-hi.el}
|
|
|
622
|
|
|
623 @item ilisp-out.el
|
|
|
624 Output handling, include typeout window (a popper replacement).
|
|
|
625 @cindex @file{ilisp-out.el}
|
|
|
626
|
|
|
627 @item ilisp-prc.el
|
|
|
628 Process handling code.
|
|
|
629 @cindex @file{ilisp-prc.el}
|
|
|
630
|
|
|
631 @item ilisp-val.el
|
|
|
632 Buffer value interface.
|
|
|
633 @cindex @file{ilisp-val.el}
|
|
|
634
|
|
|
635 @item ilisp-rng.el
|
|
|
636 Match ring code.
|
|
|
637 @cindex @file{ilisp-rng.el}
|
|
|
638
|
|
|
639 @item ilisp-utl.el
|
|
|
640 Misc. utilities.
|
|
|
641 @cindex @file{ilisp-utl.el}
|
|
|
642
|
|
|
643 @item ilisp-hnd.el
|
|
|
644 Error handling.
|
|
|
645 @cindex @file{ilisp-hnd.el}
|
|
|
646
|
|
|
647 @item ilisp-kil.el
|
|
|
648 Interface to reset/kill/abort inferior lisp.
|
|
|
649 @cindex @file{ilisp-kil.el}
|
|
|
650
|
|
|
651 @item ilisp-snd.el
|
|
|
652 ilisp-send definitions and associated code.
|
|
|
653 @cindex @file{ilisp-snd.el}
|
|
|
654
|
|
|
655 @item ilisp-cmt.el
|
|
|
656 Comint related code/setup.
|
|
|
657 @cindex @file{ilisp-cmt.el}
|
|
|
658
|
|
|
659 @item ilisp-cmp.el
|
|
|
660 ILISP completer related code.
|
|
|
661 @cindex @file{ilisp-cmp.el}
|
|
|
662
|
|
|
663 @item ilisp-xfr.el
|
|
|
664 Transfer between lisp <-> emacs code.
|
|
|
665 @cindex @file{ilisp-xfr.el }
|
|
|
666
|
|
|
667 @item ilisp-cl.el
|
|
|
668 Commo-Lisp dialect definition.
|
|
|
669 @cindex @file{ilisp-cl.el}
|
|
|
670
|
|
|
671 @item ilisp-src.el
|
|
|
672 ILISP source code module.
|
|
|
673 @cindex @file{ilisp-src.el}
|
|
|
674
|
|
|
675 @item ilisp-bat.el
|
|
|
676 ILISP batch code module.
|
|
|
677 @cindex @file{ilisp-bat.el}
|
|
|
678
|
|
|
679 @item ilisp.el
|
|
|
680 File to be loaded, loads in all necessary parts of ILISP.
|
|
|
681 @cindex @file{ilisp.el}
|
|
|
682
|
|
|
683 @item *.lisp
|
|
|
684 ILISP support code. Each dialect will have one of these files.
|
|
|
685
|
|
|
686 @item *.lcd
|
|
|
687 Package descriptors for the Lisp Code Directory.
|
|
|
688
|
|
|
689 @item ilisp.texi
|
|
|
690 Texinfo file for ILISP.
|
|
|
691 @cindex @file{ilisp.texi}
|
|
|
692
|
|
|
693 @end table
|
|
|
694
|
|
|
695 @cindex @file{.el} files
|
|
|
696
|
|
|
697 @node Autoloading, , Files of ILISP, Installation
|
|
|
698 @section How to define autoload entries
|
|
|
699 @cindex autoload definitions
|
|
|
700 @cindex defining autoloads
|
|
|
701 @cindex @file{.emacs} forms
|
|
|
702 A complete example of things you may want to add to your @code{.emacs}
|
|
|
703 can be found in the in the file @file{ilisp.emacs} in the
|
|
|
704 @code{ilisp-directory} what follows is that file.
|
|
|
705
|
|
|
706
|
|
|
707 @example
|
|
|
708 @c start of ilisp.emacs
|
|
|
709 ;;;
|
|
|
710 ;;; This file shows examples of some of the things you might want to
|
|
|
711 ;;; do to install or customize ILISP. You may not want to include all
|
|
|
712 ;;; of them in your .emacs. For example, the default key binding
|
|
|
713 ;;; prefix for ILISP is C-z and this file changes the default prefix to
|
|
|
714 ;;; C-c. For more information on things that can be changed, see the
|
|
|
715 ;;; file ilisp.el.
|
|
|
716 ;;;
|
|
|
717
|
|
|
718 ;;; If ilisp lives in some non-standard directory, you must tell emacs
|
|
|
719 ;;; where to get it. This may or may not be necessary.
|
|
|
720 (setq load-path (cons (expand-file-name "~jones/emacs/ilisp/") load-path))
|
|
|
721
|
|
|
722 ;;; If you always want partial minibuffer completion
|
|
|
723 (require 'completer)
|
|
|
724
|
|
|
725 ;;; If you want to redefine typeout-window keys:
|
|
|
726 (add-hook 'ilisp-load-hook
|
|
|
727 '(lambda ()
|
|
|
728 (define-key global-map "\C-c1" 'ilisp-bury-output)
|
|
|
729 (define-key global-map "\C-cv" 'ilisp-scroll-output)
|
|
|
730 (define-key global-map "\C-cg" 'ilisp-grow-output)))
|
|
|
731
|
|
|
732
|
|
|
733 (autoload 'run-ilisp "ilisp" "Select a new inferior LISP." t)
|
|
|
734 ;;; Autoload based on your LISP. You only really need the one you use.
|
|
|
735 ;;; If called with a prefix, you will be prompted for a buffer and
|
|
|
736 ;;; program.
|
|
|
737 ;;;
|
|
|
738 ;;; [Back to the old way now -- Ivan Mon Jun 28 23:30:51 1993]
|
|
|
739 ;;;
|
|
|
740 (autoload 'clisp "ilisp" "Inferior generic Common LISP." t)
|
|
|
741 (autoload 'allegro "ilisp" "Inferior Allegro Common LISP." t)
|
|
|
742 (autoload 'lucid "ilisp" "Inferior Lucid Common LISP." t)
|
|
|
743 (autoload 'cmulisp "ilisp" "Inferior CMU Common LISP." t)
|
|
|
744 (autoload 'kcl "ilisp" "Inferior Kyoto Common LISP." t)
|
|
|
745 (autoload 'akcl "ilisp" "Inferior Austin Kyoto Common LISP." t)
|
|
|
746 (autoload 'ibcl "ilisp" "Ibuki Common LISP." t)
|
|
|
747 (autoload 'scheme "ilisp" "Inferior generic Scheme." t)
|
|
|
748 (autoload 'oaklisp "ilisp" "Inferior Oaklisp Scheme." t)
|
|
|
749
|
|
|
750 ;;; Define where LISP programs are found. (This may already be done
|
|
|
751 ;;; at your site.)
|
|
|
752 (setq allegro-program "/usr/misc/.allegro/bin/cl")
|
|
|
753 (setq lucid-program "/usr/misc/.lucid/bin/lisp")
|
|
|
754 (setq cmulisp-program "/usr/misc/.cmucl/bin/lisp")
|
|
|
755
|
|
|
756 ;;; If you run cmu-cl then set this to where your source files are.
|
|
|
757 (setq cmulisp-local-source-directory
|
|
|
758 "/usr/local/utils/CMU-CL/")
|
|
|
759
|
|
|
760
|
|
|
761 ;;; This makes reading a lisp file load in ilisp.
|
|
|
762 (set-default 'auto-mode-alist
|
|
|
763 (append '(("\\.lisp$" . lisp-mode)) auto-mode-alist))
|
|
|
764 (setq lisp-mode-hook '(lambda () (require 'ilisp)))
|
|
|
765
|
|
|
766 ;;; Sample load hook
|
|
|
767 (add-hook 'ilisp-load-hook
|
|
|
768 '(lambda ()
|
|
|
769 ;; Change default key prefix to C-c
|
|
|
770 (setq ilisp-prefix "\C-c")
|
|
|
771
|
|
|
772 ;; Define LispMachine-like key bindings, too.
|
|
|
773 (ilisp-lispm-bindings)
|
|
|
774
|
|
|
775 ;; Sample initialization hook. Set the inferior LISP directory to
|
|
|
776 ;; the directory of the buffer that spawned it on the first prompt.
|
|
|
777 (setq ilisp-init-hook
|
|
|
778 '(lambda ()
|
|
|
779 (default-directory-lisp ilisp-last-buffer)))))
|
|
|
780 @c end of ilisp.emacs
|
|
|
781 @end example
|
|
|
782
|
|
|
783 @c ==================================================================
|
|
|
784 @node Starting up, Buffers of ILISP, Installation, Top
|
|
|
785 @chapter How to run a Lisp process using ILISP
|
|
|
786 @cindex Running lisp
|
|
|
787 @cindex Starting up lisp
|
|
|
788 @cindex Supported dialects
|
|
|
789 @cindex Dialects supported
|
|
|
790 @pindex run-ilisp
|
|
|
791 @pindex clisp
|
|
|
792 @pindex allegro
|
|
|
793 @pindex lucid
|
|
|
794 @pindex cmulisp
|
|
|
795 @pindex kcl
|
|
|
796 @pindex akcl
|
|
|
797 @pindex ibcl
|
|
|
798 @pindex scheme
|
|
|
799 @pindex oaklisp
|
|
|
800
|
|
|
801 To start a Lisp use @kbd{M-x run-ilisp}, or a specific dialect like
|
|
|
802 @kbd{M-x allegro}. If called with a prefix you will be prompted for a
|
|
|
803 buffer name and a program to run. The default buffer name is the name
|
|
|
804 of the dialect. The default program for a dialect will be the value of
|
|
|
805 DIALECT-program or the value of ilisp-program inherited from a less
|
|
|
806 specific dialect. If there are multiple LISP's, use the dialect name or
|
|
|
807 @kbd{M-x select-ilisp} (@kbd{@key{C-z} S}) to select the current ILISP
|
|
|
808 buffer.
|
|
|
809
|
|
|
810 Entry into ILISP mode runs the hooks on @code{comint-mode-hook} and
|
|
|
811 @code{ilisp-mode-hook} and then DIALECT-hooks specific to LISP
|
|
|
812 dialects in the nesting order above. Many dialects call
|
|
|
813 @code{ilisp-load-init} in their dialect setup.
|
|
|
814
|
|
8
|
815 These are the currently supported dialects.
|
|
|
816
|
|
|
817 @itemize @bullet
|
|
|
818 @item allegro
|
|
|
819 Allegro Common Lisp from Franz Inc.
|
|
|
820
|
|
|
821 @item lispworks
|
|
|
822 Harlequin Common Lisp from Harlequin Ltd.
|
|
|
823
|
|
|
824 @item lucid
|
|
|
825 Lucid Common Lisp, currently supported by Harlequin Ltd.
|
|
|
826
|
|
|
827 @item kcl
|
|
|
828 Kyoto Common Lisp, original version.
|
|
|
829
|
|
|
830 @item akcl
|
|
|
831 Austin Kyoto Common Lisp, the U. Texas derivative.
|
|
|
832
|
|
|
833 @item gcl
|
|
|
834 GNU Common Lisp, the official GNU release. A derivative of AKCL.
|
|
|
835
|
|
|
836 @item ecl
|
|
|
837 EcoLisp, the Embeddable Common Lisp by Beppe Attardi. A derivative of
|
|
|
838 KCL and AKCL.
|
|
|
839
|
|
|
840 @item ibcl
|
|
|
841 Ibuki Common Lisp, derived from KCL.
|
|
|
842
|
|
|
843 @item cmucl
|
|
|
844 CMU Common Lisp, the major development platform for ILISP so far.
|
|
|
845
|
|
|
846 @item clisp-hs
|
|
|
847 CLISP by Haible and Stoll.
|
|
|
848
|
|
|
849 @item oaklisp
|
|
|
850 Oaklisp scheme.
|
|
|
851
|
|
|
852 @end itemize
|
|
|
853
|
|
|
854 The dialects
|
|
0
|
855 are listed so that the indentation correponds to the hierarchical
|
|
|
856 relationship between dialects.
|
|
|
857 @example
|
|
|
858 clisp
|
|
|
859 allegro
|
|
|
860 lucid
|
|
|
861 kcl
|
|
|
862 akcl
|
|
8
|
863 gcl
|
|
|
864 ecl
|
|
0
|
865 ibcl
|
|
|
866 cmulisp
|
|
8
|
867 clisp-hs
|
|
|
868 lispworks
|
|
0
|
869 scheme
|
|
|
870 oaklisp
|
|
|
871 @end example
|
|
|
872
|
|
|
873 If anyone figures out support for other dialects I would be happy
|
|
|
874 to include it in future releases. @xref{Dialects}.
|
|
|
875
|
|
|
876 To define a new dialect, @xref{Defining new dialects} and @xref{Customization}.
|
|
|
877
|
|
|
878
|
|
|
879 @node Buffers of ILISP, ILISP Commands, Starting up, Top
|
|
|
880 @chapter Buffers used by ILISP, and their commands
|
|
|
881 @cindex buffers of ILISP
|
|
|
882 @cindex ILISP buffers
|
|
|
883 @table @code
|
|
|
884
|
|
|
885 @item *@var{dialect}*
|
|
|
886 The Lisp listener buffer. Forms can be entered in this buffer in, and
|
|
|
887 they will be sent to lisp when you hit return if the form is complete.
|
|
|
888 This buffer is in ilisp-mode, which is built on top of comint-mode, and
|
|
|
889 all comint commands such as history mechanism and job control are
|
|
|
890 available.
|
|
|
891 @c xref..
|
|
|
892
|
|
|
893 @item @var{lisp-mode-buffers}
|
|
|
894 A buffer is assumed to contain Lisp source code if its major mode is in
|
|
|
895 the list @code{lisp-source-modes}. If it's loaded into a buffer that is
|
|
|
896 in one of these major modes, it's considered a lisp source file by
|
|
|
897 @code{find-file-lisp}, @code{load-file-lisp} and
|
|
|
898 @code{compile-file-lisp}.
|
|
|
899 Used by these commands to determine defaults.@refill
|
|
|
900
|
|
|
901 @item @code{*Completions*}
|
|
|
902 @cindex @code{*Completions*} buffer
|
|
|
903 Used for listing completions of symbols or files by the completion commands.
|
|
|
904 @xref{Completion}.
|
|
|
905
|
|
|
906 @item *Aborted Commands*
|
|
|
907 @cindex @code{*Aborted Commands*} buffer
|
|
|
908 @xref{Interrupts}.
|
|
|
909
|
|
|
910 @item *Errors*
|
|
|
911 @itemx *Output*
|
|
|
912 @itemx *Error Output*
|
|
|
913 @cindex @code{*Error Output*} buffer
|
|
|
914 @cindex @code{*Errors*} buffer
|
|
|
915 @cindex @code{*Output*} buffer
|
|
|
916 used to pop-up results and errors from the inferior LISP.
|
|
|
917
|
|
|
918 @item *ilisp-send*
|
|
|
919 @cindex @code{*ilisp-send*} buffer
|
|
|
920 Buffer containing the last form sent to the inferior LISP.
|
|
|
921
|
|
|
922 @item *Edit-Definitions*
|
|
|
923 @itemx *All-Callers*
|
|
|
924 @cindex @code{*Edit-Definitions*} buffer
|
|
|
925 @cindex @code{*All-Callers*} buffer
|
|
|
926 @xref{Source code commands}.
|
|
|
927
|
|
|
928 @item *Last-Changes*
|
|
|
929 @itemx *Changed-Definitions*
|
|
|
930 @cindex @code{*Last-Changes*} buffer
|
|
|
931 @cindex @code{*Changed-Definitions*} buffer
|
|
|
932 @xref{Batch commands}.
|
|
|
933 @end table
|
|
|
934
|
|
|
935 @menu
|
|
|
936 * Typeout windows:: temporary windows used for display.
|
|
|
937 * Switching buffers:: Switching buffers
|
|
|
938 @end menu
|
|
|
939
|
|
|
940 @node Typeout windows, Switching buffers, , Buffers of ILISP
|
|
|
941 @section Typeout windows
|
|
|
942 @cindex Typeout windows
|
|
|
943
|
|
|
944 All ILISP output is funneled through the function which is bound to
|
|
|
945 the hook @code{ilisp-display-output-function}. The function gets
|
|
|
946 a single argument, a string, and should make that output visible to
|
|
|
947 the user somehow.
|
|
|
948
|
|
|
949 One possible choice for output display is
|
|
|
950 @code{ilisp-display-output-in-typeout-window},
|
|
|
951 which pops up a window at the top of the current screen which is
|
|
|
952 just large enough to display the output. This window can be
|
|
|
953 "remote controlled" by the commands @code{ilisp-scroll-output},
|
|
|
954 @code{ilisp-bury-output}, and @code{ilisp-grow-output}.
|
|
|
955
|
|
|
956 Unlike the old popper facility, the ilisp typeout window facility
|
|
|
957 does not trounce on any existing Emacs functions or on any common
|
|
|
958 key bindings, like @kbd{C-x o}.
|
|
|
959
|
|
|
960 Other built-in functions which might be useful as values for
|
|
|
961 @code{ilisp-display-output-function} include
|
|
|
962 @code{ilisp-display-output-default},
|
|
|
963 @code{ilisp-display-output-adaptively},
|
|
|
964 @code{ilisp-display-output-in-lisp-listener},
|
|
|
965 @code{ilisp-display-output-in-temp-buffer}, and
|
|
|
966 @code{ilisp-display-output-in-typeout-window}.
|
|
|
967
|
|
|
968 The default display function is @code{ilisp-display-output-default},
|
|
|
969 which obeys the @code{lisp-no-popper} variable.
|
|
|
970
|
|
|
971 Users are encouraged to write their own output display functions
|
|
|
972 to get the exact desired behavior, displaying on a private emacs
|
|
|
973 screen, in a pop-up dialog box, or whetever.
|
|
|
974
|
|
|
975
|
|
|
976 @table @kbd
|
|
|
977
|
|
|
978 @item @key{C-z} 1 (ilisp-bury-output)
|
|
|
979 deletes and buries the typeout output window.
|
|
|
980 @kindex C-z 1
|
|
|
981 @pindex ilisp-bury-output
|
|
|
982 @cindex bury output window
|
|
|
983
|
|
|
984
|
|
|
985 @item @key{C-z} v (ilisp-scroll-output)
|
|
|
986 scrolls the output window if it is showing, otherwise does nothing.
|
|
|
987 If it is called with a negative prefix, it will scroll backwards.
|
|
|
988 @cindex scrolling output
|
|
|
989 @pindex ilisp-scroll-output
|
|
|
990 @kindex C-z v
|
|
|
991
|
|
|
992 @item @key{C-z} G (ilisp-grow-output)
|
|
|
993 will grow the output window if showing by the prefix number of lines.
|
|
|
994 @cindex grow output window
|
|
|
995 @pindex ilisp-grow-output
|
|
|
996 @kindex C-z G
|
|
|
997
|
|
|
998 @end table
|
|
|
999
|
|
|
1000 An alternative to typeout windows is to always have the inferior LISP
|
|
|
1001 buffer visible and have all output go there. Setting
|
|
|
1002 @code{lisp-no-popper} to @code{t} will cause all output to go to the
|
|
|
1003 inferior LISP buffer. Setting @code{lisp-no-popper} to @code{'message}
|
|
|
1004 will make output of one line go to the message window. Setting
|
|
|
1005 @code{comint-always-scroll} to @code{t} will cause process output to
|
|
|
1006 always be visible. If a command gets an error, you will be left in the
|
|
|
1007 break loop.@refill
|
|
|
1008
|
|
|
1009 @cindex Turning off typeout windows
|
|
|
1010 @vindex comint-always-scroll
|
|
|
1011 @vindex lisp-no-popper
|
|
|
1012
|
|
|
1013
|
|
|
1014
|
|
|
1015 @node Switching buffers, ,Typeout windows, Buffers of ILISP
|
|
|
1016 @section Switching buffers
|
|
|
1017
|
|
|
1018 Commands to make switching between buffers easier.
|
|
|
1019 @cindex Switching buffers
|
|
|
1020
|
|
|
1021 @table @kbd
|
|
|
1022 @item @key{C-z} b (switch-to-lisp)
|
|
|
1023 @kindex @key{C-z} b
|
|
|
1024 @pindex switch-to-lisp
|
|
|
1025 will pop to the current ILISP buffer or if already in an ILISP buffer,
|
|
|
1026 it will return to the buffer that last switched to an ILISP buffer.
|
|
|
1027 With a prefix, it will also go to the end of the buffer. If you do not
|
|
|
1028 want it to pop, set @code{pop-up-windows} to nil.
|
|
|
1029 @vindex pop-up-windows
|
|
|
1030
|
|
|
1031
|
|
|
1032 @item M-C-l (previous-buffer-lisp)
|
|
|
1033 will switch to the last visited buffer in the current window or the Nth
|
|
|
1034 previous buffer with a prefix.
|
|
|
1035 @cindex Previous lisp buffer
|
|
|
1036 @pindex previous-buffer-lisp
|
|
|
1037 @kindex M-C-l
|
|
|
1038
|
|
|
1039 @end table
|
|
|
1040
|
|
|
1041
|
|
|
1042 @node ILISP Commands, Customization, Buffers of ILISP, Top
|
|
|
1043 @chapter ILISP Commands
|
|
|
1044
|
|
|
1045
|
|
|
1046 Most of these key bindings work in both Lisp Mode and ILISP mode.
|
|
|
1047 There are a few additional and-go bindings found in Lisp Mode.
|
|
|
1048
|
|
|
1049
|
|
|
1050 @menu
|
|
|
1051 * Eval and compile functions::
|
|
|
1052 * Documentation functions::
|
|
|
1053 * Macroexpansion::
|
|
|
1054 * Tracing functions::
|
|
|
1055 * Package Commands::
|
|
|
1056 * Source code commands:: Working on several files
|
|
|
1057 * Batch commands:: Grouping changes for eval/compile
|
|
|
1058 * Files and directories::
|
|
|
1059 * Keyboard modes:: Interactive and raw keyboard modes
|
|
|
1060 * Interrupts:: Interrupts, aborts, and errors
|
|
|
1061 * Command history::
|
|
|
1062 * Completion::
|
|
|
1063 * Miscellany:: Indentation, parenthesis balancing,
|
|
|
1064 and comment commands.
|
|
|
1065 @end menu
|
|
|
1066
|
|
|
1067 @node Eval and compile functions, Documentation functions, , ILISP Commands
|
|
|
1068 @section Eval and compile functions
|
|
|
1069 @cindex Eval/compile commands
|
|
|
1070 @cindex Compile/eval commands
|
|
|
1071
|
|
|
1072 In LISP, the major unit of interest is a form, which is anything between
|
|
|
1073 two matching parentheses. Some of the commands here also refer to
|
|
|
1074 ``defun,'' which is a list that starts at the left margin in a LISP
|
|
|
1075 buffer, or after a prompt in the ILISP buffer. These commands refer to
|
|
|
1076 the ``defun'' that contains the point.
|
|
|
1077 @cindex Defun
|
|
|
1078
|
|
|
1079 ``A call'' refers to a reference to a function call for a function or
|
|
|
1080 macro, or a reference to a variable. Commands which ``insert a call''
|
|
|
1081 in the ILISP buffer will bring up the last command which matches it or
|
|
|
1082 else will insert a template for a call.
|
|
|
1083 @cindex Call
|
|
|
1084
|
|
|
1085 When an eval is done of a single form matching @code{ilisp-defvar-regexp}
|
|
|
1086 the corresponding symbol will be unbound and the value assigned again.
|
|
|
1087 @vindex ilisp-defvar-regexp
|
|
|
1088
|
|
|
1089 When you send a form to LISP, the status light will reflect the
|
|
|
1090 progress of the command. In a lisp mode buffer the light will reflect
|
|
|
1091 the status of the currently selected inferior LISP unless
|
|
|
1092 @code{lisp-show-status} is nil. If you want to find out what command is
|
|
|
1093 currently running, use the command @kbd{@key{C-z} s} (status-lisp).
|
|
|
1094 If you call it with a prefix, the pending commands will be displayed as
|
|
|
1095 well.@refill
|
|
|
1096 @cindex Currently running command
|
|
|
1097 @cindex Displaying commands
|
|
|
1098 @pindex status-lisp
|
|
|
1099 @kindex @key{C-z} s
|
|
|
1100 @vindex lisp-show-status
|
|
|
1101 @cindex Status light
|
|
|
1102 @cindex Modeline status
|
|
|
1103
|
|
|
1104 Note that in this table as elsewhere, the key @key{C-z} (ilisp-prefix)
|
|
|
1105 is used as a prefix character for ILISP commands, though this may be
|
|
|
1106 changed.
|
|
|
1107 @kindex @key{C-z} prefix
|
|
|
1108 @vindex ilisp-prefix
|
|
|
1109 @c xref .. custom? or autoload?
|
|
|
1110 For a full list of key-bindings, use @kbd{M-x describe-mode} or
|
|
|
1111 @kbd{M-x describe-bindings} while in an ILISP-mode buffer.@refill
|
|
|
1112 @cindex Listing bindings
|
|
|
1113 @cindex Describing bindings
|
|
|
1114
|
|
|
1115
|
|
|
1116 The eval/compile commands verify that their expressions are balanced and
|
|
|
1117 then send the form to the inferior LISP. If called with a positive
|
|
|
1118 prefix, the result of the operation will be inserted into the buffer
|
|
|
1119 after the form that was just sent.
|
|
|
1120 @cindex Inserting results
|
|
|
1121
|
|
|
1122 For commands which operate on a region, the result of the compile or eval
|
|
|
1123 is the last form in the region.
|
|
|
1124 @cindex Region commands
|
|
|
1125
|
|
|
1126 The @samp{and-go} versions will perform the operation and then
|
|
|
1127 immediately switch to the ILISP buffer where you will see the results of
|
|
|
1128 executing your form. If @code{eval-defun-and-go-lisp} or
|
|
|
1129 @code{compile-defun-and-go-lisp} is called with a prefix, a call for the
|
|
|
1130 form will be inserted as well.@refill
|
|
|
1131 @cindex Inserting calls
|
|
|
1132 @pindex compile-defun-and-go-lisp
|
|
|
1133 @pindex eval-defun-and-go-lisp
|
|
|
1134 @cindex @samp{and-go} functions
|
|
|
1135
|
|
|
1136 @table @kbd
|
|
|
1137
|
|
|
1138 @item @key{C-z}
|
|
|
1139 The prefix-key for most ILISP commands. This can be changed by setting
|
|
|
1140 the variable @code{ilisp-prefix}.
|
|
|
1141 @c xref custom?
|
|
|
1142
|
|
|
1143 @item RET (return-ilisp)
|
|
|
1144 In ILISP-mode buffer, sends the current form to lisp if complete,
|
|
|
1145 otherwise creates a new line and indents. If you edit old input, the
|
|
|
1146 input will be copied to the end of the buffer first and then sent.
|
|
|
1147 @cindex Sending input to lisp
|
|
|
1148 @pindex return-ilisp
|
|
|
1149 @kindex RET
|
|
|
1150
|
|
|
1151 @item C-] (close-and-send-lisp)
|
|
|
1152 Closes the current sexp, indents it, and then sends it to the current
|
|
|
1153 inferior LISP.
|
|
|
1154 @pindex close-and-send-lisp
|
|
|
1155 @kindex C-]
|
|
|
1156
|
|
|
1157 @item LFD (newline-and-indent-lisp)
|
|
|
1158 Insert a new line and then indent to the appropriate level. If called
|
|
|
1159 at the end of the inferior LISP buffer and an sexp, the sexp will be
|
|
|
1160 sent to the inferior LISP without a trailing newline.
|
|
|
1161 @pindex newline-and-indent-lisp
|
|
|
1162 @kindex LFD
|
|
|
1163
|
|
|
1164 @item @key{C-z} e (eval-defun-lisp)
|
|
|
1165 @itemx M-C-x (eval-defun-lisp)
|
|
|
1166 @itemx @key{C-z} C-e (eval-defun-and-go-lisp)
|
|
|
1167 @kindex M-C-x
|
|
|
1168 @kindex @key{C-z} e
|
|
|
1169 @kindex @key{C-z} C-e
|
|
|
1170 Send the defun to lisp.
|
|
|
1171 @pindex eval-defun-and-go-lisp
|
|
|
1172 @pindex eval-defun-lisp
|
|
|
1173
|
|
|
1174 @item @key{C-z} r (eval-region-lisp)
|
|
|
1175 @itemx @key{C-z} C-r (eval-region-and-go-lisp)
|
|
|
1176 @kindex @key{C-z} r
|
|
|
1177 @pindex eval-region-lisp
|
|
|
1178 @kindex @key{C-z} C-r
|
|
|
1179 @pindex eval-region-and-go-lisp
|
|
|
1180 @cindex Eval region
|
|
|
1181
|
|
|
1182 @item @key{C-z} n (eval-next-sexp-lisp)
|
|
|
1183 @itemx @key{C-z} C-n (eval-next-sexp-and-go-lisp)
|
|
|
1184 @kindex @key{C-z} n
|
|
|
1185 @pindex eval-next-sexp-lisp
|
|
|
1186 @kindex @key{C-z} C-n
|
|
|
1187 @pindex eval-next-sexp-and-go-lisp
|
|
|
1188
|
|
|
1189 @item @key{C-z} c (compile-defun-lisp)
|
|
|
1190 @kindex @key{C-z} c
|
|
|
1191 @pindex compile-defun-lisp
|
|
|
1192 @item @key{C-z} C-c (compile-defun-lisp-and-go)
|
|
|
1193 @kindex @key{C-z} C-c
|
|
|
1194 When @code{compile-defun-lisp} is called in an inferior LISP buffer with
|
|
|
1195 no current form, the last form typed to the top-level will be compiled.
|
|
|
1196 @cindex Compile last form
|
|
|
1197 @pindex compile-defun-lisp-and-go
|
|
|
1198
|
|
|
1199 @item @key{C-z} w (compile-region-lisp)
|
|
|
1200 @itemx @key{C-z} C-w (compile-region-and-go-lisp)
|
|
|
1201 @kindex @key{C-z} w
|
|
|
1202 @pindex compile-region-lisp
|
|
|
1203 @kindex @key{C-z} C-w
|
|
|
1204 @pindex compile-region-and-go-lisp
|
|
|
1205 @cindex Compile region
|
|
|
1206
|
|
|
1207 @end table
|
|
|
1208
|
|
|
1209
|
|
|
1210 If any of the forms contain an interactive command, then the command
|
|
|
1211 will never return. To get out of this state, you need to use
|
|
|
1212 @code{abort-commands-lisp} (@kbd{@key{C-z} g}). If @code{lisp-wait-p}
|
|
|
1213 is t, then EMACS will display the result of the command in the
|
|
|
1214 minibuffer or a pop-up window. If @code{lisp-wait-p} is @code{nil},
|
|
|
1215 (the default) the send is done asynchronously and the results will be
|
|
|
1216 brought up only if there is more than one line or there is an error. In
|
|
|
1217 this case, you will be given the option of ignoring the error, keeping
|
|
|
1218 it in another buffer or keeping it and aborting all pending sends. If
|
|
|
1219 there is not a command already running in the inferior LISP, you can
|
|
|
1220 preserve the break loop. If called with a negative prefix, the sense of
|
|
|
1221 @code{lisp-wait-p} will be inverted for the next command.
|
|
|
1222 @c @cindex Aborting commands
|
|
|
1223 @vindex lisp-wait-p
|
|
|
1224 @kindex @key{C-z} g
|
|
|
1225 @pindex abort-commands-lisp
|
|
|
1226
|
|
|
1227
|
|
|
1228
|
|
|
1229 @node Documentation functions, Macroexpansion, Eval and compile functions, ILISP Commands
|
|
|
1230 @section Documentation functions
|
|
|
1231
|
|
|
1232 @code{describe-lisp}, @code{inspect-lisp}, @code{arglist-lisp}, and
|
|
|
1233 @code{documentation-lisp} switch whether they prompt for a response or
|
|
|
1234 use a default when called with a negative prefix. If they are
|
|
|
1235 prompting, there is completion through the inferior LISP by using
|
|
|
1236 @kbd{TAB} or @kbd{M-TAB}. When entering an expression in the
|
|
|
1237 minibuffer, all of the normal ilisp commands like @code{arglist-lisp}
|
|
|
1238 also work.@refill
|
|
|
1239 @cindex Arglist lisp
|
|
|
1240 @cindex Describing lisp objects
|
|
|
1241 @kindex @key{M-TAB}
|
|
|
1242 @kindex @key{TAB}
|
|
|
1243 @cindex Negative prefix
|
|
|
1244 @cindex Minibuffer completion
|
|
|
1245 @pindex documentation-lisp
|
|
|
1246 @pindex arglist-lisp
|
|
|
1247 @pindex describe-lisp
|
|
|
1248 @pindex inspect-lisp
|
|
|
1249 @cindex Documentation Functions
|
|
|
1250
|
|
|
1251 Commands that work on a function will use the nearest previous function
|
|
|
1252 symbol. This is either a symbol after a @samp{#'} or the symbol at the
|
|
|
1253 start of the current list.
|
|
|
1254
|
|
|
1255 @table @code
|
|
|
1256
|
|
|
1257 @item @key{C-z} a (arglist-lisp)
|
|
|
1258 @kindex @key{C-z} a
|
|
|
1259 Return the arglist of the current function. With a numeric prefix, the
|
|
|
1260 leading paren will be removed and the arglist will be inserted into the
|
|
|
1261 buffer.
|
|
|
1262
|
|
|
1263 @item @key{C-z} d (documentation-lisp)
|
|
|
1264 @kindex @key{C-z} d
|
|
|
1265 Infers whether function or variable documentation is desired. With a
|
|
|
1266 negative prefix, you can specify the type of documentation as well.
|
|
|
1267 With a positive prefix the documentation of the current function call is
|
|
|
1268 inserted into the buffer.
|
|
|
1269
|
|
|
1270 @item @key{C-z} i (describe-lisp)
|
|
|
1271 @kindex @key{C-z} i
|
|
|
1272 Describe the previous sexp (it is evaluated). If there is no previous
|
|
|
1273 sexp and if called from inside an ILISP buffer, the previous result will
|
|
|
1274 be described.
|
|
|
1275
|
|
|
1276 @item @key{C-z} i (describe-lisp)
|
|
|
1277 @kindex @key{C-z} i
|
|
|
1278 Describe the previous sexp (it is evaluated). If there is no previous
|
|
|
1279 sexp and if called from inside an ILISP buffer, the previous result will
|
|
|
1280 be described.
|
|
|
1281
|
|
|
1282 @item @key{C-z} I (inspect-lisp)
|
|
|
1283 @kindex @key{C-z} I
|
|
|
1284 Switch to the current inferor LISP and inspect the previous sexp (it is
|
|
|
1285 evaluated). If there is no previous sexp and if called from inside an
|
|
|
1286 ILISP buffer, the previous result will be inspected.
|
|
|
1287
|
|
|
1288 @item @key{C-z} D (fi:clman)
|
|
|
1289 @itemx @key{C-z} A (fi:clman-apropos)
|
|
|
1290 @kindex @key{C-z} D
|
|
|
1291 @pindex fi:clman
|
|
|
1292 @kindex @key{C-z} A
|
|
|
1293 @pindex fi:clman-apropos
|
|
|
1294 If the Franz online Common LISP manual is available, get information on
|
|
|
1295 a specific symbol. @code{fi:clman-apropos} will get information apropos
|
|
|
1296 a specific string. Some of the documentation is specific to the allegro
|
|
|
1297 dialect, but most of it is for standard Common LISP.
|
|
|
1298 @cindex Apropos help
|
|
|
1299 @cindex Common Lisp manual
|
|
|
1300 @cindex Franz manual
|
|
|
1301
|
|
|
1302 @end table
|
|
|
1303
|
|
|
1304
|
|
|
1305 @node Macroexpansion, Tracing functions, Documentation functions, ILISP Commands
|
|
|
1306 @section Macroexpansion
|
|
|
1307
|
|
|
1308 @table @kbd
|
|
|
1309 @item @key{C-z} M (macroexpand-lisp)
|
|
|
1310 @itemx @key{C-z} m (macroexpand-1-lisp)
|
|
|
1311 @kindex @key{C-z} M
|
|
|
1312 @pindex macroexpand-lisp
|
|
|
1313 @kindex @key{C-z} m
|
|
|
1314 @pindex macroexpand-1-lisp
|
|
|
1315 These commands apply to the next sexp. If called with a positive
|
|
|
1316 numeric prefix, the result of the macroexpansion will be inserted into
|
|
|
1317 the buffer. With a negative prefix, prompts for expression to expand.
|
|
|
1318 @cindex Expanding macro forms
|
|
|
1319 @cindex Macroexpansion
|
|
|
1320
|
|
|
1321
|
|
|
1322 @end table
|
|
|
1323
|
|
|
1324 @node Tracing functions, Package Commands, Macroexpansion, ILISP Commands
|
|
|
1325 @section Tracing functions
|
|
|
1326
|
|
|
1327 @table @kbd
|
|
|
1328 @item @key{C-z} t (trace-defun-lisp)
|
|
|
1329 @kindex @key{C-z} t
|
|
|
1330 @pindex trace-defun-lisp
|
|
|
1331 @cindex Tracing defuns
|
|
|
1332 @cindex Untracing defuns
|
|
|
1333 traces the current defun. When called with a numeric prefix the
|
|
|
1334 function will be untraced. When called with negative prefix, prompts
|
|
|
1335 for function to be traced.
|
|
|
1336 @end table
|
|
|
1337
|
|
|
1338 @node Package Commands, Source code commands, Tracing functions, ILISP Commands
|
|
|
1339 @section Package Commands
|
|
|
1340 @cindex Package commands
|
|
|
1341
|
|
|
1342 The first time an inferior LISP mode command is executed in a Lisp Mode
|
|
|
1343 buffer, the package will be determined by using the regular expression
|
|
|
1344 @code{ilisp-package-regexp} to find a package sexp and then passing that
|
|
|
1345 sexp to the inferior LISP through @code{ilisp-package-command}.
|
|
|
1346 For the @samp{clisp} dialect, this will find the first @code{(in-package
|
|
|
1347 PACKAGE)} form in the file.
|
|
|
1348 A buffer's package will be displayed in the mode line.
|
|
|
1349 If a buffer has no
|
|
|
1350 specification, forms will be evaluated in the current inferior LISP
|
|
|
1351 package.@refill
|
|
|
1352
|
|
|
1353 Buffer package caching can be turned off by setting the variable
|
|
|
1354 @code{lisp-dont-cache-package} to @code{T}. This will force ILISP to
|
|
|
1355 search for the closest previous @code{ilisp-package-regexp} in the
|
|
|
1356 buffer each time an inferior LISP mode command is executed.
|
|
|
1357 @cindex Buffer package
|
|
|
1358 @cindex Buffer package caching
|
|
|
1359 @vindex lisp-dont-cache-package
|
|
|
1360 @vindex ilisp-package-regexp
|
|
|
1361 @findex ilisp-package-command
|
|
|
1362 @cindex In-package form
|
|
|
1363
|
|
|
1364 @table @code
|
|
|
1365
|
|
|
1366 @item @key{C-z} p (package-lisp)
|
|
|
1367 @kindex @key{C-z} p
|
|
|
1368 @pindex package-lisp
|
|
|
1369 @cindex Show current package
|
|
|
1370 Show the current package of the inferior LISP.
|
|
|
1371
|
|
|
1372 @item @key{C-z} P (set-package-lisp)
|
|
|
1373 @kindex @key{C-z} P
|
|
|
1374 @pindex set-package-lisp
|
|
|
1375 Set the inferior LISP package to the current buffer's package or with a
|
|
|
1376 prefix to a manually entered package.
|
|
|
1377
|
|
|
1378 @item M-x set-buffer-package-lisp
|
|
|
1379 @kindex M-x set-buffer-package-lisp
|
|
|
1380 @cindex Set buffer package
|
|
|
1381 @pindex set-buffer-package-lisp
|
|
|
1382 Set the buffer's package from the buffer. If it is called with a
|
|
|
1383 prefix, the package can be set manually.
|
|
|
1384
|
|
|
1385 @end table
|
|
|
1386
|
|
|
1387 @node Source code commands, Batch commands, Package Commands, ILISP Commands
|
|
|
1388 @section Source Code Commands
|
|
|
1389 @cindex Source Code Commands
|
|
|
1390 @cindex Finding source
|
|
|
1391
|
|
|
1392 The following commands all deal with finding things in source code.
|
|
|
1393 The first time that one of these commands is used, there may be some
|
|
|
1394 delay while the source module is loaded. When searching files, the
|
|
|
1395 first applicable rule is used:
|
|
|
1396 @itemize @bullet
|
|
|
1397 @item
|
|
|
1398 try the inferior LISP,
|
|
|
1399 @item
|
|
|
1400 try a tags file if defined,
|
|
|
1401 @item
|
|
|
1402 try all buffers in one of @code{lisp-source-modes} or all files
|
|
|
1403 defined using @code{lisp-directory}.@refill
|
|
|
1404 @pindex lisp-directory
|
|
|
1405 @vindex lisp-source-modes
|
|
|
1406 @end itemize
|
|
|
1407
|
|
|
1408 @code{M-x lisp-directory} defines a set of files to be
|
|
|
1409 searched by the source code commands. It prompts for a directory and
|
|
|
1410 sets the source files to be those in the directory that match entries
|
|
|
1411 in @code{auto-mode-alist} for modes in @code{lisp-source-modes}.
|
|
|
1412 With a positive
|
|
|
1413 prefix, the files are appended. With a negative prefix, all current
|
|
|
1414 buffers that are in one of @code{lisp-source-modes} will be searched. This
|
|
|
1415 is also what happens by default. Using this command stops using a
|
|
|
1416 tags file.@refill
|
|
|
1417 @cindex Source modes
|
|
|
1418 @vindex auto-mode-alist
|
|
|
1419 @kindex M-x lisp-directory
|
|
|
1420
|
|
|
1421 @code{edit-definitions-lisp}, @code{who-calls-lisp}, and
|
|
|
1422 @code{edit-callers-lisp} will switch whether they prompt for a response
|
|
|
1423 or use a default when called with a negative prefix. If they are
|
|
|
1424 prompting, there is completion through the inferior LISP by using
|
|
|
1425 @kbd{TAB} or @kbd{M-TAB}. When entering an expression in the
|
|
|
1426 minibuffer, all of the normal ILISP commands like @kbd{arglist-lisp}
|
|
|
1427 also work.@refill
|
|
|
1428 @pindex edit-callers-lisp
|
|
|
1429 @pindex who-calls-lisp
|
|
|
1430 @pindex edit-definitions-lisp
|
|
|
1431
|
|
|
1432 @code{edit-definitions-lisp} (@kbd{M-.}) will find a
|
|
|
1433 particular type of definition for a symbol. It tries to use the rules
|
|
|
1434 described above. The files to be searched are listed in the buffer
|
|
|
1435 @code{*Edit-Definitions*}. If @code{lisp-edit-files} is nil, no search will be
|
|
|
1436 done if not found through the inferior LISP. The variable
|
|
|
1437 @code{ilisp-locator} contains a function that when given the name and type
|
|
|
1438 should be able to find the appropriate definition in the file. There
|
|
|
1439 is often a flag to cause your LISP to record source files that you
|
|
|
1440 will need to set in the initialization file for your LISP. The
|
|
|
1441 variable is @code{*record-source-files*} in both allegro and lucid. Once a
|
|
|
1442 definition has been found, @code{next-definition-lisp}
|
|
|
1443 (@kbd{M-,}) will find the next definition
|
|
|
1444 (or the previous definition with a prefix).@refill
|
|
|
1445 @pindex next-definition-lisp
|
|
|
1446 @vindex *record-source-files*
|
|
|
1447 @vindex ilisp-locator
|
|
|
1448 @vindex lisp-edit-files
|
|
|
1449 @cindex @code{*Edit-Definitions*} buffer
|
|
|
1450 @kindex M-.
|
|
|
1451
|
|
|
1452 @code{edit-callers-lisp} (@kbd{@key{C-z} ^}) will generate a list of all
|
|
|
1453 of the callers of a function in the current inferior LISP and edit the
|
|
|
1454 first caller using @code{edit-definitions-lisp}. Each successive call to
|
|
|
1455 @code{next-caller-lisp} (@kbd{M-`}) will edit the next caller
|
|
|
1456 (or the previous caller with a prefix). The list is stored in the
|
|
|
1457 buffer @code{*All-Callers*}. You can also look at the callers by doing
|
|
|
1458 @kbd{M-x who-calls-lisp}.@refill
|
|
|
1459 @cindex List callers
|
|
|
1460 @cindex Find callers
|
|
|
1461 @cindex @code{*All-Callers*} buffer
|
|
|
1462 @kindex M-x who-calls-lisp
|
|
|
1463 @kindex M-`
|
|
|
1464 @pindex next-caller-lisp
|
|
|
1465 @kindex @key{C-z} ^
|
|
|
1466 @pindex edit-callers-lisp
|
|
|
1467
|
|
|
1468 @code{search-lisp} (@kbd{M-?}) will search the current tags files,
|
|
|
1469 @code{lisp-directory} files or buffers in one of @code{lisp-source-modes} for a
|
|
|
1470 string or a regular expression when called with a prefix.
|
|
|
1471 @code{next-definition-lisp} (@kbd{M-,}) will find the next definition
|
|
|
1472 (or the previous definition with a prefix).@refill
|
|
|
1473 @cindex Next definition
|
|
|
1474 @cindex Previous definition
|
|
|
1475 @kindex M-,
|
|
|
1476 @pindex next-definition-lisp
|
|
|
1477 @kindex M-?
|
|
|
1478 @pindex search-lisp
|
|
|
1479
|
|
|
1480 @code{replace-lisp} (@kbd{M-"}) will replace a string (or a regexp with
|
|
|
1481 a prefix) in the current tags files, @code{lisp-directory} files or
|
|
|
1482 buffers in one of @code{lisp-source-modes}.@refill
|
|
|
1483 @cindex Replace lisp
|
|
|
1484 @kindex M-"
|
|
|
1485 @pindex replace-lisp
|
|
|
1486
|
|
|
1487
|
|
|
1488 Here is a summary of the above commands (behavior when given prefix
|
|
|
1489 argument is given in parentheses):
|
|
|
1490
|
|
|
1491 @table @code
|
|
|
1492 @item M-x lisp-directory
|
|
|
1493 Define a set of files to be used by the source code commands.
|
|
|
1494
|
|
|
1495 @item M-. (edit-definitions-lisp)
|
|
|
1496 Find definition of a symbol.
|
|
|
1497
|
|
|
1498 @item M-, (next-definition-lisp)
|
|
|
1499 Find next (previous) definition.
|
|
|
1500
|
|
|
1501 @item @key{C-z} ^ (edit-callers-lisp)
|
|
|
1502 Find all callers of a function, and edit the first.
|
|
|
1503
|
|
|
1504 @item M-` (next-caller-lisp)
|
|
|
1505 Edit next (previous) caller of function set by @code{edit-callers-lisp}.
|
|
|
1506
|
|
|
1507 @item M-x who-calls-lisp
|
|
|
1508 List all the callers of a function.
|
|
|
1509
|
|
|
1510
|
|
|
1511 @item M-? (search-lisp)
|
|
|
1512 Search for string (regular expression) in current tags,
|
|
|
1513 @code{lisp-directory} files or buffers. Use @code{next-definition-lisp}
|
|
|
1514 to find next occurence.
|
|
|
1515
|
|
|
1516 @item M-" (replace-lisp)
|
|
|
1517 Replace a string (regular expression) in files.
|
|
|
1518
|
|
|
1519 @end table
|
|
|
1520
|
|
|
1521
|
|
|
1522 @node Batch commands, Files and directories, Source code commands, ILISP Commands
|
|
|
1523 @section Batch commands
|
|
|
1524
|
|
|
1525
|
|
|
1526 The following commands all deal with making a number of changes all at
|
|
|
1527 once. The first time one of these commands is used, there may be some
|
|
|
1528 delay as the module is loaded. The eval/compile versions of these
|
|
|
1529 commands are always executed asynchronously.
|
|
|
1530 @cindex Group changes
|
|
|
1531 @cindex File changes
|
|
|
1532 @cindex Change commands
|
|
|
1533
|
|
|
1534 @code{mark-change-lisp} (@kbd{@key{C-z} SPC}) marks the current defun as
|
|
|
1535 being changed. A prefix causes it to be unmarked. @code{clear-changes-lisp}
|
|
|
1536 (@kbd{@key{C-z} * 0}) will clear all of the changes.
|
|
|
1537 @code{list-changes-lisp} (@kbd{@key{C-z} * l}) will show the forms
|
|
|
1538 currently marked.@refill
|
|
|
1539 @cindex Marking changes
|
|
|
1540 @cindex Clearing changes
|
|
|
1541 @cindex Listing changes
|
|
|
1542 @kindex @key{C-z} * l
|
|
|
1543 @kindex @key{C-z} * 0
|
|
|
1544 @kindex @key{C-z} SPC
|
|
|
1545 @pindex list-changes-lisp
|
|
|
1546 @pindex clear-changes-lisp
|
|
|
1547 @pindex mark-change-lisp
|
|
|
1548
|
|
|
1549 @code{eval-changes-lisp} (@kbd{@key{C-z} * e}), or
|
|
|
1550 @code{compile-changes-lisp} (@kbd{@key{C-z} * c}) will
|
|
|
1551 evaluate or compile these changes as appropriate.
|
|
|
1552 If called with a positive prefix, the changes will be kept.
|
|
|
1553 If there is an error, the process will stop and show the error
|
|
|
1554 and all remaining changes will remain in the list. All of the results
|
|
|
1555 will be kept in the buffer @code{*Last-Changes*}.@refill
|
|
|
1556 @cindex Eval'ing changes
|
|
|
1557 @cindex Compiling changes
|
|
|
1558 @cindex @code{*Last-Changes*} buffer
|
|
|
1559 @kindex @key{C-z} * e
|
|
|
1560 @kindex @key{C-z} * c
|
|
|
1561 @pindex compile-changes-lisp
|
|
|
1562 @pindex eval-changes-lisp
|
|
|
1563
|
|
|
1564 @noindent
|
|
|
1565 Summary:
|
|
|
1566
|
|
|
1567 @table @code
|
|
|
1568 @item @key{C-z} SPC (mark-change-lisp)
|
|
|
1569 Mark (unmark) current defun as changed.
|
|
|
1570 @item @key{C-z} * e (eval-changes-lisp)
|
|
|
1571 @itemx @key{C-z} * c (compile-changes-lisp)
|
|
|
1572 Call with a positive prefix to keep changes.
|
|
|
1573 @item @key{C-z} * 0 (clear-changes-lisp)
|
|
|
1574 @item @key{C-z} * l (list-changes-lisp)
|
|
|
1575 @end table
|
|
|
1576
|
|
|
1577
|
|
|
1578 @node Files and directories, Keyboard modes, Batch commands, ILISP Commands
|
|
|
1579 @section Files and directories
|
|
|
1580
|
|
|
1581 @cindex Files and directories
|
|
|
1582 @cindex Directories and files
|
|
|
1583 @cindex Current directory
|
|
|
1584 File commands in lisp-source-mode buffers keep track of the last used
|
|
|
1585 directory and file. If the point is on a string, that will be the
|
|
|
1586 default if the file exists. If the buffer is one of
|
|
|
1587 @code{lisp-source-modes}, the buffer file will be the default. Otherwise,
|
|
|
1588 the last file used in a lisp-source-mode will be used.
|
|
|
1589
|
|
|
1590
|
|
|
1591 @table @kbd
|
|
|
1592 @item C-x C-f (find-file-lisp)
|
|
|
1593 @kindex C-x C-f
|
|
|
1594 @cindex Find file
|
|
|
1595 @cindex Lisp find file
|
|
|
1596 @cindex Symbolic link expansion
|
|
|
1597 @pindex find-file-lisp
|
|
|
1598 will find a file. If it is in a string, that will be used as the
|
|
|
1599 default if it matches an existing file. Symbolic links are expanded so
|
|
|
1600 that different references to the same file will end up with the same
|
|
|
1601 buffer.
|
|
|
1602
|
|
|
1603 @item @key{C-z} l (load-file-lisp)
|
|
|
1604 @kindex @key{C-z} l
|
|
|
1605 will load a file into the inferior LISP. You will be given the
|
|
|
1606 opportunity to save the buffer if it has changed and to compile the file
|
|
|
1607 if the compiled version is older than the current version.
|
|
|
1608 @pindex load-file-lisp
|
|
|
1609 @cindex Loading files
|
|
|
1610
|
|
|
1611 @item @key{C-z} k (compile-file-lisp)
|
|
|
1612 @kindex @key{C-z} k
|
|
|
1613 will compile a file in the current inferior LISP.
|
|
|
1614 @pindex compile-file-lisp
|
|
|
1615 @cindex Compiling files
|
|
|
1616
|
|
|
1617 @item @key{C-z} ! (default-directory-lisp)
|
|
|
1618 @kindex @key{C-z} !
|
|
|
1619 sets the default inferior LISP directory to the directory of the current
|
|
|
1620 buffer. If called in an inferior LISP buffer, it sets the Emacs
|
|
|
1621 @code{default-directory} to the LISP default directory.
|
|
|
1622 @vindex default-directory
|
|
|
1623 @cindex Default directory
|
|
|
1624 @cindex Set default directory
|
|
|
1625 @pindex default-directory-lisp
|
|
|
1626
|
|
|
1627 @end table
|
|
|
1628
|
|
|
1629 @node Keyboard modes, Interrupts, Files and directories, ILISP Commands
|
|
|
1630 @section Switching between interactive and raw keyboard modes
|
|
|
1631
|
|
|
1632 @cindex Raw keyboard mode
|
|
|
1633 @cindex Interactive keyboard mode
|
|
|
1634 @vindex ilisp-raw-echo
|
|
|
1635
|
|
|
1636 There are two keyboard modes for interacting with the inferior LISP,
|
|
|
1637 \"interactive\" and \"raw\". Normally you are in interactive mode
|
|
|
1638 where keys are interpreted as commands to EMACS and nothing is sent to
|
|
|
1639 the inferior LISP unless a specific command does so. In raw mode, all
|
|
|
1640 characters are passed directly to the inferior LISP without any
|
|
|
1641 interpretation as EMACS commands. Keys will not be echoed unless
|
|
|
1642 ilisp-raw-echo is T.
|
|
|
1643
|
|
|
1644 @pindex raw-keys-ilisp
|
|
|
1645 @kindex @key{C-z} #
|
|
|
1646 @pindex io-bridge-ilisp
|
|
|
1647 @kindex M-x io-bridge-ilisp
|
|
|
1648
|
|
|
1649 Raw mode can be turned on interactively by the command
|
|
|
1650 @code{raw-keys-ilisp} (@kbd{@key{C-z} #}) and will continue until you
|
|
|
1651 type @key{C-g}. Raw mode can also be turned on/off by inferior LISP
|
|
|
1652 functions if the command @code{io-bridge-ilisp} (M-x io-bridge-ilisp)
|
|
|
1653 has been executed in the inferior LISP either interactively or on a
|
|
|
1654 hook. To turn on raw mode, a function should print ^[1^] and to turn
|
|
|
1655 it off should print ^[0^]. An example in Common LISP would be:
|
|
|
1656
|
|
|
1657 @code{(progn (format t "1 ") (print (read-char)) (format t "0 "))}
|
|
|
1658
|
|
|
1659 @node Interrupts, Command history, Keyboard modes, ILISP Commands
|
|
|
1660 @section Interrupts, aborts, and errors
|
|
|
1661
|
|
|
1662
|
|
|
1663 If you want to abort the last command you can use @kbd{C-g}.
|
|
|
1664 @kindex C-g
|
|
|
1665 @cindex Errors
|
|
|
1666 @cindex Aborting commands
|
|
|
1667 @cindex Interrupting commands
|
|
|
1668
|
|
|
1669 If you want to abort all commands, you should use the command
|
|
|
1670 @code{abort-commands-lisp} (@kbd{@key{C-z} g}). Commands that are
|
|
|
1671 aborted will be put in the buffer @code{*Aborted Commands*} so that
|
|
|
1672 you can see what was aborted. If you want to abort the currently
|
|
|
1673 running top-level command, use @code{interrupt-subjob-ilisp} (@kbd{C-c
|
|
|
1674 C-c}). As a last resort, @kbd{M-x panic-lisp} will reset the ILISP
|
|
|
1675 state without affecting the inferior LISP so that you can see what is
|
|
|
1676 happening.
|
|
|
1677
|
|
|
1678 @pindex interrupt-subjob-ilisp
|
|
|
1679 @cindex @code{*Aborted Commands*} buffer
|
|
|
1680 @kindex @key{C-z} g
|
|
|
1681 @pindex abort-commands-lisp
|
|
|
1682 @pindex panic-lisp
|
|
|
1683
|
|
|
1684 @code{delete-char-or-pop-ilisp} (@kbd{C-d}) will delete
|
|
|
1685 prefix characters unless you are at the end of an ILISP buffer in
|
|
|
1686 which case it will pop one level in the break loop.
|
|
|
1687 @cindex Pop in break loop
|
|
|
1688 @cindex Break loop
|
|
|
1689 @kindex C-d
|
|
|
1690 @pindex delete-char-or-pop-ilisp
|
|
|
1691
|
|
|
1692 @code{reset-ilisp}, (@kbd{@key{C-z} z}) will reset the current inferior
|
|
|
1693 LISP's top-level so that it will no longer be in a break loop.
|
|
|
1694 @cindex Resetting lisp
|
|
|
1695 @cindex Top-level, return to
|
|
|
1696 @kindex @key{C-z} z
|
|
|
1697 @pindex reset-ilisp
|
|
|
1698
|
|
|
1699
|
|
|
1700 Summary:
|
|
|
1701
|
|
|
1702 @table @kbd
|
|
|
1703 @item C-c C-c (interrupt-subjob-ilisp)
|
|
|
1704 Send a keyboard interrupt signal to lisp.
|
|
|
1705 @item @key{C-z} g (abort-commands-lisp)
|
|
|
1706 Abort all running or unsent commands.
|
|
|
1707 @item M-x panic-lisp (panic-lisp)
|
|
|
1708 Reset the ILISP process state.
|
|
|
1709 @item @key{C-z} z (reset-ilisp)
|
|
|
1710 Reset lisp to top-level.
|
|
|
1711 @item C-d (delete-char-or-pop-ilisp)
|
|
|
1712 If at end of buffer, pop a level in break loop.
|
|
|
1713
|
|
|
1714 @end table
|
|
|
1715
|
|
|
1716 @c duplicated from eval section.
|
|
|
1717 If @code{lisp-wait-p} is @code{nil} (the default),
|
|
|
1718 all sends are done asynchronously and the results will be
|
|
|
1719 brought up only if there is more than one line or there is an error.
|
|
|
1720 In case, you will be given the option of ignoring the error, keeping
|
|
|
1721 it in another buffer or keeping it and aborting all pending sends.
|
|
|
1722 If there is not a command already running in the inferior LISP, you can
|
|
|
1723 preserve the break loop. If called with a negative prefix, the sense of
|
|
|
1724 @code{lisp-wait-p} will be inverted for the next command.
|
|
|
1725 @vindex lisp-wait-p
|
|
|
1726
|
|
|
1727
|
|
|
1728
|
|
|
1729 @node Command history, Completion, Interrupts, ILISP Commands
|
|
|
1730 @section Command history
|
|
|
1731 @cindex Command history
|
|
|
1732 @cindex Last command
|
|
|
1733 @cindex Previous commands
|
|
|
1734
|
|
|
1735 ILISP mode is built on top of @code{comint-mode}, the general
|
|
|
1736 command-interpreter-in-a-buffer mode. As such, it inherits many
|
|
|
1737 commands and features from this, including a command history mechanism.
|
|
|
1738 @cindex @code{comint-mode}
|
|
|
1739
|
|
|
1740 Each ILISP buffer has a command history associated with it. Commands
|
|
|
1741 that do not match @code{ilisp-filter-regexp} and that are longer than
|
|
|
1742 @code{ilisp-filter-length} and that do not match the immediately prior
|
|
|
1743 command will be added to this history.
|
|
|
1744 @vindex ilisp-filter-length
|
|
|
1745 @vindex ilisp-filter-regexp
|
|
|
1746
|
|
|
1747 @table @kbd
|
|
|
1748
|
|
|
1749 @item M-n (comint-next-input)
|
|
|
1750 @itemx M-p (comint-previous-input)
|
|
|
1751 @kindex M-n
|
|
|
1752 @pindex comint-next-input
|
|
|
1753 @cindex Next input
|
|
|
1754 @kindex M-p
|
|
|
1755 @pindex comint-previous-input
|
|
|
1756 Cycle through the input history.
|
|
|
1757
|
|
|
1758 @item M-s (comint-previous-similar-input)
|
|
|
1759 @kindex M-s
|
|
|
1760 @pindex comint-previous-similar-input
|
|
|
1761 @cindex Similar input
|
|
|
1762 Cycle through input that has the string typed so far as a prefix.
|
|
|
1763
|
|
|
1764 @item M-N (comint-psearch-input)
|
|
|
1765 @kindex M-N
|
|
|
1766 @pindex comint-psearch-input
|
|
|
1767 @cindex Search input
|
|
|
1768 @cindex Input search
|
|
|
1769 Search forwards for prompt.
|
|
|
1770 @item M-P (comint-msearch-input)
|
|
|
1771 @kindex M-P
|
|
|
1772 @pindex comint-msearch-input
|
|
|
1773 Search backwards for prompt.
|
|
|
1774
|
|
|
1775 @item C-c R (comint-msearch-input-matching)
|
|
|
1776 @kindex C-c R
|
|
|
1777 @pindex comint-msearch-input-matching
|
|
|
1778 Search backwards for occurrence of prompt followed by string which is prompted
|
|
|
1779 for (@emph{not} a regular expression).
|
|
|
1780 @end table
|
|
|
1781
|
|
|
1782 See @code{comint-mode} documentation for more information on
|
|
|
1783 @samp{comint} commands.
|
|
|
1784
|
|
|
1785
|
|
|
1786 @node Completion, Miscellany, Command history, ILISP Commands
|
|
|
1787 @section Completion
|
|
|
1788
|
|
|
1789 Commands to reduce number of keystrokes.
|
|
|
1790 @cindex Completion
|
|
|
1791 @cindex Partial completion
|
|
|
1792 @cindex Filename completion
|
|
|
1793
|
|
|
1794 @table @kbd
|
|
|
1795 @item M-TAB (complete-lisp)
|
|
|
1796 @kindex M-TAB
|
|
|
1797 @pindex complete-lisp
|
|
|
1798 @vindex ilisp-prefix-match
|
|
|
1799 will try to complete the previous symbol in the current inferior LISP.
|
|
|
1800 Partial completion is supported unless @code{ilisp-prefix-match} is set to @code{t}.
|
|
|
1801 (If you set it to @code{t}, inferior LISP completions will be faster.)
|
|
|
1802 With partial completion, @samp{p--n} would complete to
|
|
|
1803 @samp{position-if-not} in Common LISP.
|
|
|
1804 If the symbol follows a left paren or a @samp{#'}, only symbols with
|
|
|
1805 function cells will be considered.
|
|
|
1806 If the symbol starts with a @samp{*} or you call with a
|
|
|
1807 positive prefix all possible completions will be considered.
|
|
|
1808 Only external symbols are considered if there is a package qualification
|
|
|
1809 with only one colon.
|
|
|
1810 The first time you try to complete a string the longest common substring
|
|
|
1811 will be inserted and the cursor will be left
|
|
|
1812 on the point of ambiguity.
|
|
|
1813 If you try to complete again, you can see the possible completions.
|
|
|
1814 If you are in a string, then filename completion will be done instead.
|
|
|
1815 And if you try to complete a filename twice, you will see a list of
|
|
|
1816 possible completions.
|
|
|
1817 Filename components are completed individually, so @samp{/u/mi/} could
|
|
|
1818 expand to @samp{/usr/misc/}.
|
|
|
1819 If you complete with a negative
|
|
|
1820 prefix, the most recent completion (symbol or filename) will be undone.@refill
|
|
|
1821
|
|
|
1822
|
|
|
1823 @item M-RET (complete)
|
|
|
1824 @kindex M-RET
|
|
|
1825 @pindex complete
|
|
|
1826 @cindex TMC completion
|
|
|
1827 will complete the current symbol to the most recently seen symbol in
|
|
|
1828 Emacs that matches what you have typed so far. Executing it repeatedly
|
|
|
1829 will cycle through potential matches. This is from the TMC completion
|
|
|
1830 package and there may be some delay as it is initially loaded.
|
|
|
1831
|
|
|
1832 @end table
|
|
|
1833
|
|
|
1834 @node Miscellany, , Completion, ILISP Commands
|
|
|
1835 @section Miscellany
|
|
|
1836
|
|
|
1837 Indentation, parenthesis balancing, and comment commands.
|
|
|
1838
|
|
|
1839 @table @kbd
|
|
|
1840
|
|
|
1841 @item @kbd{TAB} (indent-line-ilisp)
|
|
|
1842 @kindex @kbd{TAB}
|
|
|
1843 indents for LISP. With prefix, shifts rest of expression rigidly with
|
|
|
1844 the current line.
|
|
|
1845 @pindex indent-line-ilisp
|
|
|
1846 @cindex Indentation
|
|
|
1847 @cindex Rigid indentation
|
|
|
1848
|
|
|
1849
|
|
|
1850 @item M-C-q (indent-sexp-ilisp)
|
|
|
1851 @kindex M-C-q
|
|
|
1852 will indent each line in the next sexp.
|
|
|
1853 @pindex indent-sexp-ilisp
|
|
|
1854
|
|
|
1855 @item M-q (reindent-lisp)
|
|
|
1856 @kindex M-q
|
|
|
1857 will reindent the current paragraph if in a comment or string.
|
|
|
1858 Otherwise it will close the containing defun and reindent it.
|
|
|
1859 @pindex reindent-lisp
|
|
|
1860 @cindex Reindent lisp
|
|
|
1861
|
|
|
1862 @item @key{C-z} ; (comment-region-lisp)
|
|
|
1863 @kindex @key{C-z} ;
|
|
|
1864 will put prefix copies of @code{comment-start} before and
|
|
|
1865 @code{comment-end}'s after the lines in region. To uncomment a region,
|
|
|
1866 use a minus prefix.@refill
|
|
|
1867 @pindex comment-region-lisp
|
|
|
1868 @cindex Comment region
|
|
|
1869 @cindex Uncomment region
|
|
|
1870
|
|
|
1871 @item @key{C-z} ) (find-unbalanced-lisp)
|
|
|
1872 @kindex @key{C-z} )
|
|
|
1873 will find unbalanced parens in the current buffer. When called with a
|
|
|
1874 prefix it will look in the current region.
|
|
|
1875 @pindex find-unbalanced-lisp
|
|
|
1876 @cindex Find unbalanced parens
|
|
|
1877 @cindex Parenthesis balancing
|
|
|
1878
|
|
|
1879 @item ] (close-all-lisp)
|
|
|
1880 @kindex ]
|
|
|
1881 will close all outstanding parens back to the containing form, or a
|
|
|
1882 previous left bracket which will be converted to a left parens. If
|
|
|
1883 there are too many parens, they will be deleted unless there is text
|
|
|
1884 between the last paren and the end of the defun. If called with a
|
|
|
1885 prefix, all open left brackets will be closed.
|
|
|
1886 @pindex close-all-lisp
|
|
|
1887 @cindex Close all parens
|
|
|
1888 @cindex Close brackets
|
|
|
1889
|
|
|
1890 @end table
|
|
|
1891
|
|
|
1892
|
|
|
1893 @node Customization, Dialects, ILISP Commands, Top
|
|
|
1894 @chapter ILISP Customization
|
|
|
1895
|
|
|
1896 @c = = = = = = = = = = = = = = = = = = = = = = = =
|
|
|
1897 @c this refers to hierarchiy, which isn't shown here.
|
|
|
1898 @cindex Customization
|
|
|
1899 @cindex Hooks
|
|
|
1900 @cindex Dialect startup
|
|
|
1901
|
|
|
1902
|
|
|
1903 Starting a dialect runs the hooks on @code{comint-mode-hook}
|
|
|
1904 and @code{ilisp-mode-hook} and then @var{DIALECT}@code{-hooks} specific
|
|
|
1905 to dialects in the nesting order below.
|
|
|
1906 @vindex ilisp-mode-hook
|
|
|
1907 @vindex comint-mode-hook
|
|
|
1908 @example
|
|
|
1909 clisp
|
|
|
1910 allegro
|
|
|
1911 lucid
|
|
|
1912 kcl
|
|
|
1913 akcl
|
|
|
1914 ibcl
|
|
|
1915 cmulisp
|
|
|
1916 scheme
|
|
|
1917 oaklisp
|
|
|
1918 @end example
|
|
|
1919
|
|
|
1920 On the very first prompt in the inferior LISP,
|
|
|
1921 the hooks on @code{ilisp-init-hook} are run. For more information on
|
|
|
1922 creating a new dialect or variables to set in hooks, see @file{ilisp.el}.
|
|
|
1923 @cindex First prompt
|
|
|
1924 @vindex ilisp-init-hook
|
|
|
1925
|
|
|
1926
|
|
|
1927
|
|
|
1928 @c -> -> -> -> -> -> -> -> -> -> -> plenty of indexing here
|
|
|
1929 @c put these in a table for later expandment
|
|
|
1930 @c
|
|
|
1931
|
|
|
1932 ILISP Mode Hooks:
|
|
|
1933 @cindex ILISP Mode Hooks
|
|
|
1934 @table @code
|
|
|
1935 @item ilisp-site-hook
|
|
|
1936 @vindex ilisp-site-hook
|
|
|
1937 Executed when file is loaded
|
|
|
1938 @item ilisp-load-hook
|
|
|
1939 @vindex ilisp-load-hook
|
|
|
1940 Executed when file is loaded
|
|
|
1941 @item ilisp-mode-hook
|
|
|
1942 @vindex ilisp-mode-hook
|
|
|
1943 Executed when an ilisp buffer is created
|
|
|
1944 @item ilisp-init-hook
|
|
|
1945 @vindex ilisp-init-hook
|
|
|
1946 Executed after inferior LISP is initialized and the first prompt is
|
|
|
1947 seen.
|
|
|
1948 @item @var{DIALECT}-hook
|
|
|
1949 @vindex @var{DIALECT}-hook
|
|
|
1950 Executed when dialect is set
|
|
|
1951 @end table
|
|
|
1952
|
|
|
1953 Variables you might want to set in a hook or dialect:
|
|
|
1954 @table @code
|
|
|
1955 @item ilisp-prefix
|
|
|
1956 @vindex ilisp-prefix
|
|
|
1957 Keys to prefix ilisp key bindings
|
|
|
1958 @item ilisp-program
|
|
|
1959 @vindex ilisp-program
|
|
|
1960 Program to start for inferior LISP
|
|
|
1961 @item ilisp-motd
|
|
|
1962 @vindex ilisp-motd
|
|
|
1963 String printed on startup with version
|
|
|
1964 @item lisp-wait-p
|
|
|
1965 @vindex lisp-wait-p
|
|
|
1966 Set to T for synchronous sends
|
|
|
1967 @item ilisp-handle-errors
|
|
|
1968 @vindex ilisp-handle-errors
|
|
|
1969 Set to T for ilisp to handle errors from the underlying lisp.
|
|
|
1970 @item ilisp-display-output-function
|
|
|
1971 @vindex ilisp-display-output-function
|
|
|
1972 The name of a function which displays ILISP output.
|
|
|
1973 @item lisp-no-popper
|
|
|
1974 @vindex lisp-no-popper
|
|
|
1975 Set to T to have all output in inferior LISP
|
|
|
1976 @item lisp-show-status
|
|
|
1977 @vindex lisp-show-status
|
|
|
1978 Set to nil to stop showing process status
|
|
|
1979 @item ilisp-prefix-match
|
|
|
1980 @vindex ilisp-prefix-match
|
|
|
1981 Set to T if you do not want partial completion
|
|
|
1982 @item ilisp-filter-regexp
|
|
|
1983 @vindex ilisp-filter-regexp
|
|
|
1984 Input history filter
|
|
|
1985 @item ilisp-filter-length
|
|
|
1986 @vindex ilisp-filter-length
|
|
|
1987 Input history minimum length
|
|
|
1988 @item ilisp-other-prompt
|
|
|
1989 @vindex ilisp-other-prompt
|
|
|
1990 Prompt for non- top-level read-eval print loops
|
|
|
1991 @end table
|
|
|
1992
|
|
|
1993 @node Dialects, Concept index, Customization, Top
|
|
|
1994 @chapter Dialects
|
|
|
1995 @cindex Dialects
|
|
|
1996
|
|
|
1997 A @dfn{dialect} of lisp is a specific implementation. For the parts of
|
|
|
1998 Common Lisp which are well specified, they are usually the same. For
|
|
|
1999 the parts that are not (debugger, top-level loop, etc.), there is
|
|
|
2000 usually the same functionality but different commands.
|
|
|
2001
|
|
|
2002 ILISP provides the means to specify these differences so that the ILISP
|
|
|
2003 commands will use the specific command peculiar to an implementation,
|
|
|
2004 but still offer the same behavior with the same interface.
|
|
|
2005
|
|
|
2006
|
|
|
2007 @menu
|
|
|
2008 * Defining new dialects::
|
|
|
2009 * Writing new commands::
|
|
|
2010 @end menu
|
|
|
2011
|
|
|
2012 @node Defining new dialects, Writing new commands, , Dialects
|
|
|
2013 @section Defining new dialects
|
|
|
2014
|
|
|
2015
|
|
|
2016 To define a new dialect use the macro @code{defdialect}. For examples,
|
|
|
2017 look at the dialect definitions in @file{ilisp-acl.el},
|
|
|
2018 @file{ilisp-cmu.el}, @file{ilisp-kcl.el}, @file{ilisp-luc}. There are
|
|
|
2019 hooks and variables for almost anything that you are likely to need to
|
|
|
2020 change. The relationship between dialects is hierarchical with the root
|
|
|
2021 values being defined in @code{setup-ilisp}. For a new dialect, you only
|
|
|
2022 need to change the variables that are different than in the parent
|
|
|
2023 dialect.
|
|
|
2024 @cindex Defining new dialects
|
|
|
2025 @pindex setup-ilisp
|
|
|
2026 @pindex defdialect
|
|
|
2027
|
|
|
2028
|
|
|
2029 @node Writing new commands, , Defining new dialects, Dialects
|
|
|
2030 @section Writing new commands
|
|
|
2031 @cindex Internal ILISP functions
|
|
|
2032
|
|
|
2033 Basic tools for creating new commands:
|
|
|
2034 @table @code
|
|
|
2035 @item deflocal
|
|
|
2036 @findex deflocal
|
|
|
2037 Define a new buffer local variable.
|
|
|
2038 @item ilisp-dialect
|
|
|
2039 @findex ilisp-dialect
|
|
|
2040 List of dialect types. For specific dialect clauses.
|
|
|
2041 @item lisp-symbol
|
|
|
2042 @findex lisp-symbol
|
|
|
2043 Create a symbol.
|
|
|
2044 @item lisp-symbol-name
|
|
|
2045 @findex lisp-symbol-name
|
|
|
2046 Return a symbol's name
|
|
|
2047 @item lisp-symbol-delimiter
|
|
|
2048 @findex lisp-symbol-delimiter
|
|
|
2049 Return a symbol's qualification
|
|
|
2050 @item lisp-symbol-package
|
|
|
2051 @findex lisp-symbol-package
|
|
|
2052 Return a symbol's package
|
|
|
2053 @item lisp-string-to-symbol
|
|
|
2054 @findex lisp-string-to-symbol
|
|
|
2055 Convert string to symbol
|
|
|
2056 @item lisp-symbol-to-string
|
|
|
2057 @findex lisp-symbol-to-string
|
|
|
2058 Convert symbol to string
|
|
|
2059 @item lisp-buffer-symbol
|
|
|
2060 @findex lisp-buffer-symbol
|
|
|
2061 Convert symbol to string qualified for buffer
|
|
|
2062 @item lisp-previous-symbol
|
|
|
2063 @findex lisp-previous-symbol
|
|
|
2064 Return previous symbol
|
|
|
2065 @item lisp-previous-sexp
|
|
|
2066 @findex lisp-previous-sexp
|
|
|
2067 Return previous sexp
|
|
|
2068 @item lisp-def-name
|
|
|
2069 @findex lisp-def-name
|
|
|
2070 Return name of current definition
|
|
|
2071 @item lisp-function-name
|
|
|
2072 @findex lisp-function-name
|
|
|
2073 Return previous function symbol
|
|
|
2074 @item ilisp-read
|
|
|
2075 @findex ilisp-read
|
|
|
2076 Read an sexp with completion, arglist, etc
|
|
|
2077 @item ilisp-read-symbol
|
|
|
2078 @findex ilisp-read-symbol
|
|
|
2079 Read a symbol or list with completion
|
|
|
2080 @item ilisp-completing-read
|
|
|
2081 @findex ilisp-completing-read
|
|
|
2082 Read from choices or list with completion
|
|
|
2083 @end table
|
|
|
2084
|
|
|
2085 @noindent
|
|
|
2086 Notes:
|
|
|
2087 @itemize @bullet
|
|
|
2088 @item
|
|
|
2089 Special commands like arglist should use @code{ilisp-send} to send a
|
|
|
2090 message to the inferior LISP.
|
|
|
2091 @findex ilisp-send
|
|
|
2092
|
|
|
2093 @item
|
|
|
2094 Eval/compile commands should use @code{eval-region-lisp} or
|
|
|
2095 @code{compile-region-lisp}.
|
|
|
2096 @findex compile-region-lisp
|
|
|
2097 @findex eval-region-lisp
|
|
|
2098
|
|
|
2099 @end itemize
|
|
|
2100
|
|
|
2101 @node Concept index, Key index, Dialects, Top
|
|
|
2102 @unnumbered Concept Index
|
|
|
2103 @printindex cp
|
|
|
2104
|
|
|
2105 @node Key index, Command index, Concept index, Top
|
|
|
2106 @unnumbered Key Index
|
|
|
2107 @printindex ky
|
|
|
2108
|
|
|
2109 @node Command index, Variable index, Key index, Top
|
|
|
2110 @unnumbered Command Index
|
|
|
2111
|
|
|
2112 @noindent
|
|
|
2113 Commands available via @kbd{M-x} prefix.
|
|
|
2114
|
|
|
2115 @printindex pg
|
|
|
2116
|
|
|
2117 @node Variable index, Function index, Command index, Top
|
|
|
2118 @unnumbered Variable Index
|
|
|
2119
|
|
|
2120 @noindent
|
|
|
2121 Variables and hooks of ILISP.
|
|
|
2122
|
|
|
2123 @printindex vr
|
|
|
2124
|
|
|
2125 @node Function index, , Variable index, Top
|
|
|
2126 @unnumbered Function Index
|
|
|
2127
|
|
|
2128 @noindent
|
|
|
2129 Internal functions of ILISP which can be used to write new commands.
|
|
|
2130
|
|
|
2131 @printindex fn
|
|
|
2132
|
|
|
2133 @contents
|
|
|
2134
|
|
|
2135 @bye
|
|
|
2136
|
|
|
2137
|
|
|
2138 Should this stuff go anywhere??
|
|
|
2139
|
|
|
2140 misc ILISP
|
|
|
2141 bol-ilisp (C-a) will go after the prompt as defined by
|
|
|
2142 comint-prompt-regexp or ilisp-other-prompt or to the left margin with
|
|
|
2143 a prefix.
|
|
|
2144
|
|
|
2145 misc
|
|
|
2146 backward-delete-char-untabify (DEL)
|
|
|
2147 converts tabs to spaces as it moves back.
|
|
|
2148
|
|
|
2149
|
|
|
2150 about cmds
|
|
|
2151 The very first inferior LISP command executed may send some forms to
|
|
|
2152 initialize the inferior LISP.
|
|
|
2153
|
|
|
2154 Each time an inferior LISP command is executed, the last form sent can be
|
|
|
2155 seen in the *ilisp-send* buffer.
|
|
|
2156
|
|
|
2157
|
|
|
2158 @comment Local variables:
|
|
|
2159 @comment version-control: t
|
|
|
2160 @comment End:
|
