home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / bbs / may94 / util / edit / jade.lha / Jade / doc / jade.doc < prev    next >
Text File  |  1994-04-20  |  92KB  |  2,533 lines
  1. This is Edition 1, last updated 19 April 1994, of `The Jade Manual',
  2. for Jade, Version 3.0.
  3.  
  4.    Jade is a text editor for Unix (with X11) and the Amiga.
  5.  
  6.    Copyright 1993, 1994 John Harper.
  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 that
  14. the entire resulting derived work is distributed under the terms of a
  15. permission notice identical to this one.
  16.  
  17.    This is so that jade doesn't try to eval the example use.
  18. ::jade-code::
  19. ::end::
  20.  
  21. Jade
  22. ****
  23.  
  24.    Jade is a highly flexible text editor for the Unix (with X11) and
  25. Amiga operating systems.
  26.  
  27.    This is Edition 1 of its documentation, last updated 19 April 1994
  28. for Jade version 3.0.
  29.  
  30. Copying
  31. *******
  32.  
  33.    Jade is distributed under the terms of the GNU General Public
  34. License, this basically means that you can give it to anyone for any
  35. price as long as full source code is included. For the actual legalese
  36. see the file `COPYING' in the distribution. I reserve the right to use
  37. a different license in future releases.
  38.  
  39.    The only parts of Jade which are not my own work are the regexp
  40. code, this is by Henry Spencer (though I have made some small
  41. modifications) and is distributed under his conditions, and the ARexx
  42. interface in the Amiga version which is based on `MinRexx' by Radical
  43. Eye Software.
  44.  
  45.    Be aware that there is absolutely NO WARRANTY for this program, you
  46. use it at your own risk. Obviously I hope there are no bugs, but I make
  47. no promises reguarding the reliability of this software.
  48.  
  49. Introduction
  50. ************
  51.  
  52.    Jade is a text editor primarily designed for programmers. It is
  53. easily customised through a Lisp-style extension language and can be
  54. tailored to the user's own requirements.
  55.  
  56.    Jade is designed to run under a graphical windowing system, systems
  57. currently supported are the Commodore Amiga and the X Window System
  58. version 11 (but only under Unix).
  59.  
  60.    It is the successor to the editor `Jed 2.10' which I released for the
  61. Amiga in early 1993. I have decided to rename it now that I have made a
  62. Unix version since there is already an editor called `Jed' available
  63. (there is no connection between the two, I haven't even looked at the
  64. other one). "Jade" is an anagram of "A Jed", if you want an acronym you
  65. could use "Just Another Damn Editor", if you can think of anything
  66. better please tell me.
  67.  
  68.    Jade is compatible with GNU Emacs in terms of keystrokes and command
  69. names to a certain extent but it is not intended as a simple copy of
  70. Emacs (indeed, when I started this I had never actually used Emacs!). I
  71. have tried to take my favourite aspects of all the editors I have used
  72. as well as adding features that I have not found elsewhere.
  73. Consequently, it is very much the editor that *I* want -- you may not
  74. find it so appealing.
  75.  
  76.    The feature that the most people will dislike is that it doesn't
  77. support "proper" tabs. By this I mean that it expands all tabs to a
  78. sequence of spaces when loading a file, they are not converted back to
  79. tabs until the file is saved back to disk (though this is optional).
  80.  
  81. Requirements
  82. ************
  83.  
  84.    Jade will only run on certain operating systems, this chapter
  85. details just what it needs as well as some notes relevant to each
  86. system.
  87.  
  88. Amiga Jade
  89. ==========
  90.  
  91.    The only real requirement for Jade running on an Amiga is that it
  92. must run an operating system revision of at least V37 (thats V2.04) and
  93. have about 300K free memory available.
  94.  
  95.    It also needs more stack than the average Amiga application. For
  96. normal use 20K should be okay. If you want to use the Lisp compiler 50K
  97. would be a better bet.
  98.  
  99.    It assumes that its directory is pointed to by the `JADE:'
  100. assignment.  This means that the main Lisp files are stored in
  101. `JADE:lisp/' and the file of doc-strings is `JADE:DOC-strings'.
  102.  
  103. Unix and X11 Jade
  104. =================
  105.  
  106.    Jade will only run on version 11 of X, it has absolutely no support
  107. for character terminals or different windowing systems. As long as it
  108. compiles it should work on your system.
  109.  
  110.    One problem you might find is that the BackSpace and Delete keys
  111. don't work properly. As far as I have been able to find out, most X
  112. terminals map both the BackSpace (normally at the top-right of the
  113. alpha-keyboard) and the Delete (normally somewhere above the cursor
  114. keys) keys to the `Delete' keysym. Obviously, since I want these keys
  115. to have different effects (1) this is no good. What I decided to do
  116. about this was two things,
  117.  
  118.   1. Use `xmodmap' to map the Delete key to the `BackSpace' keysym.
  119.      This may sound backwards but most programs seem to use the
  120.      `Delete' keysym as what I call `BackSpace' so mapping as I
  121.      described doesn't break this.
  122.  
  123.      To do this, I have the following in my `.Xmodmap' file
  124.  
  125.           keycode 107 = BackSpace
  126.  
  127.      Note that the `107' is the Delete key's keycode on *my* keyboard,
  128.      your keyboard may, and probably will, be different.
  129.  
  130.   2. In the function which binds descriptions of keystrokes to Lisp
  131.      forms, swap the meanings of the `BackSpace' and `Delete' keysyms.
  132.  
  133.    This means that everything works okay! You can bind to Delete key
  134. and it will work properly.
  135.  
  136.    ---------- Footnotes ----------
  137.  
  138.    (1)  BackSpace should rub out the key before the cursor and Delete
  139. should delete the character under the cursor
  140.  
  141. Editor Concepts
  142. ***************
  143.  
  144.    Before I describe the editor in detail there are several concepts
  145. which you should be familiar with. Some will be explained in more
  146. detail later.
  147.  
  148. "buffer"
  149.      Buffers are used by the editor to store the text that you are
  150.      editing.  Broadly speaking, each buffer holds the contents of one
  151.      text-file loaded into the editor (it is not necessary for each
  152.      buffer to be associated with a file, some buffers exist for other
  153.      purposes for example the `*jade*' buffer is used to interact with
  154.      the Lisp system.
  155.  
  156. "current buffer"
  157.      The buffer being edited in the current window (see below), most
  158.      editor commands work on this buffer unless told otherwise.
  159.  
  160. "window"
  161.      Corresponds to a window in the window-system. Each window can
  162.      display one buffer at a single time (although a buffer may be
  163.      displayed in more than one window at once).
  164.  
  165. "current window"
  166.      Jade always keeps track of which one of its windows is active. It
  167.      is called the current window. Whenever you type a key or press a
  168.      mouse button in one of Jade's windows, that window automatically
  169.      becomes the current window.  Amongst other things, all messages
  170.      from the editor are displayed in the status line of the current
  171.      window.
  172.  
  173. "cursor"
  174.      The cursor marks your current position in the current buffer (see
  175.      above), when you type something it is inserted into the buffer
  176.      between the cursor and the character preceding it (unless you type
  177.      a command).
  178.  
  179. "status line"
  180.      One line in a window is devoted to displaying messages from the
  181.      editor, Using Windows.
  182.  
  183. "Lisp"
  184.      The programming language which Jade uses, although the internals
  185.      of the editor are written in C, all commands are written in a
  186.      dialect of Lisp (even if the command only calls a C function).
  187.      Jade contains an interpreter, compiler and debugger for this
  188.      language. See Programming Jade.
  189.  
  190. "variable"
  191.      Variables are used to store Lisp values, each variable has a
  192.      unique name.  Note that unlike many programming languages
  193.      variables in Lisp are *not* typed, the data values themselves have
  194.      a type associated with them.
  195.  
  196. "form"
  197.      A form is a single Lisp expression. For example, all of these are
  198.      forms:
  199.  
  200.           foo
  201.           42
  202.           "hello"
  203.           (setq foo 200)
  204.  
  205. "command"
  206.      A command is a sequence of Lisp forms which may be called
  207.      interactively (ie, from the keyboard). It may be a key sequence
  208.      (such as `Ctrl-x Ctrl-f') or a Lisp function to evaluate (such as
  209.      `ESC x find-file').
  210.  
  211. "regular expression"
  212.      A regular expression is a string which is used to match against
  213.      other strings.  It has a special syntax which allows you to form a
  214.      kind of template against which the other strings can be matched.
  215.      They are used extensively by the editor, but you -- the user --
  216.      will mainly encounter them when searching and replacing strings in
  217.      buffers.
  218.  
  219. Key Definitions
  220. ***************
  221.  
  222.    In this manual I have adopted a consistent notation for all
  223. keypresses, since most editor commands are invoked via a typed
  224. key-sequence it is very important that you can decipher this notation.
  225.  
  226.    Every keypress has a set of "modifiers"; these are the keys such as
  227. "Shift" or "Control" which don't actually produce a character when
  228. typed, they only effect the rest of the keyboard. Each key, then, can
  229. have one or more modifiers.
  230.  
  231.    The actual key definition consists of zero or more hyphen-separated
  232. modifiers, followed by a hyphen and the name of the actual key (or
  233. event).
  234.  
  235.    Some commands are triggered by a sequence of one or more of these key
  236. definitions, press each key definition in turn to invoke the command.
  237.  
  238.    Note that the case of modifiers is not important, however some of
  239. the keys *are*, so you should always specify them in their correct case.
  240.  
  241. Modifiers
  242. =========
  243.  
  244. "Shift"
  245. "SFT"
  246.      The shift key.
  247.  
  248. "Ctrl"
  249. "CTL"
  250.      The control key, or its equivalent.
  251.  
  252. "Meta"
  253.      This depends on the window-system, on X11 it is the "Mod1"
  254.      modifier, on the Amiga the "Alt" key.
  255.  
  256. "LMB"
  257.      The left mouse button.
  258.  
  259. "MMB"
  260.      The middle mouse button.
  261.  
  262. "RMB"
  263.      The right mouse button.
  264.  
  265.    As well as these, there are also some others, "Mod1" to "Mod2"
  266. represent the X11 modifiers of the same name. "Button1" to "Button5"
  267. also correspond to their X11 conterparts (Button1 to Button3 are LMB to
  268. RMB). For Amiga users, "Amiga" corresponds to the Amiga key (this is
  269. the same as Mod2).
  270.  
  271. Keys
  272. ====
  273.  
  274.    As far as possible each single character key-definition corresponds
  275. to where that character is on the keyboard (a is `a', etc...).
  276.  
  277.    When using an Amiga this should be true for *all* keys since the
  278. Amiga's "keymap.library" makes it easy to look up what key a character
  279. belongs to.  However, this is not so easy on X11. All of the standard
  280. ASCII character set should be okay, but the more esoteric characters
  281. may have to be specified by the names of their X11 keysym (without the
  282. `XK_' prefix). Look in the <X11/keysymdef.h> include file for all
  283. keysyms, for example `XK_question' would have to be used for `?' if the
  284. editor didn't treat it, and many others, specially.
  285.  
  286.    Some keys which don't follow this pattern are
  287.  
  288. "Space"
  289. "SPC"
  290. "SpaceBar"
  291.      The space bar.
  292.  
  293. "TAB"
  294.      The tab key.
  295.  
  296. "RET"
  297. "Return"
  298.      The return key.
  299.  
  300. "ESC"
  301. "Escape"
  302.      The escape key.
  303.  
  304. "BS"
  305. "BackSpace"
  306.      The backspace key.
  307.  
  308. "DEL"
  309. "Delete"
  310.      The delete key.
  311.  
  312. "HELP"
  313.      The help key, not all keyboards have this.
  314.  
  315. "UP"
  316.      The cursor up key.
  317.  
  318. "DOWN"
  319.      The cursor down key
  320.  
  321. "LEFT"
  322.      The cursor left key.
  323.  
  324. "RIGHT"
  325.      The cursor right key.
  326.  
  327. "KP_Enter"
  328. "KP_Multiply"
  329. "KP_Divide"
  330. "KP_Minus"
  331. "KP_Add"
  332. "KP_Decimal"
  333. "KP_N"
  334.      Keys on the numeric keypad. For KP_N, N is a digit.
  335.  
  336. "Click1"
  337.      Single clicking a mouse button.
  338.  
  339. "Click2"
  340.      Double clicking a mouse button.
  341.  
  342. "Off"
  343.      Releasing a mouse button.
  344.  
  345. "Move"
  346.      Moving the mouse. This doesn't work on X11 yet.
  347.  
  348. Example Keys
  349. ============
  350.  
  351.    Some examples of proper key definitions are,
  352.  
  353. `Ctrl-x'
  354.      Hold down Control, type x.
  355.  
  356. `Meta-Shift-RET'
  357.      Hold down Meta and Shift, then type the Return key.
  358.  
  359. `LMB-Click1'
  360.      Click the left mouse button once.
  361.  
  362. `Meta-RMB-Click1'
  363.      Hold down Meta then click the right mouse button once.
  364.  
  365. Starting Jade
  366. *************
  367.  
  368.    This chapter describes Jade's initialisation process. This includes
  369. how to start it, what options it will accept and what it actually does
  370. after being started.
  371.  
  372. Invocation
  373. ==========
  374.  
  375.    Since Jade supports two vastly different operating systems they both
  376. need to be covered separately.
  377.  
  378.    * Amiga
  379.  
  380.      The normal way to start Jade on the Amiga is to type its name at
  381.      the Shell (or CLI) together with any options (see Startup Options)
  382.      you want. Note that these options are in the traditional Unix
  383.      style, a dash followed by the option name and any arguments, not
  384.      the standard AmigaDOS method.
  385.  
  386.      It is also possible to invoke the editor from the Workbench,
  387.      simply double clicking on its icon will cause Jade to open its
  388.      initial window. Unfortunately there is no support for passing
  389.      arguments via Tool Types, nor is there any way to create icons
  390.      with saved files. This is largely due to the fact that I rarely
  391.      use the Workbench -- if enough people complain about this I will
  392.      probably fix it. Jade doesn't have an icon yet, you'll have to
  393.      make one yourself.
  394.  
  395.    * Unix with X11
  396.  
  397.      Jade should be started like most other Unix programs, type its
  398.      name and any arguments to a shell. It must be able to connect to
  399.      an X server (preferably the one controlling your terminal), the
  400.      `-display' option can be used if needed.
  401.  
  402. Startup Options
  403. ===============
  404.  
  405.    The acceptable options can be split into three classes. Note that
  406. they must be specified on the command line in order of their class.
  407. This means that, for example, the `-rc' option must be after the `-font'
  408. option.
  409.  
  410.    So, the general usage pattern is
  411.  
  412.      jade [SYSTEM-DEPENDANT-OPTIONS] [STANDARD-OPTIONS] [LISP-OPTIONS]
  413.  
  414.    Note that the LISP-OPTIONS may include files to be loaded.
  415.  
  416.   1. System dependant options.
  417.  
  418.         * Options for the Amiga system.
  419.  
  420.          `-pubscreen SCREEN-NAME'
  421.                Defines the name of the public screen on which the first
  422.                window is opened. By default (or if SCREEN-NAME doesn't
  423.                exits) the `Workbench' screen is used.
  424.  
  425.          `-font FONT-STRING'
  426.                Defines the font used in the first window. FONT-STRING
  427.                is the font to use, it is the name of the font (for
  428.                example, `topaz.font'), followed by a hyphen and the
  429.                point size to use. For example, a FONT-STRING of
  430.                `topaz.font-8' gives 8-point topaz. This is the default.
  431.  
  432.         * Options for X11.
  433.  
  434.           There are two types of options to the X11 version of the
  435.           editor, those specified on the command line and those defined
  436.           in the resource database (ie, in your `.Xdefaults' file).
  437.           Resources are looked for under two names, firstly the name
  438.           under which the editor was invoked (normally `jade'), if this
  439.           fails it tries again with the name `Jade'. Naturally, options
  440.           specified on the command line overide those in the resource
  441.           database.
  442.  
  443.          `-display DISPLAY-NAME'
  444.                Defines the name of X display to open, by default the
  445.                contents of the environment variable `DISPLAY'. It is a
  446.                string of the form `hostname:number.screen_number'.
  447.  
  448.          `-name NAME'
  449.                The name to use when looking up resource values, this
  450.                replaces the base name of the executable (normally
  451.                `jade').
  452.  
  453.          `-geometry GEOM-SPEC'
  454.                Specifies where to place the first window on the screen.
  455.                This is a standard X style geometry specification.
  456.  
  457.          `-fg FOREGROUND-COLOUR'
  458.          `fg: FOREGROUND-COLOUR' *RESOURCE*
  459.                The colour of the window's foreground (ie, the text).
  460.  
  461.          `-bg BACKGROUND-COLOUR'
  462.          `bg: BACKGROUND-COLOUR' *RESOURCE*
  463.                The background colour of the window.
  464.  
  465.          `-font FONT-NAME'
  466.          `font: FONT-NAME' *RESOURCE*
  467.                The name of the font used for all text in the initial
  468.                window.
  469.  
  470.   2. Standard options.
  471.  
  472.     `-rc LISP-FILE'
  473.           Load the Lisp script LISP-FILE instead of the normal
  474.           initialisation script (`init'). Warning: the editor depends
  475.           heavily on the normal file, if you change this without due
  476.           care the editor could be unusable -- no keys will be bound
  477.           and many standard functions won't exist.
  478.  
  479.     `-v'
  480.           Print the version and revision numbers of this copy of the
  481.           editor then quit.
  482.  
  483.     `-log-msgs'
  484.           This option makes all messages which are displayed in the
  485.           status line also be written to the standard error stream.
  486.           This is sometimes useful for debugging purposes.
  487.  
  488.   3. All other options are passed to the Lisp initialisation process in
  489.      the variable `command-line-args', these are available to any Lisp
  490.      packages loaded in the initialisation script. Any left after that
  491.      are scanned for the following options,
  492.  
  493.     `-f FUNCTION'
  494.           Call the Lisp function FUNCTION.
  495.  
  496.     `-l FILE'
  497.           Load the Lisp file FILE.
  498.  
  499.     `-q'
  500.           Quit cleanly.
  501.  
  502.     `FILE'
  503.           Load the file of text FILE into a new buffer.
  504.  
  505.    An example command line for starting Jade from a Unix shell could be
  506.  
  507.      $ jade -fg white -bg black -log-msgs foo.c bar.jl
  508.  
  509.    This means white text, black background, save messages and load the
  510. files `foo.c' and `bar.jl'.
  511.  
  512. Startup Procedure
  513. =================
  514.  
  515.    This is a description of what happens when the editor initialises
  516. itself.
  517.  
  518.   1. Firstly lots of internal data structures are created, memory
  519.      pools, symbols and their symbol-table (including all the primitive
  520.      Lisp functions).
  521.  
  522.   2. The window-system is initialised (parse the system-dependant
  523.      options, and the xrdb resources if in X).
  524.  
  525.   3. Parse the standard options.
  526.  
  527.   4. Create the initial window and the first buffer to display in it
  528.      (this is the buffer called `*jade*').
  529.  
  530.   5. Load the initialisation script, this is either the Lisp file
  531.      called `init' or whatever was given to the `-rc' command line
  532.      option.
  533.  
  534.      Some selected highlights of what the standard file does are,
  535.  
  536.         * Load lots of Lisp files, some notable ones are
  537.  
  538.          `loadsyms'
  539.                Initialise the autoload stubs.
  540.  
  541.          `loadkeys'
  542.                Creates the standard keymaps and keybindings.
  543.  
  544.         * Try to find the user's personal startup file, this is
  545.           normally the file `.jaderc' in their home directory (1).
  546.  
  547.         * Load any files which were specified on the command line.
  548.  
  549.   6. Start the top-level recursive edit, this doesn't exit until the
  550.      editor does.
  551.  
  552.    ---------- Footnotes ----------
  553.  
  554.    (1)  The Amiga has no notion of a user's home directory, Jade uses
  555. the contents of the environment variable `HOME', or if this doesn't
  556. exist the `SYS:' assignment.
  557.  
  558. Using Jade
  559. **********
  560.  
  561.    This chapter of the manual is meant to teach you to *use* the editor,
  562. because of this I have attempted to reduce references to the Lisp
  563. extension language to an absolute minimum. The only things that you
  564. need to know about at this time are how to set or reference Lisp
  565. variables and how to invoke Lisp commands.
  566.  
  567.    Luckily, it is very easy to do this by typing one of the following
  568. sequences to the editor,
  569.  
  570. `ESC x FUN'
  571.      Calls the command called FUN and displays its result in the status
  572.      line.
  573.  
  574. `ESC x set-variable RET FOO RET BAR'
  575.      This sets the Lisp variable FOO to the value BAR.
  576.  
  577. `ESC x show-variable RET FOO'
  578.      This displays the value of the variable FOO in the status line.
  579.  
  580.    Note that throughout this manual it is assumed that you press the RET
  581. (return) key after each `ESC x' command. For example, to invoke the
  582. command `ESC x find-file' you would actually type the following (but
  583. not the spaces -- they are for readability).
  584.  
  585.      `ESC x f i n d - f i l e RET'
  586.  
  587. The Help System
  588. ===============
  589.  
  590.    To invoke the help system type the key sequence `Ctrl-h' or if your
  591. keyboard has it the `HELP' key.
  592.  
  593.    A prompt will be displayed in the status line showing you which keys
  594. you can press next to enter one of the main options of the help system
  595. explained below. Alternatively, you can type either `Ctrl-h' or `HELP'
  596. again to display some text telling you more about the help system and
  597. how to use it.
  598.  
  599.    The help system is exited after successfully invoking one of the
  600. commands described below or typing anything which is not a recognised
  601. command to the help system.
  602.  
  603. `a'
  604.      To list all function names matching REGEXP, type `a REGEXP RET'
  605.      when in the help system.
  606.  
  607. `e'
  608.      Similarly, to list all variable names matching REGEXP, type `e
  609.      REGEXP RET' when in the help system.
  610.  
  611. `f'
  612.      Displays the online documentation for a function. After invoking
  613.      this option type the name of the function.
  614.  
  615. `h'
  616.      Shows some helpful text describing how to use the help system.
  617.  
  618. `i'
  619.      Enters the Info viewer. This allows you to browse through files
  620.      written in the Info hypertext format. For more information see
  621.      Info-mode, for more information on Info files in general see
  622.      info/Info.
  623.  
  624. `m'
  625.      Display the current editing modes documentation.
  626.  
  627. `v'
  628.      Displays the online documentation and current value of a variable.
  629.      Type the name of the variable after invoking this option.
  630.  
  631. Loading and Saving Files
  632. ========================
  633.  
  634.    Since `jade' is a text editor its main function is to edit files of
  635. text.  This means that you must be able to read the text contained in a
  636. file into one of the editor's buffers, then save it back to disk when
  637. you have finished editing it. That is what this section deals with.
  638.  
  639. Commands To Load Files
  640. ----------------------
  641.  
  642.    There are several commands used to load files into buffers, these
  643. are,
  644.  
  645. `Ctrl-x Ctrl-f'
  646.      Prompts for the name of a file (using file-completion) and display
  647.      the buffer containing that file. If the file has not already been
  648.      loaded it will be read into a new buffer.
  649.  
  650. `Ctrl-x Ctrl-v'
  651.      Prompts for the name of a file, the current buffer is killed and
  652.      the buffer in which the prompted-for file is being edited is
  653.      displayed. As in `find-file' it will be read into a new buffer if
  654.      it is not already in memory.
  655.  
  656. `Ctrl-x Ctrl-r'
  657.      Similar to `find-file' except that the buffer is marked as being
  658.      read-only. This means that no modifications can be made to the
  659.      buffer.
  660.  
  661. `Ctrl-x i'
  662.      Prompts for a file, then inserts it into the current buffer at the
  663.      cursor position.
  664.  
  665.    You can use the prompt's completion feature to expand abbreviated
  666. filenames typed to the prompt, for more information see The Buffer
  667. Prompt.
  668.  
  669. Commands To Save Files
  670. ----------------------
  671.  
  672.    These are the commands used to save buffers and the keystrokes
  673. associated with them,
  674.  
  675. `Ctrl-x Ctrl-s'
  676.      Saves the current buffer to the file that it is associated with
  677.      (this is either the file that it was loaded from or something else
  678.      set by the function `set-file-name'). If no modifications have
  679.      been made to the file since it was loaded it won't be saved (a
  680.      message will be displayed warning you of this).
  681.  
  682. `Ctrl-x Ctrl-w'
  683.      Prompts for a name to save the file as. The file associated with
  684.      this buffer is renamed and the file is saved as its new name.
  685.  
  686. `Ctrl-x s'
  687.      For each buffer which has been modified since it was loaded, ask
  688.      the user if it should be saved or not. If so, the command
  689.      `save-file' is used to save the file
  690.  
  691. Backup Files
  692. ------------
  693.  
  694.    The editor can optionally preserve the previous contents of a file
  695. when they are about to be overwritten by saving a buffer. It does this
  696. by renaming the old file, `foo' as `foo~' (the original name plus a
  697. tilde appended to it).
  698.  
  699.  - Variable: make-backup-files
  700.      This variable controls whether or not backups are made of files
  701.      about to overwritten by the function `write-buffer' (ie, the
  702.      commands `save-file' and `save-file-as'). When non-nil the old
  703.      instance of the file is renamed so that it has a tilde appended to
  704.      its old name.
  705.  
  706.  - Variable: backup-by-copying
  707.      When non-nil all backups are made by copying the original file
  708.      instead of renaming it as the backup file. This is slower but less
  709.      destructive.
  710.  
  711.    If `backup-by-copying' is nil and renaming the original file as its
  712. backup would be damaging (ie, changing the ownership of the file or
  713. breaking a link) no backup will be made.
  714.  
  715. Auto-Saving Files
  716. -----------------
  717.  
  718.    Jade is able to save snapshots of a buffer's contents at set time
  719. intervals.  When this time interval expires and the buffer has been
  720. modified since it was last (auto-) saved to disk (and the editor is
  721. idle) the buffer is saved to a special file (usually the base component
  722. of the file's name surrounded by `#' characters in the file's
  723. directory).
  724.  
  725.  - Variable: auto-save-p
  726.      When non-nil this makes the function `open-file' (and therefore the
  727.      commands `find-file', etc) flag that the file it just read should
  728.      be auto saved regularly.
  729.  
  730.  - Variable: default-auto-save-interval
  731.      This is the default number of seconds between each auto save. This
  732.      variable is only referenced when each file is opened.
  733.  
  734.      Its standard value is 120 seconds.
  735.  
  736.  - Variable: auto-save-interval
  737.      This buffer-local variable controls the number of seconds between
  738.      each auto-save of the buffer it belongs to. A value of zero means
  739.      never auto-save.
  740.  
  741.    When the buffer is saved properly (ie, with `save-file' and friends)
  742. its auto-save file is deleted. Note that this doesn't happen when you
  743. kill a buffer and an auto-save file exists (in case you didn't mean to
  744. kill the buffer).
  745.  
  746.    If you want to change the format of the name of auto-saved files
  747. look at the function `make-auto-save-name' and its documentation.
  748.  
  749. Tab Expansion
  750. -------------
  751.  
  752.    The editor does not leave tab characters (ASCII 9) as they are. They
  753. are expanded into one or more spaces when the file is read into its
  754. buffer. The size of the expansion depends upon the column number at
  755. which the tab has occured and the value of the variable `disk-tab'.
  756.  
  757.  - Variable: disk-tab
  758.      This buffer-local variable determines the size of tab stops used
  759.      when a file is read from disk (by the `read-buffer' function) into
  760.      a buffer.
  761.  
  762.    It is desirable that the files which the editor produces have tabs
  763. in them though, so something has to be done.
  764.  
  765.    The variable `save-tabs' controls exactly how files are saved (in
  766. respect to saving tab characters).
  767.  
  768.  - Variable: save-tabs
  769.      The value of this buffer-local variable is used to decide exactly
  770.      which sequences of spaces are changed to tab characters when a
  771.      buffer is saved to disk (with the `write-buffer' and
  772.      `write-buffer-area' functions).  There are three possible options
  773.      (all of which are Lisp symbols):
  774.  
  775.     `nil'
  776.           *No* tabs are saved at all. All whitespace is left untouched,
  777.           this may be necessary with some types of file whose format is
  778.           strongly defined.
  779.  
  780.     `leading'
  781.           Any whitespace at the start of each line is translated into
  782.           tabs and spaces such that the first non-whitespace character
  783.           in the line is at the same logical position as it was in the
  784.           buffer.
  785.  
  786.     `all'
  787.           Any sequence of two or more space characters is translated
  788.           into tab characters when the logical structure of the line
  789.           would be unaltered by doing so. *No* translations take place
  790.           after the first quote character (ie, `'', ``' or `"') in the
  791.           line (this is to try and prevent errors).
  792.  
  793. Automatic Mode Selection
  794. ------------------------
  795.  
  796.    As described elsewhere in this manual, each buffer can have an
  797. editing mode associated with it (ie, `c-mode' for editing buffers of C
  798. source code).
  799.  
  800.    Since it would be extremely tedious to have to invoke the mode's
  801. initialisation function manually whenever a new file is loaded the
  802. editor can initialise the mode automatically. It does this by scanning
  803. an association list called `mode-alist' for a regular expression
  804. matching the name of the file (or the string in the buffer-local
  805. variable `mode-name' if it is non-nil). If a match is found the function
  806. associated with the matching regular expression is called, thereby
  807. initialising the mode.
  808.  
  809.    If you don't understand this, don't worry -- it works.
  810.  
  811.    For example, the mode-alist contains this fragment as one of its
  812. elements:
  813.  
  814.      ("\\.[ch]$" . c-mode)
  815.  
  816. which means call the function `c-mode' for any file ending in `.c' or
  817. `.h'.
  818.  
  819.  - Variable: mode-alist
  820.      A list of elements of `(MATCH-REGEXP . MODE-FUN)'. When a file is
  821.      loaded each MATCH-REGEXP is compared with the name of the file in
  822.      question (or it's `mode-name' value). When a match is found the
  823.      corresponding MODE-FUN function is called.
  824.  
  825. Embedding Lisp In Files
  826. -----------------------
  827.  
  828.    It is possible to include Lisp commands in the text of a file so
  829. that they will be read and evaluated when that file is loaded into a
  830. buffer.
  831.  
  832.    This is normally used to set buffer-local options which are specific
  833. to one particular file, ie, to set the name of the editing mode, or the
  834. size of tab characters in this file.
  835.  
  836.    The way to do this is to include a section of text of the form in
  837. the file:
  838.  
  839.      ...
  840.      XXX ::jade-code::
  841.      XXX Lisp Line1
  842.      XXX Lisp Line2
  843.      XXX ...
  844.      XXX Lisp LineN
  845.      XXX ::end::
  846.      ...
  847.  
  848.    The `XXX' just means that any text to the left of the column in which
  849. the `jade-code' begins is ignored (This is mainly to allow for any
  850. comments needed to make sure that the Lisp text is not used by whatever
  851. uses the file).
  852.  
  853.    Only one block such as this is allowed per file, it is not evaluated
  854. until the whole of the file has been read.
  855.  
  856.    Some examples uses of this could be,
  857.  
  858.    In a lisp file:
  859.      ;;; ::jade-code::
  860.      ;;; (setq lisp-mode-tab 4)
  861.      ;;; (setq mode-name "lisp-mode")
  862.      ;;; ::end::
  863.  
  864.    Or in a C source file:
  865.      /* ::jade-code::
  866.       * (setq c-mode-tab 4)
  867.       * (setq mode-name "c-mode")
  868.       */::end::
  869.  
  870.    It is also possible to prohibit the evaluation of these special
  871. sections.
  872.  
  873.  - Variable: no-file-code-p
  874.      When non-nil the section of a file marked for auto-evaluation
  875.      (with the `::jade-code::' marker) is *not* evaluated.
  876.  
  877. Editing Buffers
  878. ===============
  879.  
  880.    The majority of keys when typed will simply insert themselves into
  881. the buffer (this is not always true but it's a good assumption) since
  882. they have not been bound. Typically this includes all normal characters
  883. (ie, alphanumeric, puntuation, etc) as well as any of the more obtuse
  884. key-sequences which have not been bound to a function (`Ctrl-l' is one
  885. of the more useful of these).
  886.  
  887.    The behaviour of the TAB key is different to many other editors -- it
  888. doesn't insert anything (unless a specific editing mode has bound it to
  889. something else, like `c-mode' for example), generally it just moves the
  890. cursor to the next tab stop. This is partly because Jade doesn't use
  891. "proper" tabs and partly because it makes it easier to move around a
  892. line (because the keystroke `Shift-TAB' moves to the previous tab stop).
  893.  
  894.    Some miscellaneous editing commands are,
  895.  
  896. `RET'
  897.      This generally splits the line into two at the position of the
  898.      cursor, some editing modes may provide an option which
  899.      automatically indents the line after it's split.
  900.  
  901. `BS'
  902.      Deletes the character before the cursor.
  903.  
  904. `DEL'
  905.      Deletes the character under the cursor.
  906.  
  907. `Shift-BS'
  908.      Kills the characters between the start of the line and the cursor.
  909.  
  910. `Shift-DEL'
  911. `Ctrl-d'
  912.      Kills the characters from the cursor to the end of the line.
  913.  
  914. `Ctrl-DEL'
  915.      Kills the whole line.
  916.  
  917. `Ctrl-o'
  918.      Splits the line in two at the cursor, but leaves the cursor in its
  919.      original position.
  920.  
  921. `ESC d'
  922. `ESC DEL'
  923.      Kills from the cursor to the end of the current word.
  924.  
  925. `ESC i'
  926.      Inserts spaces to fill from the cursor to the next tab stop.
  927.  
  928. `ESC l'
  929.      Makes the characters from the cursor to the end of the word lower
  930.      case.
  931.  
  932. `ESC u'
  933.      Upper cases the characters from the cursor to the end of the word.
  934.  
  935. `ESC BS'
  936.      Kills from the cursor to the beginning of the word.
  937.  
  938. Moving Around Buffers
  939. =====================
  940.  
  941.    These are the commands which are used to move the cursor around the
  942. current buffer,
  943.  
  944. `UP'
  945. `Ctrl-p'
  946.      Move one line up.
  947.  
  948. `DOWN'
  949. `Ctrl-n'
  950.      Move one line down.
  951.  
  952. `LEFT'
  953.      Move one column to the left, stopping at the first column.
  954.  
  955. `Ctrl-b'
  956.      Move to the previous character, at the beginning of the line moves
  957.      to the end of the previous line.
  958.  
  959. `RIGHT'
  960.      Move one column to the right. This keeps moving past the end of
  961.      the line.
  962.  
  963. `Ctrl-f'
  964.      Move to the next character, at the end of a line moves to the
  965.      start of the next line.
  966.  
  967. `Shift-UP'
  968.      Move to the first line in the buffer.
  969.  
  970. `Shift-DOWN'
  971.      Move to the last line in the buffer.
  972.  
  973. `ESC <'
  974.      Move to the first character in the buffer.
  975.  
  976. `ESC >'
  977.      Move to the last character in the buffer.
  978.  
  979. `Shift-LEFT'
  980. `Ctrl-a'
  981.      Move to the beginning of the current line.
  982.  
  983. `Shift-RIGHT'
  984. `Ctrl-e'
  985.      Move to the last character in the current line.
  986.  
  987. `Ctrl-UP'
  988. `ESC v'
  989.      Move to the previous screenful of text.
  990.  
  991. `Ctrl-DOWN'
  992. `Ctrl-v'
  993.      Move to the next screenful of text.
  994.  
  995. `Meta-LEFT'
  996. `ESC b'
  997.      Move to the previous word.
  998.  
  999. `Meta-RIGHT'
  1000. `ESC f'
  1001.      Move to the next word.
  1002.  
  1003. `Meta-UP'
  1004. `ESC ['
  1005.      Move to the start of the previous paragraph.
  1006.  
  1007. `Meta-DOWN'
  1008. `ESC ]'
  1009.      Move to the start of the next paragraph.
  1010.  
  1011. `TAB'
  1012. `ESC TAB'
  1013.      Move to the next tab position. Note that some editing modes
  1014.      redefine TAB to make it indent the current line.
  1015.  
  1016. `Shift-TAB'
  1017.      Move to the position of the previous tab.
  1018.  
  1019. `Ctrl-TAB'
  1020. `ESC i'
  1021.      Insert a tab (ie, enough spaces to move to the next tab position).
  1022.  
  1023. `Ctrl-j'
  1024. `ESC x goto-line'
  1025.      Prompt for a line number and go to it.
  1026.  
  1027. `ESC m'
  1028.      Move to the first non-space character in the current line.
  1029.  
  1030.    There are several variables which affect the commands described
  1031. above, these are,
  1032.  
  1033.  - Variable: screen-tab
  1034.      This buffer-local variable controls the size of tab characters in
  1035.      a buffer.  Its standard value is 8. This variable does not affect
  1036.      the size of tabs in files read into the buffer, that is controlled
  1037.      by `disk-tab'.
  1038.  
  1039.  - Variable: y-scroll-step-ratio
  1040.      A window-local variable which controls what happens when you move
  1041.      the cursor off the top or bottom of the window. A value of zero
  1042.      means move as much as needed to get the cursor back into view, for
  1043.      example, if you move down one line, it will scroll the window one
  1044.      line only. If the value is not zero the screen is moved by the
  1045.      number of rows in the window divided by the value. For example, a
  1046.      value of 2 means scroll the window in chunks half the size of the
  1047.      window -- this is useful for when you are working with a slow
  1048.      updating display.
  1049.  
  1050.  - Variable: x-scroll-step-ratio
  1051.      Similar to `y-scroll-step-ratio' except for horizontal movement.
  1052.  
  1053. Cutting And Pasting
  1054. ===================
  1055.  
  1056.    One of the main functions of any editor is to allow you to move
  1057. around chunks of text, jade makes this very easy.
  1058.  
  1059.    Generally, to paste down some text you have to get the text to be
  1060. inserted into the window-system's clipboard (1). If the text you wish
  1061. to paste is in one of the editor's buffers jade has a number of
  1062. commands for doing this, this is sometimes referred to as "killing" the
  1063. text.
  1064.  
  1065.    If the text to be pasted is in the same buffer as the position to
  1066. which you want to copy it there is an easier way than putting it into
  1067. the clipboard. For more details see Commands on Blocks and the command
  1068. `Ctrl-i'.
  1069.  
  1070.    Once the text to be pasted is in the clipboard there are two
  1071. commands which can be used to insert it into the buffer before the
  1072. cursor,
  1073.  
  1074. `Ctrl-y'
  1075.      Inserts the contents of the standard clipboard into the buffer at
  1076.      the cursor position.
  1077.  
  1078. `Ctrl-Y'
  1079.      This is a variant of `Ctrl-y', it treats the string that it is
  1080.      pasting as a "rectangle" of text. That is, each successive line in
  1081.      the string (each separated by a newline character) is inserted on
  1082.      successive lines in the buffer but at the same column position.
  1083.      For more details see Rectangular Blocks and the function
  1084.      `insert-rect'.
  1085.  
  1086.    ---------- Footnotes ----------
  1087.  
  1088.    (1)  When using an Amiga, unit zero of the `clipboard.device' is
  1089. used. For X11, the first cut-buffer.
  1090.  
  1091. Using Blocks
  1092. ============
  1093.  
  1094.    A "block" is a section of a buffer, you mark it by specifying its
  1095. edges (ie, the first and last characters). This part of the buffer can
  1096. then have various things done to it, for example insert it somewhere
  1097. else.
  1098.  
  1099.    Each window can only have a single block marked at any one time, it
  1100. will be displayed in the reverse of normal text (ie white on black, not
  1101. black on white).
  1102.  
  1103. Marking Blocks
  1104. --------------
  1105.  
  1106.    To mark a block you must specify its outermost points, note that the
  1107. text marked by the block ends one character before the marked position
  1108. (this is so that it easy to mark whole lines).
  1109.  
  1110.    Rectangular blocks are a bit different for more information, see
  1111. Rectangular Blocks.
  1112.  
  1113.    Note also that block marks shrink and grow as text is deleted and
  1114. inserted inside them, similar to what normal marks do.
  1115.  
  1116.    These are the commands used to mark a block,
  1117.  
  1118. `Ctrl-m'
  1119.      If a block is currently marked in this window it will unmark it.
  1120.      Otherwise it will either mark the beginning or end of the block
  1121.      depending on whether or not a block has previously been partially
  1122.      marked.
  1123.  
  1124.      The normal method for marking a few characters is to first make
  1125.      sure that no block is currently marked (the status line displays
  1126.      the status of the block marks, a `b' means that one end of a block
  1127.      has been marked and a `B' means that both ends of a block are
  1128.      marked in which case it will be highlighted somewhere in the
  1129.      buffer) then press `Ctrl-m' at one end, move the cursor to the
  1130.      opposite end and press `Ctrl-m' again.
  1131.  
  1132. `Meta-m'
  1133.      Set the beginning of the block to the current cursor position.
  1134.  
  1135. `Meta-M'
  1136.      Set the end of the block.
  1137.  
  1138. `Ctrl-x h'
  1139.      Mark the whole of the buffer.
  1140.  
  1141. `ESC @'
  1142.      Mark the current word.
  1143.  
  1144. `ESC h'
  1145.      Mark the current paragraph.
  1146.  
  1147. `Ctrl-SPC'
  1148.      Mark from the position of the auto-mark to the cursor.
  1149.  
  1150.    Another method for marking a block is to use the mouse, double
  1151. clicking the left mouse button on a character has the same effect as
  1152. moving to that character and typing `Ctrl-m'. Similarly, clicking the
  1153. left mouse button while pressing the SHIFT key clears a marked block.
  1154.  
  1155. Commands on Blocks
  1156. ------------------
  1157.  
  1158. `Ctrl-i'
  1159.      Inserts the block marked in this window, at the cursor position,
  1160.      then unmarks the block.
  1161.  
  1162. `Ctrl-w'
  1163.      Copies the contents of the marked block to the standard clipboard
  1164.      and then deletes the block.
  1165.  
  1166. `ESC w'
  1167.      Copies the marked block to the standard clipboard, then unmarks
  1168.      the block.  This is a less destructive version of `Ctrl-w'.
  1169.  
  1170. `Ctrl-z'
  1171.      Deletes the text in the currently marked block.
  1172.  
  1173. `Ctrl-x Ctrl-l'
  1174.      Makes all alpha characters in the current block lower case.
  1175.  
  1176. `Ctrl-x Ctrl-u'
  1177.      Makes all characters in the block upper case.
  1178.  
  1179. Rectangular Blocks
  1180. ------------------
  1181.  
  1182.    Normally blocks are thought of sequentially from their first to last
  1183. characters, this does not have to be so. It is also possible to mark
  1184. rectangles, the block marks being thought of as the opposite corners of
  1185. the rectangle.
  1186.  
  1187. `Ctrl-M'
  1188.      Toggle between marking sequential and rectangular blocks, each
  1189.      window has its own value for this attribute (ie one window can be
  1190.      marking rectangles while the rest don't).
  1191.  
  1192. `Ctrl-Y'
  1193.      Similar to `Ctrl-y' except that the string inserted is treated as a
  1194.      rectangle -- newline characters don't get inserted, instead the
  1195.      next line is inserted in the next line in the buffer at the same
  1196.      column as that inserted into the previous line. For more details
  1197.      see the function `insert-rect'.
  1198.  
  1199.    At present there is a problem with changing the case of a
  1200. rectangular block with `Ctrl-x Ctrl-l' or `Ctrl-x Ctrl-u', they treat
  1201. it as a sequential block. This will be fixed soon.
  1202.  
  1203. Searching and Replacing
  1204. =======================
  1205.  
  1206.    It is very easy to search any of jade's buffers for a specific
  1207. string, the standard search command will search the current buffer for
  1208. a specified regular expression.
  1209.  
  1210.    Once you have found an occurrence of the string you are looking for
  1211. it is then possible to replace it with something else.
  1212.  
  1213. Regular Expressions
  1214. -------------------
  1215.  
  1216.    Jade uses the regexp(3) package by Henry Spencer, with some
  1217. modifications that I have added. It comes with this heading:
  1218.  
  1219.      Copyright (c) 1986 by University of Toronto.
  1220.      Written by Henry Spencer.  Not derived from licensed software.
  1221.  
  1222.      Permission is granted to anyone to use this software for any
  1223.      purpose on any computer system, and to redistribute it freely,
  1224.      subject to the following restrictions:
  1225.  
  1226.        1. The author is not responsible for the consequences of use of
  1227.           this software, no matter how awful, even if they arise from
  1228.           defects in it.
  1229.  
  1230.        2. The origin of this software must not be misrepresented, either
  1231.           by explicit claim or by omission.
  1232.  
  1233.        3. Altered versions must be plainly marked as such, and must not
  1234.           be misrepresented as being the original software.
  1235.  
  1236.    The syntax of a regular expression (or regexp) is as follows (this
  1237. is quoted from the regexp(3) manual page):
  1238.  
  1239.      A regular expression is zero or more "branches", separated by `|'.
  1240.      It matches anything that matches one of the branches.
  1241.  
  1242.      A branch is zero or more "pieces", concatenated. It matches a
  1243.      match for the first, followed by a match for the second, etc.
  1244.  
  1245.      A piece is an "atom" possibly followed by `*', `+', or `?'.  An
  1246.      atom followed by `*' matches a sequence of 0 or more matches of
  1247.      the atom. An atom followed by `+' matches a sequence of 1 or more
  1248.      matches of the atom. An atom followed by `?' matches a match of
  1249.      the atom, or the null string.
  1250.  
  1251.      An atom is a regular expression in parentheses (matching a match
  1252.      for the regular expression), a "range" (see below), `.' (matching
  1253.      any single character), `^' (matching the null string at the
  1254.      beginning of the input string), `$' (matching the null string at
  1255.      the end of the input string), a `\' followed by a single character
  1256.      (matching that character), or a single character with no other
  1257.      significance (matching that character).
  1258.  
  1259.      A "range" is a sequence of characters enclosed in `[]'. It
  1260.      normally matches any single character from the sequence. If the
  1261.      sequence begins with `^', it matches any single character *not*
  1262.      from the rest of the sequence. If two characters in the sequence
  1263.      are separated by `-', this is shorthand for the full list of ASCII
  1264.      characters between them (e.g. `[0-9]' matches any decimal digit).
  1265.      To include a literal `]' in the sequence, make it the first
  1266.      character (following a possible `^'). To include a literal `-',
  1267.      make it the first or last character.
  1268.  
  1269.    Some example legal regular expressions could be:
  1270.  
  1271. `ab*a+b'
  1272.      Matches an `a' followed by zero or more `b' characters, followed by
  1273.      one or more `a' characters, followed by a `b'. For example,
  1274.      `aaab', `abbbab', etc...
  1275.  
  1276. `(one|two)_three'
  1277.      Matches `one_three' or `two_three'.
  1278.  
  1279. `^cmd_[0-9]+'
  1280.      Matches `cmd_' followed by one or more digits, it must start at the
  1281.      beginning of the line.
  1282.  
  1283.    As well as being matched against, regexps also provide a means of
  1284. "remembering" portions of the string that they match. The first 9
  1285. parenthesised expressions and the whole string that matched are
  1286. recorded so that they can be used later.
  1287.  
  1288.    The main use for this is in the command to replace a previously
  1289. found regexp (`ESC p') and the Lisp functions `regexp-expand',
  1290. `regexp-expand-line' and `replace-regexp'. The string which is given as
  1291. the template (ie, the string that replaces the matched string) is
  1292. expanded inserting these recorded strings where asked to.
  1293.  
  1294.    Each occurrence of `\C' in the template is a candidate for
  1295. expansion. C can be one of:
  1296.  
  1297. `&'
  1298. `0'
  1299.      Replaces the whole substring matched by the regular expression.
  1300.  
  1301. `1' to `9'
  1302.      The numbered parenthesised expression.
  1303.  
  1304. `\'
  1305.      The character `\'.
  1306.  
  1307.    For example, if a regexp of `:([0-9]+):' matches a line
  1308. `foo:123:bar', the expansion template `x_\1' would produce `x_123'.
  1309.  
  1310. Commands for Searching
  1311. ----------------------
  1312.  
  1313. `Ctrl-s'
  1314.      Asks for a regular expression then tries to move to the start of
  1315.      the next match in this buffer.
  1316.  
  1317. `Ctrl-S'
  1318.      Attempts to move to the next occurrence of the regexp which was
  1319.      last entered for the `Ctrl-s' or `Ctrl-r' commands.
  1320.  
  1321. `Ctrl-r'
  1322.      Asks for a regexp, then moves to the start of previous occurrence
  1323.      of that regexp.
  1324.  
  1325. `Ctrl-R'
  1326.      Attempts to move to the previous occurrence of the regexp which
  1327.      was last entered for the `Ctrl-s' or `Ctrl-r' commands.
  1328.  
  1329. Commands for Replacing
  1330. ----------------------
  1331.  
  1332. `ESC p'
  1333.      Asks for a template to replace the string under the cursor (which
  1334.      should match the regexp which the search commands last looked for.
  1335.      This string is then replaced with the expansion (re the string
  1336.      under the cursor) of the template you entered.
  1337.  
  1338. `ESC P'
  1339.      Variant of the above, doesn't prompt for the template, uses the
  1340.      last one that you gave.
  1341.  
  1342. Editing Modes
  1343. =============
  1344.  
  1345.    Modes are used to tailor the editor to the *type* of the file being
  1346. edited in a buffer. They are normally a file of Lisp which installs the
  1347. buffer-local keybindings and variables which are needed for that type of
  1348. file.
  1349.  
  1350.    For example, C-mode is a mode used to edit C source code, its main
  1351. function is to try to indent each line to its correct position
  1352. automatically.
  1353.  
  1354.    At present there are only a small number of modes available. It is
  1355. fairly straightforward to write a mode for most types of files though.
  1356.  
  1357. Invoking a Mode
  1358. ---------------
  1359.  
  1360.    When a new file is loaded the function `init-mode' tries to find the
  1361. mode that it should be edited with. If it is successful the mode will be
  1362. automatically invoked. For more information see Automatic Mode Selection
  1363. and the documentation for `init-mode'.
  1364.  
  1365. Generic-mode
  1366. ------------
  1367.  
  1368.    This is not a mode as such since there is no Lisp code associated
  1369. with it.  When no mode is being used to edit the buffer, it is said to
  1370. use the "Generic" mode.
  1371.  
  1372.    This is the base from which all other modes build, it consists of
  1373. all the standard keybindings. Words are defined as one or more
  1374. alphanumeric characters, paragraphs are separated by a single blank
  1375. line.
  1376.  
  1377. C-mode
  1378. ------
  1379.  
  1380.    `c-mode' is used for editing C source code files. Any files which
  1381. end in `.c' or `.h' are automatically edited in this mode.
  1382.  
  1383.    It's one and only function is to try and indent lines to their
  1384. correct depth, it doesn't always get it right but it works fairly well.
  1385. The keys that it rebinds to achieve this are,
  1386.  
  1387. `RET'
  1388.      Splits the line in two like normal. If `c-mode-auto-indent' is
  1389.      non-nil then the line that the cursor ends up on is automatically
  1390.      indented.
  1391.  
  1392. `Shift-RET'
  1393.      Splits the line in two, doesn't take any notice of
  1394.      `c-mode-auto-indent'.
  1395.  
  1396. `{'
  1397. `}'
  1398. `:'
  1399.      These keys are handled specially since the indentation of the line
  1400.      that they are inserted on may have to be adjusted.
  1401.  
  1402. `TAB'
  1403.      Indents the current line to what the editor thinks is the correct
  1404.      position.
  1405.  
  1406. `Meta-TAB'
  1407.      Moves the cursor to the next tab stop.
  1408.  
  1409.    Words are defined as being a sequence of alphanumeric or underscore
  1410. characters, paragraphs as being separated by a `{' as the first
  1411. character of a line.
  1412.  
  1413.  - Function: c-mode
  1414.      Editing mode for C source code. Automatically used for files
  1415.      ending in `.c' or `.h'.
  1416.  
  1417.  - Hook: c-mode-hook
  1418.      Called by `c-mode' each time it is called.
  1419.  
  1420.  - Variable: c-mode-tab
  1421.      Size of tab stops used by `c-mode'.
  1422.  
  1423.  - Variable: c-mode-auto-indent
  1424.      When non-nil `RET' will indent the line after splitting it.
  1425.  
  1426. Lisp-mode
  1427. ---------
  1428.  
  1429.    `lisp-mode' is used to edit files of Lisp intended to be read by the
  1430. editor. It is *very* basic, all it does is count the number of unmatched
  1431. parentheses in each line and indent it accordingly. I find this okay
  1432. though.
  1433.  
  1434.    There is also support for using a buffer as a simple shell-interface
  1435. to the editor's Lisp subsystem.
  1436.  
  1437.    Special keybindings are,
  1438.  
  1439. `RET'
  1440.      Splits the line in two like normal. If `lisp-mode-auto-indent' is
  1441.      non-nil then the line that the cursor ends up on is automatically
  1442.      indented.
  1443.  
  1444. `Shift-RET'
  1445.      Splits the line in two, doesn't take any notice of
  1446.      `c-mode-auto-indent'.
  1447.  
  1448. `Ctrl-RET'
  1449.      Evaluates the paragraph preceding the cursor, prints the value on
  1450.      the next line.
  1451.  
  1452. `TAB'
  1453.      Indents the current line.
  1454.  
  1455. `Meta-TAB'
  1456.      Moves the cursor to the next tab stop.
  1457.  
  1458. `ESC Ctrl-x'
  1459.      Evaluates the paragraph before the cursor, prints it's value in
  1460.      the status line.
  1461.  
  1462.  - Function: lisp-mode
  1463.      Editing mode for Jade's Lisp. Automatically invoked for files
  1464.      ending in `.jl'.
  1465.  
  1466.  - Hook: lisp-mode-hook
  1467.      Evaluated as soon as `lisp-mode' is called.
  1468.  
  1469.  - Variable: lisp-mode-tab
  1470.      Size of tabs in `lisp-mode'.
  1471.  
  1472.  - Variable: lisp-mode-auto-indent
  1473.      When non-nil `RET' indents lines after splitting them.
  1474.  
  1475. Texinfo-mode
  1476. ------------
  1477.  
  1478.    `texinfo-mode' is used to edit Texinfo source files, it is
  1479. automatically selected for files ending in `.texi' or `.texinfo'. It
  1480. provides a few basic keybindings to take some of the tedium out of
  1481. editing these files.
  1482.  
  1483.    Paragraphs are separated by the regexp `^@node', ie, each node is a
  1484. separate paragraph.
  1485.  
  1486.    The provided keybindings are,
  1487.  
  1488. `Ctrl-c Ctrl-c c'
  1489.      Insert the string `@code{}', positioning the cursor between the
  1490.      braces.
  1491.  
  1492. `Ctrl-c Ctrl-c d'
  1493.      Insert the string `@dfn{}', positioning the cursor between the
  1494.      braces.
  1495.  
  1496. `Ctrl-c Ctrl-c e'
  1497.      Inserts the string `@end'.
  1498.  
  1499. `Ctrl-c Ctrl-c f'
  1500.      Inserts the string `@file{}', the cursor is put between the braces.
  1501.  
  1502. `Ctrl-c Ctrl-c i'
  1503.      Inserts the string `@item'.
  1504.  
  1505. `Ctrl-c Ctrl-c l'
  1506.      Inserts the string `@lisp\n'.
  1507.  
  1508. `Ctrl-c Ctrl-c m'
  1509.      Inserts the string `@menu\n'.
  1510.  
  1511. `Ctrl-c Ctrl-c Ctrl-m'
  1512.      Prompts for the name of a node and makes a menuitem for it.
  1513.  
  1514. `Ctrl-c Ctrl-c n'
  1515.      Prompts for each part of a node definition (name, next, prev, up)
  1516.      and inserts the `@node ...' string needed.
  1517.  
  1518. `Ctrl-c Ctrl-c s'
  1519.      Inserts the string `@samp{}' and puts the cursor between the
  1520.      braces.
  1521.  
  1522. `Ctrl-c Ctrl-c v'
  1523.      Inserts the string `@var{}', the cursor is put between the braces.
  1524.  
  1525. `Ctrl-c Ctrl-c {'
  1526.      Inserts a pair of braces with the cursor between them.
  1527.  
  1528. `Ctrl-c Ctrl-c }'
  1529. `Ctrl-c Ctrl-c ]'
  1530.      Moves the cursor to the character after the next closing brace.
  1531.  
  1532.  - Function: texinfo-mode
  1533.      Mode for editing Texinfo source files.
  1534.  
  1535.  - Hook: texinfo-mode-hook
  1536.      Evaluated when `texinfo-mode' is invoked.
  1537.  
  1538. Info-mode
  1539. ---------
  1540.  
  1541.    Despite the name of this section there is actually no such thing as
  1542. the `info-mode'. The Lisp file `info.jl' is what this section documents
  1543. -- it is a set of Lisp functions which make a buffer (the `*Info*'
  1544. buffer) into a simple browser for Info files.
  1545.  
  1546.    To invoke it type `Ctrl-h i' or `ESC x info', the `*Info' buffer
  1547. will be displayed showing the `(dir)' node (the root of the Info
  1548. documentation tree).
  1549.  
  1550.    When in the `*Info*' buffer these keybindings are in effect,
  1551.  
  1552. `SPC'
  1553.      Moves to the next page.
  1554.  
  1555. `BS'
  1556.      Moves to the previous page.
  1557.  
  1558. `1'
  1559. `2'
  1560. `3'
  1561. `4'
  1562. `5'
  1563.      Move to the specified menuitem (`1' means the first, etc) in the
  1564.      menu in this node.
  1565.  
  1566. `b'
  1567.      Move to the beginning of the current node.
  1568.  
  1569. `f'
  1570.      Follow a reference, the one under the cursor if it exists.  This
  1571.      command is still unimplemented.
  1572.  
  1573. `g'
  1574.      Prompt for the name of a node and try to display it.
  1575.  
  1576. `l'
  1577.      Go back to the last node that was displayed before this one.
  1578.  
  1579. `m'
  1580.      Prompts for a menuitem (the one on the same line as the cursor is
  1581.      the default) and display the node it points to.
  1582.  
  1583. `n'
  1584.      Display the next node.
  1585.  
  1586. `p'
  1587.      Display the previous node.
  1588.  
  1589. `u'
  1590.      Display the node "above" this one.
  1591.  
  1592. `q'
  1593.      Quit the Info browser.
  1594.  
  1595.    This mode has a number of disadvantages over the other Info browsers
  1596. available (ie, the standalone `info' program, or Emacs' Info viewer):
  1597.  
  1598.    * It depends wholly on being able to find a tag table in the Info
  1599.      file, if it can't it will complain and exit.
  1600.  
  1601.    * There is no support for the `*' node name.
  1602.  
  1603.    * As yet, no automatic following of references.
  1604.  
  1605.    * Seems not to work 100% with files formatted by Emacs, `makeinfo'
  1606.      formatted files work properly though.
  1607.  
  1608.    * No editing of modes.
  1609.  
  1610.  - Function: info [NODE-NAME]
  1611.      Invoke the Info viewer. If NODE-NAME is given display it, otherwise
  1612.      the node `(dir)' is used.
  1613.  
  1614. Using Buffers
  1615. =============
  1616.  
  1617.    As you have probably realised, buffers are probably the most
  1618. important part of the editor. Each file that is being edited must be
  1619. stored in a buffer. They are not restricted to editing files though,
  1620. all buffers are reguarded as simply being a list of lines which can be
  1621. displayed in a window and modified as needed.
  1622.  
  1623.    This means that they are very flexible, for example, the Lisp
  1624. debugger uses a buffer for its user interface, the Info reader uses two
  1625. buffers - one to display the current node, the other to store the
  1626. file's tag table (never displayed, just used to look up the position of
  1627. nodes).
  1628.  
  1629.    Each buffer has a name, generally buffers which contain proper files
  1630. use the base part of the filename, while buffers which don't correspond
  1631. to files use a word which starts and ends with asterisks (ie, `*jade*').
  1632.  
  1633.    Each window can display one buffer at any time. There is no
  1634. restriction on the number of windows which may display the same buffer
  1635. at once.
  1636.  
  1637. Displaying Buffers
  1638. ------------------
  1639.  
  1640.    There are two main commands for switching to a different buffer,
  1641.  
  1642. `Ctrl-x b'
  1643.      Prompt for the name of a buffer and display it in the current
  1644.      window.
  1645.  
  1646. `Ctrl-x 4 b'
  1647.      In a different window (opens a new window if there is currently
  1648.      only one) prompt for the name of a buffer and display it in that
  1649.      window.
  1650.  
  1651.    Both commands are very similar, the `Ctrl-x 4 b' variant simply
  1652. invokes a command to switch to a different window before calling the
  1653. `Ctrl-x b' command.
  1654.  
  1655.    When typing the name of the new buffer you can use the prompt's
  1656. completion mechanism to expand abbreviations (see see The Buffer
  1657. Prompt). If you just press RET with an empty prompt the default choice
  1658. will be used.  This will be the the buffer that was being shown in this
  1659. window before the current buffer was selected (its name is displayed in
  1660. the prompt's title).
  1661.  
  1662.    The `Ctrl-x Ctrl-f' command and its variants also switch buffers
  1663. since they look an existing copy of the file in a buffer before loading
  1664. it from disk, see Commands To Load Files.
  1665.  
  1666. Deleting Buffers
  1667. ----------------
  1668.  
  1669.    There is no real need to delete buffers, those that haven't been
  1670. used for a while just hang around at the end of the list. If you're
  1671. short on memory though it can help to kill some of the unused buffers
  1672. which you have accumulated.
  1673.  
  1674.    The command to kill a buffer is,
  1675.  
  1676. `Ctrl-x k'
  1677.      Prompts for the name of a buffer (with completion) then deletes
  1678.      that buffer (if the buffer contains unsaved modifications you are
  1679.      asked if you really want to lose them). It is removed from all
  1680.      window's buffer-lists and any window which is displaying it is
  1681.      switched to another buffer (the next in its list).  Any marks
  1682.      which point to the buffer are made "non-resident" (that is, they
  1683.      point to the name of the file in the buffer) and the buffer is
  1684.      discarded.
  1685.  
  1686. Other Buffer Commands
  1687. ---------------------
  1688.  
  1689. `ESC x rotate-buffers-forward'
  1690.      Rotates the current window's list of buffers.
  1691.  
  1692. `ESC x recover-file'
  1693.      Loads the auto-saved copy of the file stored in this buffer
  1694.      overwriting its current contents (if any changes are to be lost
  1695.      the user will have to agree to losing them).
  1696.  
  1697. `ESC x revert-buffer'
  1698.      Restores the contents of the current buffer to the contents of the
  1699.      file that it was loaded from, if an auto-save file exists you are
  1700.      asked if you want to revert to that instead.
  1701.  
  1702. `Ctrl-x s'
  1703.      Ask whether to save any modified buffers that exist.
  1704.  
  1705. `ESC x clear-buffer'
  1706.      Deletes the contents of the current buffer. Beware, you *won't* be
  1707.      warned if you're about to lose any unsaved modifications!
  1708.  
  1709. Using Windows
  1710. =============
  1711.  
  1712.    Windows have two main functions: to display the contents of buffers
  1713. (but only one buffer at a time) and to collect input from you, the user.
  1714.  
  1715.    The editor *must* have at least one window open at all times, when
  1716. you close the last window jade will exit, there is no limit to the
  1717. number of windows which you may have open though.
  1718.  
  1719.    Each window is split into two parts, they are
  1720.  
  1721. "The Main Display Area"
  1722.      This is the largest part of the window, it is where the buffer
  1723.      that this window is displaying is drawn.
  1724.  
  1725. "The Status Line"
  1726.      A single line of text associated with the window, under X11 this
  1727.      is the area of the beneath the horizontal line at the bottom of
  1728.      the window, on the Amiga it is the title of the window. The status
  1729.      line is normally used to display information about this window and
  1730.      what it is displaying, it has this format:
  1731.  
  1732.           BUFFER-NAME [MODE-NAME] (COL,ROW) N line(s) [FLAGS]
  1733.  
  1734.      Where the individual parts mean
  1735.  
  1736.     BUFFER-NAME
  1737.           The name of the buffer being edited, it can have either a `+'
  1738.           or a `-' appended to it, a plus means the buffer has been
  1739.           modified since it was saved, a minus means that the buffer is
  1740.           read-only.
  1741.  
  1742.     MODE-NAME
  1743.           Most editing modes set this to their name.
  1744.  
  1745.     COL
  1746.           The column that the cursor is at.
  1747.  
  1748.     ROW
  1749.           The row number of the cursor.
  1750.  
  1751.     N
  1752.           The number of lines in this buffer
  1753.  
  1754.     FLAGS
  1755.           General one-character flags related to the status of the
  1756.           window and its buffer.
  1757.  
  1758.    Each window maintains a list of all buffers which are available for
  1759. displaying, this is kept in order, from the most recently used to the
  1760. least. This list (called `buffer-list') is used by some of the buffer
  1761. manipulation commands when they are working out which buffer should be
  1762. displayed.
  1763.  
  1764. Creating Windows
  1765. ----------------
  1766.  
  1767. `Ctrl-x 2'
  1768. `Ctrl-x 5'
  1769.      Opens a new window, it will have the most of the attributes that
  1770.      the current window does, things like: size, buffer, font, etc...
  1771.      If you are using X11 you will probably have to use your mouse to
  1772.      select its position, depending on the window manager you use, on
  1773.      the Amiga it will be created at the same position as the current
  1774.      window.
  1775.  
  1776. `Ctrl-x 4 Ctrl-f'
  1777. `Ctrl-x 4 f'
  1778.      In a different window, one will be created if only one window is
  1779.      open, find a file, for more details see Commands To Load Files.
  1780.  
  1781. `Ctrl-x 4 a'
  1782.      In a different window add an entry to a change-log file. See
  1783.      Keeping ChangeLogs.
  1784.  
  1785. `Ctrl-x 4 b'
  1786.      In a different window, choose a buffer to display, similar to the
  1787.      `Ctrl-x b' command. See Displaying Buffers.
  1788.  
  1789. `Ctrl-x 4 h'
  1790.      Enter the help system in a different window. See The Help System.
  1791.  
  1792. `Ctrl-x 4 i'
  1793.      Enter the Info browser in a different window. See Info-mode.
  1794.  
  1795. `Ctrl-x 4 `'
  1796.      Display the next error (or whatever) in the `*compilation*' buffer
  1797.      in a different window. See Finding Errors.
  1798.  
  1799. Killing Windows
  1800. ---------------
  1801.  
  1802. `Ctrl-x 0'
  1803.      Close the current window, if it is the last window that the editor
  1804.      has open it will exit (after asking you if you wish to lose any
  1805.      unsaved modifications to buffers).
  1806.  
  1807. `Ctrl-x 1'
  1808.      Close all windows except the current one.
  1809.  
  1810. Other Window Commands
  1811. ---------------------
  1812.  
  1813. `Ctrl-x o'
  1814.      Activate the next window of the editor's. Under X11 this involves
  1815.      warping the [mouse-]cursor to the top left corner of the newly
  1816.      activated window.
  1817.  
  1818. Using the Prompt
  1819. ================
  1820.  
  1821.    There are two different styles of prompt that the editor uses when it
  1822. wants you to enter a string.
  1823.  
  1824. The Simple Prompt
  1825. -----------------
  1826.  
  1827.    The simplest prompt uses the the bottom-most line in the window, it
  1828. prints the prompt's title on the left hand side, you should type your
  1829. response and then press the RET key. This prompt is very primitive, the
  1830. only special commands that it has are,
  1831.  
  1832. `BS'
  1833.      Delete the previous character.
  1834.  
  1835. `UP'
  1836. `DOWN'
  1837.      Replace the contents of the prompt with the last string entered.
  1838.      When you type `UP' or `DOWN' again the original contents are
  1839.      restored.
  1840.  
  1841. `ESC'
  1842.      Cancel the prompt.
  1843.  
  1844. All other keys are simply printed in the prompt -- whatever they are.
  1845.  
  1846. The Buffer Prompt
  1847. -----------------
  1848.  
  1849.    This type of prompt is more sophisticated. It creates a new buffer
  1850. for you to type your response into (called `*prompt*'), the title of the
  1851. prompt is displayed in the buffer's first line.
  1852.  
  1853.    Normally you type the answer to the prompt into the buffer and then
  1854. press the RET key. All normal editor commands are available while you
  1855. are using the prompt, you can switch buffers, load new files, whatever
  1856. you like.
  1857.  
  1858.    Another advantage of this type of prompt is that it supports
  1859. "completion", this allows you to type the beginning of your response
  1860. then press the TAB key. What you have typed will be matched against the
  1861. list of responses that the editor has (ie, when being prompted for the
  1862. name of a file it will be matched against all available files), if a
  1863. unique match is found your response will be completed to that match.
  1864.  
  1865.    If several potential completions are found, these will be displayed
  1866. after the line `::Completions::' in the buffer and your response will
  1867. only be completed as far as the potential completions are similar. For
  1868. example, if you enter `fo' then press TAB and files called `foo' and
  1869. `foobar' exist, the contents of the prompt will become `foo'.
  1870.  
  1871.    Completion is provided for many different things, some are: files,
  1872. buffers, symbols, functions, variables, Info nodes, etc...
  1873.  
  1874.    The special commands for this type of prompt are,
  1875.  
  1876. `TAB'
  1877.      Complete the contents of the prompt. If more than one potential
  1878.      completion exists they are printed in the buffer.
  1879.  
  1880. `RET'
  1881.      Enter the result of this prompt. If you press RET while the cursor
  1882.      is on a printed potential completion (those under the
  1883.      `::Completions::' line) the whole line will be entered. Otherwise,
  1884.      just the text to the left of the cursor is entered.
  1885.  
  1886. `ESC ?'
  1887.      Print all possible completions of the current prompt but do not
  1888.      try to actually change the contents of the prompt.
  1889.  
  1890. `Ctrl-g'
  1891.      Cancel the prompt.
  1892.  
  1893. Using Marks
  1894. ===========
  1895.  
  1896.    Marks are used to record a position in a file, as the file's buffer
  1897. is modifed so does the position that the mark points to -- a mark will
  1898. keep pointing at the same character no matter what happens (unless the
  1899. character is deleted!).
  1900.  
  1901.    The other good thing about marks is that they point to files *not*
  1902. buffers. This means that you can set a mark in a buffer, delete the
  1903. buffer and then move to the position of the mark, the file will be
  1904. reloaded and the cursor will point at the original character.
  1905.  
  1906.    Normally there are three user-accessible marks (1) and one special
  1907. `auto-mark' which is used, amongst other things, to record the
  1908. "previous" position of the cursor, allowing you to retrace your last
  1909. major step.
  1910.  
  1911.    The commands available on marks are,
  1912.  
  1913. `F1'
  1914. `F2'
  1915. `F3'
  1916.      Move to the mark #1, #2 or #3, depending on which function key is
  1917.      pressed (F1 means mark #1, etc...). If the file pointed to is not
  1918.      in memory it will be loaded into a new buffer.
  1919.  
  1920. `Shift-F1'
  1921. `Shift-F2'
  1922. `Shift-F3'
  1923.      Set the position of mark #1, #2 or #3, depending on the function
  1924.      key.
  1925.  
  1926. `Ctrl-x Ctrl-x'
  1927.      Swap the positions of the cursor and the `auto-mark'.
  1928.  
  1929. `Ctrl-@'
  1930.      Set the position of the `auto-mark'.
  1931.  
  1932.    ---------- Footnotes ----------
  1933.  
  1934.    (1)  There is no reason why you can't have more, the editor sets no
  1935. limitation on the number of marks available. This is just how I have
  1936. set the editor up.
  1937.  
  1938. Compiling Programs
  1939. ==================
  1940.  
  1941.    Jade has a number of features to help you develop programs, foremost
  1942. is the ability to run a compilation inside one of the editor's buffers.
  1943. Unfortunately, this is only possible when using the Unix operating
  1944. system at the present.
  1945.  
  1946.    Once the compilation has finished you can then step through each
  1947. error produced.
  1948.  
  1949. Running a Compilation
  1950. ---------------------
  1951.  
  1952.    The command to run a shell command in a buffer is,
  1953.  
  1954. `ESC x compile'
  1955.      Prompts you for the command to execute, with a default of the last
  1956.      command you ran (starts as `make'). A shell process is created
  1957.      which runs asynchronously to the editor in the same directory as
  1958.      the current buffer's file was loaded from. The buffer
  1959.      `*compilation*' is selected and this is where all output from the
  1960.      program is printed.
  1961.  
  1962.    When the process finishes running a message is printed in the
  1963. `*compilation*' buffer telling you its exit-code.
  1964.  
  1965.    Only one process may be run with the `compile' function at once.
  1966.  
  1967.    This command is not available on the Amiga version yet.
  1968.  
  1969. Finding Errors
  1970. --------------
  1971.  
  1972.    When you have compiled something with the `ESC x compile' command it
  1973. is possible to step through each of the errors that it produces. To do
  1974. this use the command,
  1975.  
  1976. `Ctrl-x `'
  1977. `ESC x next-error'
  1978.      Displays the next error in the `*compilation*' buffer. The file
  1979.      that is in is loaded (if necessary) and the line with the error is
  1980.      found.
  1981.  
  1982.    If you edit a file which has errors in it, then try to find the next
  1983. error (which is in the same file) everything will still work. The
  1984. positions of errors are updated as the buffers are modified.
  1985.  
  1986.    The only exception to this is when you invoke the `next-error'
  1987. function while the `*compilation*' buffer is still being written to. If
  1988. more errors are produced in a file which has been modified since the
  1989. compilation started it is likely that the positions will get out of
  1990. sync.
  1991.  
  1992.    By default, the `next-error' function understands the type of error
  1993. output that `gcc' produces. This is of the form,
  1994.  
  1995.      FILE:LINE-NUMBER:DESCRIPTION
  1996.  
  1997.    It is possible to use other formats though, the variables which
  1998. control this are,
  1999.  
  2000.  - Variable: compile-error-regexp
  2001.      Regular expression to match a line containing an error. For `gcc'
  2002.      this is `^(.*):([0-9]+):(.+)'.
  2003.  
  2004.  - Variable: compile-file-expand
  2005.      Expansion template to produce the name of the file with the error,
  2006.      using `compile-error-regexp' and the line containing the error. By
  2007.      default this is `\1'.
  2008.  
  2009.  - Variable: compile-line-expand
  2010.      Similar to `compile-file-expand' except that it expands to a string
  2011.      defining the number of the line with the error. By default, `\2'.
  2012.  
  2013.  - Variable: compile-error-expand
  2014.      Similar to `compile-file-expand', but produces the description of
  2015.      the error. By default, `\3'.
  2016.  
  2017. Using Grep
  2018. ----------
  2019.  
  2020.    It is often very useful to grep through a set of files looking for a
  2021. regular expression, this is what the `grep' command does. With jade it
  2022. is possible to run an external `grep' program in the `*compilation*'
  2023. buffer. This then enables you to step through each grep hit using the
  2024. `Ctrl-x `' command, Finding Errors.
  2025.  
  2026.    The commands to use grep are,
  2027.  
  2028. `ESC x grep'
  2029.      Prompt for a string of arguments to give `grep', you do not need to
  2030.      provide the name of the program, or the `-n' switch, this is done
  2031.      automatically. The shell will do any filename-globbing on the
  2032.      arguments so it is advisable to surround the regular expression
  2033.      with single quotes.
  2034.  
  2035.      Note that the regular expression syntax will be different to that
  2036.      which jade uses. Also this command won't work on an Amiga.
  2037.  
  2038. `ESC x grep-buffer'
  2039.      This command provides a method for scanning the current buffer for
  2040.      all lines matching a regular expression (which you are prompted
  2041.      for). It is written entirely in Lisp -- this means that the normal
  2042.      regular expression syntax is needed and it will work on an Amiga.
  2043.  
  2044. Keeping ChangeLogs
  2045. ------------------
  2046.  
  2047.    A ChangeLog is a file (usually called `ChangeLog') which keeps a log
  2048. of all changes you have made to the files in its directory. For
  2049. example, the `src/ChangeLog' file for Jade keeps a list of changes made
  2050. to the editor's source code.
  2051.  
  2052.    There is no magic involved, you simply use a command to add a new
  2053. entry to a directory's log after modifying a file in that directory.
  2054. You then have to enter a summary of the changes that you made.
  2055.  
  2056.    The command to do this is,
  2057.  
  2058. `ESC a'
  2059.      Prompts for the name of a directory then lets you type a
  2060.      description of the changes you have made.
  2061.  
  2062.    If you enter more than one change in the same day (and from the same
  2063. host) the same heading will be used. The heading consists of the time
  2064. and date, your name, your login and the name of the host you're on. (1)
  2065.  
  2066.    ---------- Footnotes ----------
  2067.  
  2068.    (1)  On the Amiga there is no way to get these details. So, Jade
  2069. looks for some environment variables, `USERNAME' for the login name,
  2070. `HOSTNAME' for the name of the host and `REALNAME' for your actual name.
  2071.  
  2072. Simple Customisation
  2073. ====================
  2074.  
  2075.    The best way to tailor the editor to your own requirements is with
  2076. your personal startup file. This is called `.jaderc' in your home
  2077. directory (1), it is a file of Lisp forms evaluated when Jade
  2078. initialises itself.
  2079.  
  2080.    Usually, setting the values of variables in your startup file is
  2081. enough to configure Jade how you want, the Lisp function to set a
  2082. variable is called `setq', it's first argument is the name of the
  2083. variable, it's second the value you wish to set it to. Normally this
  2084. value will be one of the following data types,
  2085.  
  2086. `"xyz"'
  2087.      A string `xyz'.
  2088.  
  2089. `123'
  2090. `0173'
  2091. `0x7b'
  2092.      A number, all of the above have the value 123 (in decimal, octal
  2093.      and hexadecimal).
  2094.  
  2095. `nil'
  2096. `t'
  2097.      A boolean value, `nil' means false, or not true. `t' is the
  2098.      opposite (in fact, any value not `nil' is true).
  2099.  
  2100.    My `.jaderc' file looks something like this (note that semicolons
  2101. introduce comments),
  2102.  
  2103.      ;; Size of tabs for C source is 4
  2104.      (setq c-mode-tab 4)
  2105.      
  2106.      ;; Size of tabs for Lisp source is 2
  2107.      (setq lisp-mode-tab 2)
  2108.      
  2109.      ;; On X11 scroll quarter of a screen at once, else a line at a time
  2110.      (setq y-scroll-step-ratio (if (x11-p) 4 0))
  2111.      
  2112.      ;; When on an Amiga, flag that I don't want pulldown menus
  2113.      (when (amiga-p)
  2114.        (setq amiga-no-menus t))
  2115.  
  2116.    ---------- Footnotes ----------
  2117.  
  2118.    (1)  On the Amiga, your home directory is defined as the contents of
  2119. the environment variable `HOME'.
  2120.  
  2121. Programming Jade
  2122. ****************
  2123.  
  2124.    Unfortunately I haven't written this section yet. If you wan't to
  2125. program Jade your best bet is to look at the files in the `lisp/'
  2126. directory.  Online documentation is available for all editor functions,
  2127. The Help System.
  2128.  
  2129.    If you don't know Lisp look at any Lisp book. Jade's Lisp is fairly
  2130. similar to Emacs-Lisp (though the editor-related functions differ
  2131. greatly) so a good starting point may be the Emacs-Lisp manual.
  2132.  
  2133. Reporting Bugs
  2134. **************
  2135.  
  2136.    If you think you've found a bug in Jade I want to know about it,
  2137. there is a list of problems that I am aware of in the `BUGS' file, if
  2138. your's appears in here tell me anyway to make me fix it.
  2139.  
  2140.    When submitting bug reports I need to know as much as possible, both
  2141. about the problem and the circumstamces in which it occurs. In general,
  2142. send me as much information as possible, even if you think it's probably
  2143. irrelevant.
  2144.  
  2145.    If you can, contact me via email, my address is `jsh@ukc.ac.uk'.  If
  2146. you don't get a reply within about a week it's probably a university
  2147. vacation -- this means that I won't get your message for a while, if
  2148. it's important try my postal address, this is,
  2149.  
  2150.      John Harper
  2151.      91 Springdale Road
  2152.      Broadstone
  2153.      Dorset
  2154.      BH18 9BW
  2155.      England
  2156.  
  2157.    As well as bugs I'm interested in any comments you have about the
  2158. editor, even if you just tell me you hate it (as long as you say *why*
  2159. you hate it!).
  2160.  
  2161. Function Index
  2162. **************
  2163.  
  2164.  
  2165.  
  2166.  `c-mode'                               C-mode
  2167.  `compile'                              Running a Compilation
  2168.  `grep'                                 Using Grep
  2169.  `grep-buffer'                          Using Grep
  2170.  `info'                                 Info-mode
  2171.  `lisp-mode'                            Lisp-mode
  2172.  `next-error'                           Finding Errors
  2173.  `recover-file'                         Other Buffer Commands
  2174.  `revert-buffer'                        Other Buffer Commands
  2175.  `rotate-buffers-forward'               Other Buffer Commands
  2176.  `texinfo-mode'                         Texinfo-mode
  2177.  
  2178. Variable Index
  2179. **************
  2180.  
  2181.  
  2182.  
  2183.  auto-save-interval                     Auto-Saving Files
  2184.  auto-save-p                            Auto-Saving Files
  2185.  backup-by-copying                      Backup Files
  2186.  c-mode-auto-indent                     C-mode
  2187.  c-mode-hook                            C-mode
  2188.  c-mode-tab                             C-mode
  2189.  compile-error-expand                   Finding Errors
  2190.  compile-error-regexp                   Finding Errors
  2191.  compile-file-expand                    Finding Errors
  2192.  compile-line-expand                    Finding Errors
  2193.  default-auto-save-interval             Auto-Saving Files
  2194.  disk-tab                               Loading and Saving Tabs
  2195.  lisp-mode-auto-indent                  Lisp-mode
  2196.  lisp-mode-hook                         Lisp-mode
  2197.  lisp-mode-tab                          Lisp-mode
  2198.  make-backup-files                      Backup Files
  2199.  mode-alist                             Automatic Mode Selection
  2200.  no-file-code-p                         Embedding Lisp In Files
  2201.  save-tabs                              Loading and Saving Tabs
  2202.  screen-tab                             Moving Around Buffers
  2203.  texinfo-mode-hook                      Texinfo-mode
  2204.  x-scroll-step-ratio                    Moving Around Buffers
  2205.  y-scroll-step-ratio                    Moving Around Buffers
  2206.  
  2207. Key Index
  2208. *********
  2209.  
  2210.  
  2211.  
  2212.  1                                      Info-mode
  2213.  2                                      Info-mode
  2214.  3                                      Info-mode
  2215.  4                                      Info-mode
  2216.  5                                      Info-mode
  2217.  :                                      C-mode
  2218.  BS                                     Info-mode
  2219.  BS                                     Editing Buffers
  2220.  DEL                                    Editing Buffers
  2221.  DOWN                                   Moving Around Buffers
  2222.  ESC <                                  Moving Around Buffers
  2223.  ESC >                                  Moving Around Buffers
  2224.  ESC ?                                  The Buffer Prompt
  2225.  ESC @                                  Marking Blocks
  2226.  ESC BS                                 Editing Buffers
  2227.  ESC DEL                                Editing Buffers
  2228.  ESC TAB                                Moving Around Buffers
  2229.  ESC a                                  Keeping ChangeLogs
  2230.  ESC b                                  Moving Around Buffers
  2231.  ESC Ctrl-x                             Lisp-mode
  2232.  ESC d                                  Editing Buffers
  2233.  ESC f                                  Moving Around Buffers
  2234.  ESC h                                  Marking Blocks
  2235.  ESC i                                  Moving Around Buffers
  2236.  ESC i                                  Editing Buffers
  2237.  ESC l                                  Editing Buffers
  2238.  ESC m                                  Moving Around Buffers
  2239.  ESC P                                  Commands for Replacing
  2240.  ESC p                                  Commands for Replacing
  2241.  ESC u                                  Editing Buffers
  2242.  ESC v                                  Moving Around Buffers
  2243.  ESC w                                  Commands on Blocks
  2244.  ESC x clear-buffer                     Other Buffer Commands
  2245.  ESC x compile                          Running a Compilation
  2246.  ESC x goto-line                        Moving Around Buffers
  2247.  ESC x grep                             Using Grep
  2248.  ESC x grep-buffer                      Using Grep
  2249.  ESC x recover-file                     Other Buffer Commands
  2250.  ESC x revert-buffer                    Other Buffer Commands
  2251.  ESC x rotate-buffers-forward           Other Buffer Commands
  2252.  ESC [                                  Moving Around Buffers
  2253.  ESC ]                                  Moving Around Buffers
  2254.  F1                                     Using Marks
  2255.  F2                                     Using Marks
  2256.  F3                                     Using Marks
  2257.  HELP                                   The Help System
  2258.  HELP a                                 The Help System
  2259.  HELP e                                 The Help System
  2260.  HELP f                                 The Help System
  2261.  HELP h                                 The Help System
  2262.  HELP i                                 The Help System
  2263.  HELP m                                 The Help System
  2264.  HELP v                                 The Help System
  2265.  LEFT                                   Moving Around Buffers
  2266.  RET                                    The Buffer Prompt
  2267.  RET                                    Lisp-mode
  2268.  RET                                    C-mode
  2269.  RET                                    Editing Buffers
  2270.  RIGHT                                  Moving Around Buffers
  2271.  SPC                                    Info-mode
  2272.  TAB                                    The Buffer Prompt
  2273.  TAB                                    Lisp-mode
  2274.  TAB                                    C-mode
  2275.  TAB                                    Moving Around Buffers
  2276.  UP                                     Moving Around Buffers
  2277.  {                                      C-mode
  2278.  }                                      C-mode
  2279.  b                                      Info-mode
  2280.  Ctrl                                   Modifiers
  2281.  Ctrl-@                                 Using Marks
  2282.  Ctrl-DEL                               Editing Buffers
  2283.  Ctrl-DOWN                              Moving Around Buffers
  2284.  Ctrl-RET                               Lisp-mode
  2285.  Ctrl-SPC                               Marking Blocks
  2286.  Ctrl-TAB                               Moving Around Buffers
  2287.  Ctrl-UP                                Moving Around Buffers
  2288.  Ctrl-a                                 Moving Around Buffers
  2289.  Ctrl-b                                 Moving Around Buffers
  2290.  Ctrl-c Ctrl-c {                        Texinfo-mode
  2291.  Ctrl-c Ctrl-c }                        Texinfo-mode
  2292.  Ctrl-c Ctrl-c c                        Texinfo-mode
  2293.  Ctrl-c Ctrl-c Ctrl-m                   Texinfo-mode
  2294.  Ctrl-c Ctrl-c d                        Texinfo-mode
  2295.  Ctrl-c Ctrl-c e                        Texinfo-mode
  2296.  Ctrl-c Ctrl-c f                        Texinfo-mode
  2297.  Ctrl-c Ctrl-c i                        Texinfo-mode
  2298.  Ctrl-c Ctrl-c l                        Texinfo-mode
  2299.  Ctrl-c Ctrl-c m                        Texinfo-mode
  2300.  Ctrl-c Ctrl-c n                        Texinfo-mode
  2301.  Ctrl-c Ctrl-c s                        Texinfo-mode
  2302.  Ctrl-c Ctrl-c v                        Texinfo-mode
  2303.  Ctrl-c Ctrl-c ]                        Texinfo-mode
  2304.  Ctrl-d                                 Editing Buffers
  2305.  Ctrl-e                                 Moving Around Buffers
  2306.  Ctrl-f                                 Moving Around Buffers
  2307.  Ctrl-g                                 The Buffer Prompt
  2308.  Ctrl-h                                 The Help System
  2309.  Ctrl-h a                               The Help System
  2310.  Ctrl-h e                               The Help System
  2311.  Ctrl-h f                               The Help System
  2312.  Ctrl-h h                               The Help System
  2313.  Ctrl-h i                               The Help System
  2314.  Ctrl-h m                               The Help System
  2315.  Ctrl-h v                               The Help System
  2316.  Ctrl-i                                 Commands on Blocks
  2317.  Ctrl-j                                 Moving Around Buffers
  2318.  Ctrl-M                                 Rectangular Blocks
  2319.  Ctrl-m                                 Marking Blocks
  2320.  Ctrl-n                                 Moving Around Buffers
  2321.  Ctrl-o                                 Editing Buffers
  2322.  Ctrl-p                                 Moving Around Buffers
  2323.  Ctrl-R                                 Commands for Searching
  2324.  Ctrl-r                                 Commands for Searching
  2325.  Ctrl-S                                 Commands for Searching
  2326.  Ctrl-s                                 Commands for Searching
  2327.  Ctrl-v                                 Moving Around Buffers
  2328.  Ctrl-w                                 Commands on Blocks
  2329.  Ctrl-x 0                               Killing Windows
  2330.  Ctrl-x 1                               Killing Windows
  2331.  Ctrl-x 2                               Creating Windows
  2332.  Ctrl-x 4 a                             Creating Windows
  2333.  Ctrl-x 4 b                             Creating Windows
  2334.  Ctrl-x 4 b                             Displaying Buffers
  2335.  Ctrl-x 4 Ctrl-f                        Creating Windows
  2336.  Ctrl-x 4 f                             Creating Windows
  2337.  Ctrl-x 4 h                             Creating Windows
  2338.  Ctrl-x 4 i                             Creating Windows
  2339.  Ctrl-x 4 `                             Creating Windows
  2340.  Ctrl-x 5                               Creating Windows
  2341.  Ctrl-x b                               Displaying Buffers
  2342.  Ctrl-x Ctrl-f                          Commands To Load Files
  2343.  Ctrl-x Ctrl-l                          Commands on Blocks
  2344.  Ctrl-x Ctrl-r                          Commands To Load Files
  2345.  Ctrl-x Ctrl-s                          Commands To Save Files
  2346.  Ctrl-x Ctrl-u                          Commands on Blocks
  2347.  Ctrl-x Ctrl-v                          Commands To Load Files
  2348.  Ctrl-x Ctrl-w                          Commands To Save Files
  2349.  Ctrl-x Ctrl-x                          Using Marks
  2350.  Ctrl-x h                               Marking Blocks
  2351.  Ctrl-x i                               Commands To Load Files
  2352.  Ctrl-x k                               Deleting Buffers
  2353.  Ctrl-x s                               Other Buffer Commands
  2354.  Ctrl-x s                               Commands To Save Files
  2355.  Ctrl-x `                               Finding Errors
  2356.  Ctrl-Y                                 Rectangular Blocks
  2357.  Ctrl-Y                                 Cutting And Pasting
  2358.  Ctrl-y                                 Cutting And Pasting
  2359.  Ctrl-z                                 Commands on Blocks
  2360.  f                                      Info-mode
  2361.  g                                      Info-mode
  2362.  l                                      Info-mode
  2363.  LMB                                    Modifiers
  2364.  m                                      Info-mode
  2365.  Meta                                   Modifiers
  2366.  Meta-DOWN                              Moving Around Buffers
  2367.  Meta-LEFT                              Moving Around Buffers
  2368.  Meta-RIGHT                             Moving Around Buffers
  2369.  Meta-TAB                               Lisp-mode
  2370.  Meta-TAB                               C-mode
  2371.  Meta-UP                                Moving Around Buffers
  2372.  Meta-M                                 Marking Blocks
  2373.  Meta-m                                 Marking Blocks
  2374.  MMB                                    Modifiers
  2375.  n                                      Info-mode
  2376.  p                                      Info-mode
  2377.  q                                      Info-mode
  2378.  RMB                                    Modifiers
  2379.  Shift                                  Modifiers
  2380.  Shift-BS                               Editing Buffers
  2381.  Shift-DEL                              Editing Buffers
  2382.  Shift-DOWN                             Moving Around Buffers
  2383.  Shift-F1                               Using Marks
  2384.  Shift-F2                               Using Marks
  2385.  Shift-F3                               Using Marks
  2386.  Shift-LEFT                             Moving Around Buffers
  2387.  Shift-RET                              Lisp-mode
  2388.  Shift-RET                              C-mode
  2389.  Shift-RIGHT                            Moving Around Buffers
  2390.  Shift-TAB                              Moving Around Buffers
  2391.  Shift-UP                               Moving Around Buffers
  2392.  Space                                  Keys
  2393.  u                                      Info-mode
  2394.  
  2395. Concept Index
  2396. *************
  2397.  
  2398.  
  2399.  
  2400.  Address, my                            Reporting Bugs
  2401.  Arguments, startup                     Startup Options
  2402.  Auto-saving files                      Auto-Saving Files
  2403.  Automatic mode selection               Automatic Mode Selection
  2404.  Backup files                           Backup Files
  2405.  Blocks, commands                       Commands on Blocks
  2406.  Blocks, marking                        Marking Blocks
  2407.  Blocks, rectangular                    Rectangular Blocks
  2408.  Blocks, using                          Using Blocks
  2409.  Buffer                                 Editor Concepts
  2410.  Buffer prompt                          The Buffer Prompt
  2411.  Buffer, current                        Editor Concepts
  2412.  Buffers, deleting                      Deleting Buffers
  2413.  Buffers, displaying                    Displaying Buffers
  2414.  Buffers, editing                       Editing Buffers
  2415.  Buffers, moving around                 Moving Around Buffers
  2416.  Buffers, other commands                Other Buffer Commands
  2417.  Buffers, searching and replacing       Searching and Replacing
  2418.  Buffers, using                         Using Buffers
  2419.  Bugs, reporting                        Reporting Bugs
  2420.  C-mode                                 C-mode
  2421.  ChangeLogs, keeping                    Keeping ChangeLogs
  2422.  Columnar blocks                        Rectangular Blocks
  2423.  Command                                Editor Concepts
  2424.  Commands for replacing                 Commands for Replacing
  2425.  Commands for searching                 Commands for Searching
  2426.  Commands on blocks                     Commands on Blocks
  2427.  Commands to load files                 Commands To Load Files
  2428.  Commands to save files                 Commands To Save Files
  2429.  Commands, window                       Other Window Commands
  2430.  Compilation, finding errors            Finding Errors
  2431.  Compilation, running                   Running a Compilation
  2432.  Compiling programs                     Compiling Programs
  2433.  Concepts, editor                       Editor Concepts
  2434.  Copying                                Copying
  2435.  Copying text                           Cutting And Pasting
  2436.  Creating windows                       Creating Windows
  2437.  Current buffer                         Editor Concepts
  2438.  Current window                         Editor Concepts
  2439.  Cursor                                 Editor Concepts
  2440.  Customisation, simple                  Simple Customisation
  2441.  Cutting and pasting                    Cutting And Pasting
  2442.  Deleting buffers                       Deleting Buffers
  2443.  Deleting text                          Cutting And Pasting
  2444.  Displaying buffers                     Displaying Buffers
  2445.  Distribution conditions                Copying
  2446.  Editing buffers                        Editing Buffers
  2447.  Editing modes                          Editing Modes
  2448.  Editing modes, automatic selection     Automatic Mode Selection
  2449.  Editing modes, invoking                Invoking a Mode
  2450.  Editor concepts                        Editor Concepts
  2451.  Email, my address                      Reporting Bugs
  2452.  Embedding lisp in files                Embedding Lisp In Files
  2453.  Example key definitions                Example Keys
  2454.  Files, auto-saving                     Auto-Saving Files
  2455.  Files, backups                         Backup Files
  2456.  Files, loading and loading             Loading and Saving Files
  2457.  Finding errors                         Finding Errors
  2458.  Form                                   Editor Concepts
  2459.  Generic-mode                           Generic-mode
  2460.  Grep, using                            Using Grep
  2461.  Help system                            The Help System
  2462.  Help, starting                         The Help System
  2463.  Info browser                           Info-mode
  2464.  Info-mode                              Info-mode
  2465.  Initialisation procedure               Startup Procedure
  2466.  Introduction                           Introduction
  2467.  Invocation                             Invocation
  2468.  Invoking a mode                        Invoking a Mode
  2469.  Jade, Using                            Using Jade
  2470.  Keeping ChangeLogs                     Keeping ChangeLogs
  2471.  Key definitions                        Key Definitions
  2472.  Key definitions, examples              Example Keys
  2473.  Key Definitions, keys                  Keys
  2474.  Key definitions, modifiers             Modifiers
  2475.  Keys                                   Keys
  2476.  Killing windows                        Killing Windows
  2477.  License                                Copying
  2478.  Lisp                                   Editor Concepts
  2479.  Lisp-interactive-mode                  Lisp-mode
  2480.  Lisp-mode                              Lisp-mode
  2481.  Loading files                          Loading and Saving Files
  2482.  Marking blocks                         Marking Blocks
  2483.  Marks, using                           Using Marks
  2484.  Modes, automatic selection             Automatic Mode Selection
  2485.  Modes, editing                         Editing Modes
  2486.  Modes, invoking                        Invoking a Mode
  2487.  Modifiers                              Modifiers
  2488.  Moving around buffers                  Moving Around Buffers
  2489.  Options, startup                       Startup Options
  2490.  Other buffer commands                  Other Buffer Commands
  2491.  Other window commands                  Other Window Commands
  2492.  Pasting text                           Cutting And Pasting
  2493.  Programs, running                      Running a Compilation
  2494.  Prompt, buffer                         The Buffer Prompt
  2495.  Prompt, simple                         The Simple Prompt
  2496.  Prompt, using                          Using the Prompt
  2497.  Rectangular blocks                     Rectangular Blocks
  2498.  Regexps                                Regular Expressions
  2499.  Regular expression, definition         Editor Concepts
  2500.  Regular expressions                    Regular Expressions
  2501.  Replace, search and                    Searching and Replacing
  2502.  Replacing, commands for                Commands for Replacing
  2503.  Reporting bugs                         Reporting Bugs
  2504.  Requirements                           Systems Supported
  2505.  Running a compilation                  Running a Compilation
  2506.  Saving files                           Loading and Saving Files
  2507.  Searching and replacing                Searching and Replacing
  2508.  Searching, commands for                Commands for Searching
  2509.  Simple customisation                   Simple Customisation
  2510.  Simple prompt                          The Simple Prompt
  2511.  Starting jade                          Starting Jade
  2512.  Startup options                        Startup Options
  2513.  Startup procedure                      Startup Procedure
  2514.  Tab Expansion                          Loading and Saving Tabs
  2515.  Tabs, loading                          Loading and Saving Tabs
  2516.  Texinfo-mode                           Texinfo-mode
  2517.  Unix and X11 Jade                      Unix and X11 Jade
  2518.  Using blocks                           Using Blocks
  2519.  Using buffers                          Using Buffers
  2520.  Using grep                             Using Grep
  2521.  Using jade                             Using Jade
  2522.  Using marks                            Using Marks
  2523.  Using the prompt                       Using the Prompt
  2524.  Using windows                          Using Windows
  2525.  Variable                               Editor Concepts
  2526.  Window                                 Editor Concepts
  2527.  Window, current                        Editor Concepts
  2528.  Windows, creating                      Creating Windows
  2529.  Windows, killing                       Killing Windows
  2530.  Windows, other commands                Other Window Commands
  2531.  Windows, using                         Using Windows
  2532.  
  2533.