Sorting Text
============

SXEmacs 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 sort records, identify a 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.

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.

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.

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.

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.

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

M-x sort-columns
     Like 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.

For example, if the buffer contains:

     On systems where clash detection (locking of files being edited) is
     implemented, SXEmacs 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.

then if you apply M-x sort-lines to the entire buffer you get:

     On systems where clash detection (locking of files being edited) is
     implemented, SXEmacs 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

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

     saved.  If it has, you are asked to confirm that you want to change
     implemented, SXEmacs 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

where the sort keys were If, SXEmacs, buffer, systems, and the.

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. See Rectangles.

Running Shell Commands from SXEmacs
===================================

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

M-!
     Run a specified shell command line and display the output (shell-command).

M-|
     Run a specified shell command line with region contents as input; optionally replace the region with the output (shell-command-on-region).

M-x shell
     Run a subshell with input and output through an SXEmacs buffer. You can then give commands interactively.

M-x term
     Run a subshell with input and output through an SXEmacs buffer. You can then give commands interactively. Full terminal emulation is available.

Single Shell Commands
---------------------

M-! (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 SXEmacs buffer named *Shell Command Output*, which is displayed in another window but not selected.  A numeric argument, as in 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.

M-| (shell-command-on-region) is like 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.

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

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

Interactive Inferior Shell
--------------------------

To run a subshell interactively with its typescript in an SXEmacs buffer, use M-x shell.  This creates (or reuses) a buffer named *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 RET.

SXEmacs 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 SXEmacs has time to process it; this happens whenever SXEmacs is waiting for keyboard input or for time to elapse.

To get multiple subshells, change the name of buffer *shell* to something different by using M-x rename-buffer.  The next use of M-x shell creates a new buffer *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.

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

As soon as the subshell is started, it is sent as input the contents of the file ~/.emacs_SHELLNAME, if that file exists, where SHELLNAME is the name of the file that the shell was loaded from. For example, if you use csh, the file sent to it is ~/.emacs_csh.

cd, pushd, and popd commands given to the inferior shell are watched by SXEmacs so it can keep the *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 SXEmacs to recognize them also.  For example, if the value of the variable shell-pushd-regexp matches the beginning of a shell command line, that line is regarded as a pushd command.  Change this variable when you add aliases for pushd.  Likewise, shell-popd-regexp and shell-cd-regexp are used to recognize commands with the meaning of popd and cd.

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

SXEmacs keeps a history of the most recent commands you have typed in the *shell* buffer.  If you are at the beginning of a shell command line and type M-p, the previous shell input is inserted into the buffer before point.  Immediately typing M-p again deletes that input and inserts the one before it.  By repeating 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 RET if you wish. M-n moves forward through the command history, in case you moved backward past the one you wanted while using M-p.  If you type the first few characters of a previous command and then type 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 input-ring-size controls how many commands are saved in your input history.  The default is 30.

Shell Mode
----------

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

RET
     At end of buffer send line as input; otherwise, copy current line to end of buffer and send it (send-shell-input).  When a line is copied, any text at the beginning of the line that matches the variable 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.

C-c C-d
     Send end-of-file as input, probably causing the shell or its current subjob to finish (shell-send-eof).

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 (comint-delchar-or-maybe-eof).

C-c C-u
     Kill all text that has yet to be sent as input (kill-shell-input).

C-c C-w
     Kill a word before point (backward-kill-word).

C-c C-c
     Interrupt the shell or its current subjob if any (interrupt-shell-subjob).

C-c C-z
     Stop the shell or its current subjob if any (stop-shell-subjob).

C-c C-\
     Send quit signal to the shell or its current subjob if any (quit-shell-subjob).

C-c C-o
     Delete last batch of output from shell (kill-output-from-shell).

C-c C-r
     Scroll top of last batch of output to top of window (show-output-from-shell).

C-c C-y
     Copy the previous bunch of shell input and insert it into the buffer before point (copy-last-shell-input).  No final newline is inserted, and the input copied is not resubmitted until you type RET.

M-p
     Move backward through the input history.  Search for a matching command if you have typed the beginning of a command (comint-previous-input).

M-n
     Move forward through the input history.  Useful when you are using M-p quickly and go past the desired command (comint-next-input).

TAB
     Complete the file name preceding point (comint-dynamic-complete).

Interactive Inferior Shell with Terminal Emulator
-------------------------------------------------

To run a subshell in a terminal emulator, putting its typescript in an SXEmacs buffer, use M-x term.  This creates (or reuses) a buffer named *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 SXEmacs 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 C-c. see Term Mode.) Any ``terminal output'' from the subshell goes into the buffer, advancing point.

Some programs (such as SXEmacs 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 SXEmacs inside an SXEmacs Term window!

SXEmacs 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 SXEmacs has time to process it; this happens whenever SXEmacs is waiting for keyboard input or for time to elapse.

To make multiple terminal emulators, rename the buffer *term* to something different using 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.

Term Mode
---------

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

To switch between line and char mode, use these commands:

     findex term-char-mode

C-c C-j
     Switch to line mode.  Do nothing if already in line mode.

C-c C-k
     Switch to char mode.  Do nothing if already in char mode.

The following commands are only available in Char mode:

C-c C-c
     Send a literal C-c to the sub-shell.

C-c C-x
     A prefix command to conveniently access the global C-x commands. For example, C-c C-x o invokes the global binding of C-x o, which is normally other-window.

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.

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 page.

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 **MORE** in the mode-line. Type a Space to display the next screenful of output. Type ? to see your other options.  The interface is similar to the Unix more program.

Narrowing
=========

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 widening. The amount of narrowing in effect in a buffer at any time is called the buffer's restriction.

C-x n n
     Narrow down to between point and mark (narrow-to-region).

C-x n w
     Widen to make the entire buffer visible again (widen).

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 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.

The primary narrowing command is C-x n n (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, 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.  See Disabling.

To undo narrowing, use C-x n w (widen).  This makes all text in the buffer accessible again.

Use the C-x = command to get information on what part of the buffer you narrowed down.  See Position Info.

Hardcopy Output
===============

The SXEmacs commands for making hardcopy derive their names from the Unix commands print and lpr.

M-x print-buffer
     Print hardcopy of current buffer using Unix command print

     (lpr -p).  This command adds page headings containing the file name and page number.

M-x lpr-buffer
     Print hardcopy of current buffer using Unix command lpr. This command does not add page headings.

M-x print-region
     Like print-buffer, but prints only the current region.

M-x lpr-region
     Like lpr-buffer, but prints only the current region.

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

Recursive Editing Levels
========================

A recursive edit is a situation in which you are using SXEmacs commands to perform arbitrary editing while in the middle of another SXEmacs command.  For example, when you type C-r inside a 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 query-replace.

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

You can also abort a recursive edit.  This is like exiting, but also quits the unfinished command immediately.  Use the command C-] (abort-recursive-edit) for this.  See 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 SXEmacs as a whole, rather than any particular buffer, is in a recursive edit.

It is possible to be in recursive edits within recursive edits.  For example, after typing C-r in a 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 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 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, SXEmacs 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.

Dissociated Press
=================

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 SXEmacs buffer.  Dissociated Press writes its output in a buffer named *Dissociation*, and redisplays that buffer after every couple of lines (approximately) to facilitate reading it.

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

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.

A positive argument to 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 *Dissociation*.  The buffer you start with is not changed.

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.

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.

CONX
====

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

M-x conx
     Generate random sentences in the *conx* buffer.

M-x conx-buffer
     Absorb the text in the current buffer into the conx database.

M-x conx-init
     Forget the current word-frequency tree.

M-x conx-load
     Load a conx database that has been previously saved with M-x conx-save.

M-x conx-region
     Absorb the text in the current buffer into the conx database.

M-x conx-save
     Save the current conx database to a file for future retrieval.

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

Other Amusements
================

If you are a little bit bored, you can try 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 M-x doctor.  End each input by typing RET twice.

When you are feeling strange, type M-x yow.

Emulation
=========

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

Viper (a vi emulator)
     In SXEmacs, Viper is the preferred emulation of vi within SXEmacs. Viper is designed to allow you to take advantage of the best features of SXEmacs 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 SXEmacs commands, to an ``expert'' mode that combines the most useful vi commands with the most useful SXEmacs commands.

     To start Viper, put the command

          (viper-mode)

     in your init file.  See Init File.

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

EDT (DEC VMS editor)
     Turn on EDT emulation with M-x edt-emulation-on.  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.

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

     It is also possible to run Mocklisp code written for Gosling Emacs. See Mocklisp.