XEmacs 21.4.9 "Informed Management".

[chise/xemacs-chise.git.1] / man / xemacs / misc.texi

@iftex
@chapter Miscellaneous Commands

  This chapter contains several brief topics that do not fit anywhere else.

@end iftex

@node Sorting, Shell, Calendar/Diary, Top
@section Sorting Text
@cindex sorting

  XEmacs provides several commands for sorting text in a buffer.  All
operate on the contents of the region (the text between point and the
mark).  They divide the text of the region into many @dfn{sort records},
identify a @dfn{sort key} for each record, and then reorder the records
using the order determined by the sort keys.  The records are ordered so
that their keys are in alphabetical order, or, for numerical sorting, in
numerical order.  In alphabetical sorting, all upper-case letters `A'
through `Z' come before lower-case `a', in accordance with the ASCII
character sequence.

  The sort commands differ in how they divide the text into sort
records and in which part of each record they use as the sort key.  Most of
the commands make each line a separate sort record, but some commands use
paragraphs or pages as sort records.  Most of the sort commands use each
entire sort record as its own sort key, but some use only a portion of the
record as the sort key.

@findex sort-lines
@findex sort-paragraphs
@findex sort-pages
@findex sort-fields
@findex sort-numeric-fields
@table @kbd
@item M-x sort-lines
Divide the region into lines and sort by comparing the entire
text of a line.  A prefix argument means sort in descending order.

@item M-x sort-paragraphs
Divide the region into paragraphs and sort by comparing the entire
text of a paragraph (except for leading blank lines).  A prefix
argument means sort in descending order.

@item M-x sort-pages
Divide the region into pages and sort by comparing the entire
text of a page (except for leading blank lines).  A prefix
argument means sort in descending order.

@item M-x sort-fields
Divide the region into lines and sort by comparing the contents of
one field in each line.  Fields are defined as separated by
whitespace, so the first run of consecutive non-whitespace characters
in a line constitutes field 1, the second such run constitutes field
2, etc.

You specify which field to sort by with a numeric argument: 1 to sort
by field 1, etc.  A negative argument means sort in descending
order.  Thus, minus 2 means sort by field 2 in reverse-alphabetical
order.

@item M-x sort-numeric-fields
Like @kbd{M-x sort-fields}, except the specified field is converted
to a number for each line and the numbers are compared.  @samp{10}
comes before @samp{2} when considered as text, but after it when
considered as a number.

@item M-x sort-columns
Like @kbd{M-x sort-fields}, except that the text within each line
used for comparison comes from a fixed range of columns.  An explanation
is given below.
@end table

For example, if the buffer contains:

@smallexample
On systems where clash detection (locking of files being edited) is
implemented, XEmacs also checks the first time you modify a buffer
whether the file has changed on disk since it was last visited or
saved.  If it has, you are asked to confirm that you want to change
the buffer.
@end smallexample

@noindent
then if you apply @kbd{M-x sort-lines} to the entire buffer you get:

@smallexample
On systems where clash detection (locking of files being edited) is
implemented, XEmacs also checks the first time you modify a buffer
saved.  If it has, you are asked to confirm that you want to change
the buffer.
whether the file has changed on disk since it was last visited or
@end smallexample

@noindent
where the upper case `O' comes before all lower case letters.  If you apply
instead @kbd{C-u 2 M-x sort-fields} you get:

@smallexample
saved.  If it has, you are asked to confirm that you want to change
implemented, XEmacs also checks the first time you modify a buffer
the buffer.
On systems where clash detection (locking of files being edited) is
whether the file has changed on disk since it was last visited or
@end smallexample

@noindent
where the sort keys were @samp{If}, @samp{XEmacs}, @samp{buffer},
@samp{systems}, and @samp{the}.@refill

@findex sort-columns
  @kbd{M-x sort-columns} requires more explanation.  You specify the
columns by putting point at one of the columns and the mark at the other
column.  Because this means you cannot put point or the mark at the
beginning of the first line to sort, this command uses an unusual
definition of `region': all of the line point is in is considered part of
the region, and so is all of the line the mark is in.

  For example, to sort a table by information found in columns 10 to 15,
you could put the mark on column 10 in the first line of the table, and
point on column 15 in the last line of the table, and then use this command.
Or you could put the mark on column 15 in the first line and point on
column 10 in the last line.

  This can be thought of as sorting the rectangle specified by point and
the mark, except that the text on each line to the left or right of the
rectangle moves along with the text inside the rectangle.
@xref{Rectangles}.

@node Shell, Narrowing, Sorting, Top
@section Running Shell Commands from XEmacs
@cindex subshell
@cindex shell commands

  XEmacs has commands for passing single command lines to inferior shell
processes; it can also run a shell interactively with input and output to
an XEmacs buffer @samp{*shell*}.

@table @kbd
@item M-!
Run a specified shell command line and display the output
(@code{shell-command}).
@item M-|
Run a specified shell command line with region contents as input;
optionally replace the region with the output
(@code{shell-command-on-region}).
@item M-x shell
Run a subshell with input and output through an XEmacs buffer.
You can then give commands interactively.
@item M-x term
Run a subshell with input and output through an XEmacs buffer.
You can then give commands interactively.
Full terminal emulation is available.
@end table

@menu
* Single Shell::         How to run one shell command and return.
* Interactive Shell::    Permanent shell taking input via XEmacs.
* Shell Mode::           Special XEmacs commands used with permanent shell.
* Terminal emulator::    An XEmacs window as a terminal emulator.
* Term Mode::            Special XEmacs commands used in Term mode.
* Paging in Term::       Paging in the terminal emulator.
@end menu

@node Single Shell, Interactive Shell, Shell, Shell
@subsection Single Shell Commands

@kindex M-!
@findex shell-command
  @kbd{M-!} (@code{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 an XEmacs buffer named
@samp{*Shell Command Output*}, which is displayed in another window but not
selected.  A numeric argument, as in @kbd{M-1 M-!}, directs this command to
insert any output into the current buffer.  In that case, point is left
before the output and the mark is set after the output.

@kindex M-|
@findex shell-command-on-region
  @kbd{M-|} (@code{shell-command-on-region}) is like @kbd{M-!} but passes
the contents of the region as input to the shell command, instead of no
input.  If a numeric argument is used to direct  output to the current
buffer, then the old region is deleted first and the output replaces it as
the contents of the region.@refill

@vindex shell-file-name
@cindex environment
  Both @kbd{M-!} and @kbd{M-|} use @code{shell-file-name} to specify the
shell to use.  This variable is initialized based on your @code{SHELL}
environment variable when you start XEmacs.  If the file name does not
specify a directory, the directories in the list @code{exec-path} are
searched; this list is initialized based on the @code{PATH} environment
variable when you start XEmacs.  You can override either or both of these
default initializations in your init file. @xref{Init File}.@refill

  When you use @kbd{M-!} and @kbd{M-|}, XEmacs has to wait until the
shell command completes.  You can quit with @kbd{C-g}; that terminates
the shell command.

@node Interactive Shell, Shell Mode, Single Shell, Shell
@subsection Interactive Inferior Shell

@findex shell
  To run a subshell interactively with its typescript in an XEmacs
buffer, use @kbd{M-x shell}.  This creates (or reuses) a buffer named
@samp{*shell*} and runs a subshell with input coming from and output going
to that buffer.  That is to say, any ``terminal output'' from the subshell
will go into the buffer, advancing point, and any ``terminal input'' for
the subshell comes from text in the buffer.  To give input to the subshell,
go to the end of the buffer and type the input, terminated by @key{RET}.

  XEmacs does not wait for the subshell to do anything.  You can switch
windows or buffers and edit them while the shell is waiting, or while it is
running a command.  Output from the subshell waits until XEmacs has time to
process it; this happens whenever XEmacs is waiting for keyboard input or
for time to elapse.

 To get multiple subshells, change the name of buffer
@samp{*shell*} to something different by using @kbd{M-x rename-buffer}.  The
next use of @kbd{M-x shell} creates a new buffer @samp{*shell*} with
its own subshell.  By renaming this buffer as well you can create a third
one, and so on.  All the subshells run independently and in parallel.

@vindex explicit-shell-file-name
  The file name used to load the subshell is the value of the variable
@code{explicit-shell-file-name}, if that is non-@code{nil}.  Otherwise, the
environment variable @code{ESHELL} is used, or the environment variable
@code{SHELL} if there is no @code{ESHELL}.  If the file name specified
is relative, the directories in the list @code{exec-path} are searched
(@pxref{Single Shell,Single Shell Commands}).@refill

  As soon as the subshell is started, it is sent as input the contents of
the file @file{~/.emacs_@var{shellname}}, if that file exists, where
@var{shellname} is the name of the file that the shell was loaded from.
For example, if you use @code{csh}, the file sent to it is
@file{~/.emacs_csh}.@refill

@vindex shell-pushd-regexp
@vindex shell-popd-regexp
@vindex shell-cd-regexp
  @code{cd}, @code{pushd}, and @code{popd} commands given to the inferior
shell are watched by XEmacs so it can keep the @samp{*shell*} buffer's
default directory the same as the shell's working directory.  These
commands are recognized syntactically by examining lines of input that are
sent.  If you use aliases for these commands, you can tell XEmacs to
recognize them also.  For example, if the value of the variable
@code{shell-pushd-regexp} matches the beginning of a shell command line,
that line is regarded as a @code{pushd} command.  Change this variable when
you add aliases for @samp{pushd}.  Likewise, @code{shell-popd-regexp} and
@code{shell-cd-regexp} are used to recognize commands with the meaning of
@samp{popd} and @samp{cd}.@refill

@kbd{M-x shell-resync-dirs} queries the shell and resynchronizes XEmacs'
idea of what the current directory stack is.  @kbd{M-x
shell-dirtrack-toggle} turns directory tracking on and off.

@vindex input-ring-size
XEmacs keeps a history of the most recent commands you have typed in the
@samp{*shell*} buffer.  If you are at the beginning of a shell command
line and type @key{M-p}, the previous shell input is inserted into the
buffer before point.  Immediately typing @key{M-p} again deletes that
input and inserts the one before it.  By repeating @key{M-p} you can
move backward through your commands until you find one you want to
repeat.  You may then edit the command before typing @key{RET} if you
wish. @key{M-n} moves forward through the command history, in case you
moved backward past the one you wanted while using @key{M-p}.  If you
type the first few characters of a previous command and then type
@key{M-p}, the most recent shell input starting with those characters is
inserted.  This can be very convenient when you are repeating a sequence
of shell commands.  The variable @code{input-ring-size} controls how
many commands are saved in your input history.  The default is 30.


@node Shell Mode, Terminal emulator, Interactive Shell, Shell
@subsection Shell Mode

@cindex Shell mode
  The shell buffer uses Shell mode, which defines several special keys
attached to the @kbd{C-c} prefix.  They are chosen to resemble the usual
editing and job control characters present in shells that are not under
XEmacs, except that you must type @kbd{C-c} first.  Here is a list
of the special key bindings of Shell mode:

@kindex RET (Shell mode)
@kindex C-c C-d (Shell mode)
@kindex C-d (Shell mode)
@kindex C-c C-u (Shell mode)
@kindex C-c C-w (Shell mode)
@kindex C-c C-c (Shell mode)
@kindex C-c C-z (Shell mode)
@kindex C-c C-\ (Shell mode)
@kindex C-c C-o (Shell mode)
@kindex C-c C-r (Shell mode)
@kindex C-c C-y (Shell mode)
@kindex M-p (Shell mode)
@kindex M-n (Shell mode)
@kindex TAB (Shell mode)
@findex send-shell-input
@findex shell-send-eof
@findex comint-delchar-or-maybe-eof
@findex interrupt-shell-subjob
@findex stop-shell-subjob
@findex quit-shell-subjob
@findex kill-output-from-shell
@findex show-output-from-shell
@findex copy-last-shell-input
@findex comint-previous-input
@findex comint-next-input
@findex comint-dynamic-complete
@vindex shell-prompt-pattern
@table @kbd
@item @key{RET}
At end of buffer send line as input; otherwise, copy current line to end of
buffer and send it (@code{send-shell-input}).  When a line is copied, any
text at the beginning of the line that matches the variable
@code{shell-prompt-pattern} is left out; this variable's value should be a
regexp string that matches the prompts that you use in your subshell.
@item C-c C-d
Send end-of-file as input, probably causing the shell or its current
subjob to finish (@code{shell-send-eof}).
@item C-d
If point is not at the end of the buffer, delete the next character just
like most other modes.  If point is at the end of the buffer, send
end-of-file as input, instead of generating an error as in other modes
(@code{comint-delchar-or-maybe-eof}).
@item C-c C-u
Kill all text that has yet to be sent as input (@code{kill-shell-input}).
@item C-c C-w
Kill a word before point (@code{backward-kill-word}).
@item C-c C-c
Interrupt the shell or its current subjob if any
(@code{interrupt-shell-subjob}).
@item C-c C-z
Stop the shell or its current subjob if any (@code{stop-shell-subjob}).
@item C-c C-\
Send quit signal to the shell or its current subjob if any
(@code{quit-shell-subjob}).
@item C-c C-o
Delete last batch of output from shell (@code{kill-output-from-shell}).
@item C-c C-r
Scroll top of last batch of output to top of window
(@code{show-output-from-shell}).
@item C-c C-y
Copy the previous bunch of shell input and insert it into the
buffer before point (@code{copy-last-shell-input}).  No final newline
is inserted, and the input copied is not resubmitted until you type
@key{RET}.
@item M-p
Move backward through the input history.  Search for a matching command
if you have typed the beginning of a command (@code{comint-previous-input}).
@item M-n
Move forward through the input history.  Useful when you are
using @key{M-p} quickly and go past the desired command 
(@code{comint-next-input}).
@item @key{TAB}
Complete the file name preceding point (@code{comint-dynamic-complete}).
@end table

@node Terminal emulator, Term Mode, Shell Mode, Shell
@subsection Interactive Inferior Shell with Terminal Emulator
@findex term

  To run a subshell in a terminal emulator, putting its typescript in an XEmacs
buffer, use @kbd{M-x term}.  This creates (or reuses) a buffer named
@samp{*term*} and runs a subshell with input coming from your keyboard and
output going to that buffer.

All the normal keys that you type are sent without any interpretation
by XEmacs directly to the subshell, as ``terminal input.''
Any ``echo'' of your input is the responsibility of the subshell.
(The exception is the terminal escape character,
which by default is @kbd{C-c}. @pxref{Term Mode}.)
Any ``terminal output'' from the subshell goes into the buffer,
advancing point.

  Some programs (such as XEmacs itself) need to control the
appearance on the terminal screen in detail.  They do this by
sending special control codes.  The exact control
codes needed vary from terminal to terminal, but nowadays
most terminals and terminal emulators (including xterm)
understand the so-called "ANSI escape sequences" (first
popularized by the Digital's VT100 family of terminal).
The term mode also understands these escape sequences,
and for each control code does the appropriate thing
to change the buffer so that the appearance of the window
will match what it would be on a real terminal.
Thus you can actually run XEmacs inside an XEmacs Term window!

   XEmacs does not wait for the subshell to do anything.  You can switch
windows or buffers and edit them while the shell is waiting, or while
it is running a command.  Output from the subshell waits until XEmacs
has time to process it; this happens whenever XEmacs is waiting for
keyboard input or for time to elapse.

   To make multiple terminal emulators, rename the buffer @samp{*term*}
to something different using @kbd{M-x rename-uniquely},
just as with Shell mode.

   The file name used to load the subshell is determined
the same way as for Shell mode.

Unlike Shell mode, Term mode does not track the current directory
by examining your input.  Instead, if you use a programmable
shell, you can have it tell Term what the current directory is.
This is done automatically by bash for version 1.15 and later.

@node Term Mode, Paging in Term, Terminal emulator, Shell
@subsection Term Mode
@cindex Term mode
@cindex mode, Term

  Term uses Term mode, which has two input modes:
In line mode, Term basically acts like Shell mode.  @xref{Shell Mode}.
In Char mode, each character is sent directly to the inferior subshell,
except for the Term escape character, normally @kbd{C-c}.

To switch between line and char mode, use these commands:
@table @kbd
@kindex C-c C-j @r{(Term mode)}
findex term-char-mode
@item C-c C-j
Switch to line mode.  Do nothing if already in line mode.

@kindex C-c C-k @r{(Term mode)}
@findex term-line-mode
@item C-c C-k
Switch to char mode.  Do nothing if already in char mode.
@end table

The following commands are only available in Char mode:
@table @kbd
@item C-c C-c
Send a literal @key{C-c} to the sub-shell.

@item C-c C-x
A prefix command to conveniently access the global @key{C-x} commands.
For example, @kbd{C-c C-x o} invokes the global binding of
@kbd{C-x o}, which is normally @samp{other-window}.
@end table

@node Paging in Term,, Term Mode, Shell
@subsection Paging in the terminal emulator

Term mode has a pager feature.  When the pager is enabled,
term mode will pause at the end of each screenful.

@table @kbd
@kindex C-c C-q @r{(Term mode)}
@findex term-pager-toggle
@item C-c C-q
Toggles the pager feature:  Disables the pager if it is enabled,
and vice versa.  This works in both line and char modes.
If the pager enabled, the mode-line contains the word @samp{page}.
@end table

If the pager is enabled, and Term receives more than a screenful
of output since your last input, Term will enter More break mode.
This is indicated by @samp{**MORE**} in the mode-line.
Type a @kbd{Space} to display the next screenful of output.
Type @kbd{?} to see your other options.  The interface is similar
to the Unix @samp{more} program.

@node Narrowing, Hardcopy, Shell, Top
@section Narrowing
@cindex widening
@cindex restriction
@cindex narrowing

  @dfn{Narrowing} means focusing in on some portion of the buffer, making
the rest temporarily invisible and inaccessible.  Cancelling the narrowing
and making the entire buffer once again visible is called @dfn{widening}.
The amount of narrowing in effect in a buffer at any time is called the
buffer's @dfn{restriction}.

@c WideCommands
@table @kbd
@item C-x n n
Narrow down to between point and mark (@code{narrow-to-region}).
@item C-x n w
Widen to make the entire buffer visible again (@code{widen}).
@end table

  Narrowing sometimes makes it easier to concentrate on a single
subroutine or paragraph by eliminating clutter.  It can also be used to
restrict the range of operation of a replace command or repeating
keyboard macro.  The word @samp{Narrow} appears in the mode line
whenever narrowing is in effect.  When you have narrowed to a part of the
buffer, that part appears to be all there is.  You can't see the rest,
can't move into it (motion commands won't go outside the visible part),
and can't change it in any way.  However, the invisible text is not
gone; if you save the file, it will be saved.

@kindex C-x n n
@findex narrow-to-region
  The primary narrowing command is @kbd{C-x n n} (@code{narrow-to-region}).
It sets the current buffer's restrictions so that the text in the current
region remains visible but all text before the region or after the region
is invisible.  Point and mark do not change.

  Because narrowing can easily confuse users who do not understand it,
@code{narrow-to-region} is normally a disabled command.  Attempting to use
this command asks for confirmation and gives you the option of enabling it;
once you enable the command, confirmation will no longer be required.  @xref{Disabling}.

@kindex C-x n w
@findex widen
   To undo narrowing, use @kbd{C-x n w} (@code{widen}).  This makes all
text in the buffer accessible again.

   Use the @kbd{C-x =} command to get information on what part of the
buffer you narrowed down.  @xref{Position Info}.

@node Hardcopy, Recursive Edit, Narrowing, Top
@section Hardcopy Output
@cindex hardcopy

  The XEmacs commands for making hardcopy derive their names from the
Unix commands @samp{print} and @samp{lpr}.

@table @kbd
@item M-x print-buffer
Print hardcopy of current buffer using Unix command @samp{print}
@*(@samp{lpr -p}).  This command adds page headings containing the file name
and page number.
@item M-x lpr-buffer
Print hardcopy of current buffer using Unix command @samp{lpr}.
This command does not add page headings.
@item M-x print-region
Like @code{print-buffer}, but prints only the current region.
@item M-x lpr-region
Like @code{lpr-buffer}, but prints only the current region.
@end table

@findex print-buffer
@findex print-region
@findex lpr-buffer
@findex lpr-region
@vindex lpr-switches
  All the hardcopy commands pass extra switches to the @code{lpr} program
based on the value of the variable @code{lpr-switches}.  Its value should
be a list of strings, each string a switch starting with @samp{-}.  For
example, the value could be @code{("-Pfoo")} to print on printer
@samp{foo}.

@node Recursive Edit, Dissociated Press, Hardcopy, Top
@section Recursive Editing Levels
@cindex recursive editing level
@cindex editing level, recursive

  A @dfn{recursive edit} is a situation in which you are using XEmacs
commands to perform arbitrary editing while in the middle of another
XEmacs command.  For example, when you type @kbd{C-r} inside a
@code{query-replace}, you enter a recursive edit in which you can change
the current buffer.  When you exit from the recursive edit, you go back to
the @code{query-replace}.

@kindex C-M-c
@findex exit-recursive-edit
@cindex exiting
  @dfn{Exiting} a recursive edit means returning to the unfinished
command, which continues execution.  For example, exiting the recursive
edit requested by @kbd{C-r} in @code{query-replace} causes query replacing
to resume.  Exiting is done with @kbd{C-M-c} (@code{exit-recursive-edit}).

@kindex C-]
@findex abort-recursive-edit
  You can also @dfn{abort} a recursive edit.  This is like exiting, but
also quits the unfinished command immediately.  Use the command @kbd{C-]}
(@code{abort-recursive-edit}) for this.  @xref{Quitting}.

  The mode line shows you when you are in a recursive edit by displaying
square brackets around the parentheses that always surround the major
and minor mode names.  Every window's mode line shows the square
brackets, since XEmacs as a whole, rather than any particular buffer, is
in a recursive edit.

@findex top-level
  It is possible to be in recursive edits within recursive edits.  For
example, after typing @kbd{C-r} in a @code{query-replace}, you might
type a command that entered the debugger.  In such a case, two or
more sets of square brackets appear in the mode line(s).  Exiting the
inner recursive edit (here with the debugger @kbd{c} command)
resumes the query-replace command where it called the debugger.  After
the end of the query-replace command, you would be able to exit the
first recursive edit.  Aborting exits only one level of recursive edit;
it returns to the command level of the previous recursive edit.  You can
then abort that one as well.

  The command @kbd{M-x top-level} aborts all levels of
recursive edits, returning immediately to the top level command reader.

  The text you edit inside the recursive edit need not be the same text
that you were editing at top level.  If the command that invokes the
recursive edit selects a different buffer first, that is the buffer you
will edit recursively.  You can switch buffers within the recursive edit
in the normal manner (as long as the buffer-switching keys have not been
rebound).  While you could theoretically do the rest of your editing
inside the recursive edit, including visiting files, this could have
surprising effects (such as stack overflow) from time to time.  It is
best if you always exit or abort a recursive edit when you no longer
need it.

  In general, XEmacs tries to avoid using recursive edits.  It is
usually preferable to allow users to switch among the possible editing
modes in any order they like.  With recursive edits, the only way to get
to another state is to go ``back'' to the state that the recursive edit
was invoked from.

@node Dissociated Press, CONX, Recursive Edit, Top
@section Dissociated Press

@findex dissociated-press
  @kbd{M-x dissociated-press} is a command for scrambling a file of text
either word by word or character by character.  Starting from a buffer of
straight English, it produces extremely amusing output.  The input comes
from the current XEmacs buffer.  Dissociated Press writes its output in a
buffer named @samp{*Dissociation*}, and redisplays that buffer after every
couple of lines (approximately) to facilitate reading it.

  @code{dissociated-press} asks every so often whether to continue
operating.  Answer @kbd{n} to stop it.  You can also stop at any time by
typing @kbd{C-g}.  The dissociation output remains in the @samp{*Dissociation*}
buffer for you to copy elsewhere if you wish.

@cindex presidentagon
  Dissociated Press operates by jumping at random from one point in the
buffer to another.  In order to produce plausible output rather than
gibberish, it insists on a certain amount of overlap between the end of one
run of consecutive words or characters and the start of the next.  That is,
if it has just printed out `president' and then decides to jump to a
different point in the file, it might spot the `ent' in `pentagon' and
continue from there, producing `presidentagon'.  Long sample texts produce
the best results.

@cindex againformation
  A positive argument to @kbd{M-x dissociated-press} tells it to operate
character by character, and specifies the number of overlap characters.  A
negative argument tells it to operate word by word and specifies the number
of overlap words.  In this mode, whole words are treated as the elements to
be permuted, rather than characters.  No argument is equivalent to an
argument of two.  For your againformation, the output goes only into the
buffer @samp{*Dissociation*}.  The buffer you start with is not changed.

@cindex Markov chain
@cindex ignoriginal
@cindex techniquitous
  Dissociated Press produces nearly the same results as a Markov chain
based on a frequency table constructed from the sample text.  It is,
however, an independent, ignoriginal invention.  Dissociated Press
techniquitously copies several consecutive characters from the sample
between random choices, whereas a Markov chain would choose randomly for
each word or character.  This makes for more plausible sounding results
and runs faster.

@cindex outragedy
@cindex buggestion
@cindex properbose
  It is a mustatement that too much use of Dissociated Press can be a
developediment to your real work.  Sometimes to the point of outragedy.
And keep dissociwords out of your documentation, if you want it to be well
userenced and properbose.  Have fun.  Your buggestions are welcome.

@node CONX, Amusements, Dissociated Press, Top
@section CONX
@cindex random sentences

Besides producing a file of scrambled text with Dissociated Press, you 
can generate random sentences by using CONX.

@table @kbd
@item M-x conx
Generate random sentences in the @code{*conx*} buffer.
@item M-x conx-buffer
Absorb the text in the current buffer into the @code{conx} database.
@item M-x conx-init
Forget the current word-frequency tree.
@item M-x conx-load
Load a @code{conx} database that has been previously saved with 
@code{M-x conx-save}.
@item M-x conx-region
Absorb the text in the current buffer into the @code{conx} database.
@item M-x conx-save
Save the current @code{conx} database to a file for future retrieval.
@end table

@findex conx
@findex conx-buffer
@findex conx-load
@findex conx-region
@findex conx-init
@findex conx-save

Copy text from a buffer using @kbd{M-x conx-buffer} or @kbd{M-x conx-region}
and then type @kbd{M-x conx}.  Output is continuously generated until you
type @key{^G}. You can save the @code{conx} database to a file with
@kbd{M-x conx-save}, which you can retrieve with @code{M-x conx-load}. 
To clear the database, use @code{M-x conx-init}.

@node Amusements, Emulation, CONX, Top
@section Other Amusements
@cindex boredom
@findex hanoi
@findex yow

  If you are a little bit bored, you can try @kbd{M-x hanoi}.  If you are
considerably bored, give it a numeric argument.  If you are very, very
bored, try an argument of 9.  Sit back and watch.

  When you are frustrated, try the famous Eliza program.  Just do
@kbd{M-x doctor}.  End each input by typing @kbd{RET} twice.

  When you are feeling strange, type @kbd{M-x yow}.

@node Emulation, Customization, Amusements, Top
@comment  node-name,  next,  previous,  up
@section Emulation
@cindex other editors
@cindex vi
@cindex EDT

  XEmacs can be programmed to emulate (more or less) most other
editors.  Standard facilities can emulate these:

@table @asis
@item Viper (a vi emulator)
@cindex Viper
In XEmacs, Viper is the preferred emulation of vi within XEmacs.
Viper is designed to allow you to take advantage of the best
features of XEmacs while still doing your basic editing in a
familiar, vi-like fashion.  Viper provides various different
levels of vi emulation, from a quite complete emulation that
allows almost no access to native XEmacs commands, to an
``expert'' mode that combines the most useful vi commands with
the most useful XEmacs commands.

To start Viper, put the command

@example
(viper-mode)
@end example

in your init file.  @xref{Init File}.

Viper comes with a separate manual that is provided standard
with the XEmacs distribution.

@ignore
@item evi (alternative vi emulator)
@cindex evi
evi is an alternative vi emulator that also provides a nearly complete
emulation of vi.

evi comes with a separate manual that is provided standard
with the XEmacs distribution.

Warning: loading more than one vi emulator at once may cause name
conflicts; no one has checked.
@end ignore

@item EDT (DEC VMS editor)
@findex edt-emulation-on
@findex edt-emulation-off
Turn on EDT emulation with @kbd{M-x edt-emulation-on}.  @kbd{M-x
@*edt-emulation-off} restores normal Emacs command bindings.

Most of the EDT emulation commands are keypad keys, and most standard
Emacs key bindings are still available.  The EDT emulation rebindings
are done in the global keymap, so there is no problem switching
buffers or major modes while in EDT emulation.

@item Gosling Emacs
@findex set-gosmacs-bindings
@findex set-gnu-bindings
Turn on emulation of Gosling Emacs (aka Unipress Emacs) with @kbd{M-x
set-gosmacs-bindings}.  This redefines many keys, mostly on the
@kbd{C-x} and @kbd{ESC} prefixes, to work as they do in Gosmacs.
@kbd{M-x set-gnu-bindings} returns to normal XEmacs by rebinding
the same keys to the definitions they had at the time @kbd{M-x
set-gosmacs-bindings} was done.

It is also possible to run Mocklisp code written for Gosling Emacs.
@xref{Mocklisp}.
@end table