Fresh Fish 5

home *** CD-ROM | disk | FTP | other *** search

/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / jade-3.0.lha / Jade / doc / jade.info-2 < prev next >

Wrap

GNU Info File | 1994-04-20 | 44.1 KB | 1,241 lines

This is Info file jade.info, produced by Makeinfo-1.55 from the input file jade.texi. This is Edition 1, last updated 19 April 1994, of `The Jade Manual', for Jade, Version 3.0. Jade is a text editor for Unix (with X11) and the Amiga. Copyright 1993, 1994 John Harper. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. This is so that jade doesn't try to eval the example use. ::jade-code:: ::end:: File: jade.info, Node: Commands for Searching, Next: Commands for Replacing, Prev: Regular Expressions, Up: Searching and Replacing Commands for Searching ---------------------- `Ctrl-s' Asks for a regular expression then tries to move to the start of the next match in this buffer. `Ctrl-S' Attempts to move to the next occurrence of the regexp which was last entered for the `Ctrl-s' or `Ctrl-r' commands. `Ctrl-r' Asks for a regexp, then moves to the start of previous occurrence of that regexp. `Ctrl-R' Attempts to move to the previous occurrence of the regexp which was last entered for the `Ctrl-s' or `Ctrl-r' commands. File: jade.info, Node: Commands for Replacing, Prev: Commands for Searching, Up: Searching and Replacing Commands for Replacing ---------------------- `ESC p' Asks for a template to replace the string under the cursor (which should match the regexp which the search commands last looked for. This string is then replaced with the expansion (re the string under the cursor) of the template you entered. `ESC P' Variant of the above, doesn't prompt for the template, uses the last one that you gave. File: jade.info, Node: Editing Modes, Next: Using Buffers, Prev: Searching and Replacing, Up: Using Jade Editing Modes ============= Modes are used to tailor the editor to the *type* of the file being edited in a buffer. They are normally a file of Lisp which installs the buffer-local keybindings and variables which are needed for that type of file. For example, C-mode is a mode used to edit C source code, its main function is to try to indent each line to its correct position automatically. At present there are only a small number of modes available. It is fairly straightforward to write a mode for most types of files though. * Menu: * Invoking a Mode:: How editing modes are invoked on a buffer * Generic-mode:: The foundations which all modes build from * C-mode:: Mode for C source code * Lisp-mode:: Mode for Lisp * Texinfo-mode:: Mode for editing Texinfo source * Info-mode:: The Info browser File: jade.info, Node: Invoking a Mode, Next: Generic-mode, Up: Editing Modes Invoking a Mode --------------- When a new file is loaded the function `init-mode' tries to find the mode that it should be edited with. If it is successful the mode will be automatically invoked. For more information see *Note Automatic Mode Selection:: and the documentation for `init-mode'. File: jade.info, Node: Generic-mode, Next: C-mode, Prev: Invoking a Mode, Up: Editing Modes Generic-mode ------------ This is not a mode as such since there is no Lisp code associated with it. When no mode is being used to edit the buffer, it is said to use the "Generic" mode. This is the base from which all other modes build, it consists of all the standard keybindings. Words are defined as one or more alphanumeric characters, paragraphs are separated by a single blank line. File: jade.info, Node: C-mode, Next: Lisp-mode, Prev: Generic-mode, Up: Editing Modes C-mode ------ `c-mode' is used for editing C source code files. Any files which end in `.c' or `.h' are automatically edited in this mode. It's one and only function is to try and indent lines to their correct depth, it doesn't always get it right but it works fairly well. The keys that it rebinds to achieve this are, `RET' Splits the line in two like normal. If `c-mode-auto-indent' is non-nil then the line that the cursor ends up on is automatically indented. `Shift-RET' Splits the line in two, doesn't take any notice of `c-mode-auto-indent'. `{' `}' `:' These keys are handled specially since the indentation of the line that they are inserted on may have to be adjusted. `TAB' Indents the current line to what the editor thinks is the correct position. `Meta-TAB' Moves the cursor to the next tab stop. Words are defined as being a sequence of alphanumeric or underscore characters, paragraphs as being separated by a `{' as the first character of a line. - Function: c-mode Editing mode for C source code. Automatically used for files ending in `.c' or `.h'. - Hook: c-mode-hook Called by `c-mode' each time it is called. - Variable: c-mode-tab Size of tab stops used by `c-mode'. - Variable: c-mode-auto-indent When non-nil `RET' will indent the line after splitting it. File: jade.info, Node: Lisp-mode, Next: Texinfo-mode, Prev: C-mode, Up: Editing Modes Lisp-mode --------- `lisp-mode' is used to edit files of Lisp intended to be read by the editor. It is *very* basic, all it does is count the number of unmatched parentheses in each line and indent it accordingly. I find this okay though. There is also support for using a buffer as a simple shell-interface to the editor's Lisp subsystem. Special keybindings are, `RET' Splits the line in two like normal. If `lisp-mode-auto-indent' is non-nil then the line that the cursor ends up on is automatically indented. `Shift-RET' Splits the line in two, doesn't take any notice of `c-mode-auto-indent'. `Ctrl-RET' Evaluates the paragraph preceding the cursor, prints the value on the next line. `TAB' Indents the current line. `Meta-TAB' Moves the cursor to the next tab stop. `ESC Ctrl-x' Evaluates the paragraph before the cursor, prints it's value in the status line. - Function: lisp-mode Editing mode for Jade's Lisp. Automatically invoked for files ending in `.jl'. - Hook: lisp-mode-hook Evaluated as soon as `lisp-mode' is called. - Variable: lisp-mode-tab Size of tabs in `lisp-mode'. - Variable: lisp-mode-auto-indent When non-nil `RET' indents lines after splitting them. File: jade.info, Node: Texinfo-mode, Next: Info-mode, Prev: Lisp-mode, Up: Editing Modes Texinfo-mode ------------ `texinfo-mode' is used to edit Texinfo source files, it is automatically selected for files ending in `.texi' or `.texinfo'. It provides a few basic keybindings to take some of the tedium out of editing these files. Paragraphs are separated by the regexp `^@node', ie, each node is a separate paragraph. The provided keybindings are, `Ctrl-c Ctrl-c c' Insert the string `@code{}', positioning the cursor between the braces. `Ctrl-c Ctrl-c d' Insert the string `@dfn{}', positioning the cursor between the braces. `Ctrl-c Ctrl-c e' Inserts the string `@end'. `Ctrl-c Ctrl-c f' Inserts the string `@file{}', the cursor is put between the braces. `Ctrl-c Ctrl-c i' Inserts the string `@item'. `Ctrl-c Ctrl-c l' Inserts the string `@lisp\n'. `Ctrl-c Ctrl-c m' Inserts the string `@menu\n'. `Ctrl-c Ctrl-c Ctrl-m' Prompts for the name of a node and makes a menuitem for it. `Ctrl-c Ctrl-c n' Prompts for each part of a node definition (name, next, prev, up) and inserts the `@node ...' string needed. `Ctrl-c Ctrl-c s' Inserts the string `@samp{}' and puts the cursor between the braces. `Ctrl-c Ctrl-c v' Inserts the string `@var{}', the cursor is put between the braces. `Ctrl-c Ctrl-c {' Inserts a pair of braces with the cursor between them. `Ctrl-c Ctrl-c }' `Ctrl-c Ctrl-c ]' Moves the cursor to the character after the next closing brace. - Function: texinfo-mode Mode for editing Texinfo source files. - Hook: texinfo-mode-hook Evaluated when `texinfo-mode' is invoked. File: jade.info, Node: Info-mode, Prev: Texinfo-mode, Up: Editing Modes Info-mode --------- Despite the name of this section there is actually no such thing as the `info-mode'. The Lisp file `info.jl' is what this section documents -- it is a set of Lisp functions which make a buffer (the `*Info*' buffer) into a simple browser for Info files. To invoke it type `Ctrl-h i' or `ESC x info', the `*Info' buffer will be displayed showing the `(dir)' node (the root of the Info documentation tree). When in the `*Info*' buffer these keybindings are in effect, `SPC' Moves to the next page. `BS' Moves to the previous page. `1' `2' `3' `4' `5' Move to the specified menuitem (`1' means the first, etc) in the menu in this node. `b' Move to the beginning of the current node. `f' Follow a reference, the one under the cursor if it exists. This command is still unimplemented. `g' Prompt for the name of a node and try to display it. `l' Go back to the last node that was displayed before this one. `m' Prompts for a menuitem (the one on the same line as the cursor is the default) and display the node it points to. `n' Display the next node. `p' Display the previous node. `u' Display the node "above" this one. `q' Quit the Info browser. This mode has a number of disadvantages over the other Info browsers available (ie, the standalone `info' program, or Emacs' Info viewer): * It depends wholly on being able to find a tag table in the Info file, if it can't it will complain and exit. * There is no support for the `*' node name. * As yet, no automatic following of references. * Seems not to work 100% with files formatted by Emacs, `makeinfo' formatted files work properly though. * No editing of modes. - Function: info [NODE-NAME] Invoke the Info viewer. If NODE-NAME is given display it, otherwise the node `(dir)' is used. File: jade.info, Node: Using Buffers, Next: Using Windows, Prev: Editing Modes, Up: Using Jade Using Buffers ============= As you have probably realised, buffers are probably the most important part of the editor. Each file that is being edited must be stored in a buffer. They are not restricted to editing files though, all buffers are reguarded as simply being a list of lines which can be displayed in a window and modified as needed. This means that they are very flexible, for example, the Lisp debugger uses a buffer for its user interface, the Info reader uses two buffers - one to display the current node, the other to store the file's tag table (never displayed, just used to look up the position of nodes). Each buffer has a name, generally buffers which contain proper files use the base part of the filename, while buffers which don't correspond to files use a word which starts and ends with asterisks (ie, `*jade*'). Each window can display one buffer at any time. There is no restriction on the number of windows which may display the same buffer at once. * Menu: * Displaying Buffers:: How to make a window display a buffer * Deleting Buffers:: Killing unwanted buffers * Other Buffer Commands:: General buffer manipulation File: jade.info, Node: Displaying Buffers, Next: Deleting Buffers, Up: Using Buffers Displaying Buffers ------------------ There are two main commands for switching to a different buffer, `Ctrl-x b' Prompt for the name of a buffer and display it in the current window. `Ctrl-x 4 b' In a different window (opens a new window if there is currently only one) prompt for the name of a buffer and display it in that window. Both commands are very similar, the `Ctrl-x 4 b' variant simply invokes a command to switch to a different window before calling the `Ctrl-x b' command. When typing the name of the new buffer you can use the prompt's completion mechanism to expand abbreviations (see *note The Buffer Prompt::.). If you just press RET with an empty prompt the default choice will be used. This will be the the buffer that was being shown in this window before the current buffer was selected (its name is displayed in the prompt's title). The `Ctrl-x Ctrl-f' command and its variants also switch buffers since they look an existing copy of the file in a buffer before loading it from disk, see *Note Commands To Load Files::. File: jade.info, Node: Deleting Buffers, Next: Other Buffer Commands, Prev: Displaying Buffers, Up: Using Buffers Deleting Buffers ---------------- There is no real need to delete buffers, those that haven't been used for a while just hang around at the end of the list. If you're short on memory though it can help to kill some of the unused buffers which you have accumulated. The command to kill a buffer is, `Ctrl-x k' Prompts for the name of a buffer (with completion) then deletes that buffer (if the buffer contains unsaved modifications you are asked if you really want to lose them). It is removed from all window's buffer-lists and any window which is displaying it is switched to another buffer (the next in its list). Any marks which point to the buffer are made "non-resident" (that is, they point to the name of the file in the buffer) and the buffer is discarded. File: jade.info, Node: Other Buffer Commands, Prev: Deleting Buffers, Up: Using Buffers Other Buffer Commands --------------------- `ESC x rotate-buffers-forward' Rotates the current window's list of buffers. `ESC x recover-file' Loads the auto-saved copy of the file stored in this buffer overwriting its current contents (if any changes are to be lost the user will have to agree to losing them). `ESC x revert-buffer' Restores the contents of the current buffer to the contents of the file that it was loaded from, if an auto-save file exists you are asked if you want to revert to that instead. `Ctrl-x s' Ask whether to save any modified buffers that exist. `ESC x clear-buffer' Deletes the contents of the current buffer. Beware, you *won't* be warned if you're about to lose any unsaved modifications! File: jade.info, Node: Using Windows, Next: Using the Prompt, Prev: Using Buffers, Up: Using Jade Using Windows ============= Windows have two main functions: to display the contents of buffers (but only one buffer at a time) and to collect input from you, the user. The editor *must* have at least one window open at all times, when you close the last window jade will exit, there is no limit to the number of windows which you may have open though. Each window is split into two parts, they are "The Main Display Area" This is the largest part of the window, it is where the buffer that this window is displaying is drawn. "The Status Line" A single line of text associated with the window, under X11 this is the area of the beneath the horizontal line at the bottom of the window, on the Amiga it is the title of the window. The status line is normally used to display information about this window and what it is displaying, it has this format: BUFFER-NAME [MODE-NAME] (COL,ROW) N line(s) [FLAGS] Where the individual parts mean BUFFER-NAME The name of the buffer being edited, it can have either a `+' or a `-' appended to it, a plus means the buffer has been modified since it was saved, a minus means that the buffer is read-only. MODE-NAME Most editing modes set this to their name. COL The column that the cursor is at. ROW The row number of the cursor. N The number of lines in this buffer FLAGS General one-character flags related to the status of the window and its buffer. Each window maintains a list of all buffers which are available for displaying, this is kept in order, from the most recently used to the least. This list (called `buffer-list') is used by some of the buffer manipulation commands when they are working out which buffer should be displayed. * Menu: * Creating Windows:: Opening a new window * Killing Windows:: How to close windows * Other Window Commands:: General window manipulation File: jade.info, Node: Creating Windows, Next: Killing Windows, Up: Using Windows Creating Windows ---------------- `Ctrl-x 2' `Ctrl-x 5' Opens a new window, it will have the most of the attributes that the current window does, things like: size, buffer, font, etc... If you are using X11 you will probably have to use your mouse to select its position, depending on the window manager you use, on the Amiga it will be created at the same position as the current window. `Ctrl-x 4 Ctrl-f' `Ctrl-x 4 f' In a different window, one will be created if only one window is open, find a file, for more details see *Note Commands To Load Files::. `Ctrl-x 4 a' In a different window add an entry to a change-log file. *Note Keeping ChangeLogs::. `Ctrl-x 4 b' In a different window, choose a buffer to display, similar to the `Ctrl-x b' command. *Note Displaying Buffers::. `Ctrl-x 4 h' Enter the help system in a different window. *Note The Help System::. `Ctrl-x 4 i' Enter the Info browser in a different window. *Note Info-mode::. `Ctrl-x 4 `' Display the next error (or whatever) in the `*compilation*' buffer in a different window. *Note Finding Errors::. File: jade.info, Node: Killing Windows, Next: Other Window Commands, Prev: Creating Windows, Up: Using Windows Killing Windows --------------- `Ctrl-x 0' Close the current window, if it is the last window that the editor has open it will exit (after asking you if you wish to lose any unsaved modifications to buffers). `Ctrl-x 1' Close all windows except the current one. File: jade.info, Node: Other Window Commands, Prev: Killing Windows, Up: Using Windows Other Window Commands --------------------- `Ctrl-x o' Activate the next window of the editor's. Under X11 this involves warping the [mouse-]cursor to the top left corner of the newly activated window. File: jade.info, Node: Using the Prompt, Next: Using Marks, Prev: Using Windows, Up: Using Jade Using the Prompt ================ There are two different styles of prompt that the editor uses when it wants you to enter a string. * Menu: * The Simple Prompt:: The prompt at the bottom of the window * The Buffer Prompt:: Prompt with its own buffer and completion File: jade.info, Node: The Simple Prompt, Next: The Buffer Prompt, Up: Using the Prompt The Simple Prompt ----------------- The simplest prompt uses the the bottom-most line in the window, it prints the prompt's title on the left hand side, you should type your response and then press the RET key. This prompt is very primitive, the only special commands that it has are, `BS' Delete the previous character. `UP' `DOWN' Replace the contents of the prompt with the last string entered. When you type `UP' or `DOWN' again the original contents are restored. `ESC' Cancel the prompt. All other keys are simply printed in the prompt -- whatever they are. File: jade.info, Node: The Buffer Prompt, Prev: The Simple Prompt, Up: Using the Prompt The Buffer Prompt ----------------- This type of prompt is more sophisticated. It creates a new buffer for you to type your response into (called `*prompt*'), the title of the prompt is displayed in the buffer's first line. Normally you type the answer to the prompt into the buffer and then press the RET key. All normal editor commands are available while you are using the prompt, you can switch buffers, load new files, whatever you like. Another advantage of this type of prompt is that it supports "completion", this allows you to type the beginning of your response then press the TAB key. What you have typed will be matched against the list of responses that the editor has (ie, when being prompted for the name of a file it will be matched against all available files), if a unique match is found your response will be completed to that match. If several potential completions are found, these will be displayed after the line `::Completions::' in the buffer and your response will only be completed as far as the potential completions are similar. For example, if you enter `fo' then press TAB and files called `foo' and `foobar' exist, the contents of the prompt will become `foo'. Completion is provided for many different things, some are: files, buffers, symbols, functions, variables, Info nodes, etc... The special commands for this type of prompt are, `TAB' Complete the contents of the prompt. If more than one potential completion exists they are printed in the buffer. `RET' Enter the result of this prompt. If you press RET while the cursor is on a printed potential completion (those under the `::Completions::' line) the whole line will be entered. Otherwise, just the text to the left of the cursor is entered. `ESC ?' Print all possible completions of the current prompt but do not try to actually change the contents of the prompt. `Ctrl-g' Cancel the prompt. File: jade.info, Node: Using Marks, Next: Compiling Programs, Prev: Using the Prompt, Up: Using Jade Using Marks =========== Marks are used to record a position in a file, as the file's buffer is modifed so does the position that the mark points to -- a mark will keep pointing at the same character no matter what happens (unless the character is deleted!). The other good thing about marks is that they point to files *not* buffers. This means that you can set a mark in a buffer, delete the buffer and then move to the position of the mark, the file will be reloaded and the cursor will point at the original character. Normally there are three user-accessible marks (1) and one special `auto-mark' which is used, amongst other things, to record the "previous" position of the cursor, allowing you to retrace your last major step. The commands available on marks are, `F1' `F2' `F3' Move to the mark #1, #2 or #3, depending on which function key is pressed (F1 means mark #1, etc...). If the file pointed to is not in memory it will be loaded into a new buffer. `Shift-F1' `Shift-F2' `Shift-F3' Set the position of mark #1, #2 or #3, depending on the function key. `Ctrl-x Ctrl-x' Swap the positions of the cursor and the `auto-mark'. `Ctrl-@' Set the position of the `auto-mark'. ---------- Footnotes ---------- (1) There is no reason why you can't have more, the editor sets no limitation on the number of marks available. This is just how I have set the editor up. File: jade.info, Node: Compiling Programs, Next: Simple Customisation, Prev: Using Marks, Up: Using Jade Compiling Programs ================== Jade has a number of features to help you develop programs, foremost is the ability to run a compilation inside one of the editor's buffers. Unfortunately, this is only possible when using the Unix operating system at the present. Once the compilation has finished you can then step through each error produced. * Menu: * Running a Compilation:: * Finding Errors:: Stepping through compile errors * Using Grep:: Searching files for a regexp * Keeping ChangeLogs:: Simple recording of file revisions File: jade.info, Node: Running a Compilation, Next: Finding Errors, Up: Compiling Programs Running a Compilation --------------------- The command to run a shell command in a buffer is, `ESC x compile' Prompts you for the command to execute, with a default of the last command you ran (starts as `make'). A shell process is created which runs asynchronously to the editor in the same directory as the current buffer's file was loaded from. The buffer `*compilation*' is selected and this is where all output from the program is printed. When the process finishes running a message is printed in the `*compilation*' buffer telling you its exit-code. Only one process may be run with the `compile' function at once. This command is not available on the Amiga version yet. File: jade.info, Node: Finding Errors, Next: Using Grep, Prev: Running a Compilation, Up: Compiling Programs Finding Errors -------------- When you have compiled something with the `ESC x compile' command it is possible to step through each of the errors that it produces. To do this use the command, `Ctrl-x `' `ESC x next-error' Displays the next error in the `*compilation*' buffer. The file that is in is loaded (if necessary) and the line with the error is found. If you edit a file which has errors in it, then try to find the next error (which is in the same file) everything will still work. The positions of errors are updated as the buffers are modified. The only exception to this is when you invoke the `next-error' function while the `*compilation*' buffer is still being written to. If more errors are produced in a file which has been modified since the compilation started it is likely that the positions will get out of sync. By default, the `next-error' function understands the type of error output that `gcc' produces. This is of the form, FILE:LINE-NUMBER:DESCRIPTION It is possible to use other formats though, the variables which control this are, - Variable: compile-error-regexp Regular expression to match a line containing an error. For `gcc' this is `^(.*):([0-9]+):(.+)'. - Variable: compile-file-expand Expansion template to produce the name of the file with the error, using `compile-error-regexp' and the line containing the error. By default this is `\1'. - Variable: compile-line-expand Similar to `compile-file-expand' except that it expands to a string defining the number of the line with the error. By default, `\2'. - Variable: compile-error-expand Similar to `compile-file-expand', but produces the description of the error. By default, `\3'. File: jade.info, Node: Using Grep, Next: Keeping ChangeLogs, Prev: Finding Errors, Up: Compiling Programs Using Grep ---------- It is often very useful to grep through a set of files looking for a regular expression, this is what the `grep' command does. With jade it is possible to run an external `grep' program in the `*compilation*' buffer. This then enables you to step through each grep hit using the `Ctrl-x `' command, *Note Finding Errors::. The commands to use grep are, `ESC x grep' Prompt for a string of arguments to give `grep', you do not need to provide the name of the program, or the `-n' switch, this is done automatically. The shell will do any filename-globbing on the arguments so it is advisable to surround the regular expression with single quotes. Note that the regular expression syntax will be different to that which jade uses. Also this command won't work on an Amiga. `ESC x grep-buffer' This command provides a method for scanning the current buffer for all lines matching a regular expression (which you are prompted for). It is written entirely in Lisp -- this means that the normal regular expression syntax is needed and it will work on an Amiga. File: jade.info, Node: Keeping ChangeLogs, Prev: Using Grep, Up: Compiling Programs Keeping ChangeLogs ------------------ A ChangeLog is a file (usually called `ChangeLog') which keeps a log of all changes you have made to the files in its directory. For example, the `src/ChangeLog' file for Jade keeps a list of changes made to the editor's source code. There is no magic involved, you simply use a command to add a new entry to a directory's log after modifying a file in that directory. You then have to enter a summary of the changes that you made. The command to do this is, `ESC a' Prompts for the name of a directory then lets you type a description of the changes you have made. If you enter more than one change in the same day (and from the same host) the same heading will be used. The heading consists of the time and date, your name, your login and the name of the host you're on. (1) ---------- Footnotes ---------- (1) On the Amiga there is no way to get these details. So, Jade looks for some environment variables, `USERNAME' for the login name, `HOSTNAME' for the name of the host and `REALNAME' for your actual name. File: jade.info, Node: Simple Customisation, Prev: Compiling Programs, Up: Using Jade Simple Customisation ==================== The best way to tailor the editor to your own requirements is with your personal startup file. This is called `.jaderc' in your home directory (1), it is a file of Lisp forms evaluated when Jade initialises itself. Usually, setting the values of variables in your startup file is enough to configure Jade how you want, the Lisp function to set a variable is called `setq', it's first argument is the name of the variable, it's second the value you wish to set it to. Normally this value will be one of the following data types, `"xyz"' A string `xyz'. `123' `0173' `0x7b' A number, all of the above have the value 123 (in decimal, octal and hexadecimal). `nil' `t' A boolean value, `nil' means false, or not true. `t' is the opposite (in fact, any value not `nil' is true). My `.jaderc' file looks something like this (note that semicolons introduce comments), ;; Size of tabs for C source is 4 (setq c-mode-tab 4) ;; Size of tabs for Lisp source is 2 (setq lisp-mode-tab 2) ;; On X11 scroll quarter of a screen at once, else a line at a time (setq y-scroll-step-ratio (if (x11-p) 4 0)) ;; When on an Amiga, flag that I don't want pulldown menus (when (amiga-p) (setq amiga-no-menus t)) ---------- Footnotes ---------- (1) On the Amiga, your home directory is defined as the contents of the environment variable `HOME'. File: jade.info, Node: Programming Jade, Next: Reporting Bugs, Prev: Using Jade, Up: Top Programming Jade **************** Unfortunately I haven't written this section yet. If you wan't to program Jade your best bet is to look at the files in the `lisp/' directory. Online documentation is available for all editor functions, *Note The Help System::. If you don't know Lisp look at any Lisp book. Jade's Lisp is fairly similar to Emacs-Lisp (though the editor-related functions differ greatly) so a good starting point may be the Emacs-Lisp manual. File: jade.info, Node: Reporting Bugs, Next: Function Index, Prev: Programming Jade, Up: Top Reporting Bugs ************** If you think you've found a bug in Jade I want to know about it, there is a list of problems that I am aware of in the `BUGS' file, if your's appears in here tell me anyway to make me fix it. When submitting bug reports I need to know as much as possible, both about the problem and the circumstamces in which it occurs. In general, send me as much information as possible, even if you think it's probably irrelevant. If you can, contact me via email, my address is `jsh@ukc.ac.uk'. If you don't get a reply within about a week it's probably a university vacation -- this means that I won't get your message for a while, if it's important try my postal address, this is, John Harper 91 Springdale Road Broadstone Dorset BH18 9BW England As well as bugs I'm interested in any comments you have about the editor, even if you just tell me you hate it (as long as you say *why* you hate it!). File: jade.info, Node: Function Index, Next: Variable Index, Prev: Reporting Bugs, Up: Top Function Index ************** * Menu: * c-mode: C-mode. * compile: Running a Compilation. * grep: Using Grep. * grep-buffer: Using Grep. * info: Info-mode. * lisp-mode: Lisp-mode. * next-error: Finding Errors. * recover-file: Other Buffer Commands. * revert-buffer: Other Buffer Commands. * rotate-buffers-forward: Other Buffer Commands. * texinfo-mode: Texinfo-mode. File: jade.info, Node: Variable Index, Next: Key Index, Prev: Function Index, Up: Top Variable Index ************** * Menu: * auto-save-interval: Auto-Saving Files. * auto-save-p: Auto-Saving Files. * backup-by-copying: Backup Files. * c-mode-auto-indent: C-mode. * c-mode-hook: C-mode. * c-mode-tab: C-mode. * compile-error-expand: Finding Errors. * compile-error-regexp: Finding Errors. * compile-file-expand: Finding Errors. * compile-line-expand: Finding Errors. * default-auto-save-interval: Auto-Saving Files. * disk-tab: Loading and Saving Tabs. * lisp-mode-auto-indent: Lisp-mode. * lisp-mode-hook: Lisp-mode. * lisp-mode-tab: Lisp-mode. * make-backup-files: Backup Files. * mode-alist: Automatic Mode Selection. * no-file-code-p: Embedding Lisp In Files. * save-tabs: Loading and Saving Tabs. * screen-tab: Moving Around Buffers. * texinfo-mode-hook: Texinfo-mode. * x-scroll-step-ratio: Moving Around Buffers. * y-scroll-step-ratio: Moving Around Buffers. File: jade.info, Node: Key Index, Next: Concept Index, Prev: Variable Index, Up: Top Key Index ********* * Menu: * 1: Info-mode. * 2: Info-mode. * 3: Info-mode. * 4: Info-mode. * 5: Info-mode. * :: C-mode. * BS: Info-mode. * BS: Editing Buffers. * DEL: Editing Buffers. * DOWN: Moving Around Buffers. * ESC <: Moving Around Buffers. * ESC >: Moving Around Buffers. * ESC ?: The Buffer Prompt. * ESC @: Marking Blocks. * ESC BS: Editing Buffers. * ESC DEL: Editing Buffers. * ESC TAB: Moving Around Buffers. * ESC a: Keeping ChangeLogs. * ESC b: Moving Around Buffers. * ESC Ctrl-x: Lisp-mode. * ESC d: Editing Buffers. * ESC f: Moving Around Buffers. * ESC h: Marking Blocks. * ESC i: Moving Around Buffers. * ESC i: Editing Buffers. * ESC l: Editing Buffers. * ESC m: Moving Around Buffers. * ESC P: Commands for Replacing. * ESC p: Commands for Replacing. * ESC u: Editing Buffers. * ESC v: Moving Around Buffers. * ESC w: Commands on Blocks. * ESC x clear-buffer: Other Buffer Commands. * ESC x compile: Running a Compilation. * ESC x goto-line: Moving Around Buffers. * ESC x grep: Using Grep. * ESC x grep-buffer: Using Grep. * ESC x recover-file: Other Buffer Commands. * ESC x revert-buffer: Other Buffer Commands. * ESC x rotate-buffers-forward: Other Buffer Commands. * ESC [: Moving Around Buffers. * ESC ]: Moving Around Buffers. * F1: Using Marks. * F2: Using Marks. * F3: Using Marks. * HELP: The Help System. * HELP a: The Help System. * HELP e: The Help System. * HELP f: The Help System. * HELP h: The Help System. * HELP i: The Help System. * HELP m: The Help System. * HELP v: The Help System. * LEFT: Moving Around Buffers. * RET: The Buffer Prompt. * RET: Lisp-mode. * RET: C-mode. * RET: Editing Buffers. * RIGHT: Moving Around Buffers. * SPC: Info-mode. * TAB: The Buffer Prompt. * TAB: Lisp-mode. * TAB: C-mode. * TAB: Moving Around Buffers. * UP: Moving Around Buffers. * {: C-mode. * }: C-mode. * b: Info-mode. * Ctrl: Modifiers. * Ctrl-@: Using Marks. * Ctrl-DEL: Editing Buffers. * Ctrl-DOWN: Moving Around Buffers. * Ctrl-RET: Lisp-mode. * Ctrl-SPC: Marking Blocks. * Ctrl-TAB: Moving Around Buffers. * Ctrl-UP: Moving Around Buffers. * Ctrl-a: Moving Around Buffers. * Ctrl-b: Moving Around Buffers. * Ctrl-c Ctrl-c {: Texinfo-mode. * Ctrl-c Ctrl-c }: Texinfo-mode. * Ctrl-c Ctrl-c c: Texinfo-mode. * Ctrl-c Ctrl-c Ctrl-m: Texinfo-mode. * Ctrl-c Ctrl-c d: Texinfo-mode. * Ctrl-c Ctrl-c e: Texinfo-mode. * Ctrl-c Ctrl-c f: Texinfo-mode. * Ctrl-c Ctrl-c i: Texinfo-mode. * Ctrl-c Ctrl-c l: Texinfo-mode. * Ctrl-c Ctrl-c m: Texinfo-mode. * Ctrl-c Ctrl-c n: Texinfo-mode. * Ctrl-c Ctrl-c s: Texinfo-mode. * Ctrl-c Ctrl-c v: Texinfo-mode. * Ctrl-c Ctrl-c ]: Texinfo-mode. * Ctrl-d: Editing Buffers. * Ctrl-e: Moving Around Buffers. * Ctrl-f: Moving Around Buffers. * Ctrl-g: The Buffer Prompt. * Ctrl-h: The Help System. * Ctrl-h a: The Help System. * Ctrl-h e: The Help System. * Ctrl-h f: The Help System. * Ctrl-h h: The Help System. * Ctrl-h i: The Help System. * Ctrl-h m: The Help System. * Ctrl-h v: The Help System. * Ctrl-i: Commands on Blocks. * Ctrl-j: Moving Around Buffers. * Ctrl-M: Rectangular Blocks. * Ctrl-m: Marking Blocks. * Ctrl-n: Moving Around Buffers. * Ctrl-o: Editing Buffers. * Ctrl-p: Moving Around Buffers. * Ctrl-R: Commands for Searching. * Ctrl-r: Commands for Searching. * Ctrl-S: Commands for Searching. * Ctrl-s: Commands for Searching. * Ctrl-v: Moving Around Buffers. * Ctrl-w: Commands on Blocks. * Ctrl-x 0: Killing Windows. * Ctrl-x 1: Killing Windows. * Ctrl-x 2: Creating Windows. * Ctrl-x 4 a: Creating Windows. * Ctrl-x 4 b: Creating Windows. * Ctrl-x 4 b: Displaying Buffers. * Ctrl-x 4 Ctrl-f: Creating Windows. * Ctrl-x 4 f: Creating Windows. * Ctrl-x 4 h: Creating Windows. * Ctrl-x 4 i: Creating Windows. * Ctrl-x 4 `: Creating Windows. * Ctrl-x 5: Creating Windows. * Ctrl-x b: Displaying Buffers. * Ctrl-x Ctrl-f: Commands To Load Files. * Ctrl-x Ctrl-l: Commands on Blocks. * Ctrl-x Ctrl-r: Commands To Load Files. * Ctrl-x Ctrl-s: Commands To Save Files. * Ctrl-x Ctrl-u: Commands on Blocks. * Ctrl-x Ctrl-v: Commands To Load Files. * Ctrl-x Ctrl-w: Commands To Save Files. * Ctrl-x Ctrl-x: Using Marks. * Ctrl-x h: Marking Blocks. * Ctrl-x i: Commands To Load Files. * Ctrl-x k: Deleting Buffers. * Ctrl-x s: Other Buffer Commands. * Ctrl-x s: Commands To Save Files. * Ctrl-x `: Finding Errors. * Ctrl-Y: Rectangular Blocks. * Ctrl-Y: Cutting And Pasting. * Ctrl-y: Cutting And Pasting. * Ctrl-z: Commands on Blocks. * f: Info-mode. * g: Info-mode. * l: Info-mode. * LMB: Modifiers. * m: Info-mode. * Meta: Modifiers. * Meta-DOWN: Moving Around Buffers. * Meta-LEFT: Moving Around Buffers. * Meta-RIGHT: Moving Around Buffers. * Meta-TAB: Lisp-mode. * Meta-TAB: C-mode. * Meta-UP: Moving Around Buffers. * Meta-M: Marking Blocks. * Meta-m: Marking Blocks. * MMB: Modifiers. * n: Info-mode. * p: Info-mode. * q: Info-mode. * RMB: Modifiers. * Shift: Modifiers. * Shift-BS: Editing Buffers. * Shift-DEL: Editing Buffers. * Shift-DOWN: Moving Around Buffers. * Shift-F1: Using Marks. * Shift-F2: Using Marks. * Shift-F3: Using Marks. * Shift-LEFT: Moving Around Buffers. * Shift-RET: Lisp-mode. * Shift-RET: C-mode. * Shift-RIGHT: Moving Around Buffers. * Shift-TAB: Moving Around Buffers. * Shift-UP: Moving Around Buffers. * Space: Keys. * u: Info-mode.