![[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.