   This is the _Zile_ manual.

   Zile is another Emacs-clone.  Zile is a customizable,
self-documenting real-time display editor.  Zile was written to be as
similar as possible to Emacs; every Emacs user should feel at home with
Zile.

1 Overview
**********

The _Zile_ editor is written entirely in _ANSI C_.  It should run on
any POSIX system. It has also been ported to _EPOC_.

   Zile should really appear like Emacs, but a lot of good ideas were
also taken from other editors; in particular, ce for the internal
structure.

2 Features
**********

   - Small but fast and powerful.  It is very useful for small
     footprint installations (e.g. on floppy disk) or quick editing
     sessions.

   - 8-bit clean.  Zile can operate with binary files.

   - Looks like _Emacs_.  Most Zile key sequences and function names
     are identical to Emacs ones.

   - Multi buffer editing with multi level undo.  Zile can open an
     infinite number of files and can record an infinite sequence of
     undo operations (limited only by the amount of free memory).

   - Multi window.  Zile can display multiple windows on the screen.

   - Killing, yanking and registers.  The killing, yanking and register
     features of Emacs are available in Zile.

   - Minibuffer completion.  This works for `M-x' commands and for file
     names.

   - Auto fill (word wrap).  Zile automatically breaks the lines when
     they become too wide (if the Auto Fill Mode is enabled).

   - Auto line ending detection.  When a file is loaded, its line
     ending is detected automatically according to the first end of
     line, either LF, CR, CRLF or LFCR.  Files with mixed line endings
     will not be corrupted, but the line breaks will not be correctly
     displayed.

3 Invoking Zile
***************

The options are as follows:

`FILE'
     Edit file `FILE'.

`+NUMBER'
     For the first file the cursor will be positioned on the line
     specified by `NUMBER' (do not insert a space between the `+' sign
     and the number).

`--batch'
     Run in batch mode.

`-f, --funcall FUNC'
     Call Lisp function `FUNC'.

`--help'
     Print the command line syntax and exit.

`-q, --no-init-file'
     Do not load ~/.zile.

`--version'
     Print version information and exit.

4 Initialization file
*********************

When Zile is started, it normally loads the `.zile' file in your home
directory. We call this file your "initialization file" because it
specifies how to initialize Zile for you. You can use the command line
switch `-q' to tell Zile not to load the initialization file.

4.1 File syntax
===============

The initialization file is an ordinary Lisp file. See the Lisp manual
for more details. The file is most commonly used to initialize
variables; see the next subsection for an example.

4.2 A sample file
=================

This is the initialization file that comes with the Zile sources.

     ; .zile sample configuration

     ; Do not display the splash screen at startup [default: nil]
     (setq skip-splash-screen nil)

     ; The default tabulation width [default: 8]
     (setq tab-width 8)

     ; Always indent [default: t]
     ; Controls the operation of the TAB key.
     ; If enabled, hitting TAB always just indents the current line.
     ; Otherwise, hitting TAB indents the current line if point is at the
     ; left margin or in the line's indentation, otherwise it moves to the
     ; next tab stop.
     (setq tab-always-indent t)

     ; Insert real tabs [default: nil]
     ; If enabled, insert-tab inserts `real' tabs; otherwise, it always
     ; inserts spaces.
     (setq indent-tabs-mode nil)

     ; The default fill column (in Auto Fill Mode) [default: 72]
     (setq fill-column 72)

     ; Enable the Auto Fill Mode [default: nil]
     (setq auto-fill-mode nil)

     ; Kill whole line regardless of cursor position [default: nil]
     (setq kill-whole-line nil)

     ; Ignore case when searching [default: t]
     (setq case-fold-search t)

     ; Match case when replacing [default: t]
     (setq case-replace t)

     ; Enable beep [default: t]
     ; If enabled, a sound will be emitted on any error.
     (setq beep t)

     ; Standard indentation level [default: 4]
     ; Default number of columns for margin-changing functions to indent.
     (setq standard-indent 4)

     ; If enabled, deactivates the mark when the buffer contents change.
     ; Also enables highlighting of the region whenever the mark is active.
     ; The variable `highlight-nonselected-windows' controls whether to
     ; highlight all windows or just the selected window. [default: t]
     (setq transient-mark-mode t)

     ; If enabled, highlight region even in nonselected windows.
     ; [default: nil]
     (setq highlight-nonselected-windows nil)

     ; Specify whether backups are made [default: t]
     ; Non-nil means make a backup of a file the first time it is saved.
     ; This is done by appending `~' to the file name.
     (setq make-backup-files t)

     ; Specify target backup directory [default: nil]
     ; The directory for backup files, which must exist.
     ; If this variable is nil, the backup is made in the original file's
     ; directory.
     ; This value is used only when `make-backup-files' is `t'.
     (setq backup-directory nil)

     ; Rebind keys
     ; (global-set-key "key" 'func)

     ; Better bindings for when backspace generates C-h
     ;(global-set-key "\BS"    'backward-delete-char)
     ;(global-set-key "\C-h"   'backward-delete-char)
     ;(global-set-key "\M-:"   'mark-paragraph)
     ;(global-set-key "\M-hb"  'list-bindings)
     ;(global-set-key "\M-hd"  'describe-function)
     ;(global-set-key "\M-hf"  'describe-function)
     ;(global-set-key "\M-hF"  'view-zile-FAQ)
     ;(global-set-key "\M-hk"  'describe-key)
     ;(global-set-key "\M-hlr" 'list-registers)
     ;(global-set-key "\M-hs"  'help-config-sample)
     ;(global-set-key "\M-ht"  'help-with-tutorial)
     ;(global-set-key "\M-hw"  'where-is)
     ;(global-set-key "\M-hv"  'describe-variable)

5 Getting help
**************

This table contains the commands that can be used during an editing
session to get help.

`C-h F'
     Show the Frequently Asked Questions about Zile.

`C-h c'
     Describe briefly a key sequence.

`C-h d, C-h f'
     Describe a function.

`C-h h, <F1>'
     Show this manual.

`C-h k'
     Describe a key sequence.

`C-h b'
     Show the defined bindings.

`C-h l r'
     Show the defined registers.

`C-h s'
     Show a sample configuration file.

`C-h t'
     Show a tutorial window.

`C-h v'
     Describe a variable.

`C-h w'
     Show the key or keys to which a command is bound.

6 Key names
***********

This table contains the names of the keys that are used in Zile.

<SPC>
     Space

<RET>
     Return

<LFD>
     Linefeed

<TAB>
     Tab

<BS>
     Backspace

<ESC>
     Escape

<DEL>
     Delete

<CTRL>
     Control

<META>
     Meta (also known as <EDIT> or <ALT> on some keyboards).

   In key combinations, like `M-g', the `M-' prefix means hold the
<META> (or <EDIT> or <ALT>) key down while typing `g'.  The combination
`C-x' means hold the <CTRL> key down while typing `x'.

7 Key bindings
**************

This table contains the full list of commands associated with key
sequences.

   At run-time, you can list the current defined bindings with the
`list-bindings' command.

   This section includes only a brief documentation for each command.
For full documentation, see *Note Functions::.

`<TAB>'
     Insert indentation.  Bound to `indent-for-tab-command'.

`<RET>'
     Insert a new line.  Bound to `newline'.

`<BS>'
     Delete the previous character.  Bound to `backward-delete-char'.

`<INS>'
     Toggle Overwrite Mode.  Bound to `overwrite-mode'.

`C-@, C-<SPC>, <F5>'
     Set mark.  Bound to `set-mark-command'.

`C-\'
     Delete spaces and tabs around point.  Bound to
     `delete-horizontal-space'.

`C-a, <HOME>'
     Go to the beginning of line.  Bound to `beginning-of-line'.

`C-b, <LEFT>'
     Move cursor to the previous char.  Bound to `backward-char'.

`C-d, <DEL>'
     Delete current char.  Bound to `delete-char'.

`C-e, <END>'
     Go to the end of line.  Bound to `end-of-line'.

`C-f, <RIGHT>'
     Move cursor to the next char.  Bound to `forward-char'.

`C-g'
     Cancel current command.  Bound to `keyboard-quit'.

`C-h F'
     Show the FAQ.  Bound to `view-zile-FAQ'.

`C-h d, C-h f'
     Describe a function.  Bound to `describe-function'.

`C-h h, <F1>'
     Show a help window.  Bound to `help'.

`C-h k'
     Describe a key sequence.  Bound to `describe-key'.

`C-h b'
     Show the defined bindings.  Bound to `list-bindings'.

`C-h l r'
     Show the defined registers.  Bound to `list-registers'.

`C-h s'
     Show a sample configuration file.  Bound to `help-config-sample'.

`C-h t'
     Show a tutorial window.  Bound to `help-with-tutorial'.

`C-h v'
     Describe a variable.  Bound to `describe-variable'.

`C-j'
     Equivalent to <RET> followed by <TAB>.  Bound to
     `newline-and-indent'.

`C-k, <F6>'
     Kill line.  Bound to `kill-line'.

`C-l'
     Redraw display.  Bound to `recenter'.

`C-n, <DOWN>'
     Move cursor to the next line.  Bound to `next-line'.

`C-o'
     Insert a newline and leave point before it.  Bound to `open-line'.

`C-p, <UP>'
     Move cursor to the previous line.  Bound to `previous-line'.

`C-q'
     Read next input character and insert it.  Bound to `quoted-insert'.

`C-r'
     Incrementally search backward.  Bound to `isearch-backward'.

`C-s'
     Incrementally search forward.  Bound to `isearch-forward'.

`C-t'
     Transpose two characters.  Bound to `transpose-chars'.

`C-u'
     Begin a numeric argument for the following command.  Bound to
     `universal-argument'.

`C-v, <PGDN>'
     Scroll up one screen page.  Bound to `scroll-up'.

`C-w, <F7>'
     Kill region.  Bound to `kill-region'.

`C-x ('
     Start recording keyboard macro.  Bound to `start-kbd-macro'.

`C-x )'
     End recording keyboard macro.  Bound to `end-kbd-macro'.

`C-x 0'
     Delete the current window.  Bound to `delete-window'.

`C-x 1'
     Delete the other open windows.  Bound to `delete-other-windows'.

`C-x 2'
     Split current window.  Bound to `split-window'.

`C-x ^'
     Enlarge current window.  Bound to `enlarge-window'.

`C-x b'
     Switch to a buffer.  Bound to `switch-to-buffer'.

`C-x e, <F12>'
     Execute the last recorded keyboard macro.  Bound to
     `call-last-kbd-macro'.

`C-x f'
     Set the fill column.  Bound to `set-fill-column'.

`C-x h'
     Mark whole buffer.  Bound to `mark-whole-buffer'.

`C-x i'
     Insert the contents of a file.  Bound to `insert-file'.

`C-x k'
     Kill current buffer.  Bound to `kill-buffer'.

`C-x o'
     Select the other window.  Bound to `other-window'.

`C-x r i'
     Insert register.  Bound to `insert-register'.

`C-x r s'
     Copy region to register.  Bound to `copy-to-register'.

`C-x s'
     Save modified buffers.  Bound to `save-some-buffers'.

`C-x u, C-_, <F4>'
     Undo some previous changes.  Bound to `undo'.

`C-x C-o'
     Delete all but one of many consecutive blank lines.  Bound to
     `delete-blank-lines'.

`C-y, <F8>'
     Yank killed text.  Bound to `yank'.

`C-z, C-x C-z'
     Stop Zile and return to superior process.  Bound to `suspend-zile'.

`C-x C-b'
     List buffers.  Bound to `list-buffers'.

`C-x C-c'
     Save modified buffers and quit zile.  Bound to
     `save-buffers-kill-zile'.

`C-x C-f, <F2>'
     Find a file for editing.  Bound to `find-file'.

`C-x C-r'
     Edit a file read-only.  Bound to `find-file-read-only'.

`C-x C-l'
     Convert the region to lower case.  Bound to `downcase-region'.

`C-x C-q'
     Toggle Read Only Mode.  Bound to `toggle-read-only'.

`C-x C-s, <F3>'
     Save the current buffer.  Bound to `save-buffer'.

`C-x C-t'
     Transpose two lines.  Bound to `transpose-lines'.

`C-x C-u'
     Convert the region to upper case.  Bound to `upcase-region'.

`C-x C-v'
     Kill the current buffer and find a file for editing.  Bound to
     `find-alternate-file'.

`C-x C-w'
     Write buffer to a file.  Bound to `write-file'.

`C-x C-x'
     Exchange point and mark.  Bound to `exchange-point-and-mark'.

`M-<BS>'
     Kill word backward.  Bound to `backward-kill-word'.

`M-<SPC>'
     Delete spaces and tabs around point, leaving one space.  Bound to
     `just-one-space'.

`M-@'
     Mark the end of the next word.  Bound to `mark-word'.

`M-!'
     Execute an external command in inferior shell.  Bound to
     `shell-command'.

`M-|'
     Execute an external command on current region.  Bound to
     `shell-command-on-region'.

`M-<'
     Go to the beginning of buffer.  Bound to `beginning-of-buffer'.

`M->'
     Go to the end of buffer.  Bound to `end-of-buffer'.

`M-b'
     Move backward until encountering the end of a word.  Bound to
     `backward-word'.

`M-c'
     Capitalize the following word.  Bound to `capitalize-word'.

`M-d'
     Kill word.  Bound to `kill-word'.

`M-f'
     Move point forward one word.  Bound to `forward-word'.

`M-g'
     Read line number and go there.  Bound to `goto-line'.

`M-h'
     Put point at beginning of this paragraph, mark at end.  Bound to
     `mark-paragraph'.

`M-i'
     Insert a tab character.  Bound to `tab-to-tab-stop'.

`M-l'
     Convert following word to lower case.  Bound to `downcase-word'.

`M-m'
     Move point to the first non-whitespace character on this line.
     Bound to `back-to-indentation'.

`M-q'
     Fill paragraph at or after point.  Bound to `fill-paragraph'.

`M-s'
     Shrink current window.  Bound to `shrink-window'.

`M-t'
     Transpose two words.  Bound to `transpose-words'.

`M-u'
     Convert following word to upper case.  Bound to `upcase-word'.

`M-v, <PGUP>'
     Scroll down one screen page.  Bound to `scroll-down'.

`M-w'
     Save the region as if killed, but don't kill it.  Bound to
     `copy-region-as-kill'.

`M-x'
     Execute extended command.  Bound to `execute-extended-command'.

`M-{'
     Move backward one paragraph.  Bound to `backward-paragraph'.

`M-}'
     Move forward one paragraph.  Bound to `forward-paragraph'.

`C-M-@'
     Put mark after following expression.  Bound to `mark-sexp'.

`C-M-b'
     Move backward over a balanced expression.  Bound to
     `backward-sexp'.

`C-M-f'
     Move forward over a balanced expression.  Bound to `forward-sexp'.

`C-M-k'
     Kill balanced expression forward.  Bound to `kill-sexp'.

`C-M-r'
     Incrementally regexp search backward.  Bound to
     `isearch-backward-regexp'.

`C-M-s'
     Incrementally regexp search forward.  Bound to
     `isearch-forward-regexp'.

`C-M-t'
     Transpose two balanced expressions.  Bound to `transpose-sexps'.

8 Functions
***********

This table contains the full list of available functions, that can be
called with the `M-x' key (please note that most functions have a key
binding, anyway).

   Please note that some functions may be not available depending on
the compilation options given to `configure'.

`auto-fill-mode'
     Toggle Auto Fill Mode.  In Auto Fill Mode, inserting a space at a
     column beyond `fill-column' automatically breaks the line at a
     previous space.

`back-to-indentation'
     Move point to the first non-whitespace character on this line.

`backward-char'
     Move point left one character.  On attempt to pass beginning or
     end of buffer, stop and signal error.

`backward-delete-char'
     Delete the previous character.  Join lines if the character is a
     newline.

`backward-kill-word'
     Kill characters backward until encountering the end of a word.
     With argument, do this that many times.

`backward-paragraph'
     Move backward to start of paragraph.  With argument N, do it N
     times.

`backward-sexp'
     Move backward across one balanced expression (sexp).  With
     argument, do it that many times.  Negative arg -N means move
     forward across N balanced expressions.

`backward-word'
     Move backward until encountering the end of a word (forward if the
     argument is negative).  With argument, do this that many times.

`beginning-of-buffer'
     Move point to the beginning of the buffer; leave mark at previous
     position.

`beginning-of-line'
     Move point to beginning of current line.

`call-last-kbd-macro'
     Call the last keyboard macro that you defined with `C-x ('.  A
     prefix argument serves as a repeat count.

`capitalize-word'
     Capitalize the following word (or argument N words), moving over.
     This gives the word(s) a first character in upper case and the rest
     lower case.

`cd'
     Make the user specified directory become the current buffer's
     default directory.

`copy-region-as-kill'
     Save the region as if killed, but don't kill it.

`copy-to-register'
     Copy region into the user specified register.

`delete-blank-lines'
     On blank line, delete all surrounding blank lines, leaving just
     one.  On isolated blank line, delete that one.  On non-blank line,
     delete any immediately following blank lines.

`delete-char'
     Delete the following character.  Join lines if the character is a
     newline.

`delete-horizontal-space'
     Delete all spaces and tabs around point.

`delete-other-windows'
     Make the selected window fill the screen.

`just-one-space'
     Delete all spaces and tabs around point, leaving one space.

`delete-region'
     Delete the text between point and mark.

`delete-window'
     Remove the current window from the screen.

`describe-function'
     Display the full documentation of a function.

`describe-key'
     Display documentation of the function invoked by a key sequence.

`describe-variable'
     Display the full documentation of a variable.

`downcase-region'
     Convert the region to lower case.

`downcase-word'
     Convert following word (or argument N words) to lower case, moving
     over.

`end-kbd-macro'
     Finish defining a keyboard macro.  The definition was started by
     `C-x ('.  The macro is now available for use via `C-x e'.

`end-of-buffer'
     Move point to the end of the buffer; leave mark at previous
     position.

`end-of-line'
     Move point to end of current line.

`enlarge-window'
     Make current window one line bigger.

`exchange-point-and-mark'
     Put the mark where point is now, and point where the mark is now.

`execute-extended-command'
     Read function name, then read its arguments and call it.

`fill-paragraph'
     Fill paragraph at or after point.

`find-alternate-file'
     Find the file specified by the user, select its buffer, kill
     previous buffer.  If the current buffer now contains an empty file
     that you just visited (presumably by mistake), use this command to
     visit the file you really want.

`find-file'
     Edit the specified file.  Switch to a buffer visiting the file,
     creating one if none already exists.

`find-file-read-only'
     Edit the specified file but don't allow changes.  Like `find-file'
     but marks buffer as read-only.  Use M-x toggle-read-only to permit
     editing.

`forward-char'
     Move point right one character.  On reaching end of buffer, stop
     and signal error.

`forward-line'
     Move N lines forward (backward if N is negative).  Precisely, if
     point is on line I, move to the start of line I + N.

`forward-paragraph'
     Move forward to end of paragraph.  With argument N, do it N times.

`forward-sexp'
     Move forward across one balanced expression (sexp).  With
     argument, do it that many times.  Negative arg -N means move
     backward across N balanced expressions.

`forward-word'
     Move point forward one word (backward if the argument is negative).
     With argument, do this that many times.

`global-set-key'
     Bind a command to a key sequence.  Read key sequence and function
     name, and bind the function to the key sequence.

`goto-char'
     Read a number N and move the cursor to character number N.
     Position 1 is the beginning of the buffer.

`goto-line'
     Move cursor to the beginning of the specified line.  Line 1 is the
     beginning of the buffer.

`help'
     Show a help window.

`help-config-sample'
     Show a configuration file sample.

`help-with-tutorial'
     Show a tutorial window.

`indent-for-tab-command'
     Indent line in proper way for current major mode or insert a tab.

`insert-buffer'
     Insert after point the contents of the user specified buffer.
     Puts mark after the inserted text.

`insert-file'
     Insert contents of the user specified file into buffer after point.
     Set mark after the inserted text.

`insert-register'
     Insert contents of the user specified register.  Puts point before
     and mark after the inserted text.

`isearch-backward'
     Do incremental search backward.  With a prefix argument, do a
     regular expression search instead.  As you type characters, they
     add to the search string and are found.  Type return to exit,
     leaving point at location found.  Type `C-r' to search again
     backward, `C-s' to search again forward.  `C-g' when search is
     successful aborts and moves point to starting point.

`isearch-backward-regexp'
     Do incremental search forward for regular expression.  With a
     prefix argument, do a regular string search instead.  Like
     ordinary incremental search except that your input is treated as a
     regexp.  See `C-s' for more info.

`isearch-forward'
     Do incremental search forward.  With a prefix argument, do an
     incremental regular expression search instead.  As you type
     characters, they add to the search string and are found.  Type
     return to exit, leaving point at location found.  Type `C-s' to
     search again forward, `C-r' to search again backward.  `C-g' when
     search is successful aborts and moves point to starting point.

`isearch-forward-regexp'
     Do incremental search forward for regular expression.  With a
     prefix argument, do a regular string search instead.  Like
     ordinary incremental search except that your input is treated as a
     regexp.  See `C-s' for more info.

`keyboard-quit'
     Cancel current command.

`kill-buffer'
     Kill the current buffer or the user specified one.

`kill-line'
     Kill the rest of the current line; if no non-blanks there, kill
     thru newline.

`kill-region'
     Kill between point and mark.  The text is deleted but saved in the
     kill ring.  The command `C-y' (yank) can retrieve it from there.

     If the buffer is read-only, Zile will beep and refrain from
     deleting the text, but put the text in the kill ring anyway.  This
     means that you can use the killing commands to copy text from a
     read-only buffer.

     If the previous command was also a kill command, the text killed
     this time appends to the text killed last time to make one entry
     in the kill ring.

`kill-sexp'
     Kill the sexp (balanced expression) following the cursor.  With
     ARG, kill that many sexps after the cursor.  Negative arg -N means
     kill N sexps before the cursor.

`kill-word'
     Kill characters forward until encountering the end of a word.
     With argument, do this that many times.

`list-bindings'
     List defined bindings.

`list-buffers'
     Display a list of names of existing buffers.  The list is
     displayed in a buffer named `*Buffer List*'.  Note that buffers
     with names starting with spaces are omitted.

        - The `M' column contains a `*' for buffers that are modified.

        - The `R' column contains a `%' for buffers that are read-only.

`list-registers'
     List defined registers.

`mark-paragraph'
     Put point at beginning of this paragraph, mark at end.  The
     paragraph marked is the one that contains point or follows point.

`mark-whole-buffer'
     Put point at beginning and mark at end of buffer.

`mark-sexp'
     Set mark argument sexps from point.  The place mark goes is the
     same place `C-M-f' would move to with the same argument.

`mark-word'
     Set mark argument words away from point.

`name-last-kbd-macro'
     Assign a name to the last keyboard macro defined.  Argument SYMBOL
     is the name to define.  The symbol's function definition becomes
     the keyboard macro string.  Such a "function" cannot be called
     from Lisp, but it is a valid editor command.

`newline'
     Insert a newline at the current point position into the current
     buffer.

`newline-and-indent'
     Insert a newline, then indent according to major mode.
     Indentation is done using the indent-for-tab-command function.

`next-line'
     Move cursor vertically down one line.  If there is no character in
     the target line exactly in the current column, the cursor is
     positioned after the character in that line which spans this
     column, or at the end of the line if it is not long enough.

`open-line'
     Insert a newline and leave point before it.

`other-window'
     Select the first different window on the screen.  All windows are
     arranged in a cyclic order.  This command selects the window one
     step away in that order.

`overwrite-mode'
     In Overwrite Mode, printing characters typed in replace existing
     text on a one-for-one basis, rather than pushing it to the right.
     At the end of a line, such characters extend the line.  `C-q'
     still inserts characters in Overwrite Mode; this is supposed to
     make it easier to insert characters when necessary.

`previous-line'
     Move cursor vertically up one line.  If there is no character in
     the target line exactly over the current column, the cursor is
     positioned after the character in that line which spans this
     column, or at the end of the line if it is not long enough.

`query-replace'
     Replace occurrences of a string with other text.  As each match is
     found, the user must type a character saying what to do with it.

`quoted-insert'
     Read next input character and insert it.  This is useful for
     inserting control characters.  You may also type up to 3 octal
     digits, to insert a character with that code.

`recenter'
     Center point in window and redisplay screen.  The desired position
     of point is always relative to the current window.

`replace-string'
     Replace occurrences of a string with other text.

`save-buffer'
     Save current buffer in visited file if modified. By default, makes
     the previous version into a backup file if this is the first save.

`save-buffers-kill-zile'
     Offer to save each buffer, then kill this Zile process.

`save-some-buffers'
     Save some modified file-visiting buffers.  Asks user about each
     one.

`scroll-down'
     Scroll text of current window downward near full screen.

`scroll-up'
     Scroll text of current window upward near full screen.

`search-backward'
     Search backward from point for the user specified text.

`search-backward-regexp'
     Search backward from point for match for regular expression REGEXP.

`search-forward'
     Search forward from point for the user specified text.

`search-forward-regexp'
     Search forward from point for regular expression REGEXP.

`self-insert-command'
     Insert the character you type.

`set-fill-column'
     Set the fill column.  If an argument value is passed, set the
     `fill-column' variable with that value, otherwise with the current
     column value.

`set-mark-command'
     Set mark at where point is.

`set-variable'
     Set a variable value to the user specified value.

`shell-command'
     Reads a line of text using the minibuffer and creates an inferior
     shell to execute the line as a command.

     Standard input from the command comes from the null device.  If the
     shell command produces any output, the output goes to a Zile buffer
     named `*Shell Command Output*', which is displayed in another
     window but not selected.

     If the output is one line, it is displayed in the echo area.  A
     numeric argument, as in `M-1 M-!' or `C-u M-!', directs this
     command to insert any output into the current buffer.

`shell-command-on-region'
     Reads a line of text using the minibuffer and creates an inferior
     shell to execute the line as a command; passes the contents of the
     region as input to the shell command.

     If the shell command produces any output, the output goes to a
     Zile buffer named `*Shell Command Output*', which is displayed in
     another window but not selected.

     If the output is one line, it is displayed in the echo area.  A
     numeric argument, as in `M-1 M-|' or `C-u M-|', directs output to
     the current buffer, then the old region is deleted first and the
     output replaces it as the contents of the region.

`shrink-window'
     Make current window one line smaller.

`split-window'
     Split current window into two windows, one above the other.  Both
     windows display the same buffer now current.

`start-kbd-macro'
     Record subsequent keyboard input, defining a keyboard macro.  The
     commands are recorded even as they are executed.  Use `C-x )' to
     finish recording and make the macro available.

`suspend-zile'
     Stop Zile and return to superior process.

`switch-to-buffer'
     Select to the user specified buffer in the current window.

`tabify'
     Convert multiple spaces in region to tabs when possible.  A group
     of spaces is partially replaced by tabs when this can be done
     without changing the column they end at.  The variable `tab-width'
     controls the spacing of tab stops.

`tab-to-tab-stop'
     Insert a tabulation at the current point position into the current
     buffer.

`toggle-read-only'
     Change whether this buffer is visiting its file read-only.

`transient-mark-mode'
     Toggle Transient Mark mode.  With arg, turn Transient Mark mode on
     if arg is positive, off otherwise.

`transpose-chars'
     Interchange characters around point, moving forward one character.
     If at end of line, the previous two chars are exchanged.

`transpose-lines'
     Exchange current line and previous line, leaving point after both.
     With argument ARG, takes previous line and moves it past ARG lines.
     With argument 0, interchanges line point is in with line mark is
     in.

`transpose-sexps'
     Like `M-t' but applies to sexps.

`transpose-words'
     Interchange words around point, leaving point at end of them.

`undo'
     Undo some previous changes.  Repeat this command to undo more
     changes.

`universal-argument'
     Begin a numeric argument for the following command.  Digits or
     minus sign following `C-u' make up the numeric argument.  `C-u'
     following the digits or minus sign ends the argument.  `C-u'
     without digits or minus sign provides 4 as argument.  Repeating
     `C-u' without digits or minus sign multiplies the argument by 4
     each time.

`untabify'
     Convert all tabs in region to multiple spaces, preserving columns.
     The variable `tab-width' controls the spacing of tab stops.

`upcase-region'
     Convert the region to upper case.

`upcase-word'
     Convert following word (or argument N words) to upper case, moving
     over.

`view-zile-FAQ'
     Show the Zile Frequently Asked Questions list (FAQ).

`where-is'
     Show the key or keys to which the given command is bound.

`write-file'
     Write current buffer into the user specified file.  Makes buffer
     visit that file, and marks it not modified.

`yank'
     Reinsert the last stretch of killed text.  More precisely,
     reinsert the stretch of killed text most recently killed or
     yanked.  Put point at end, and set mark at beginning.

`zile-version'
     Show the zile version.

9 Variables
***********

This table contains the full list of available variables, that can be
modified at run-time with the `set-variable' function or set at start-up
in the `.zile' initialization file.

   Please note that some variables may be not available depending on
the compilation options given to `configure'.

`backup-directory'
     Specify target backup directory, which must exist, or `nil'.
     Default value is `nil'.

`make-backup-files'
     Specify whether a backup is made the first time a file is saved.
     If enabled, Zile will create a backup file with a tilde `~'
     appended to the name (e.g. on saving `foo.c' it will create the
     backup `foo.c~').  Default value is `t'.

`beep'
     If enabled, a sound will be emitted on any error.  Default value
     is `t'.

`case-fold-search'
     Non-nil means searches ignore case.

`case-replace'
     Non-nil means `query-replace' should preserve case in replacements.

`fill-column'
     The default fill column (used in Auto Fill Mode).  Default value
     is `72'.

`indent-tabs-mode'
     If enabled, insert-tab inserts `real' tabs; otherwise, it always
     inserts spaces.  Default value is `nil'.

`kill-whole-line'
     If enabled, `kill-line' with no arg at the beginning of a line
     kills the whole line.  Default value is `nil'.

`highlight-nonselected-windows'
     If enabled, highlight region even in nonselected windows.  Default
     value is `nil'.

`skip-splash-screen'
     If enabled, the splash screen at startup will be avoided.  Default
     value is `nil'.

`standard-indent'
     Default number of columns for margin-changing functions to indent.
     Default values is `4'.

`tab-always-indent'
     Controls the operation of the TAB key.  If enabled, hitting TAB
     always just indents the current line.  Otherwise, hitting TAB
     indents the current line if point is at the left margin or in the
     line's indentation, otherwise it insert a `real' tab character.
     Default value is `t'.

`tab-width'
     The default tabulation width.  Default value is `8'.

`auto-fill-mode'
     If enabled, the Auto Fill Mode is automatically enabled.  Default
     value is `nil'.

`transient-mark-mode'
     If enabled, deactivates the mark when the buffer contents change.
     Also enables highlighting of the region whenever the mark is
     active.  The variable `highlight-nonselected-windows' controls
     whether to highlight all windows or just the selected window.
     Default value is `t'.

10 Bug reports
**************

Any questions, comments, or bug reports should be sent to the
developers at <zile-devel@lists.sourceforge.net>, or even better, filed
in the relevant tracker at `http://sourceforge.net/projects/zile/'.

