Mercurial > emacs
annotate etc/OTHER.EMACSES @ 51356:8da3b8a0ca4f
(DECODE_EMACS_MULE_COMPOSITION_CHAR): If coding->flags
is nonzero, accept multibyte form of eight-bit-control chars.
(decode_composition_emacs_mule): Likewise.
(decode_coding_emacs_mule): Likewise.
(encode_coding_emacs_mule): If coding->flags is nonzero, produce
multibyte form of eight-bit-control chars.
author | Kenichi Handa <handa@m17n.org> |
---|---|
date | Sat, 31 May 2003 00:56:42 +0000 |
parents | 23a1cea22d13 |
children | 695cf19ef79e |
rev | line source |
---|---|
25853 | 1 How is this Emacs different from all other Emacses? -*-Outline-*- |
2 | |
3 This file describes the differences between GNU Emacs 19, Twenex | |
4 Emacs, Gosling Emacs (including the commercial versions by Unipress) | |
5 and CCA Emacs. | |
6 | |
7 * Copyright (c) 1985 Richard M. Stallman | |
8 | |
9 Permission is granted to anyone to make or distribute verbatim copies | |
10 of this document as received, in any medium, provided that the | |
11 copyright notice and permission notice are preserved, | |
12 and that the distributor grants the recipient permission | |
13 for further redistribution as permitted by this notice. | |
14 | |
15 Permission is granted to distribute modified versions | |
16 of this document, or of portions of it, | |
17 under the above conditions, provided also that they | |
18 carry prominent notices stating who last changed them. | |
19 | |
20 Updated March 1993 for Emacs 19 by Eric S. Raymond | |
21 | |
22 | |
23 * How is this Emacs different from Twenex Emacs? | |
24 | |
25 ** Fundamental concepts. | |
26 | |
27 *** There is no concept of "typeout" in GNU Emacs. | |
28 | |
29 Any time that a command wants to display some output, | |
30 it creates a buffer (usually with a name surrounded by asterisks) | |
31 and displays it in a window. | |
32 | |
33 This provides some advantages: | |
34 you can edit some more while looking at the output; | |
35 you can copy parts of the output into other buffers. | |
36 | |
37 It also has a disadvantage that you must type a command | |
38 in order to make the output disappear. | |
39 You can use C-x 1 to get rid of all windows except the | |
40 selected one. To be more selective, you can switch to | |
41 the window you want to get rid of and then type C-x 0 | |
42 (delete-window). | |
43 | |
44 You also need to type a command to scroll the other | |
45 window if not all the output fits in it. Meta-Control-v | |
46 will usually do the job. | |
47 | |
48 *** There is no concept of a "subsystem" in GNU Emacs. | |
49 | |
50 Where Twenex Emacs would use a subsystem, GNU Emacs | |
51 instead creates a buffer and redefines commands in it. | |
52 | |
53 For example, when you send mail in GNU Emacs, you use | |
54 a buffer named *mail* which is in Mail Mode. You can | |
55 switch away from this buffer to any other buffer and | |
56 resume normal editing; then switch back and resume | |
57 composing mail. You do not have to "exit" from | |
58 composing mail in order to do ordinary editing. | |
59 | |
60 This has many advantages, but it also has a disadvantage: | |
61 Subsystems in Emacs tend to have "exit" commands that return you | |
62 to whatever you were doing before entering the subsystem. | |
63 In GNU Emacs the idea of what to return to is not well defined, | |
64 so it is not clear what an "exit" command should do. | |
65 The only way to "exit" in general is to type C-x b, C-x C-f, or | |
66 some other suitable command to switch buffers. Some | |
67 subsystem-like major modes, such as Info and Mail mode, provide | |
68 commands to "exit" by switching to the previously selected | |
69 buffer. | |
70 | |
71 *** Files are always visited in their own buffers. | |
72 | |
73 Beginning users of Twenex Emacs were told how to edit | |
74 using a single buffer and reading one file after another | |
75 into that buffer. Use of a new buffer for each file was | |
76 regarded as a more advanced mode. | |
77 | |
78 In GNU Emacs, the idea of using a single buffer for various | |
79 files, one by one, has been dropped, given that the address | |
80 space is expected to be large enough for many buffers. C-x | |
81 C-f (find-file), which behaves nearly the same as in Twenex | |
82 Emacs, is in GNU Emacs the canonical way for all users to | |
83 visit files. | |
84 | |
85 Various commands need to read files into Emacs in the course | |
86 of their execution. In Twenex Emacs the user must tell them | |
87 whether to reuse buffers or create new ones, using the variable | |
88 Tags Find File. In GNU Emacs, these commands always use | |
89 C-x C-f. | |
90 | |
91 The command C-x C-v does still exist; it kills the current | |
92 buffer and reads the specified file into a new buffer. | |
93 It is equivalent to kill-buffer followed by find-file. | |
94 | |
95 Since there is no reusing of buffers, there is no point in | |
96 calling the initial buffer "main". So the initial buffer | |
97 in GNU Emacs is called "*scratch*" and is intended for typing | |
98 Lisp expressions to be evaluated. | |
99 | |
100 *** File name defaulting. | |
101 | |
102 GNU Emacs records a separate working directory for each buffer. | |
103 Normally this is the directory on which the buffer's file | |
104 resides; for buffers not visiting any file, it is copied from | |
105 the buffer that was current when it was created. The current buffer's | |
106 working directory can be printed with M-x pwd and set with M-x cd. | |
107 | |
108 GNU Emacs shows you the default directory by inserting it in | |
109 the minibuffer when a file name is being read. You can type | |
110 the filename you want at the end of the default as if the | |
111 default were not there, or you can edit and alter the default. | |
112 | |
113 If you want file /lose/big when the default /foo/defaultdir/ | |
114 has been inserted for you, you need not kill the default; simply | |
115 type at the end of it: /foo/defaultdir//lose/big. Such a file | |
116 name is not ordinarily considered valid, but GNU Emacs | |
117 considers it equivalent to /lose/big. | |
118 | |
119 Likewise, if you want file quux in your home directory, just add | |
120 ~/quux to the end of the supplied text, to get | |
121 /foo/defaultdir/~/quux. GNU Emacs sees "/~" and throws away | |
122 everything before the "~". | |
123 | |
124 You can refer to environment variables also within file names. | |
125 $ followed by the environment variable name is replaced by the | |
126 variable's value. The variable name should either be followed | |
127 by a nonalphanumeric character (which counts as part of the | |
128 file name) or be surrounded by braces {...} (which do not count | |
129 as part of the file name). Thus, if variable USER has value "rms", | |
130 "x/$USER-foo" is expanded to "x/rms-foo", and "x${USER}foo" | |
131 is expanded to "xrmsfoo". Note that this substitution is not | |
132 performed by the primitive file operation functions of GNU Emacs, | |
133 but rather by the interactive file name reader. It is also | |
134 available as a separate primitive, in the function | |
135 substitute-in-file-name. | |
136 | |
137 *** Exit commands C-z, C-x C-c and C-x C-z. | |
138 | |
139 There are two ways to exit GNU Emacs: killing and suspending. | |
140 Killing is like what Control-c does to ordinary Unix programs. | |
141 In GNU Emacs, you type C-x C-c to kill it. (This offers to | |
142 save any modified file buffers before really killing Emacs.) | |
143 Suspending is like what Control-z does to ordinary Unix programs. | |
144 To suspend GNU Emacs, type C-x C-z, or type just C-z. | |
145 Note that C-z suspends ordinary programs instantly, but | |
146 Emacs does not suspend until it reads the C-z. | |
147 | |
148 Usually it is better to suspend: once a system is smart | |
149 enough to have job control, why ever kill an editor? | |
150 You'll just have to make a new one in a minute. | |
151 This is why the convenient command C-z is provided for | |
152 suspending. | |
153 | |
154 C-c is used as a prefix key for mode-specific commands and for users' | |
155 own commands. We deliberately do not make C-c ever kill Emacs, | |
156 because it should not be so easy to do something irreversible. | |
157 | |
158 *** Quitting with C-g. | |
159 | |
160 If you type C-g while GNU Emacs is waiting for input, it | |
161 is an ordinary command (which is defined to beep). If you | |
162 type C-g while Lisp code is executing, it sets a flag which | |
163 causes a special signal, nearly the same as an error, to | |
164 happen at the next safe place in Lisp execution. This usually | |
165 has the effect of aborting the current command in a safe way. | |
166 | |
167 Because at times there have been bugs causing GNU Emacs to loop | |
168 without checking the quit flag, a special feature causes | |
169 GNU Emacs to be suspended immediately if you type a second C-g | |
170 while the flag is already set. So you can always get out | |
171 of GNU Emacs. Normally GNU Emacs recognizes and clears the quit flag | |
172 quickly enough to prevent this from happening. | |
173 | |
174 When you resume GNU Emacs after a suspension caused by multiple C-g, it | |
175 asks two questions before resuming execution: | |
176 Checkpoint? | |
177 Dump core? | |
178 Answer each one with `y' or `n' and a Return. | |
179 `y' to Checkpoint? causes immediate auto-saving of all | |
180 buffers in which auto-saving is enabled. | |
181 `y' to Dump core? causes an illegal instruction to be executed. | |
182 This is to enable a wizard to figure out why GNU Emacs was | |
183 looping without checking for quits. Execution does not continue | |
184 after a core dump. If you answer `n', execution continues. | |
185 With luck, GNU Emacs will ultimately check the quit flag, | |
186 and quit normally. If not, and you type another C-g, it | |
187 is suspended again. | |
188 | |
189 If GNU Emacs is not really hung, just slow, you may invoke | |
190 the double C-g feature without really meaning to. Then just | |
191 resume and answer `n' to both questions, and you will | |
192 arrive at your former state. Presumably the quit you | |
193 wanted will finish happening soon. | |
194 | |
195 These questions are not asked if you suspend GNU Emacs with the C-z | |
196 command. Continuing GNU Emacs after a C-z takes you straight back | |
197 into editing. | |
198 | |
199 *** Undoing with C-x u or C-_ | |
200 | |
201 You can undo many commands--up to 10,000 characters worth. | |
202 Each time you type C-x u or C-_, another command or batch of change | |
203 is undone. Undo information is stored per buffer, and the undo | |
204 command always applies to the current buffer. A numeric argument | |
205 serves as a repeat count. | |
206 | |
207 Consecutive self-inserting characters are undone in groups of twenty. | |
208 | |
209 *** Different character set. | |
210 | |
211 GNU Emacs does not expect anyone ever to have a keyboard in which | |
212 the Control key sets an independent bit which may accompany any | |
213 character. The only control characters that can exist are the | |
214 ASCII control characters. | |
215 | |
216 There is, as a result, no "control prefix" character. | |
217 | |
218 *** Control-h is the Help character. | |
219 | |
220 I'm amazed it took me so long to get this idea. In Twenex Emacs, C-h | |
221 and C-b are equivalent commands, making C-h redundant. C-h is not | |
222 only easy to type, it is mnemonic for "Help". So in GNU Emacs the | |
223 Help character is C-h. | |
224 | |
225 *** Completion is done by TAB, not ESC. | |
226 | |
227 ESC in the minibuffer is a Meta prefix, same as at top level. | |
228 | |
229 *** The string-argument reader is the minibuffer is an editor window. | |
230 | |
231 In GNU Emacs, the line at the bottom of the screen is the minibuffer. | |
232 Commands that want string arguments always use this line to read them, | |
233 and you can use the ordinary Emacs editing commands to edit the | |
234 input. You can terminate input with Return because Return is defined | |
235 as the exit-minibuffer command when in the minibuffer. If you | |
236 are using a command that needs several arguments, terminate each | |
237 one with Return. You cannot separate arguments with Escape | |
238 the way you would in Twenex Emacs. | |
239 | |
240 The minibuffer window does not overlay other editor windows; | |
241 it is a nearly ordinary editor window which lacks a mode line | |
242 and is "turned off" when not in use. While it IS in use, you | |
243 can switch windows to and from the minibuffer, kill text in other | |
244 windows and yank in the minibuffer, etc. | |
245 | |
246 You can even issue a command that uses the minibuffer while in the | |
247 minibuffer. This gets you temporarily into a recursive minibuffer. | |
248 However, this is allowed only if you enable it, since it could be | |
249 confusing for beginners. | |
250 | |
251 When you exit the minibuffer, the cursor immediately moves back to | |
252 column zero of the minibuffer line, to show you that the exit | |
253 command has been obeyed. The minibuffer contents remain on the screen | |
254 until the end of the command, unless some other text is displayed there. | |
255 | |
256 A single Control-g exits the minibuffer. | |
257 | |
258 *** There are no &'s or ^R's or spaces in function names. | |
259 | |
260 For example, the function which is called ^R Forward Word | |
261 in Twenex Emacs is called forward-word in GNU Emacs. | |
262 | |
263 *** The extension language is Lisp rather than TECO. | |
264 | |
265 Libraries must be written in Lisp. Meta-ESC reads a Lisp | |
266 expression, evaluates it, and prints the result. Note that | |
267 Meta-ESC is "disabled" by default, so that beginning users | |
268 do not get into the minibuffer by accident in a confusing way. | |
269 | |
270 Data types available include integers (which double as characters), | |
271 strings, symbols, lists, vectors, buffers, buffer pointers, | |
272 windows, and process channels. | |
273 | |
274 For now, to learn about writing Lisp code for GNU Emacs, read some of | |
275 the source code, which is in directory ../lisp. Read the GNU Emacs Lisp | |
276 Reference Manual. Also, all Lisp primitives have self-documentation you can | |
277 read with C-h f. | |
278 | |
279 *** Enabling the error handler. | |
280 | |
281 GNU Emacs has a Lisp debugger/stepper/trace package, but normally | |
282 errors do not enter the debugger because that is slow, and unlikely to | |
283 be of interest to most users. Set the variable debug-on-error to t to | |
284 cause errors to invoke the debugger. Set debug-on-quit to cause quit | |
285 signals (caused by C-g) to invoke the debugger. | |
286 | |
287 ** Other changes. | |
288 | |
289 *** More than two windows are allowed. | |
290 | |
291 C-x 2 splits the current window into two windows, | |
292 one above the other. Initially they both display | |
293 the same buffer. | |
294 | |
295 C-x 2 now accepts a numeric argument to specify the number of | |
296 lines to give to the uppermost of the two windows it makes. | |
297 | |
298 C-x 0 kills the current window, making all others larger. | |
299 C-x 1 kills all windows except the current one. | |
300 C-x O switches to the next window down. | |
301 It rotates from the bottom one to the top one. | |
302 An argument serves as a repeat count; negative arguments | |
303 circulate in the reverse order. | |
304 | |
305 If the same buffer is displayed in several windows, | |
306 changes made in it are redisplayed in all of them. | |
307 | |
308 *** Side by side windows are supported. | |
309 | |
310 The command C-x 3 splits the current window into | |
311 two side-by-side windows. | |
312 | |
313 C-x } makes the selected window ARG columns wider at the | |
314 expense of the windows at its sides. C-x { makes the selected | |
315 window ARG columns narrower. An argument to C-x 5 specifies | |
316 how many columns to give to the leftmost of the two windows made. | |
317 | |
318 *** Horizontal scrolling of the lines in a window is implemented. | |
319 | |
320 C-x < (scroll-left) scrolls all displayed lines left, | |
321 with the numeric argument (default 1) saying how far to scroll. | |
322 When the window is scrolled left, some amount of the beginning | |
323 of each nonempty line is replaced by an "$". | |
324 C-x > scrolls right. If a window has no text hidden at the left | |
325 margin, it cannot be scrolled any farther right than that. | |
326 When nonzero leftwards scrolling is in effect in a window. | |
327 lines are automatically truncated at the window's right margin | |
328 regardless of the value of the variable truncate-lines in the | |
329 buffer being displayed. | |
330 | |
331 *** Return key does not use up empty lines. | |
332 | |
333 In Twenex Emacs, the Return command advances over an existing | |
334 empty line in some cases. In GNU Emacs, the Return command always | |
335 makes inserts a newline. Twenex Emacs was designed at a time when | |
336 most display terminals did not have the ability to scroll part | |
337 of the screen, and using existing empty lines made redisplay faster. | |
338 Nowadays, terminals that cannot scroll part of the screen are rare, | |
339 so there is no need to make Return behave in a more complicated manner. | |
340 | |
341 *** Help m. | |
342 | |
343 Typing C-h m displays documentation of the current major mode., | |
344 telling you what special commands and features are available | |
345 and how to use them or get more information on them. | |
346 | |
347 This is simply the documentation, as a function, of the | |
348 symbol which is the value of major-mode. Each major mode | |
349 function has been given documentation intended for C-h m. | |
350 | |
351 *** Display-hiding features. | |
352 | |
353 **** Hiding indented lines | |
354 | |
355 The command C-x $ with numeric argument N causes lines indented by N | |
356 or more columns to become invisible. All you see is " ..." appended | |
357 to the previous line, in place of any number of consecutive invisible | |
358 lines. | |
359 | |
360 **** Outline Mode. | |
361 | |
362 Outline mode is designed for editing outline-structured | |
363 files, such as this one. | |
364 | |
365 Headings should be lines starting with one or more asterisks. | |
366 Major headings have one asterisk, subheadings two, etc. | |
367 Lines not starting with asterisks are body text. | |
368 | |
369 You can make the body under a heading, or the subheadings | |
370 under a heading, temporarily invisible, or visible again. | |
371 Invisible lines are attached to the end of the previous line | |
372 so they go with it if you kill it and yank it back. | |
373 | |
374 Commands: | |
375 Meta-} next-visible-heading move by visible headings | |
376 Meta-{ previous-visible-heading move by visible headings | |
377 | |
378 Meta-x hide-body make all body text invisible (not headings). | |
379 Meta-x show-all make everything in buffer visible. | |
380 | |
381 The remaining commands are used when dot is on a heading line. | |
382 They apply to some of the body or subheadings of that heading. | |
383 C-c C-h hide-subtree make text and subheadings invisible. | |
384 C-c C-s show-subtree make text and subheadings visible. | |
385 C-c C-i show-children make direct subheadings visible. | |
386 No effect on body, or subheadings 2 or more levels down. | |
387 With arg N, affects subheadings N levels down. | |
388 M-x hide-entry make immediately following body invisible. | |
389 M-x show-entry make it visible. | |
390 M-x hide-leaves make text under heading and under its subheadings invisible. | |
391 The subheadings remain visible. | |
392 M-x show-branches make all subheadings at all levels visible. | |
393 | |
394 *** C mode is fancy. | |
395 | |
396 C mode assumes that you put the initial open-brace of | |
397 a function definition at the beginning of a line. | |
398 If you use the popular indenting style that puts this | |
399 open-brace at the end of a line containing a type declaration, | |
400 YOU WILL LOSE: C mode does not know a function starts there. | |
401 | |
402 Open-brace at the beginning of a line makes it possible | |
403 for C mode to find function boundaries with total reliability; | |
404 something I consider vital and which cannot be done | |
405 if the other style is used. | |
406 | |
407 The Tab command indents C code very cleverly. | |
408 I know of only one cases in which Tab does not indent C code nicely: | |
409 Expressions continued over several lines with few parentheses. | |
410 Tab does not know the precedences of C operators, so it does | |
411 not know which lines of the expression should go where. | |
412 Using parentheses to indicate the nesting of operators | |
413 except within a line makes this problem go away. | |
414 | |
415 The indenting algorithm is entirely written in Lisp. | |
416 | |
417 Tab with a numeric argument in Twenex Emacs indents | |
418 that many lines. It is different in GNU Emacs: it means | |
419 to shift all the lines of a bracketed expression by the | |
420 same amount as the line being indented. For example, if you have | |
421 if (foo) | |
422 { | |
423 hack (); | |
424 /** Well? */ | |
425 } | |
426 and type C-u Tab on the line with the open brace, you get | |
427 if (foo) | |
428 { | |
429 hack (); | |
430 /* Well? */ | |
431 } | |
432 from indenting the brace line and then shifting the | |
433 lines within the braces rigidly with the first one. | |
434 | |
435 Meta-Control-q works as in Lisp mode; it should be | |
436 used with dot just before a bracketed grouping, and | |
437 indents each line INSIDE that grouping using Tab. | |
438 If used instead of C-u Tab in the previous example, it makes | |
439 if (foo) | |
440 { | |
441 hack (); | |
442 /* Well? */ | |
443 } | |
444 | |
445 Meta-Control-h puts mark at the end of the current C function | |
446 and puts dot before it. | |
447 | |
448 Most other Meta-Control commands intended for Lisp expressions | |
449 work usefully in C mode as well. | |
450 | |
451 *** Meta-g (fill-region) is different. | |
452 | |
453 In Twenex Emacs, Meta-g fills the region with no paragraph | |
454 boundaries except for blank and indented lines. In GNU Emacs, | |
455 it divides the region into paragraphs in the same manner as | |
456 Meta-], and fills each paragraph separately. There is also | |
457 the function fill-region-as-paragraph which fills the region | |
458 regarding at as a single paragraph regardless even of blank | |
459 or indented lines. | |
460 | |
461 *** Indented Text Mode instead of Edit Indented Text. | |
462 | |
463 Twenex Emacs has a command Edit Indented Text which temporarily | |
464 alters some commands for editing indented paragraphs. | |
465 GNU Emacs has instead a separate major mode, Indented Text Mode, | |
466 which is different from ordinary Text Mode in just the same | |
467 alterations. Specifically, in Indented Text Mode, | |
468 Tab runs the function indent-relative, and auto filling indents | |
469 the newly created lines. | |
470 | |
471 *** But rectangle commands are implemented. | |
472 | |
473 C-x r r stores the rectangle described by dot and mark | |
474 into a register; it reads the register name from the keyboard. | |
475 C-x r g, the command to insert the contents of a register, | |
476 can be used to reinsert the rectangle elsewhere. | |
477 | |
478 Other rectangle commands include | |
479 open-rectangle: | |
480 insert a blank rectangle in the position and size | |
481 described by dot and mark, at its corners; | |
482 the existing text is pushed to the right. | |
483 clear-rectangle: | |
484 replace the rectangle described by dot ane mark | |
485 with blanks. The previous text is deleted. | |
486 delete-rectangle: | |
487 delete the text of the specified rectangle, | |
488 moving the text beyond it on each line leftward. | |
489 kill-rectangle | |
490 like delete-rectangle but also stores the text of | |
491 the rectangle in the "rectangle kill buffer". | |
492 More precisely, it stores the text as a list of strings | |
493 (one string for each line) in the variable killed-rectangle. | |
494 yank-rectangle | |
495 inserts the text of the last killed rectangle. | |
496 extract-rectangle and delete-extract-rectangle | |
497 these functions return the text of a rectangle | |
498 as a list of strings. They are for use in writing | |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
25853
diff
changeset
|
499 other functions that operate on rectangles. |
25853 | 500 |
501 *** Keyboard Macros | |
502 | |
503 The C-x ( command for defining a keyboard macro can in GNU Emacs | |
504 be given a numeric argument, which means that the new macro | |
505 starts out not empty but rather as the same as the last | |
506 keyboard macro entered. In addition, that last keyboard | |
507 macro is replayed when the C-x ( is typed. C-x ( with an | |
508 argument is thus equivalent to typing plain C-x ( and then | |
509 retyping the last keyboard macro entered. | |
510 | |
511 The command write-kbd-macro and append-kbd-macro can be used to | |
512 save a keyboard macro definition in a file. It is represented as | |
513 a Lisp expression which, when evaluated, will define the keyboard | |
514 macro. write-kbd-macro writes the specified file from scratch, | |
515 whereas append-kbd-macro adds to any existing text in the file. | |
516 Both expect the keyboard macro to be saved to be specified by | |
517 name; this means you must use the command name-last-kbd-macro to | |
518 give the macro a name before you can save it. | |
519 | |
520 *** The command to resume a terminated tags-search or tags-query-replace | |
521 | |
522 is Meta-comma in GNU Emacs. | |
523 | |
524 *** Auto Save is on by default. | |
525 | |
526 Auto Save mode is enabled by default in all buffers | |
527 that are visiting files. | |
528 | |
529 The file name used for auto saving is made by prepending | |
530 "#" to the file name visited. | |
531 | |
532 *** Backup files. | |
533 | |
534 Since Unix stupidly fails to have file version numbers, | |
535 GNU Emacs compensates slightly in the customary fashion: | |
536 when a file is modified and saved for the first time in | |
537 a particular GNU Emacs run, the original file is renamed, | |
538 appending "~" to its name. Thus, foo.c becomes foo.c~. | |
539 | |
540 Emacs can also put a version number into the name of the backup file, | |
541 as in foo.c.~69~ for version number 69. This is an optional feature | |
542 that the user has to enable. | |
543 | |
544 *** Mode Line differences. | |
545 | |
546 Each window in GNU Emacs has its own mode line, which always | |
547 displays the status of that window's buffer and nothing else. | |
548 The mode line appears at the bottom of the window. It is | |
549 full of dashes, to emphasize the boundaries between windows, | |
550 and is displayed in inverse video if the terminal supports it. | |
551 The information usually available includes: | |
552 | |
553 *** Local Modes feature changed slightly. | |
554 | |
555 GNU Emacs supports local mode lists much like those in Twenex Emacs, | |
556 but you can only set variables, not commands. You write | |
557 | |
558 Local variables: | |
559 tab-width: 10 | |
560 end: | |
561 | |
562 in the last page of a file, if you want to make tab-width be ten in a | |
563 file's buffer. The value you specify must be a Lisp object! | |
564 It will be read, but not evaluated. So, to specify a string, | |
565 you MUST use doublequotes. For "false", in variables whose | |
566 meanings are true or false, you MUST write nil . | |
567 | |
568 Two variable names are special: "mode" and "eval". | |
569 Mode is used for specifying the major mode (as in Twenex Emacs). | |
570 | |
571 mode: text | |
572 | |
573 specifies text mode. Eval is used for requesting the evaluation | |
574 of a Lisp expression; its value is ignored. Thus, | |
575 | |
576 eval: (set-syntax-table lisp-mode-syntax-table) | |
577 | |
578 causes Lisp Mode syntax to be used. | |
579 | |
580 | |
581 Note that GNU Emacs looks for the string "Local variables:" | |
582 whereas Twenex Emacs looks for "Local modes:". This incompatibility | |
583 id deliberate, so that neither one will see local settings | |
584 intended for the other. | |
585 | |
586 *** Lisp code libraries. | |
587 | |
588 Libraries of commands, and init files, are written in Lisp. | |
589 libraries conventionally have names ending in .el, while the | |
590 init file is named .emacs and is in your home directory. | |
591 | |
592 Use Meta-x load-library to load a library. Most standard libraries | |
593 load automatically if you try to use the commands in them. | |
594 | |
595 Meta-x byte-compile-file filename | |
596 compiles the file into byte code which loads and runs faster | |
597 than Lisp source code. The file of byte code is given a name | |
598 made by appending "c" to the end of the input file name. | |
599 | |
600 Meta-x byte-recompile-directory directoryname | |
601 compiles all files in the specified directory (globbing not allowed) | |
602 which have been compiled before but have been changed since then. | |
603 | |
604 Meta-x load-library automatically checks for a compiled file | |
605 before loading the source file. | |
606 | |
607 Libraries once loaded do not retain their identity within GNU | |
608 Emacs. Therefore, you cannot tell just what was loaded from a | |
609 library, and you cannot un-load a library. Normally, libraries | |
610 are written so that loading one has no effect on the editing | |
611 operations that you would have used if you had not loaded the | |
612 library. | |
613 | |
614 *** Dired features. | |
615 | |
616 You can do dired on partial directories --- any pattern | |
617 the shell can glob. Dired creates a buffer named after | |
618 the directory or pattern, so you can dired several different | |
619 directories. If you repeat dired on the same directory or | |
620 pattern, it just reselects the same buffer. Use Meta-x Revert | |
621 on that buffer to read in the current contents of the directory. | |
622 | |
623 *** Directory listing features. | |
624 | |
625 C-x C-d now uses the default output format of `ls', | |
626 which gives just file names in multiple columns. | |
627 C-u C-x C-d passes the -l switch to `ls'. | |
628 | |
629 Both read a directory spec from the minibuffer. It can | |
630 be any pattern that the shell can glob. | |
631 | |
632 *** Compiling other programs. | |
633 | |
634 Meta-x compile allows you to run make, or any other compilation | |
635 command, underneath GNU Emacs. Error messages go into a buffer whose | |
636 name is *compilation*. If you get error messages, you can use the | |
637 command C-x ` (that is a backquote) to find the text of the next | |
638 error message. | |
639 | |
640 You must specify the command to be run as an argument to M-x compile. | |
641 A default is placed in the minibuffer; you can kill it and start | |
642 fresh, edit it, or just type Return if it is what you want. | |
643 The default is the last compilation command you used; initially, | |
644 it is "make -k". | |
645 | |
646 *** Searching multiple files. | |
647 | |
648 Meta-x grep searches many files for a regexp by invoking grep | |
649 and reading the output of grep into a buffer. You can then | |
650 move to the text lines that grep found, using the C-x ` command | |
651 just as after M-x compile. | |
652 | |
653 *** Running inferior shells. | |
654 | |
655 Do Meta-x shell to make an inferior shell together with a buffer | |
656 which serves to hold "terminal" input and output of the shell. | |
657 The shell used is specified by the environment variable ESHELL, | |
658 or by SHELL if ESHELL is not set. | |
659 | |
660 Use C-h m whilst in the *shell* buffer to get more detailed info. | |
661 | |
662 The inferior shell loads the file .emacs_csh or.emacs_sh | |
663 (or similar using whatever name the shell has) when it starts up. | |
664 | |
665 M-! executes a shell command in an inferior shell | |
666 and displays the output from it. With a prefix argument, | |
667 it inserts the output in the current buffer after dot | |
668 and sets the mark after the output. The shell command | |
669 gets /dev/null as its standard input. | |
670 | |
671 M-| is like M-! but passes the contents of the region | |
672 as input to the shell command. A prefix argument makes | |
673 the output from the command replace the contents of the region. | |
674 | |
675 *** Sending mail. | |
676 | |
677 Once you enter Mail Mode using C-x m or C-x 4 m or M-x mail, | |
678 C-c becomes a prefix character for mail-related editing commands. | |
679 C-c C-s is vital; that's how you send the message. C-c C-c sends | |
680 and then switches buffers or kills the current window. | |
681 Use C-h m to get a list of the others. | |
682 | |
683 *** Regular expressions. | |
684 | |
685 GNU Emacs has regular expression facilities like those of most | |
686 Unix editors, but more powerful: | |
687 | |
688 **** -- + -- | |
689 | |
690 + specifies repetition of the preceding expression 1 or more | |
691 times. It is in other respect like *, which specifies repetition | |
692 0 or more times. | |
693 | |
694 **** -- ? -- | |
695 | |
696 ? is like * but matches at most one repetition of the preceding | |
697 expression. | |
698 | |
699 **** -- \| -- | |
700 | |
701 \| specifies an alternative. Two regular expressions A and B with \| in | |
702 between form an expression that matches anything that either A or B will | |
703 match. Thus, "foo\|bar" matches either "foo" or "bar" but no other | |
704 string. | |
705 | |
706 \| applies to the larges possible surrounding expressions. Only a | |
707 surrounding \( ... \) grouping can limit the grouping power of \|. | |
708 | |
709 Full backtracking capability exists when multiple \|'s are used. | |
710 | |
711 **** -- \( ... \) -- | |
712 | |
713 \( ... \) are a grouping construct that serves three purposes: | |
714 | |
715 1. To enclose a set of \| alternatives for other operations. | |
716 Thus, "\(foo\|bar\)x" matches either "foox" or "barx". | |
717 2. To enclose a complicated expression for * to operate on. | |
718 Thus, "ba\(na\)*" matches "bananana", etc., with any number | |
719 of na's (zero or more). | |
720 3. To mark a matched substring for future reference. | |
721 | |
722 Application 3 is not a consequence of the idea of a parenthetical | |
723 grouping; it is a separate feature which happens to be assigned as a | |
724 second meaning to the same \( ... \) construct because there is no | |
725 conflict in practice between the two meanings. Here is an explanation | |
726 of this feature. | |
727 | |
728 -- \digit -- | |
729 | |
730 After the end of a \( ... \) construct, the matcher remembers the | |
731 beginning and end of the text matched by that construct. Then, later on | |
732 in the regular expression, you can use \ followed by a digit to mean, | |
733 ``match the same text matched this time by the \( ... \) construct.'' | |
734 The first nine \( ... \) constructs that appear in a regular expression | |
735 are assigned numbers 1 through 9 in order of their beginnings. \1 | |
736 through \9 can be used to refer to the text matched by the corresponding | |
737 \( ... \) construct. | |
738 | |
739 For example, "\(.*\)\1" matches any string that is composed of two | |
740 identical halves. The "\(.*\)" matches the first half, which can be | |
741 anything, but the \1 that follows must match the same exact text. | |
742 | |
743 **** -- \` -- | |
744 | |
745 Matches the empty string, but only if it is at the beginning of the buffer. | |
746 | |
747 **** -- \' -- | |
748 | |
749 Matches the empty string, but only if it is at the end of the buffer. | |
750 | |
751 **** -- \b -- | |
752 | |
753 Matches the empty string, but only if it is at the beginning or end of | |
754 a word. Thus, "\bfoo\b" matches any occurrence of "foo" as a separate word. | |
755 "\bball\(s\|\)\b" matches "ball" or "balls" as a separate word. | |
756 | |
757 **** -- \B -- | |
758 | |
759 Matches the empty string, provided it is NOT at the beginning or end of | |
760 a word. | |
761 | |
762 **** -- \< -- | |
763 | |
764 Matches the empty string, provided it is at the beginning of a word. | |
765 | |
766 **** -- \> -- | |
767 | |
768 Matches the empty string, provided it is at the end of a word. | |
769 | |
770 **** -- \w -- | |
771 | |
772 Matches any word-constituent character. The editor syntax table determines | |
773 which characters these are. | |
774 | |
775 **** -- \W -- | |
776 | |
777 Matches any character that is not a word-constituent. | |
778 | |
779 **** -- \s<code> -- | |
780 | |
781 Matches any character whose syntax is <code>. <code> is a letter that | |
782 represents a syntax code: thus, "w" for word constituent, "-" for | |
783 whitespace, "(" for open-parenthesis, etc. Thus, "\s(" matches any | |
784 character with open-parenthesis syntax. | |
785 | |
786 **** -- \S<code> -- | |
787 | |
788 Matches any character whose syntax is not <code>. | |
789 | |
790 * How is this Emacs different from Gosling Emacs? | |
791 | |
792 ** Advantages of Gosling Emacs: | |
793 | |
794 1. The program itself is much smaller. | |
795 GNU Emacs uses about 250k more pure storage. | |
796 As a result, Gosling Emacs can run on machines | |
797 that cannot run GNU Emacs. There is not much difference | |
798 in the amount of impure storage in the two programs. | |
799 | |
800 2. In some versions there is support for other forks to | |
801 establish communications channels to Emacs (using sockets?). | |
802 | |
803 3. There is a direct interface to dbm (data bases). | |
804 | |
805 ** Advantages of GNU Emacs: | |
806 | |
807 *** True Lisp, not Mocklisp. | |
808 | |
809 GNU Emacs's extension language has real symbols, lists | |
810 and vectors. Many extensions are much simpler, and some | |
811 become possible that were nearly impossible in Gosling Emacs. | |
812 Many primitives can have cleaner interfaces, and some features | |
813 need not be put in as special primitives because you can do | |
814 them easily yourself. | |
815 | |
816 *** But Mocklisp still works. | |
817 | |
818 An automatic conversion package plus a run-time library | |
819 allows you to convert a Mocklisp library into a Lisp library. | |
820 | |
821 *** Commands are better crafted. | |
822 | |
823 For example, nearly every editing function for which a | |
824 numeric argument would make sense as a repeat count does | |
825 accept a repeat count, and does handle a negative argument | |
826 in the way you would expect. | |
827 | |
828 *** The manual is clearer. | |
829 | |
830 Everyone tells me it is a very good manual. | |
831 | |
832 *** Better on-line documentation. | |
833 | |
834 Both functions and variables have documentation strings that | |
835 describe exactly how to use them. | |
836 | |
837 *** C mode is smart. | |
838 | |
839 It really knows how to indent each line correctly, | |
840 for most popular indentation styles. (Some variables | |
841 control which style is used; popular named styles are also supported.) | |
842 | |
843 *** Compatible with PDP-10 Emacs, Multics Emacs and Zmacs. | |
844 | |
845 The commands in GNU Emacs are nearly the same as in the | |
846 original Emacs and the other Emacses which imitated it. | |
847 (A few have been changed to fit the Unix environment better.) | |
848 | |
849 *** Support for Gosling's Emacs commands. | |
850 | |
851 M-x set-gosmacs-bindings rebinds many editing commands for | |
852 compatibility with Gosling's Emacs. | |
853 M-x set-gnu-bindings reverses the change. | |
854 | |
855 *** Side-by-side windows. | |
856 | |
857 You can split a GNU Emacs window either horizontally or | |
858 vertically. | |
859 | |
860 *** Redisplay is faster. | |
861 | |
862 GNU Emacs sends about the same stuff to the terminal that | |
863 Gosling's does, but GNU Emacs uses much less CPU time to | |
864 decide what to do. | |
865 | |
866 *** Entirely termcap-driven. | |
867 | |
868 GNU Emacs has nearly no special code for any terminal type. Various | |
869 new termcap strings make it possible to handle all terminals nearly as | |
870 fast as they could be handled by special-case code. | |
871 | |
872 *** Display-hiding features. | |
873 | |
874 For example, Outline Mode makes it possible for you to edit | |
875 an outline, making entire sub-branches of the outline visible | |
876 or invisible when you wish. | |
877 | |
878 *** You can interrupt with Control-G. | |
879 | |
880 Even a looping Lisp program can be stopped this way. | |
881 And even a loop in C code does not stop you from killing | |
882 Emacs and getting back to your shell. | |
883 | |
884 *** Per-buffer Undo. | |
885 | |
886 You can undo the last several changes, in each buffer | |
887 independently. | |
888 | |
889 *** The editor code itself is clean. | |
890 | |
891 Many people have remarked on how much they enjoy reading | |
892 the code for GNU Emacs. | |
893 | |
894 One other note: The program etc/cvtmail that comes with GNU Emacs can | |
895 be used to convert a mail directory for Gosling Emacs's Rmail into a | |
896 Unix mail file that you could read into GNU Emacs's Rmail. | |
897 | |
898 * How is this Emacs different from CCA Emacs? | |
899 | |
900 ** GNU Emacs Lisp vs CCA Elisp. | |
901 | |
902 GNU Emacs Lisp does not have a distinction between Lisp functions | |
903 and Emacs functions, or between Lisp variables and Emacs variables. | |
904 The Lisp and the editor are integrated. A Lisp function defined | |
905 with defun is callable as an editor command if you put an | |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
25853
diff
changeset
|
906 interactive calling spec in it; for example, |
25853 | 907 (defun forward-character (n) |
908 (interactive "p") | |
909 (goto-char (+ (point) n))) | |
910 defines a function of one argument that moves point forward by | |
911 a specified number of characters. Programs could call this function, | |
912 as in (forward-character 6), or it could be assigned to a key, | |
913 in which case the "p" says to pass the prefix numeric arg as | |
914 the function's argument. As a result of this feature, you often | |
915 need not have two different functions, one to be called by programs | |
916 and another to read arguments from the user conveniently; the same | |
917 function can do both. | |
918 | |
919 CCA Elisp tries to be a subset of Common Lisp and tries to | |
920 have as many Common Lisp functions as possible (though it is still | |
921 only a small fraction of full Common Lisp). GNU Emacs Lisp | |
922 is somewhat similar to Common Lisp just because of my Maclisp | |
923 and Lisp Machine background, but it has several distinct incompatibilities | |
924 in both syntax and semantics. Also, I have not attempted to | |
925 provide many Common Lisp functions that you could write in Lisp, | |
926 or others that provide no new capability in the circumstances. | |
927 | |
928 GNU Emacs Lisp does not have packages, readtables, or character objects | |
929 (it uses integers to represent characters). | |
930 | |
931 On the other hand, windows, buffers, relocatable markers and processes | |
932 are first class objects in GNU Emacs Lisp. You can get information about them | |
933 and do things to them in a Lispy fashion. Not so in CCA Emacs. | |
934 | |
935 In GNU Emacs Lisp, you cannot open a file and read or write characters | |
936 or Lisp objects from it. This feature is painful to support, and | |
937 is not fundamentally necessary in an Emacs, because instead you | |
938 can read the file into a buffer, read or write characters or | |
939 Lisp objects in the buffer, and then write the buffer into the file. | |
940 | |
941 On the other hand, GNU Emacs Lisp does allow you to rename, delete, add | |
942 names to, and copy files; also to find out whether a file is a | |
943 directory, whether it is a symbolic link and to what name, whether | |
944 you can read it or write it, find out its directory component, | |
945 expand a relative pathname, find completions of a file name, etc., | |
946 which you cannot do in CCA Elisp. | |
947 | |
948 GNU Emacs Lisp uses dynamic scope exclusively. This enables you to | |
949 bind variables which affect the execution of the editor, such as | |
950 indent-tabs-mode. | |
951 | |
952 GNU Emacs Lisp code is normally compiled into byte code. Most of the | |
953 standard editing commands are written in Lisp, and many are | |
954 dumped, pure, in the Emacs that users normally run. | |
955 | |
956 GNU Emacs allows you to interrupt a runaway Lisp program with | |
957 Control-g. | |
958 | |
959 ** GNU Emacs Editing Advantages | |
960 | |
961 GNU Emacs is faster for many things, especially insertion of text | |
962 and file I/O. | |
963 | |
964 GNU Emacs allows you to undo more than just the last command | |
965 with the undo command (C-x u, or C-_). You can undo quite a ways back. | |
966 Undo information is separate for each buffer; changes in one buffer | |
967 do not affect your ability to undo in another buffer. | |
968 | |
969 GNU Emacs commands that want to display some output do so by putting | |
970 it in a buffer and displaying that buffer in a window. This | |
971 technique comes from Gosling Emacs. It has both advantages and | |
972 disadvantages when compared with the technique, copied by CCA Emacs | |
973 from my original Emacs which inherited it from TECO, of having "type | |
974 out" which appears on top of the text in the current window but | |
975 disappears automatically at the next input character. | |
976 | |
977 GNU Emacs does not use the concept of "subsystems". Instead, it uses | |
978 highly specialized major modes. For example, dired in GNU Emacs has | |
979 the same commands as dired does in other versions of Emacs, give or | |
980 take a few, but it is a major mode, not a subsystem. The advantage | |
981 of this is that you do not have to "exit" from dired and lose the | |
982 state of dired in order to edit files again. You can simply switch | |
983 to another buffer, and switch back to the dired buffer later. You | |
984 can also have several dired buffers, looking at different directories. | |
985 | |
986 It is still possible to write a subsystem--your own command loop-- | |
987 in GNU Emacs, but it is not recommended, since writing a major mode | |
988 for a special buffer is better. | |
989 | |
990 Recursive edits are also rarely used, for the same reason: it is better | |
991 to make a new buffer and put it in a special major mode. Sending | |
992 mail is done this way. | |
993 | |
994 GNU Emacs expects everyone to use find-file (C-x C-f) for reading | |
995 in files; its C-x C-v command kills the current buffer and then finds | |
996 the specified file. | |
997 | |
998 As a result, users do not need to think about the complexities | |
999 of subsystems, recursive edits, and various ways to read in files | |
1000 or what to do if a buffer contains changes to some other file. | |
1001 | |
1002 GNU Emacs uses its own format of tag table, made by the "etags" | |
1003 program. This format makes finding a tag much faster. | |
1004 | |
1005 Dissociated Press is supported. | |
1006 | |
1007 | |
1008 ** GNU Emacs Editing Disadvantages. | |
1009 | |
1010 GNU Emacs does not display the location of the mark. | |
1011 | |
1012 GNU Emacs does not have a concept of numbers of buffers, | |
1013 or a permanent ordering of buffers, or searching through multiple | |
1014 buffers. The tags-search command provides a way to search | |
1015 through several buffers automatically. | |
1016 | |
1017 GNU Emacs does not provide commands to visit files without | |
1018 setting the buffer's default directory. Users can write such | |
1019 commands in Lisp by copying the code of the standard file | |
1020 visiting commands and modifying them. | |
1021 | |
1022 GNU Emacs does not support "plus options" in the command | |
1023 arguments or in buffer-selection commands, except for line numbers. | |
1024 | |
1025 GNU Emacs does not support encryption. Down with security! | |
1026 | |
1027 GNU Emacs does not support replaying keystroke files, | |
1028 and does not normally write keystroke files. | |
1029 | |
1030 | |
1031 ** Neutral Differences | |
1032 | |
1033 GNU Emacs uses TAB, not ESC, to complete file names, buffer names, | |
1034 command names, etc. | |
1035 | |
1036 GNU Emacs uses LFD to terminate searches, instead of | |
1037 the C-d uses by CCA Emacs. (Actually, this character is controlled | |
1038 by a parameter in GNU Emacs.) C-M-s in GNU Emacs is an interactive | |
1039 regular expression search, but you can get to a noninteractive | |
1040 one by typing ESC right after the C-M-s. | |
1041 | |
1042 In GNU Emacs, C-x s asks, for each modified file buffer, whether | |
1043 to save it. | |
1044 | |
1045 GNU Emacs indicates line continuation with "\" and line | |
1046 truncation (at either margin) with "$". | |
1047 | |
1048 The command to resume a tags-search or tags-query-replace in | |
1049 GNU Emacs is Meta-Comma. |