home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / util / edit / jade / man / jade.info-1 (.txt) < prev    next >
GNU Info File  |  1994-10-16  |  50KB  |  1,026 lines
  1. This is Info file jade.info, produced by Makeinfo-1.55 from the input
  2. file jade.texi.
  3. START-INFO-DIR-ENTRY
  4. * Jade: (jade).            An editor for X11 and AmigaDOS
  5. END-INFO-DIR-ENTRY
  6.    This is Edition 1.3, last updated 7 October 1994, of `The Jade
  7. Manual', for Jade, Version 3.2.
  8.    Jade is a text editor for X11 (on Unix) and the Amiga.
  9.    Copyright 1993, 1994 John Harper.
  10.    Permission is granted to make and distribute verbatim copies of this
  11. manual provided the copyright notice and this permission notice are
  12. preserved on all copies.
  13.    Permission is granted to copy and distribute modified versions of
  14. this manual under the conditions for verbatim copying, provided that
  15. the entire resulting derived work is distributed under the terms of a
  16. permission notice identical to this one.
  17. File: jade.info,  Node: Top,  Next: Copying,  Prev: (dir),  Up: (dir)
  18.    Jade is a highly flexible Emacs-style text editor for X11 (on Unix)
  19. and AmigaDOS.
  20.    This is Edition 1.3 of its documentation, last updated 7 October
  21. 1994 for Jade version 3.2.
  22. * Menu:
  23. * Copying::                     Distribution conditions
  24. * Introduction::                Brief introduction to Jade
  25. * News::                        New features in this release
  26. * Systems Supported::           The operating systems Jade supports
  27. * Editor Concepts::             Some ideas you should understand
  28. * Key Names::                   How keys are described in this manual
  29. * Starting Jade::               How to start the editor
  30. * Using Jade::                  Instructions for using the editor
  31. * Programming Jade::            How to extend Jade -- its Lisp system
  32. * Reporting Bugs::              How to contact me
  33. * Function Index::              Menu of all documented functions
  34. * Variable Index::              All variables which have been mentioned
  35. * Key Index::                   Menu of all key bindings
  36. * Concept Index::               Main index, references to all sections
  37. File: jade.info,  Node: Copying,  Next: Introduction,  Prev: Top,  Up: Top
  38. Copying
  39. *******
  40.    Jade is distributed under the terms of the GNU General Public
  41. License, this basically means that you can give it to anyone for any
  42. price as long as full source code is included. For the actual legalese
  43. see the file `COPYING' in the distribution. I reserve the right to use
  44. a different licence in future releases.
  45.    The only parts of Jade which are not my own work are the regexp
  46. code, this is by Henry Spencer (though I have made some small
  47. modifications) and is distributed under his conditions, and the ARexx
  48. interface in the Amiga version which is based on `MinRexx' by Radical
  49. Eye Software.
  50.    Be aware that there is absolutely NO WARRANTY for this program, you
  51. use it at your own risk. Obviously I hope there are no bugs, but I make
  52. no promises regarding the reliability of this software.
  53. File: jade.info,  Node: Introduction,  Next: News,  Prev: Copying,  Up: Top
  54. Introduction
  55. ************
  56.    Jade is a text editor primarily designed for programmers. It is
  57. easily customised through a Lisp-style extension language and can be
  58. tailored to the user's own requirements.
  59.    Jade is designed to run under a graphical windowing system, systems
  60. currently supported are the Commodore Amiga and the X Window System
  61. version 11 (but only under Unix).
  62.    It is the successor to the editor `Jed 2.10' which I released for the
  63. Amiga in early 1993. I have decided to rename it now that I have made an
  64. X11 version since there is already an editor called `Jed' available
  65. (there is no connection between the two, I haven't even looked at the
  66. other one). "Jade" is an anagram of "A Jed", if you want an acronym you
  67. could use "Just Another Damn Editor", if you can think of anything
  68. better please tell me.
  69.    Jade is compatible with GNU Emacs in terms of key presses and
  70. command names to a certain extent but it is not intended as a simple
  71. copy of Emacs (indeed, when I started this I had never actually used
  72. Emacs!). I have tried to take my favourite aspects of all the editors I
  73. have used as well as adding features that I have not found elsewhere.
  74. Consequently, it is very much the editor that *I* want -- you may not
  75. find it so appealing.
  76. File: jade.info,  Node: News,  Next: Systems Supported,  Prev: Introduction,  Up: Top
  77.    This chapter lists the major changes to Jade and which release they
  78. occurred in. Only changes relevant to you, the user, are detailed; for
  79. more explicit history see the `ChangeLog' files with the sources.
  80. Version 3.2
  81. ===========
  82.    * The programmer's manual has finally be written.
  83.    * Undo; devote as much memory as you want to keep track of all
  84.      modifications to a buffer which can then be wound back.
  85.    * Arguments can be given to commands as they're invoked.
  86.    * Buffer menu for interactive buffer manipulation.
  87.    * An Emacs-style local variables section can be embedded in a file;
  88.      replaces the naff `::jade-code::' thing.
  89.    * `Ctrl-k' (`kill-line') works at last.
  90.    * Now possible to interrupt jade while it's working (i.e. to let you
  91.      kill infinite loops).
  92.    * The Help system now has commands to list key bindings, display
  93.      what is bound to any key sequence.
  94.    * Use of the Latin-1 character set is now controlled by the minor
  95.      mode `latin-1-mode'.
  96.    * Can load and save compressed (compress or gzip) files into/out of
  97.      buffers transparently when running on Unix.
  98.    * Transposing commands; `transpose-chars', `transpose-words',
  99.      `transpose-exps'. Bound to `Ctrl-t', `Meta-t' and `Ctrl-Meta-t'
  100.      respectively.
  101.    * Can now run a shell in an editor buffer, very basic (no
  102.      completion) but it works okay.
  103.    * Support for using gdb through the shell interface, the current
  104.      frame's source code is highlighted in a separate window.
  105.    * `Ctrl-z' moves to `Ctrl-W' so that `Ctrl-z' can (de)iconify the
  106.      current window.
  107.    * Some programs written for the previous incarnation will need to be
  108.      altered; all will have to be recompiled.
  109. Version 3.1
  110. ===========
  111.    * Now properly supports characters which print as more than one
  112.      character (i.e. proper tabs, `^L', `\123', etc...). In general any
  113.      character can print as any sequence of up to four character-images.
  114.    * Doesn't expand tabs to spaces anymore, this means that loading and
  115.      saving of largish files is noticeably quicker.
  116.    * Files containing NUL characters can be edited (more or less)
  117.      successfully.  Some commands (notably the regexp matcher) still
  118.      don't like these characters but, in the main, binary files can be
  119.      edited successfully.
  120.    * Searching and replacing has changed, it's easier to use now and
  121.      replacing globally is built in.
  122.    * Many improvements to the Info viewer, not least, the dir file
  123.      doesn't have to have a tag-table anymore.
  124.    * Client editing. This lets you load files into a running editor
  125.      from a shell. For example, if your mailer runs an editor on the
  126.      message you're writing you can use the client to edit the message
  127.      in a Jade that you are running.
  128.    * The buffer prompt's completion is now controllable by the mouse as
  129.      well as the keyboard. Click the right button to complete the
  130.      current word.  Double-clicking the left mouse button on one of the
  131.      lines under the `::Completions::' line selects that completion.
  132.    * `text-mode' and `indented-text-mode' major-modes for editing
  133.      English language (as opposed to programming languages).
  134.    * Minor-modes. These provide small variations to the major-modes.
  135.      For example, `overwrite-mode' makes typed keys overwrite
  136.      whatever's under the cursor.  Also included is a minor mode to do
  137.      auto-filling (word wrap).
  138.    * On Unix, a tilde (`~') in a filename is handled properly in most
  139.      cases
  140.    * It is now possible to Meta qualify a key press and it will pretend
  141.      that you pressed ESC then the un-Meta'd key.
  142. File: jade.info,  Node: Systems Supported,  Next: Editor Concepts,  Prev: News,  Up: Top
  143. Requirements
  144. ************
  145.    Jade will only run on certain operating systems, this chapter
  146. details just what it needs as well as some notes relevant to each
  147. system.
  148. Amiga Jade
  149. ==========
  150.    The only real requirement for Jade running on an Amiga is that it
  151. must run an operating system revision of at least V37 (thats V2.04) and
  152. have about 300K free memory available.
  153.    It also needs more stack than the average Amiga application. For
  154. normal use 20K should be okay. If you want to use the Lisp compiler 50K
  155. would be a better bet.
  156.    It assumes that its directory is pointed to by the `JADE:'
  157. assignment.  This means that the main Lisp files are stored in
  158. `JADE:lisp/' and the file of doc-strings is `JADE:DOC'.
  159. X11 Jade
  160. ========
  161.    Jade will only run on version 11 of X, it has absolutely no support
  162. for character terminals or different windowing systems. As long as it
  163. compiles it should work on your system.
  164.    One problem you might find is that the Backspace and Delete keys
  165. don't work properly. As far as I have been able to find out, most X
  166. terminals map both the Backspace (normally at the top-right of the
  167. alpha-keyboard) and the Delete (normally somewhere above the cursor
  168. keys) keys to the `Delete' keysym. Obviously, since I want these keys
  169. to have different effects (1) this is no good. What I decided to do
  170. about this was two things,
  171.   1. Use `xmodmap' to map the Delete key to the `Backspace' keysym.
  172.      This may sound backwards but most programs seem to use the
  173.      `Delete' keysym as what I call `Backspace' so mapping as I
  174.      described doesn't break this.
  175.      To do this, I have the following in my `.Xmodmap' file
  176.           keycode 107 = Backspace
  177.      Note that the `107' is the Delete key's key code on *my* keyboard,
  178.      your keyboard may, and probably will, be different.
  179.   2. In the function which binds descriptions of key presses to Lisp
  180.      forms, swap the meanings of the `Backspace' and `Delete' keysyms.
  181.    This means that everything works okay! You can bind to Delete key
  182. and it will work properly.
  183.    ---------- Footnotes ----------
  184.    (1)  Backspace should rub out the key before the cursor and Delete
  185. should delete the character under the cursor
  186. File: jade.info,  Node: Editor Concepts,  Next: Key Names,  Prev: Systems Supported,  Up: Top
  187. Editor Concepts
  188. ***************
  189.    Before I describe the editor in detail there are several concepts
  190. which you should be familiar with. Some will be explained in more
  191. detail later.
  192. "buffer"
  193.      Buffers are used by the editor to store the text that you are
  194.      editing.  Broadly speaking, each buffer holds the contents of one
  195.      text-file loaded into the editor (it is not necessary for each
  196.      buffer to be associated with a file, some buffers exist for other
  197.      purposes for example the `*jade*' buffer is used to interact with
  198.      the Lisp system).
  199. "current buffer"
  200.      The buffer being edited in the current window (see below), most
  201.      editor commands work on this buffer unless told otherwise.
  202. "window"
  203.      Corresponds to a window in the window-system. Each window can
  204.      display one buffer at a single time (although a buffer may be
  205.      displayed in more than one window at once).
  206. "current window"
  207.      Jade always keeps track of which one of its windows is active. It
  208.      is called the current window. Whenever you type a key or press a
  209.      mouse button in one of Jade's windows, that window automatically
  210.      becomes the current window.  Amongst other things, all messages
  211.      from the editor are displayed in the status line of the current
  212.      window.
  213. "cursor"
  214.      The cursor marks your current position in the current buffer (see
  215.      above), when you type something it is inserted into the buffer
  216.      between the cursor and the character preceding it (unless you type
  217.      a command).
  218. "status line"
  219.      One line in a window is devoted to displaying messages from the
  220.      editor, *Note Using Windows::.
  221. "Lisp"
  222.      The programming language which Jade uses, although the internals
  223.      of the editor are written in C, all commands are written in a
  224.      dialect of Lisp (even if the command only calls a C function).
  225.      Jade contains an interpreter, compiler and debugger for this
  226.      language. *Note Programming Jade::.
  227. "variable"
  228.      Variables are used to store Lisp values, each variable has a
  229.      unique name.  Note that unlike many programming languages
  230.      variables in Lisp are *not* typed, the data values themselves have
  231.      a type associated with them.
  232. "form"
  233.      A form is a single Lisp expression. For example, all of these are
  234.      forms:
  235.           foo
  236.           42
  237.           "hello"
  238.           (setq foo 200)
  239. "command"
  240.      A command is a sequence of Lisp forms which may be called
  241.      interactively (i.e.  from the keyboard). It may be a key sequence
  242.      (such as `Ctrl-x Ctrl-f') or a Lisp function to evaluate (such as
  243.      `find-file').
  244. "regular expression"
  245.      A regular expression is a string which is used to match against
  246.      other strings.  It has a special syntax which allows you to form a
  247.      kind of template against which the other strings can be matched.
  248.      They are used extensively by the editor, but you -- the user --
  249.      will mainly encounter them when searching and replacing strings in
  250.      buffers.
  251. File: jade.info,  Node: Key Names,  Next: Starting Jade,  Prev: Editor Concepts,  Up: Top
  252. Key Names
  253. *********
  254.    In this manual I have adopted a consistent notation for all key
  255. presses, since most editor commands are invoked via a typed key
  256. sequence it is very important that you can decipher this notation.
  257.    Note that the term `input event' (or `event') and the term `key
  258. press' have been used interchangeably throughout this manual.  A `key
  259. press' may mean a mouse event, they don't always come from the keyboard.
  260.    Every key press has a set of "modifiers"; these are the keys such as
  261. "Shift" or "Control" which don't actually produce a character when
  262. typed, they only effect the rest of the keyboard. Each key, then, can
  263. have one or more modifiers.
  264.    The name of an event consists of zero or more hyphen-separated
  265. modifier names, followed by a hyphen and the name of the actual event.
  266.    Some commands are triggered by more than one of these key presses;
  267. press each key (or do whatever is necessary to precipitate the input
  268. event) in turn to invoke the command.
  269.    Note that the case of modifiers is not important, however some of
  270. the keys *are*, so you should always specify them in their correct case.
  271. * Menu:
  272. * Modifiers::                   Names of modifier keys
  273. * Keys::                        Names of actual keys
  274. * Example Keys::                Some examples and what they mean
  275. File: jade.info,  Node: Modifiers,  Next: Keys,  Up: Key Names
  276. Modifiers
  277. =========
  278. "Shift"
  279. "SFT"
  280.      The shift key.
  281. "Ctrl"
  282. "CTL"
  283.      The control key, or its equivalent.
  284. "Meta"
  285.      This depends on the window-system, on X11 it is the "Mod1"
  286.      modifier, on the Amiga the "Alt" key. When the `meta-sends-esc'
  287.      variable is non-nil the Meta modifier is treated specially,
  288.       - Variable: meta-sends-esc
  289.           When non-nil, any Meta-modified key presses are expanded into
  290.           a sequence of two key presses, ESC and the pressed key minus
  291.           its Meta modifier.  For example typing `Meta-f' would expand
  292.           to `ESC f'. This feature is provided for compatibility with
  293.           GNU Emacs.
  294.           What this really means is that when the option is enabled (it
  295.           is by default) you can either type the key sequence `ESC X'
  296.           or the sequence `Meta-X' (where Meta is your keyboard's meta
  297.           key) to invoke a command described as `Meta-X'.
  298. "LMB"
  299.      The left mouse button.
  300. "MMB"
  301.      The middle mouse button.
  302. "RMB"
  303.      The right mouse button.
  304.    As well as these, there are also some others, "Mod1" to "Mod5"
  305. represent the X11 modifiers of the same name. "Button1" to "Button5"
  306. also correspond to their X11 counterparts (Button1 to Button3 are LMB
  307. to RMB). For Amiga users, "Amiga" corresponds to the Amiga key (this is
  308. the same as Mod2).
  309. File: jade.info,  Node: Keys,  Next: Example Keys,  Prev: Modifiers,  Up: Key Names
  310.    As far as possible each single character key-definition corresponds
  311. to where that character is on the keyboard (a is `a', etc...).
  312.    When using an Amiga this should be true for *all* keys since the
  313. Amiga's "keymap.library" makes it easy to look up what key a character
  314. belongs to.  However, this is not so easy on X11. All of the standard
  315. ASCII character set should be okay, but the more esoteric characters
  316. may have to be specified by the names of their X11 keysym (without the
  317. `XK_' prefix). Look in the <X11/keysymdef.h> include file for all
  318. keysyms, for example `XK_question' would have to be used for `?' if the
  319. editor didn't treat it, and many others, specially.
  320.    Some keys which don't follow this pattern are
  321. "SPC"
  322. "Space"
  323.      The space bar.
  324. "TAB"
  325.      The tab key.
  326. "RET"
  327. "Return"
  328.      The return key.
  329. "ESC"
  330. "Escape"
  331.      The escape key.
  332. "Backspace"
  333.      The backspace key.
  334. "DEL"
  335. "Delete"
  336.      The delete key.
  337. "Help"
  338.      The help key, not all keyboards have this.
  339.      The cursor up key.
  340. "Down"
  341.      The cursor down key
  342. "Left"
  343.      The cursor left key.
  344. "Right"
  345.      The cursor right key.
  346. "KP_Enter"
  347. "KP_Multiply"
  348. "KP_Divide"
  349. "KP_Minus"
  350. "KP_Add"
  351. "KP_Decimal"
  352. "KP_N"
  353.      Keys on the numeric keypad. For KP_N, N is a digit.
  354. "Click1"
  355.      Single clicking a mouse button.
  356. "Click2"
  357.      Double clicking a mouse button.
  358. "Off"
  359.      Releasing a mouse button.
  360. "Move"
  361.      Moving the mouse. This doesn't work on X11 yet.
  362. File: jade.info,  Node: Example Keys,  Prev: Keys,  Up: Key Names
  363. Example Keys
  364. ============
  365.    Some examples of proper key names are,
  366. `Ctrl-x'
  367.      Hold down Control, type x.
  368. `Meta-Shift-RET'
  369.      Hold down Meta and Shift, then type the Return key, or
  370.      alternatively, type the Escape key then hold down Shift and type
  371.      Return.
  372. `LMB-Click1'
  373.      Click the left mouse button once.
  374. `Ctrl-RMB-Click1'
  375.      Hold down Ctrl then click the right mouse button once.
  376. File: jade.info,  Node: Starting Jade,  Next: Using Jade,  Prev: Key Names,  Up: Top
  377. Starting Jade
  378. *************
  379.    This chapter describes Jade's initialisation process. This includes
  380. how to start it, what options it will accept and what it actually does
  381. after being started.
  382. * Menu:
  383. * Invocation::                  How to start the editor
  384. * Startup Options::             Arguments specified on the command line
  385. * Startup Procedure::           What happens on startup
  386. File: jade.info,  Node: Invocation,  Next: Startup Options,  Up: Starting Jade
  387. Invocation
  388. ==========
  389.    Since Jade supports two vastly different operating systems they both
  390. need to be covered separately.
  391. Amiga
  392. -----
  393.    The normal way to start Jade on the Amiga is to type its name at the
  394. Shell (or CLI) together with any options (*note Startup Options::.) you
  395. want. Note that these options are in the traditional Unix style, a dash
  396. followed by the option name and any arguments, not the standard
  397. AmigaDOS method.
  398.    It is also possible to invoke the editor from the Workbench, simply
  399. double clicking on its icon will cause Jade to open its initial window.
  400. Unfortunately there is no support for passing arguments via Tool Types,
  401. nor is there any way to create icons with saved files. This is largely
  402. due to the fact that I rarely use the Workbench -- if enough people
  403. complain about this I will probably fix it. Jade doesn't have an icon
  404. yet, you'll have to make one yourself.
  405.    Jade should be started like most other Unix programs, type its name
  406. and any arguments to a shell. It must be able to connect to an X server
  407. (preferably the one controlling your terminal), the `-display' option
  408. can be used if needed.
  409. File: jade.info,  Node: Startup Options,  Next: Startup Procedure,  Prev: Invocation,  Up: Starting Jade
  410. Startup Options
  411. ===============
  412.    The acceptable options can be split into three classes. Note that
  413. they must be specified on the command line in order of their class.
  414. This means that, for example, the `-rc' option must be after the `-font'
  415. option.
  416.    So, the general usage pattern is
  417.      jade [SYSTEM-DEPENDENT-OPTIONS] [STANDARD-OPTIONS] [LISP-OPTIONS]
  418.    Note that the LISP-OPTIONS may include files to be loaded.
  419.   1. System dependent options.
  420.         * Options for the Amiga system.
  421.          `-pubscreen SCREEN-NAME'
  422.                Defines the name of the public screen on which the first
  423.                window is opened. By default (or if SCREEN-NAME doesn't
  424.                exits) the `Workbench' screen is used.
  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.          `-stack STACK-SIZE'
  432.                When this argument is given Jade allocates a new stack.
  433.                STACK-SIZE is a decimal number defining the size (in
  434.                bytes) of the new stack.
  435.                If this argument is not given Jade simply uses the stack
  436.                that AmigaDOS gave it.
  437.         * Options for X11.
  438.           There are two types of options to the X11 version of the
  439.           editor, those specified on the command line and those defined
  440.           in the resource database (i.e.  in your `.Xdefaults' file).
  441.           Resources are looked for under two names, firstly the name
  442.           under which the editor was invoked (normally `jade'), if this
  443.           fails it tries again with the name `Jade'. Naturally, options
  444.           specified on the command line override those in the resource
  445.           database.
  446.          `-display DISPLAY-NAME'
  447.                Defines the name of the X display to open, by default
  448.                the contents of the environment variable `DISPLAY'. It
  449.                is a string of the form `HOST-NAME:NUMBER.SCREEN-NUMBER'.
  450.          `-name NAME'
  451.                The name to use when looking up resource values, this
  452.                replaces the base name of the executable (normally
  453.                `jade').
  454.          `-geometry GEOM-SPEC'
  455.                Specifies where to place the first window on the screen.
  456.                This is a standard X style geometry specification.
  457.          `-fg FOREGROUND-COLOUR'
  458.          Resource: `fg: FOREGROUND-COLOUR'
  459.                The colour of the window's foreground (i.e. the text).
  460.          `-bg BACKGROUND-COLOUR'
  461.          Resource: `bg: BACKGROUND-COLOUR'
  462.                The background colour of the window.
  463.          `-font FONT-NAME'
  464.          Resource: `font: FONT-NAME'
  465.                The name of the font used for all text in the initial
  466.                window.
  467.   2. Standard options.
  468.     `-rc LISP-FILE'
  469.           Load the Lisp script LISP-FILE instead of the normal
  470.           initialisation script (`init'). Warning: the editor depends
  471.           heavily on the normal file, if you change this without due
  472.           care the editor could be unusable -- no keys will be bound
  473.           and many standard functions won't exist.
  474.     `-v'
  475.           Print the version and revision numbers of this copy of the
  476.           editor then quit.
  477.     `-log-msgs'
  478.           This option makes all messages which are displayed in the
  479.           status line also be written to the standard error stream.
  480.           This is sometimes useful for debugging purposes.
  481.   3. All other options are passed to the Lisp initialisation process in
  482.      the variable `command-line-args', these are available to any Lisp
  483.      packages loaded in the initialisation script. Any left after that
  484.      are scanned for the following options,
  485.     `-f FUNCTION'
  486.           Call the Lisp function FUNCTION.
  487.     `-l FILE'
  488.           Load the Lisp file FILE.
  489.     `-q'
  490.           Quit cleanly.
  491.     `FILE'
  492.           Load the file of text FILE into a new buffer.
  493.    An example command line for starting Jade from a Unix shell could be
  494.      $ jade -fg white -bg black -log-msgs foo.c bar.jl
  495.    This means white text, black background, save messages and load the
  496. files `foo.c' and `bar.jl'.
  497. File: jade.info,  Node: Startup Procedure,  Prev: Startup Options,  Up: Starting Jade
  498. Startup Procedure
  499. =================
  500.    This is a description of what happens when the editor initialises
  501. itself.
  502.   1. Firstly lots of internal data structures are created, memory
  503.      pools, symbols and their symbol-table (including all the primitive
  504.      Lisp functions).
  505.   2. The window-system is initialised (parse the system-dependent
  506.      options, and the xrdb resources if in X).
  507.   3. Parse the standard options.
  508.   4. Create the initial window and the first buffer to display in it
  509.      (this is the buffer called `*jade*').
  510.   5. Load the initialisation script, this is either the Lisp file
  511.      called `init' or whatever was given to the `-rc' command line
  512.      option.
  513.      Some selected highlights of what the standard file does are,
  514.         * Load lots of Lisp files, some notable ones are
  515.          `autoload'
  516.                Initialise the autoload stubs.
  517.          `loadkeys'
  518.                Creates the standard keymaps and key bindings.
  519.         * Try to find the user's personal startup file, this is
  520.           normally the file `.jaderc' in their home directory (1).
  521.         * Load any files which were specified on the command line.
  522.   6. Start the top-level recursive edit, this doesn't exit until the
  523.      editor does.
  524.    ---------- Footnotes ----------
  525.    (1)  The Amiga has no notion of a user's home directory, Jade uses
  526. the contents of the environment variable `HOME', or if this doesn't
  527. exist the `SYS:' assignment.
  528. File: jade.info,  Node: Using Jade,  Next: Programming Jade,  Prev: Starting Jade,  Up: Top
  529. Using Jade
  530. **********
  531.    This chapter of the manual is meant to teach you to *use* the editor,
  532. because of this I have attempted to reduce references to the Lisp
  533. extension language to an absolute minimum.
  534. * Menu:
  535. * Invoking Commands::           How to use the commands and key-sequences
  536.                                   described in this manual.
  537. * Command Arguments::           Many commands can be modified by prefixing
  538.                                   them with a numeric argument
  539. * The Help System::             Online help facilities
  540. * Loading and Saving Files::    Manipulating files
  541. * Editing Buffers::             Simple editing commands
  542. * Moving Around Buffers::       Commands for moving the cursor
  543. * Undo::                        Go back in time
  544. * Editing Units::               Characters, words, lines, etc...
  545. * Cutting And Pasting::         How to insert text from the clipboard
  546. * Using Blocks::                Highlighting regions to manipulate
  547. * Killing::                     Deleting text for later insertion
  548. * Searching and Replacing::     Searching the buffer for a regexp
  549. * Editing Modes::               Editing different types of files
  550. * Minor Modes::                 Small alterations to editing modes
  551. * Using Buffers::               Selecting & deleting buffers
  552. * Using Windows::               Opening new windows
  553. * Using the Prompt::            Entering strings and completion
  554. * Using Marks::                 Recording positions in files
  555. * Interrupting Jade::           Breaking out of commands
  556. * Recursive Editing::           Editing within a command
  557. * Character Images::            How to get a Latin1 character set
  558. * Client Editing::              Using Jade from other programs
  559. * Compiling Programs::          Help for developing programs
  560. * Info Mode::                   Reading Info files with Jade
  561. * Shell::                       Using a shell inside a buffer
  562. * Simple Customisation::        Configuring Jade
  563. File: jade.info,  Node: Invoking Commands,  Next: Command Arguments,  Up: Using Jade
  564. Invoking Commands
  565. =================
  566.    Throughout this manual I have documented the key sequences you have
  567. to enter to make the editor perform a certain action. In fact, the key
  568. sequences are mapped to "commands" when they are typed and it is the
  569. *command* which performs the action.
  570.    Commands are simply pieces of Lisp code, usually with a unique name
  571. associated with that command. If you know the name of a command it is
  572. possible to invoke it using the `Meta-x' key sequence; simply type
  573. `Meta-x COMMAND RET' where COMMAND is the name of the command you wish
  574. to invoke.
  575. `Meta-x'
  576.      Prompt for the name of a command (completion is available) then
  577.      invoke it.
  578.    For the sake of simplicity I have often referred to key sequences as
  579. commands; what I actually mean is that the key sequence is bound to the
  580. command. For example the key sequence `Ctrl-x Ctrl-f' opens a file, in
  581. fact the key sequence `Ctrl-x Ctrl-f' is bound to the command
  582. `find-file', this Lisp function actually loads the file.
  583.    More detailed information about commands is available in the
  584. programmer's manual, see *Note Programming Jade::.
  585. File: jade.info,  Node: Command Arguments,  Next: The Help System,  Prev: Invoking Commands,  Up: Using Jade
  586. Command Arguments
  587. =================
  588.    The actions of many commands can be altered by giving them a numeric
  589. argument, this argument is entered immediately prior to invoking the
  590. command (they are technically called prefix arguments).
  591.    Each argument is built using a number of special key sequences,
  592. `Meta-0' to `Meta-9'
  593.      Append a digit to the end of the current prefix argument. Use a
  594.      sequence of these keys to build up a decimal number. For example
  595.      typing `Meta-1 Meta-0 Meta-0' creates an argument of 100 for the
  596.      following command.
  597. `Meta--'
  598.      (That's `Meta-minus'.) Negates the value of current argument, if
  599.      the command is invoked after a single `Meta--' prefix the actual
  600.      argument is -1.
  601. `Ctrl-u'
  602.      Successive `Ctrl-u' key presses multiply the argument by 4 each
  603.      time.  Note that any existing argument entered by the numeric or
  604.      minus commands (described above) is discarded with the first
  605.      `Ctrl-u'.
  606. File: jade.info,  Node: The Help System,  Next: Loading and Saving Files,  Prev: Command Arguments,  Up: Using Jade
  607. The Help System
  608. ===============
  609.    To invoke the help system type the key sequence `Ctrl-h' or if your
  610. keyboard has it the `HELP' key.
  611.    A prompt will be displayed in the status line showing you which keys
  612. you can press next to enter one of the main options of the help system
  613. explained below. Alternatively, you can type either `Ctrl-h' or `HELP'
  614. again to display some text telling you more about the help system and
  615. how to use it.
  616.    The help system is exited after successfully invoking one of the
  617. commands described below or typing anything which is not a recognised
  618. command to the help system.
  619.      To list all function names matching REGEXP, type `a REGEXP RET'
  620.      when in the help system.
  621.      Prints all key bindings and their associated commands which are
  622.      installed in the current buffer.
  623.      Similarly to the `a' command, to list all variable names matching
  624.      REGEXP, type `e REGEXP RET' when in the help system.
  625.      Displays the online documentation for a function. After invoking
  626.      this option type the name of the function.
  627.      Shows some helpful text describing how to use the help system.
  628.      Enters the Info viewer. This allows you to browse through files
  629.      written in the Info hypertext format. For more information see
  630.      *Note Info Mode::, for more information on Info files in general
  631.      see *Note Info: (info)Top.
  632.      Displays the command (with its documentation) for a key sequence.
  633.      After typing `Ctrl-h k' enter the key sequence you want documented
  634.      as if you were going to invoke the command.
  635.      Display the documentation for the current major mode.
  636.      Displays the online documentation and current value of a variable.
  637.      Type the name of the variable after invoking this option.
  638. File: jade.info,  Node: Loading and Saving Files,  Next: Editing Buffers,  Prev: The Help System,  Up: Using Jade
  639. Loading and Saving Files
  640. ========================
  641.    Since `Jade' is a text editor its main function is to edit files of
  642. text.  This means that you must be able to read the text contained in a
  643. file into one of the editor's buffers, then save it back to disk when
  644. you have finished editing it. That is what this section deals with.
  645. * Menu:
  646. * Commands To Load Files::      Key sequences to load files
  647. * Commands To Save Files::      How to save a buffer
  648. * File Variables::              Local variables defined in files
  649. * Backup Files::                Making backups
  650. * Auto-Saving Files::           Files can be saved periodically
  651. * Accessing Compressed Files::  Reading and writing gzipped files
  652. * Other File Commands::         How to delete, rename or copy files
  653. File: jade.info,  Node: Commands To Load Files,  Next: Commands To Save Files,  Up: Loading and Saving Files
  654. Commands To Load Files
  655. ----------------------
  656.    There are several commands used to load files into buffers, these
  657. `Ctrl-x Ctrl-f'
  658.      Prompts for the name of a file (using file-completion) and display
  659.      the buffer containing that file. If the file has not already been
  660.      loaded it will be read into a new buffer.
  661. `Ctrl-x Ctrl-v'
  662.      Prompts for the name of a file, the current buffer is killed and
  663.      the buffer in which the prompted-for file is being edited is
  664.      displayed. As in `find-file' it will be read into a new buffer if
  665.      it is not already in memory.
  666. `Ctrl-x Ctrl-r'
  667.      Similar to `find-file' except that the buffer is marked as being
  668.      read-only. This means that no modifications can be made to the
  669.      buffer.
  670. `Ctrl-x i'
  671.      Prompts for a file, then inserts it into the current buffer at the
  672.      cursor position.
  673.    You can use the prompt's completion feature to expand abbreviated
  674. filenames typed to the prompt, for more information see *Note The
  675. Buffer Prompt::.
  676. File: jade.info,  Node: Commands To Save Files,  Next: File Variables,  Prev: Commands To Load Files,  Up: Loading and Saving Files
  677. Commands To Save Files
  678. ----------------------
  679.    These are the commands used to save buffers and the key sequences
  680. associated with them,
  681. `Ctrl-x Ctrl-s'
  682.      Saves the current buffer to the file that it is associated with
  683.      (this is either the file that it was loaded from or something else
  684.      set by the function `set-file-name'). If no modifications have
  685.      been made to the file since it was loaded it won't be saved (a
  686.      message will be displayed warning you of this).
  687. `Ctrl-x Ctrl-w'
  688.      Prompts for a name to save the file as. The file associated with
  689.      this buffer is renamed and the file is saved as its new name.
  690. `Ctrl-x s'
  691.      For each buffer which has been modified since it was loaded, ask
  692.      the user if it should be saved or not. If so, the command
  693.      `save-file' is used to save the file
  694. File: jade.info,  Node: File Variables,  Next: Backup Files,  Prev: Commands To Save Files,  Up: Loading and Saving Files
  695. File Variables
  696. --------------
  697.    It is often useful to define `local' values of certain variables
  698. which only come into effect when a particular file is being edited.
  699. Jade allows you to include a special section in a file which, when the
  700. file is loaded, is used to give the variables specified buffer-local
  701. values. (For more information about buffer-local variables see *Note
  702. Buffer-Local Variables::.)
  703.    The special section must be somewhere in the last twenty lines of a
  704. file, and must be formatted as in the following example,
  705.      XXX Local Variables: YYY
  706.      XXX VARIABLE:VALUE YYY
  707.      ...
  708.      XXX End: YYY
  709. That is, the string `Local Variables:' followed by as many lines
  710. defining local values as necessary then the string `End:'. The two
  711. strings `XXX' and `YYY' may be anything (even nothing!) as long as they
  712. are the same on each line. They are normally used to put the local
  713. variable section into a comment in a source file.
  714.    For example, in a Texinfo source file the following piece of text at
  715. the bottom of the file would set the column at which lines are broken to
  716. 74 (note that `@c' introduces a comment in Texinfo).
  717.      @c Local Variables:
  718.      @c fill-column:74
  719.      @c End:
  720.    Two pseudo-variables which can be set using a local variables section
  721. are `mode' and `eval'. Setting the `mode' variable actually defines the
  722. major mode to use with the file (*note Editing Modes::.) while setting
  723. `eval' actually evaluates the Lisp form VALUE then discards its value.
  724.    For example,
  725.      /* Local Variables: */
  726.      /* mode:C */
  727.      /* eval:(message "How pointless!") */
  728.      /* End: */
  729. This Forces the file to be edited with the C mode and displays a
  730. pointless message. Note that no variables called `mode' or `eval' are
  731. actually set.
  732.    Several variables are used to control how the local variables feature
  733. works.
  734.  - Variable: enable-local-variables
  735.      Defines how to process the `Local Variables:' section of a file:
  736.      `nil' means to ignore it, `t' means process it as normal and
  737.      anything else means that each variable being set has to be
  738.      confirmed by the user. Its default value it `t'.
  739.  - Variable: enable-local-eval
  740.      This variable defines how the pseudo-variable `eval' is treated in
  741.      a local variables list, it works in the same way as the
  742.      `enable-local-variables' variable does. Its default value is
  743.      `maybe', making each form be confirmed before being evaluated.
  744.  - Variable: local-variable-lines
  745.      Defines how many lines at the bottom of a file are scanned for the
  746.      `Local Variables:' marker, by default it is 20.
  747.    Note that this feature is compatible with GNU Emacs, and since I have
  748. tried to keep the names of variables compatible as well, there should
  749. be few problems.
  750. File: jade.info,  Node: Backup Files,  Next: Auto-Saving Files,  Prev: File Variables,  Up: Loading and Saving Files
  751. Backup Files
  752. ------------
  753.    The editor can optionally preserve the previous contents of a file
  754. when it is about to be overwritten by the saving of a buffer. It does
  755. this by renaming the old file, `foo' as `foo~' (the original name plus
  756. a tilde appended to it) before it is obliterated.
  757.  - Variable: make-backup-files
  758.      This variable controls whether or not backups are made of files
  759.      about to overwritten by the function `write-buffer' (i.e. the
  760.      commands `save-file' and `save-file-as'). When non-nil the old
  761.      instance of the file is renamed so that it has a tilde appended to
  762.      its old name.
  763.  - Variable: backup-by-copying
  764.      When non-nil all backups are made by copying the original file
  765.      instead of renaming it as the backup file. This is slower but less
  766.      destructive.
  767.  - Variable: else-backup-by-copying
  768.      If `backup-by-copying' is `nil' and renaming the original file
  769.      would not be a good idea (i.e. it might break a link or something)
  770.      and this variable is non-`nil' the backup will be made by copying
  771.      the original file.
  772. File: jade.info,  Node: Auto-Saving Files,  Next: Accessing Compressed Files,  Prev: Backup Files,  Up: Loading and Saving Files
  773. Auto-Saving Files
  774. -----------------
  775.    Jade is able to save snapshots of a buffer's contents at set time
  776. intervals.  When this time interval expires and the buffer has been
  777. modified since it was last (auto-) saved to disk (and the editor is
  778. idle) the buffer is saved to a special file (usually the base component
  779. of the file's name surrounded by `#' characters in the file's
  780. directory).
  781.  - Variable: auto-save-p
  782.      When non-nil this makes the function `open-file' (and therefore the
  783.      commands `find-file', etc) flag that the file it just read should
  784.      be auto saved regularly.
  785.  - Variable: default-auto-save-interval
  786.      This is the default number of seconds between each auto save. This
  787.      variable is only referenced when each file is opened.
  788.      Its standard value is 120 seconds.
  789.  - Variable: auto-save-interval
  790.      This buffer-local variable controls the number of seconds between
  791.      each auto-save of the buffer it belongs to. A value of zero means
  792.      never auto-save.
  793.    When the buffer is saved properly (i.e. with `save-file' and
  794. friends) its auto-save file is deleted. Note that this doesn't happen
  795. when you kill a buffer and an auto-save file exists (in case you didn't
  796. mean to kill the buffer).
  797.    To recover an auto-saved file (i.e. after an editor crash or
  798. something!) use the command `recover-file'.
  799. `Meta-x recover-file'
  800.      Loads the auto-saved copy of the file stored in this buffer
  801.      overwriting its current contents (if any changes are to be lost
  802.      you will have to agree to losing them).
  803. File: jade.info,  Node: Accessing Compressed Files,  Next: Other File Commands,  Prev: Auto-Saving Files,  Up: Loading and Saving Files
  804. Accessing Compressed Files
  805. --------------------------
  806.    Jade contains basic support for reading, inserting and writing
  807. buffers which have been compressed using the `gzip' or `compress'
  808. compression programs. When this feature is enabled such files are
  809. transparently decompressed when loaded into the buffer and compressed
  810. when saved back to a file.
  811.    Unfortunately this doesn't work on Amigas yet. To install it the
  812. Lisp form,
  813.      (require 'gzip)
  814. should be in your `.jaderc' file (or you can do this by hand in the
  815. `*jade*' buffer if you want).
  816.    After the `gzip' package has been installed any files loaded into
  817. buffers whose filename end in `.gz' or `.Z' are uncompressed, this
  818. suffix is stripped when searching for a major mode to install in the
  819. buffer but otherwise the buffer's filename is left intact.
  820.    Any buffer saved whose filename ends in one of the above suffixes is
  821. automatically compressed (`.gz' is compressed by `gzip', `.Z' by
  822. `compress').
  823. File: jade.info,  Node: Other File Commands,  Prev: Accessing Compressed Files,  Up: Loading and Saving Files
  824. Other File Commands
  825. -------------------
  826. `Meta-x delete-file RET FILE-NAME RET'
  827.      Deletes the file called FILE-NAME.
  828. `Meta-x rename-file RET SOURCE RET DEST RET'
  829.      Renames the file called SOURCE as the file DEST.
  830. `Meta-x copy-file RET SOURCE RET DEST RET'
  831.      Makes a copy of the file called SOURCE as the file DEST.
  832. File: jade.info,  Node: Editing Buffers,  Next: Moving Around Buffers,  Prev: Loading and Saving Files,  Up: Using Jade
  833. Editing Buffers
  834. ===============
  835.    The majority of keys when typed will simply insert themselves into
  836. the buffer (this is not always true but it's a good assumption) since
  837. they have not been bound. Typically this includes all normal characters
  838. (i.e. alphanumeric, punctuation, etc) as well as any of the more obtuse
  839. key-sequences which have not been bound to a function (`Ctrl-l' is one
  840. of the more useful of these).
  841.    The behaviour of the TAB key is different to many other editors -- it
  842. doesn't insert anything (unless a specific editing mode has bound it to
  843. something else, like `c-mode' for example), generally it just moves the
  844. cursor to the next tab stop. This is partly because Jade doesn't use
  845. "proper" tabs and partly because it makes it easier to move around a
  846. line (because the key sequence `Shift-TAB' moves to the previous tab
  847. stop).
  848.    Some miscellaneous editing commands follow.
  849. `RET'
  850.      This generally splits the line into two at the position of the
  851.      cursor, some editing modes may provide an option which
  852.      automatically indents the line after it's split.
  853. `Backspace'
  854.      Deletes the character before the cursor.
  855. `DEL'
  856. `Ctrl-d'
  857.      Deletes the character under the cursor.
  858. `Shift-Backspace'
  859.      Kills the characters between the start of the line and the cursor.
  860.      *Note Killing::.
  861. `Shift-DEL'
  862.      Kills the characters from the cursor to the end of the line.
  863. `Ctrl-DEL'
  864.      Kills the whole line.
  865. `Ctrl-o'
  866.      Splits the line in two at the cursor, but leaves the cursor in its
  867.      original position.
  868. `Meta-d'
  869. `Meta-DEL'
  870.      Kills from the cursor to the end of the current word.
  871. `Ctrl-k'
  872.      Kills from the cursor to the end of the line, or if the cursor is
  873.      at the end of the line from the cursor to the start of the next
  874.      line. Each successive `Ctrl-k' appends to the text in the kill
  875.      buffer.
  876. `Meta-l'
  877.      Makes the characters from the cursor to the end of the word lower
  878.      case.
  879. `Meta-u'
  880.      Upper cases the characters from the cursor to the end of the word.
  881. `Meta-c'
  882.      Capitalises the characters from the cursor to the end of the word,
  883.      this means make the first character upper case and the rest lower.
  884. `Meta-Backspace'
  885.      Kills from the cursor to the beginning of the word.
  886. File: jade.info,  Node: Moving Around Buffers,  Next: Undo,  Prev: Editing Buffers,  Up: Using Jade
  887. Moving Around Buffers
  888. =====================
  889.    Here is a selection of the most commonly used commands which move the
  890. cursor around the current buffer.
  891. `Ctrl-p'
  892.      Move one line up.
  893. `Down'
  894. `Ctrl-n'
  895.      Move one line down.
  896. `Left'
  897.      Move one column to the left, stopping at the first column.
  898. `Ctrl-b'
  899.      Move to the previous character, at the beginning of the line moves
  900.      to the end of the previous line.
  901. `Right'
  902.      Move one column to the right. This keeps moving past the end of
  903.      the line.
  904. `Ctrl-f'
  905.      Move to the next character, at the end of a line moves to the
  906.      start of the next line.
  907. `Shift-Up'
  908.      Move to the first line in the buffer.
  909. `Shift-Down'
  910.      Move to the last line in the buffer.
  911. `Meta-<'
  912.      Move to the first character in the buffer.
  913. `Meta->'
  914.      Move to the last character in the buffer.
  915. `Shift-Left'
  916. `Ctrl-a'
  917.      Move to the beginning of the current line.
  918. `Shift-Right'
  919. `Ctrl-e'
  920.      Move to the last character in the current line.
  921. `Ctrl-Up'
  922. `Meta-v'
  923.      Move to the previous screen of text.
  924. `Ctrl-Down'
  925. `Ctrl-v'
  926.      Move to the next screen of text.
  927. `Meta-Left'
  928. `Meta-b'
  929.      Move to the previous word.
  930. `Meta-Right'
  931. `Meta-f'
  932.      Move to the next word.
  933. `Meta-Up'
  934. `Meta-['
  935.      Move to the start of the previous paragraph.
  936. `Meta-Down'
  937. `Meta-]'
  938.      Move to the start of the next paragraph.
  939. `TAB'
  940. `Meta-i'
  941.      Insert a tab character, indenting the cursor to the next tab
  942.      position.
  943.      Note that some editing modes redefine TAB to make it indent the
  944.      current line to its correct depth.
  945. `Shift-TAB'
  946.      Move to the position of the previous tab.
  947. `Ctrl-TAB'
  948.      Move to the position of the next tab.
  949. `Meta-j'
  950.      Prompt for a line number and go to it.
  951. `Meta-m'
  952.      Move to the first non-space character in the current line.
  953. File: jade.info,  Node: Undo,  Next: Editing Units,  Prev: Moving Around Buffers,  Up: Using Jade
  954.    Jade makes it very easy to undo changes to a buffer, this is very
  955. useful when you realise that actually, *that wasn't* the part of the
  956. file you wanted to delete!
  957.    Basically to undo the last command type either `Ctrl-_' or `Ctrl-x
  958. u'.  If the last thing you did was to type some text into the buffer
  959. all the consecutively-typed characters count as one command.
  960.    To undo more than one command, simply type more than one `Ctrl-_' (or
  961. `Ctrl-x u') consecutively; this will progressively work its way back
  962. through the buffer's history. The first non-undo command cancels this
  963. effect, so if you undo too far back invoke a command which doesn't
  964. modify the buffer, then undo whatever you undid.
  965. `Ctrl-_'
  966. `Ctrl-x u'
  967.      Undo the previous command, or the last block of consecutively
  968.      typed characters.  Successive undo commands work backwards though
  969.      the undo-history until a non-undo command is invoked.
  970.    The exact amount of undo-information kept for each buffer is
  971. controlled by the `max-undo-size' variable. This defines the maximum
  972. number of bytes which may be devoted to undo-information in a single
  973. buffer, the default is 10000. No matter what this is set to, the last
  974. command is *always* recoverable.
  975.  - Variable: max-undo-size
  976.      The maximum memory which may be devoted to recording
  977.      undo-information in each buffer.
  978. File: jade.info,  Node: Editing Units,  Next: Cutting And Pasting,  Prev: Undo,  Up: Using Jade
  979. Editing Units
  980. =============
  981.    To make it easier to remember which key sequences do what Jade
  982. provides a number of commands which are similar to one another but
  983. operate on different "units" in the buffer. These related-commands are
  984. bound to the same key but with a different prefix or modifier. For
  985. example `Ctrl-f' moves forward one character while `Meta-f' moves
  986. forward one word.
  987. * Menu:
  988. * Editing Characters::          Commands operating on characters,
  989. * Editing Words::               words,
  990. * Editing Expressions::         expressions,
  991. * Editing Lines::               and lines.
  992. File: jade.info,  Node: Editing Characters,  Next: Editing Words,  Up: Editing Units
  993. Editing Characters
  994. ------------------
  995.    These are the commands which operate on characters. Note that when an
  996. argument (*note Command Arguments::.) is given to one of these commands
  997. it actually operates on *number* of characters. For example, if you
  998. want to delete the next 5 characters starting at the cursor type
  999. `Meta-5 Ctrl-d'.
  1000. `Ctrl-f'
  1001.      Move forward one character.
  1002. `Ctrl-b'
  1003.      Move back one character.
  1004. `Right'
  1005.      Move one character to the right, when the end of the line is
  1006.      encountered it's ignored and the cursor keeps moving to the right.
  1007. `Left'
  1008.      Move one character to the left, stops when the beginning of the
  1009.      line is reached.
  1010. `Ctrl-d'
  1011. `DEL'
  1012.      Deletes the character beneath the cursor.
  1013. `Backspace'
  1014.      Deletes the character before the cursor.
  1015. `Ctrl-t'
  1016.      Transposes the character before the cursor with the one under the
  1017.      cursor. When given an argument the character before the cursor is
  1018.      dragged forward over that many characters.
  1019. `Meta-SPC'
  1020.      Delete all white space characters surrounding the cursor leaving a
  1021.      single space in their place. If a prefix argument is given that
  1022.      many spaces are left.
  1023. `Meta-\'
  1024.      Delete all white space characters surrounding the cursor. This is
  1025.      equivalent to the key sequence `Meta-0 Meta-SPC'.
  1026.