![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-11 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / info|
Return to emacs-11 CVS log | Up to [Apple XNU] / GNUtools / emacs / info |
1.1 root 1: This is Info file ../info/emacs, produced by Makeinfo-1.49 from the
2: input file emacs.texi.
3:
4: This file documents the GNU Emacs editor.
5:
6: Copyright (C) 1985, 1986, 1988, 1992 Richard M. Stallman.
7:
8: Permission is granted to make and distribute verbatim copies of this
9: manual provided the copyright notice and this permission notice are
10: preserved on all copies.
11:
12: Permission is granted to copy and distribute modified versions of
13: this manual under the conditions for verbatim copying, provided also
14: that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
15: General Public License" are included exactly as in the original, and
16: provided that the entire resulting derived work is distributed under the
17: terms of a permission notice identical to this one.
18:
19: Permission is granted to copy and distribute translations of this
20: manual into another language, under the above conditions for modified
21: versions, except that the sections entitled "The GNU Manifesto",
22: "Distribution" and "GNU General Public License" may be included in a
23: translation approved by the author instead of in the original English.
24:
25:
26: File: emacs, Node: Dissociated Press, Next: Amusements, Prev: Hardcopy, Up: Top
27:
28: Dissociated Press
29: =================
30:
31: `M-x dissociated-press' is a command for scrambling a file of text
32: either word by word or character by character. Starting from a buffer
33: of straight English, it produces extremely amusing output. The input
34: comes from the current Emacs buffer. Dissociated Press writes its
35: output in a buffer named `*Dissociation*', and redisplays that buffer
36: after every couple of lines (approximately) to facilitate reading it.
37:
38: `dissociated-press' asks every so often whether to continue
39: operating. Answer `n' to stop it. You can also stop at any time by
40: typing `C-g'. The dissociation output remains in the `*Dissociation*'
41: buffer for you to copy elsewhere if you wish.
42:
43: Dissociated Press operates by jumping at random from one point in the
44: buffer to another. In order to produce plausible output rather than
45: gibberish, it insists on a certain amount of overlap between the end of
46: one run of consecutive words or characters and the start of the next.
47: That is, if it has just printed out `president' and then decides to
48: jump to a different point in the file, it might spot the `ent' in
49: `pentagon' and continue from there, producing `presidentagon'. Long
50: sample texts produce the best results.
51:
52: A positive argument to `M-x dissociated-press' tells it to operate
53: character by character, and specifies the number of overlap characters.
54: A negative argument tells it to operate word by word and specifies the
55: number of overlap words. In this mode, whole words are treated as the
56: elements to be permuted, rather than characters. No argument is
57: equivalent to an argument of two. For your againformation, the output
58: goes only into the buffer `*Dissociation*'. The buffer you start with
59: is not changed.
60:
61: Dissociated Press produces nearly the same results as a Markov chain
62: based on a frequency table constructed from the sample text. It is,
63: however, an independent, ignoriginal invention. Dissociated Press
64: techniquitously copies several consecutive characters from the sample
65: between random choices, whereas a Markov chain would choose randomly for
66: each word or character. This makes for more plausible sounding results,
67: and runs faster.
68:
69: It is a mustatement that too much use of Dissociated Press can be a
70: developediment to your real work. Sometimes to the point of outragedy.
71: And keep dissociwords out of your documentation, if you want it to be
72: well userenced and properbose. Have fun. Your buggestions are welcome.
73:
74:
75: File: emacs, Node: Amusements, Next: Emulation, Prev: Dissociated Press, Up: Top
76:
77: Other Amusements
78: ================
79:
80: If you are a little bit bored, you can try `M-x hanoi'. If you are
81: considerably bored, give it a numeric argument. If you are very very
82: bored, try an argument of 9. Sit back and watch.
83:
84: When you are frustrated, try the famous Eliza program. Just do `M-x
85: doctor'. End each input by typing `RET' twice.
86:
87: When you are feeling strange, type `M-x yow'.
88:
89:
90: File: emacs, Node: Emulation, Next: Customization, Prev: Amusements, Up: Top
91:
92: Emulation
93: =========
94:
95: GNU Emacs can be programmed to emulate (more or less) most other
96: editors. Standard facilities can emulate these:
97:
98: EDT (DEC VMS editor)
99: Turn on EDT emulation with `M-x edt-emulation-on'. `M-x
100: edt-emulation-off' restores normal Emacs command bindings.
101:
102: Most of the EDT emulation commands are keypad keys, and most
103: standard Emacs key bindings are still available. The EDT
104: emulation rebindings are done in the global keymap, so there is no
105: problem switching buffers or major modes while in EDT emulation.
106:
107: Gosling Emacs
108: Turn on emulation of Gosling Emacs (aka Unipress Emacs) with `M-x
109: set-gosmacs-bindings'. This redefines many keys, mostly on the
110: `C-x' and `ESC' prefixes, to work as they do in Gosmacs. `M-x
111: set-gnu-bindings' returns to normal GNU Emacs by rebinding the
112: same keys to the definitions they had at the time `M-x
113: set-gosmacs-bindings' was done.
114:
115: It is also possible to run Mocklisp code written for Gosling Emacs.
116: *Note Mocklisp::.
117:
118: vi (Berkeley Unix editor)
119: Turn on vi emulation with `M-x vi-mode'. This is a major mode
120: that replaces the previously established major mode. All of the
121: vi commands that, in real vi, enter "input" mode are programmed in
122: the Emacs emulator to return to the previous major mode. Thus,
123: ordinary Emacs serves as vi's "input" mode.
124:
125: Because vi emulation works through major modes, it does not work
126: to switch buffers during emulation. Return to normal Emacs first.
127:
128: If you plan to use vi emulation much, you probably want to bind a
129: key to the `vi-mode' command.
130:
131: vi (alternate emulator)
132: Another vi emulator said to resemble real vi more thoroughly is
133: invoked by `M-x vip-mode'. "Input" mode in this emulator is
134: changed from ordinary Emacs so you can use ESC to go back to
135: emulated vi command mode. To get from emulated vi command mode
136: back to ordinary Emacs, type `C-z'.
137:
138: This emulation does not work through major modes, and it is
139: possible to switch buffers in various ways within the emulator.
140: It is not so necessary to assign a key to the command `vip-mode' as
141: it is with `vi-mode' because terminating insert mode does not use
142: it.
143:
144: For full information, see the long comment at the beginning of the
145: source file, which is `lisp/vip.el' in the Emacs distribution.
146:
147: I am interested in hearing which vi emulator users prefer, as well
148: as in receiving more complete user documentation for either or both
149: emulators. Warning: loading both at once may cause name conficts; no
150: one has checked.
151:
152:
153: File: emacs, Node: Customization, Next: Quitting, Prev: Emulation, Up: Top
154:
155: Customization
156: *************
157:
158: This chapter talks about various topics relevant to adapting the
159: behavior of Emacs in minor ways.
160:
161: All kinds of customization affect only the particular Emacs job that
162: you do them in. They are completely lost when you kill the Emacs job,
163: and have no effect on other Emacs jobs you may run at the same time or
164: later. The only way an Emacs job can affect anything outside of it is
165: by writing a file; in particular, the only way to make a customization
166: `permanent' is to put something in your `.emacs' file or other
167: appropriate file to do the customization in each session. *Note Init
168: File::.
169:
170: * Menu:
171:
172: * Minor Modes:: Each minor mode is one feature you can turn on
173: independently of any others.
174: * Variables:: Many Emacs commands examine Emacs variables
175: to decide what to do; by setting variables,
176: you can control their functioning.
177: * Keyboard Macros:: A keyboard macro records a sequence of keystrokes
178: to be replayed with a single command.
179: * Key Bindings:: The keymaps say what command each key runs.
180: By changing them, you can "redefine keys".
181: * Syntax:: The syntax table controls how words and expressions
182: are parsed.
183: * Init File:: How to write common customizations in the `.emacs' file.
184:
185:
186: File: emacs, Node: Minor Modes, Next: Variables, Prev: Customization, Up: Customization
187:
188: Minor Modes
189: ===========
190:
191: Minor modes are options which you can use or not. For example, Auto
192: Fill mode is a minor mode in which SPC breaks lines between words as you
193: type. All the minor modes are independent of each other and of the
194: selected major mode. Most minor modes say in the mode line when they
195: are on; for example, `Fill' in the mode line means that Auto Fill mode
196: is on.
197:
198: Append `-mode' to the name of a minor mode to get the name of a
199: command function that turns the mode on or off. Thus, the command to
200: enable or disable Auto Fill mode is called `M-x auto-fill-mode'. These
201: commands are usually invoked with `M-x', but you can bind keys to them
202: if you wish. With no argument, the function turns the mode on if it was
203: off and off if it was on. This is known as "toggling". A positive
204: argument always turns the mode on, and an explicit zero argument or a
205: negative argument always turns it off.
206:
207: Auto Fill mode allows you to enter filled text without breaking lines
208: explicitly. Emacs inserts newlines as necessary to prevent lines from
209: becoming too long. *Note Filling::.
210:
211: Overwrite mode causes ordinary printing characters to replace
212: existing text instead of shoving it over. For example, if the point is
213: in front of the `B' in `FOOBAR', then in Overwrite mode typing a `G'
214: changes it to `FOOGAR', instead of making it `FOOGBAR' as usual.
215:
216: Abbrev mode allows you to define abbreviations that automatically
217: expand as you type them. For example, `amd' might expand to `abbrev
218: mode'. *Note Abbrevs::, for full information.
219:
220:
221: File: emacs, Node: Variables, Next: Keyboard Macros, Prev: Minor Modes, Up: Customization
222:
223: Variables
224: =========
225:
226: A "variable" is a Lisp symbol which has a value. The symbol's name
227: is also called the name of the variable. Variable names can contain any
228: characters, but conventionally they are chosen to be words separated by
229: hyphens. A variable can have a documentation string which describes
230: what kind of value it should have and how the value will be used.
231:
232: Lisp allows any variable to have any kind of value, but most
233: variables that Emacs uses require a value of a certain type. Often the
234: value should always be a string, or should always be a number.
235: Sometimes we say that a certain feature is turned on if a variable is
236: "non-`nil'," meaning that if the variable's value is `nil', the feature
237: is off, but the feature is on for any other value. The conventional
238: value to use to turn on the feature--since you have to pick one
239: particular value when you set the variable--is `t'.
240:
241: Emacs uses many Lisp variables for internal recordkeeping, as any
242: Lisp program must, but the most interesting variables for you are the
243: ones that exist for the sake of customization. Emacs does not
244: (usually) change the values of these variables; instead, you set the
245: values, and thereby alter and control the behavior of certain Emacs
246: commands. These variables are called "options". Most options are
247: documented in this manual, and appear in the Variable Index (*note
248: Variable Index::.).
249:
250: One example of a variable which is an option is `fill-column', which
251: specifies the position of the right margin (as a number of characters
252: from the left margin) to be used by the fill commands (*note
253: Filling::.).
254:
255: * Menu:
256:
257: * Examining:: Examining or setting one variable's value.
258: * Edit Options:: Examining or editing list of all variables' values.
259: * Locals:: Per-buffer values of variables.
260: * File Variables:: How files can specify variable values.
261:
262:
263: File: emacs, Node: Examining, Next: Edit Options, Prev: Variables, Up: Variables
264:
265: Examining and Setting Variables
266: -------------------------------
267:
268: `C-h v'
269: `M-x describe-variable'
270: Print the value and documentation of a variable.
271:
272: `M-x set-variable'
273: Change the value of a variable.
274:
275: To examine the value of a single variable, type `C-h v'
276: (`describe-variable'), which reads a variable name using the
277: minibuffer, with completion. It prints both the value and the
278: documentation of the variable.
279:
280: C-h v fill-column RET
281:
282: prints something like
283: fill-column's value is 72
284:
285: Documentation:
286: *Column beyond which automatic line-wrapping should happen.
287: Automatically becomes local when set in any fashion.
288:
289: The star at the beginning of the documentation indicates that this
290: variable is an option. `C-h v' is not restricted to options; it allows
291: any variable name.
292:
293: If you know which option you want to set, you can set it using `M-x
294: set-variable'. This reads the variable name with the minibuffer (with
295: completion), and then reads a Lisp expression for the new value using
296: the minibuffer a second time. For example,
297:
298: M-x set-variable RET fill-column RET 72 RET
299:
300: sets `fill-column' to 72, like executing the Lisp expression
301:
302: (setq fill-column 72)
303:
304: Setting variables in this way, like all means of customizing Emacs
305: except where explicitly stated, affects only the current Emacs session.
306:
307:
308: File: emacs, Node: Edit Options, Next: Locals, Prev: Examining, Up: Variables
309:
310: Editing Variable Values
311: -----------------------
312:
313: `M-x list-options'
314: Display a buffer listing names, values and documentation of all
315: options.
316:
317: `M-x edit-options'
318: Change option values by editing a list of options.
319:
320: `M-x list-options' displays a list of all Emacs option variables, in
321: an Emacs buffer named `*List Options*'. Each option is shown with its
322: documentation and its current value. Here is what a portion of it might
323: look like:
324:
325: ;; exec-path:
326: ("." "/usr/local/bin" "/usr/ucb" "/bin" "/usr/bin" "/u2/emacs/etc")
327: *List of directories to search programs to run in subprocesses.
328: Each element is a string (directory name)
329: or nil (try the default directory).
330: ;;
331: ;; fill-column:
332: 72
333: *Column beyond which automatic line-wrapping should happen.
334: Automatically becomes local when set in any fashion.
335: ;;
336:
337: `M-x edit-options' goes one step further and immediately selects the
338: `*List Options*' buffer; this buffer uses the major mode Options mode,
339: which provides commands that allow you to point at an option and change
340: its value:
341:
342: `s'
343: Set the variable point is in or near to a new value read using the
344: minibuffer.
345:
346: `x'
347: Toggle the variable point is in or near: if the value was `nil',
348: it becomes `t'; otherwise it becomes `nil'.
349:
350: `1'
351: Set the variable point is in or near to `t'.
352:
353: `0'
354: Set the variable point is in or near to `nil'.
355:
356: `n'
357: `p'
358: Move to the next or previous variable.
359:
360: Changes take effect immediately.
361:
362:
363: File: emacs, Node: Locals, Next: File Variables, Prev: Edit Options, Up: Variables
364:
365: Local Variables
366: ---------------
367:
368: `M-x make-local-variable'
369: Make a variable have a local value in the current buffer.
370:
371: `M-x kill-local-variable'
372: Make a variable use its global value in the current buffer.
373:
374: `M-x make-variable-buffer-local'
375: Mark a variable so that setting it will make it local to the
376: buffer that is current at that time.
377:
378: Any variable can be made "local" to a specific Emacs buffer. This
379: means that its value in that buffer is independent of its value in other
380: buffers. A few variables are always local in every buffer. Every other
381: Emacs variable has a "global" value which is in effect in all buffers
382: that have not made the variable local.
383:
384: Major modes always make the variables they set local to the buffer.
385: This is why changing major modes in one buffer has no effect on other
386: buffers.
387:
388: `M-x make-local-variable' reads the name of a variable and makes it
389: local to the current buffer. Further changes in this buffer will not
390: affect others, and further changes in the global value will not affect
391: this buffer.
392:
393: `M-x make-variable-buffer-local' reads the name of a variable and
394: changes the future behavior of the variable so that it will become local
395: automatically when it is set. More precisely, once a variable has been
396: marked in this way, the usual ways of setting the variable will
397: automatically do `make-local-variable' first. We call such variables
398: "per-buffer" variables.
399:
400: Some important variables have been marked per-buffer already. These
401: include `abbrev-mode', `auto-fill-hook', `case-fold-search',
402: `ctl-arrow', `comment-column', `fill-column', `fill-prefix',
403: `indent-tabs-mode', `left-margin', `mode-line-format', `overwrite-mode',
404: `selective-display', `tab-width', `selective-display-ellipses', and
405: `truncate-lines'. Some other variables are always local in every
406: buffer, but they are used for internal purposes.
407:
408: `M-x kill-local-variable' reads the name of a variable and makes it
409: cease to be local to the current buffer. The global value of the
410: variable henceforth is in effect in this buffer. Setting the major
411: mode kills all the local variables of the buffer.
412:
413: To set the global value of a variable, regardless of whether the
414: variable has a local value in the current buffer, you can use the Lisp
415: function `setq-default'. It works like `setq'. If there is a local
416: value in the current buffer, the local value is not affected by
417: `setq-default'; thus, the new global value may not be visible until you
418: switch to another buffer. For example,
419:
420: (setq-default fill-column 72)
421:
422: `setq-default' is the only way to set the global value of a variable
423: that has been marked with `make-variable-buffer-local'.
424:
425: Programs can look at a variable's default value with `default-value'.
426: This function takes a symbol as argument and returns its default value.
427: The argument is evaluated; usually you must quote it explicitly. For
428: example,
429:
430: (default-value 'fill-column)
431:
432:
433: File: emacs, Node: File Variables, Prev: Locals, Up: Variables
434:
435: Local Variables in Files
436: ------------------------
437:
438: A file can contain a "local variables list", which specifies the
439: values to use for certain Emacs variables when that file is edited.
440: Visiting the file checks for a local variables list and makes each
441: variable in the list local to the buffer in which the file is visited,
442: with the value specified in the file.
443:
444: A local variables list goes near the end of the file, in the last
445: page. (It is often best to put it on a page by itself.) The local
446: variables list starts with a line containing the string `Local
447: Variables:', and ends with a line containing the string `End:'. In
448: between come the variable names and values, one set per line, as
449: `VARIABLE: VALUE'. The VALUEs are not evaluated; they are used
450: literally.
451:
452: The line which starts the local variables list does not have to say
453: just `Local Variables:'. If there is other text before `Local
454: Variables:', that text is called the "prefix", and if there is other
455: text after, that is called the "suffix". If these are present, each
456: entry in the local variables list should have the prefix before it and
457: the suffix after it. This includes the `End:' line. The prefix and
458: suffix are included to disguise the local variables list as a comment so
459: that the compiler or text formatter will not be perplexed by it. If
460: you do not need to disguise the local variables list as a comment in
461: this way, do not bother with a prefix or a suffix.
462:
463: Two "variable" names are special in a local variables list: a value
464: for the variable `mode' really sets the major mode, and a value for the
465: variable `eval' is simply evaluated as an expression and the value is
466: ignored. These are not real variables; setting such variables in any
467: other context has no such effect. If `mode' is used in a local
468: variables list, it should be the first entry in the list.
469:
470: Here is an example of a local variables list:
471:
472: ;;; Local Variables: ***
473: ;;; mode:lisp ***
474: ;;; comment-column:0 ***
475: ;;; comment-start: ";;; " ***
476: ;;; comment-end:"***" ***
477: ;;; End: ***
478:
479: Note that the prefix is `;;; ' and the suffix is ` ***'. Note also
480: that comments in the file begin with and end with the same strings.
481: Presumably the file contains code in a language which is like Lisp
482: (like it enough for Lisp mode to be useful) but in which comments start
483: and end in that way. The prefix and suffix are used in the local
484: variables list to make the list appear as comments when the file is read
485: by the compiler or interpreter for that language.
486:
487: The start of the local variables list must be no more than 3000
488: characters from the end of the file, and must be in the last page if the
489: file is divided into pages. Otherwise, Emacs will not notice it is
490: there. The purpose of this is so that a stray `Local Variables:' not in
491: the last page does not confuse Emacs, and so that visiting a long file
492: that is all one page and has no local variables list need not take the
493: time to search the whole file.
494:
495: You may be tempted to try to turn on Auto Fill mode with a local
496: variable list. That is a mistake. The choice of Auto Fill mode or not
497: is a matter of individual taste, not a matter of the contents of
498: particular files. If you want to use Auto Fill, set up major mode hooks
499: with your `.emacs' file to turn it on (when appropriate) for you alone
500: (*note Init File::.). Don't try to use a local variable list that would
501: impose your taste on everyone.
502:
503: If you are concerned that you might visit a file containing a
504: Trojan-horse local variable specification, you can prevent local
505: variables processing by setting the variable `inhibit-local-variables'
506: to a non-`nil' value. Emacs will display the local variables
507: specification and then ask you whether to process it.
508:
509:
510: File: emacs, Node: Keyboard Macros, Next: Key Bindings, Prev: Variables, Up: Customization
511:
512: Keyboard Macros
513: ===============
514:
515: A "keyboard macro" is a command defined by the user to abbreviate a
516: sequence of keys. For example, if you discover that you are about to
517: type `C-n C-d' forty times, you can speed your work by defining a
518: keyboard macro to do `C-n C-d' and calling it with a repeat count of
519: forty.
520:
521: `C-x ('
522: Start defining a keyboard macro (`start-kbd-macro').
523:
524: `C-x )'
525: End the definition of a keyboard macro (`end-kbd-macro').
526:
527: `C-x e'
528: Execute the most recent keyboard macro (`call-last-kbd-macro').
529:
530: `C-u C-x ('
531: Re-execute last keyboard macro, then add more keys to its
532: definition.
533:
534: `C-x q'
535: When this point is reached during macro execution, ask for
536: confirmation (`kbd-macro-query').
537:
538: `M-x name-last-kbd-macro'
539: Give a command name (for the duration of the session) to the most
540: recently defined keyboard macro.
541:
542: `M-x insert-kbd-macro'
543: Insert in the buffer a keyboard macro's definition, as Lisp code.
544:
545: Keyboard macros differ from ordinary Emacs commands in that they are
546: written in the Emacs command language rather than in Lisp. This makes
547: it easier for the novice to write them, and makes them more convenient
548: as temporary hacks. However, the Emacs command language is not powerful
549: enough as a programming language to be useful for writing anything
550: intelligent or general. For such things, Lisp must be used.
551:
552: You define a keyboard macro while executing the commands which are
553: the definition. Put differently, as you are defining a keyboard macro,
554: the definition is being executed for the first time. This way, you can
555: see what the effects of your commands are, so that you don't have to
556: figure them out in your head. When you are finished, the keyboard
557: macro is defined and also has been, in effect, executed once. You can
558: then do the whole thing over again by invoking the macro.
559:
560: * Menu:
561:
562: * Basic Kbd Macro:: Defining and running keyboard macros.
563: * Save Kbd Macro:: Giving keyboard macros names; saving them in files.
564: * Kbd Macro Query:: Keyboard macros that do different things each use.
565:
566:
567: File: emacs, Node: Basic Kbd Macro, Next: Save Kbd Macro, Prev: Keyboard Macros, Up: Keyboard Macros
568:
569: Basic Use
570: ---------
571:
572: To start defining a keyboard macro, type the `C-x (' command
573: (`start-kbd-macro'). From then on, your keys continue to be executed,
574: but also become part of the definition of the macro. `Def' appears in
575: the mode line to remind you of what is going on. When you are
576: finished, the `C-x )' command (`end-kbd-macro') terminates the
577: definition (without becoming part of it!).
578:
579: For example,
580:
581: C-x ( M-F foo C-x )
582:
583: defines a macro to move forward a word and then insert `foo'.
584:
585: The macro thus defined can be invoked again with the `C-x e' command
586: (`call-last-kbd-macro'), which may be given a repeat count as a numeric
587: argument to execute the macro many times. `C-x )' can also be given a
588: repeat count as an argument, in which case it repeats the macro that
589: many times right after defining it, but defining the macro counts as
590: the first repetition (since it is executed as you define it). So,
591: giving `C-x )' an argument of 4 executes the macro immediately 3
592: additional times. An argument of zero to `C-x e' or `C-x )' means
593: repeat the macro indefinitely (until it gets an error or you type
594: `C-g').
595:
596: If you wish to repeat an operation at regularly spaced places in the
597: text, define a macro and include as part of the macro the commands to
598: move to the next place you want to use it. For example, if you want to
599: change each line, you should position point at the start of a line, and
600: define a macro to change that line and leave point at the start of the
601: next line. Then repeating the macro will operate on successive lines.
602:
603: After you have terminated the definition of a keyboard macro, you
604: can add to the end of its definition by typing `C-u C-x ('. This is
605: equivalent to plain `C-x (' followed by retyping the whole definition
606: so far. As a consequence it re-executes the macro as previously
607: defined.
608:
609: One limitation on the use of keyboard macros is that if you exit a
610: recursive edit within a macro that was not entered within the macro,
611: then the execution of the macro stops at that point. In Emacs 18, View
612: mode uses a recursive edit, so exiting View mode is an occasion for such
613: a problem.
614:
615:
616: File: emacs, Node: Save Kbd Macro, Next: Kbd Macro Query, Prev: Basic Kbd Macro, Up: Keyboard Macros
617:
618: Naming and Saving Keyboard Macros
619: ---------------------------------
620:
621: If you wish to save a keyboard macro for longer than until you
622: define the next one, you must give it a name using `M-x
623: name-last-kbd-macro'. This reads a name as an argument using the
624: minibuffer and defines that name to execute the macro. The macro name
625: is a Lisp symbol, and defining it in this way makes it a valid command
626: name for calling with `M-x' or for binding a key to with
627: `global-set-key' (*note Keymaps::.). If you specify a name that has a
628: prior definition other than another keyboard macro, an error message is
629: printed and nothing is changed.
630:
631: Once a macro has a command name, you can save its definition in a
632: file. Then it can be used in another editing session. First visit the
633: file you want to save the definition in. Then use the command
634:
635: M-x insert-kbd-macro RET MACRONAME RET
636:
637: This inserts some Lisp code that, when executed later, will define the
638: same macro with the same definition it has now. You need not
639: understand Lisp code to do this, because `insert-kbd-macro' writes the
640: Lisp code for you. Then save the file. The file can be loaded with
641: `load-file' (*note Lisp Libraries::.). If the file you save in is your
642: init file `~/.emacs' (*note Init File::.) then the macro will be
643: defined each time you run Emacs.
644:
645: If you give `insert-kbd-macro' a prefix argument, it makes
646: additional Lisp code to record the keys (if any) that you have bound to
647: the keyboard macro, so that the macro will be reassigned the same keys
648: when you load the file.
649:
650:
651: File: emacs, Node: Kbd Macro Query, Prev: Save Kbd Macro, Up: Keyboard Macros
652:
653: Executing Macros with Variations
654: --------------------------------
655:
656: Using `C-x q' (`kbd-macro-query'), you can get an effect similar to
657: that of `query-replace', where the macro asks you each time around
658: whether to make a change. When you are defining the macro, type `C-x
659: q' at the point where you want the query to occur. During macro
660: definition, the `C-x q' does nothing, but when the macro is invoked the
661: `C-x q' reads a character from the terminal to decide whether to
662: continue.
663:
664: The special answers are SPC, DEL, `C-d', `C-l' and `C-r'. Any other
665: character terminates execution of the keyboard macro and is then read
666: as a command. SPC means to continue. DEL means to skip the remainder
667: of this repetition of the macro, starting again from the beginning in
668: the next repetition. `C-d' means to skip the remainder of this
669: repetition and cancel further repetition. `C-l' redraws the screen and
670: asks you again for a character to say what to do. `C-r' enters a
671: recursive editing level, in which you can perform editing which is not
672: part of the macro. When you exit the recursive edit using `C-M-c', you
673: are asked again how to continue with the keyboard macro. If you type a
674: SPC at this time, the rest of the macro definition is executed. It is
675: up to you to leave point and the text in a state such that the rest of
676: the macro will do what you want.
677:
678: `C-u C-x q', which is `C-x q' with a numeric argument, performs a
679: different function. It enters a recursive edit reading input from the
680: keyboard, both when you type it during the definition of the macro, and
681: when it is executed from the macro. During definition, the editing you
682: do inside the recursive edit does not become part of the macro. During
683: macro execution, the recursive edit gives you a chance to do some
684: particularized editing. *Note Recursive Edit::.
685:
686:
687: File: emacs, Node: Key Bindings, Next: Syntax, Prev: Keyboard Macros, Up: Customization
688:
689: Customizing Key Bindings
690: ========================
691:
692: This section deals with the "keymaps" which define the bindings
693: between keys and functions, and shows how you can customize these
694: bindings.
695:
696: A command is a Lisp function whose definition provides for
697: interactive use. Like every Lisp function, a command has a function
698: name, a Lisp symbol whose name usually consists of lower case letters
699: and hyphens.
700:
701: * Menu:
702:
703: * Keymaps:: Definition of the keymap data structure.
704: Names of Emacs's standard keymaps.
705: * Rebinding:: How to redefine one key's meaning conveniently.
706: * Disabling:: Disabling a command means confirmation is required
707: before it can be executed. This is done to protect
708: beginners from surprises.
709:
710:
711: File: emacs, Node: Keymaps, Next: Rebinding, Prev: Key Bindings, Up: Key Bindings
712:
713: Keymaps
714: -------
715:
716: The bindings between characters and command functions are recorded in
717: data structures called "keymaps". Emacs has many of these. One, the
718: "global" keymap, defines the meanings of the single-character keys that
719: are defined regardless of major mode. It is the value of the variable
720: `global-map'.
721:
722: Each major mode has another keymap, its "local keymap", which
723: contains overriding definitions for the single-character keys that are
724: to be redefined in that mode. Each buffer records which local keymap is
725: installed for it at any time, and the current buffer's local keymap is
726: the only one that directly affects command execution. The local
727: keymaps for Lisp mode, C mode, and many other major modes always exist
728: even when not in use. They are the values of the variables
729: `lisp-mode-map', `c-mode-map', and so on. For major modes less often
730: used, the local keymap is sometimes constructed only when the mode is
731: used for the first time in a session. This is to save space.
732:
733: There are local keymaps for the minibuffer too; they contain various
734: completion and exit commands.
735:
736: * `minibuffer-local-map' is used for ordinary input (no completion).
737:
738: * `minibuffer-local-ns-map' is similar, except that SPC exits just
739: like RET. This is used mainly for Mocklisp compatibility.
740:
741: * `minibuffer-local-completion-map' is for permissive completion.
742:
743: * `minibuffer-local-must-match-map' is for strict completion and for
744: cautious completion.
745:
746: * `repeat-complex-command-map' is for use in `C-x ESC'.
747:
748: Finally, each prefix key has a keymap which defines the key sequences
749: that start with it. For example, `ctl-x-map' is the keymap used for
750: characters following a `C-x'.
751:
752: * `ctl-x-map' is the variable name for the map used for characters
753: that follow `C-x'.
754:
755: * `help-map' is used for characters that follow `C-h'.
756:
757: * `esc-map' is for characters that follow ESC. Thus, all Meta
758: characters are actually defined by this map.
759:
760: * `ctl-x-4-map' is for characters that follow `C-x 4'.
761:
762: * `mode-specific-map' is for characters that follow `C-c'.
763:
764: The definition of a prefix key is just the keymap to use for looking
765: up the following character. Actually, the definition is sometimes a
766: Lisp symbol whose function definition is the following character
767: keymap. The effect is the same, but it provides a command name for the
768: prefix key that can be used as a description of what the prefix key is
769: for. Thus, the binding of `C-x' is the symbol `Ctl-X-Prefix', whose
770: function definition is the keymap for `C-x' commands, the value of
771: `ctl-x-map'.
772:
773: Prefix key definitions of this sort can appear in either the global
774: map or a local map. The definitions of `C-c', `C-x', `C-h' and ESC as
775: prefix keys appear in the global map, so these prefix keys are always
776: available. Major modes can locally redefine a key as a prefix by
777: putting a prefix key definition for it in the local map.
778:
779: A mode can also put a prefix definition of a global prefix character
780: such as `C-x' into its local map. This is how major modes override the
781: definitions of certain keys that start with `C-x'. This case is
782: special, because the local definition does not entirely replace the
783: global one. When both the global and local definitions of a key are
784: other keymaps, the next character is looked up in both keymaps, with
785: the local definition overriding the global one as usual. So, the
786: character after the `C-x' is looked up in both the major mode's own
787: keymap for redefined `C-x' commands and in `ctl-x-map'. If the major
788: mode's own keymap for `C-x' commands contains `nil', the definition
789: from the global keymap for `C-x' commands is used.
790:
791: A keymap is actually a Lisp object. The simplest form of keymap is a
792: Lisp vector of length 128. The binding for a character in such a
793: keymap is found by indexing into the vector with the character as an
794: index. A keymap can also be a Lisp list whose CAR is the symbol
795: `keymap' and whose remaining elements are pairs of the form `(CHAR .
796: BINDING)'. Such lists are called "sparse keymaps" because they are used
797: when most of the characters' entries will be `nil'. Sparse keymaps are
798: used mainly for prefix characters.
799:
800: Keymaps are only of length 128, so what about Meta characters, whose
801: codes are from 128 to 255? A key that contains a Meta character
802: actually represents it as a sequence of two characters, the first of
803: which is ESC. So the key `M-a' is really represented as `ESC a', and
804: its binding is found at the slot for `a' in `esc-map'.
805:
806:
807: File: emacs, Node: Rebinding, Next: Disabling, Prev: Keymaps, Up: Key Bindings
808:
809: Changing Key Bindings Interactively
810: -----------------------------------
811:
812: The way to redefine an Emacs key is to change its entry in a keymap.
813: You can change the global keymap, in which case the change is effective
814: in all major modes (except those that have their own overriding local
815: definitions for the same key). Or you can change the current buffer's
816: local map, which affects all buffers using the same major mode.
817:
818: `M-x global-set-key RET KEY CMD RET'
819: Defines KEY globally to run CMD.
820:
821: `M-x local-set-key RET KEY CMD RET'
822: Defines KEY locally (in the major mode now in effect) to run CMD.
823:
824: For example,
825:
826: M-x global-set-key RET C-f next-line RET
827:
828: would redefine `C-f' to move down a line. The fact that CMD is read
829: second makes it serve as a kind of confirmation for KEY.
830:
831: These functions offer no way to specify a particular prefix keymap
832: as the one to redefine in, but that is not necessary, as you can
833: include prefixes in KEY. KEY is read by reading characters one by one
834: until they amount to a complete key (that is, not a prefix key). Thus,
835: if you type `C-f' for KEY, that's the end; the minibuffer is entered
836: immediately to read CMD. But if you type `C-x', another character is
837: read; if that is `4', another character is read, and so on. For
838: example,
839:
840: M-x global-set-key RET C-x 4 $ spell-other-window RET
841:
842: would redefine `C-x 4 $' to run the (fictitious) command
843: `spell-other-window'.
844:
845: All the key sequences which consist of `C-c' followed by a letter
846: are supposed to be reserved for user customization. That is, Emacs Lisp
847: libraries should not define any of these commands.
848:
849: The most general way to modify a keymap is the function `define-key',
850: used in Lisp code (such as your `.emacs' file). `define-key' takes
851: three arguments: the keymap, the key to modify in it, and the new
852: definition. *Note Init File::, for an example.
853: `substitute-key-definition' is used similarly; it takes three
854: arguments, an old definition, a new definition and a keymap, and
855: redefines in that keymap all keys that were previously defined with the
856: old definition to have the new definition instead.
857:
858:
859: File: emacs, Node: Disabling, Prev: Rebinding, Up: Key Bindings
860:
861: Disabling Commands
862: ------------------
863:
864: Disabling a command marks the command as requiring confirmation
865: before it can be executed. The purpose of disabling a command is to
866: prevent beginning users from executing it by accident and being
867: confused.
868:
869: The direct mechanism for disabling a command is to have a non-`nil'
870: `disabled' property on the Lisp symbol for the command. These
871: properties are normally set up by the user's `.emacs' file with Lisp
872: expressions such as
873:
874: (put 'delete-region 'disabled t)
875:
876: If the value of the `disabled' property is a string, that string is
877: included in the message printed when the command is used:
878:
879: (put 'delete-region 'disabled
880: "Text deleted this way cannot be yanked back!\n")
881:
882: You can make a command disabled either by editing the `.emacs' file
883: directly or with the command `M-x disable-command', which edits the
884: `.emacs' file for you. *Note Init File::.
885:
886: Attempting to invoke a disabled command interactively in Emacs
887: causes the display of a window containing the command's name, its
888: documentation, and some instructions on what to do immediately; then
889: Emacs asks for input saying whether to execute the command as
890: requested, enable it and execute, or cancel it. If you decide to
891: enable the command, you are asked whether to do this permanently or
892: just for the current session. Enabling permanently works by
893: automatically editing your `.emacs' file. You can use `M-x
894: enable-command' at any time to enable any command permanently.
895:
896: Whether a command is disabled is independent of what key is used to
897: invoke it; it also applies if the command is invoked using `M-x'.
898: Disabling a command has no effect on calling it as a function from Lisp
899: programs.
900:
901:
902: File: emacs, Node: Syntax, Next: Init File, Prev: Key Bindings, Up: Customization
903:
904: The Syntax Table
905: ================
906:
907: All the Emacs commands which parse words or balance parentheses are
908: controlled by the "syntax table". The syntax table says which
909: characters are opening delimiters, which are parts of words, which are
910: string quotes, and so on. Actually, each major mode has its own syntax
911: table (though sometimes related major modes use the same one) which it
912: installs in each buffer that uses that major mode. The syntax table
913: installed in the current buffer is the one that all commands use, so we
914: call it "the" syntax table. A syntax table is a Lisp object, a vector
915: of length 256 whose elements are numbers.
916:
917: * Menu:
918:
919: * Entry: Syntax Entry. What the syntax table records for each character.
920: * Change: Syntax Change. How to change the information.
921:
922:
923: File: emacs, Node: Syntax Entry, Next: Syntax Change, Prev: Syntax, Up: Syntax
924:
925: Information about Each Character
926: --------------------------------
927:
928: The syntax table entry for a character is a number that encodes six
929: pieces of information:
930:
931: * The syntactic class of the character, represented as a small
932: integer.
933:
934: * The matching delimiter, for delimiter characters only. The
935: matching delimiter of `(' is `)', and vice versa.
936:
937: * A flag saying whether the character is the first character of a
938: two-character comment starting sequence.
939:
940: * A flag saying whether the character is the second character of a
941: two-character comment starting sequence.
942:
943: * A flag saying whether the character is the first character of a
944: two-character comment ending sequence.
945:
946: * A flag saying whether the character is the second character of a
947: two-character comment ending sequence.
948:
949: The syntactic classes are stored internally as small integers, but
950: are usually described to or by the user with characters. For example,
951: `(' is used to specify the syntactic class of opening delimiters. Here
952: is a table of syntactic classes, with the characters that specify them.
953:
954: ` '
955: The class of whitespace characters.
956:
957: `-'
958: Another name for the class of whitespace characters.
959:
960: `w'
961: The class of word-constituent characters.
962:
963: `_'
964: The class of characters that are part of symbol names but not
965: words. This class is represented by `_' because the character `_'
966: has this class in both C and Lisp.
967:
968: `.'
969: The class of punctuation characters that do not fit into any other
970: special class.
971:
972: `('
973: The class of opening delimiters.
974:
975: `)'
976: The class of closing delimiters.
977:
978: `''
979: The class of expression-adhering characters. These characters are
980: part of a symbol if found within or adjacent to one, and are part
981: of a following expression if immediately preceding one, but are
982: like whitespace if surrounded by whitespace.
983:
984: `"'
985: The class of string-quote characters. They match each other in
986: pairs, and the characters within the pair all lose their syntactic
987: significance except for the `\' and `/' classes of escape
988: characters, which can be used to include a string-quote inside the
989: string.
990:
991: `$'
992: The class of self-matching delimiters. This is intended for TeX's
993: `$', which is used both to enter and leave math mode. Thus, a
994: pair of matching `$' characters surround each piece of math mode
995: TeX input. A pair of adjacent `$' characters act like a single
996: one for purposes of matching.
997:
998: `/'
999: The class of escape characters that always just deny the following
1000: character its special syntactic significance. The character after
1001: one of these escapes is always treated as alphabetic.
1002:
1003: `\'
1004: The class of C-style escape characters. In practice, these are
1005: treated just like `/'-class characters, because the extra
1006: possibilities for C escapes (such as being followed by digits)
1007: have no effect on where the containing expression ends.
1008:
1009: `<'
1010: The class of comment-starting characters. Only single-character
1011: comment starters (such as `;' in Lisp mode) are represented this
1012: way.
1013:
1014: `>'
1015: The class of comment-ending characters. Newline has this syntax in
1016: Lisp mode.
1017:
1018: The characters flagged as part of two-character comment delimiters
1019: can have other syntactic functions most of the time. For example, `/'
1020: and `*' in C code, when found separately, have nothing to do with
1021: comments. The comment-delimiter significance overrides when the pair of
1022: characters occur together in the proper order. Only the list and sexp
1023: commands use the syntax table to find comments; the commands
1024: specifically for comments have other variables that tell them where to
1025: find comments. And the list and sexp commands notice comments only if
1026: `parse-sexp-ignore-comments' is non-`nil'. This variable is set to
1027: `nil' in modes where comment-terminator sequences are liable to appear
1028: where there is no comment; for example, in Lisp mode where the comment
1029: terminator is a newline but not every newline ends a comment.
1030:
1031:
1032: File: emacs, Node: Syntax Change, Prev: Syntax Entry, Up: Syntax
1033:
1034: Altering Syntax Information
1035: ---------------------------
1036:
1037: It is possible to alter a character's syntax table entry by storing
1038: a new number in the appropriate element of the syntax table, but it
1039: would be hard to determine what number to use. Therefore, Emacs
1040: provides a command that allows you to specify the syntactic properties
1041: of a character in a convenient way.
1042:
1043: `M-x modify-syntax-entry' is the command to change a character's
1044: syntax. It can be used interactively, and is also the means used by
1045: major modes to initialize their own syntax tables. Its first argument
1046: is the character to change. The second argument is a string that
1047: specifies the new syntax. When called from Lisp code, there is a
1048: third, optional argument, which specifies the syntax table in which to
1049: make the change. If not supplied, or if this command is called
1050: interactively, the third argument defaults to the current buffer's
1051: syntax table.
1052:
1053: 1. The first character in the string specifies the syntactic class.
1054: It is one of the characters in the previous table (*note Syntax
1055: Entry::.).
1056:
1057: 2. The second character is the matching delimiter. For a character
1058: that is not an opening or closing delimiter, this should be a
1059: space, and may be omitted if no following characters are needed.
1060:
1061: 3. The remaining characters are flags. The flag characters allowed
1062: are
1063:
1064: `1'
1065: Flag this character as the first of a two-character comment
1066: starting sequence.
1067:
1068: `2'
1069: Flag this character as the second of a two-character comment
1070: starting sequence.
1071:
1072: `3'
1073: Flag this character as the first of a two-character comment
1074: ending sequence.
1075:
1076: `4'
1077: Flag this character as the second of a two-character comment
1078: ending sequence.
1079:
1080: A description of the contents of the current syntax table can be
1081: displayed with `C-h s' (`describe-syntax'). The description of each
1082: character includes both the string you would have to give to
1083: `modify-syntax-entry' to set up that character's current syntax, and
1084: some English to explain that string if necessary.
1085:
1086:
1087: File: emacs, Node: Init File, Prev: Syntax, Up: Customization
1088:
1089: The Init File, .emacs
1090: =====================
1091:
1092: When Emacs is started, it normally loads the file `.emacs' in your
1093: home directory. This file, if it exists, should contain Lisp code. It
1094: is called your "init file". The command line switches `-q' and `-u'
1095: can be used to tell Emacs whether to load an init file (*note Entering
1096: Emacs::.).
1097:
1098: There can also be a "default init file", which is the library named
1099: `default.el', found via the standard search path for libraries. The
1100: Emacs distribution contains no such library; your site may create one
1101: for local customizations. If this library exists, it is loaded
1102: whenever you start Emacs. But your init file, if any, is loaded first;
1103: if it sets `inhibit-default-init' non-`nil', then `default' is not
1104: loaded.
1105:
1106: If you have a large amount of code in your `.emacs' file, you should
1107: move it into another file named `SOMETHING.el', byte-compile it (*note
1108: Lisp Libraries::.), and make your `.emacs' file load the other file
1109: using `load'.
1110:
1111: * Menu:
1112:
1113: * Init Syntax:: Syntax of constants in Emacs Lisp.
1114: * Init Examples:: How to do some things with an init file.
1115: * Terminal Init:: Each terminal type can have an init file.
1116: * Debugging Init:: How to debug your `.emacs' file.
1117:
1118:
1119: File: emacs, Node: Init Syntax, Next: Init Examples, Prev: Init File, Up: Init File
1120:
1121: Init File Syntax
1122: ----------------
1123:
1124: The `.emacs' file contains one or more Lisp function call
1125: expressions. Each of these consists of a function name followed by
1126: arguments, all surrounded by parentheses. For example, `(setq
1127: fill-column 60)' represents a call to the function `setq' which is used
1128: to set the variable `fill-column' (*note Filling::.) to 60.
1129:
1130: The second argument to `setq' is an expression for the new value of
1131: the variable. This can be a constant, a variable, or a function call
1132: expression. In `.emacs', constants are used most of the time. They
1133: can be:
1134:
1135: Numbers:
1136: Numbers are written in decimal, with an optional initial minus
1137: sign.
1138:
1139: Strings:
1140: Lisp string syntax is the same as C string syntax with a few extra
1141: features. Use a double-quote character to begin and end a string
1142: constant.
1143:
1144: Newlines and special characters may be present literally in
1145: strings. They can also be represented as backslash sequences:
1146: `\n' for newline, `\b' for backspace, `\r' for carriage return,
1147: `\t' for tab, `\f' for formfeed (control-l), `\e' for escape, `\\'
1148: for a backslash, `\"' for a double-quote, or `\OOO' for the
1149: character whose octal code is OOO. Backslash and double-quote are
1150: the only characters for which backslash sequences are mandatory.
1151:
1152: `\C-' can be used as a prefix for a control character, as in
1153: `\C-s' for ASCII Control-S, and `\M-' can be used as a prefix for
1154: a meta character, as in `\M-a' for Meta-A or `\M-\C-a' for
1155: Control-Meta-A.
1156:
1157: Characters:
1158: Lisp character constant syntax consists of a `?' followed by
1159: either a character or an escape sequence starting with `\'.
1160: Examples: `?x', `?\n', `?\"', `?\)'. Note that strings and
1161: characters are not interchangeable in Lisp; some contexts require
1162: one and some contexts require the other.
1163:
1164: True:
1165: `t' stands for `true'.
1166:
1167: False:
1168: `nil' stands for `false'.
1169:
1170: Other Lisp objects:
1171: Write a single-quote (') followed by the Lisp object you want.
1172:
1173:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.