# Quick intro to elvis 2.2, with links to source code and binaries

CONTENTS

- 1. About this file
- 2. Differences between vi and elvis 2.2
- 3. Differences between 2.1 and 2.2
  - Between 2.1 and 2.2b
  - Between 2.2b and 2.2c
  - Between 2.2c and 2.2d
  - Between 2.2d and 2.2e
  - Between 2.2e and 2.2f
  - Between 2.2f and 2.2g
- 4. The future of elvis
- 5. Links to related files

    .---------------------------------------------------------------.
    | This is not elvis' user manual!  The real documentation for   |
    | elvis is located in its online help facility.  While running  |
    | elvis, enter the command ":help" to see the table of contents.|
    ^---------------------------------------------------------------^

# 1. About this file

This file is written in the HTML markup language. You can view it with any WWW viewer, such as Netscape. You can also use elvis 2.2 to view it; this version of elvis has the ability to view HTML documents, and print them.

This file has many hypertext links. Use them! If you're using elvis 2.2 to browse this file, then hypertextual references will appear as underlined text. (Except on color PCs; since color video cards don't support underlining, hypertextual references will be colored -- white on red, by default.) To follow the hypertext link, move the cursor onto the underlined text and press (Enter). To go back, press (Control-T). The (Tab) key moves the cursor forward to the next hypertext reference.

If elvis 2.2 doesn't automatically start up in HTML mode when you view this file, then you'll need to force it into HTML mode by giving the command "`:display html`".

# 2. Differences between vi and elvis 2.2

Elvis is a superset of vi. It runs on more operating systems than vi, it is free, and you can obtain the source code. Elvis also has many new features. These new features are described in the first chapter of the online manual, which hypertext links to the other parts of the manual where those features are described in detail. Here's a just brief list:

- Multiple edit buffers, so you can edit several files at once.
- Multiple windows, so you can see multiple edit buffers, or different parts of the same edit buffer.
- Multiple user interfaces, including graphical interfaces under Windows95/98/NT and X11.
- A variety of display modes, including syntax coloring and HTML.
- Online help, with hypertext links.
- Enhanced tags, to support overloading in C++.
- Network support, so you can load/save files via FTP, or even use elvis as a light-weight Web browser.
- Aliases, which allow you to define new ex commands.
- Built-in calculator

For a more complete list, with links to detailed descriptions, check the online manual. You can bring up the online manual by starting elvis and giving the command "`:help`". The list of extensions appears after the table of contents and a brief introduction.

# 3. Differences between 2.1 and 2.2

The following is a summary of changes made since the release of elvis 2.1. These are in addition to any bug fixes.

## Between 2.1_4 and 2.2b

### 3.1 Color

Elvis' `:color` command has been rewritten. The new version is much more powerful, and it should be more intuitive. Instead of assigning colors to a small number of fonts as in previous versions of elvis, the new `:color` command assigns colors and font attributes to be used for a large variety of specialized text faces.

#### 3.1.1 Usage

The general syntax of the `:color` command is...

> :color [gui.]face [like face] [bold] [italic] [underlined]
> [boxed] [graphic] [fixed|proportional] [color] [on color]

... where the items in brackets are optional, bold text is literal, and italic names represent variable text. The [gui.]face must be the first argument of the command, but the other arguments can appear in any order.

As a special case, giving the `:color` command without any arguments will list the current color settings. Invoking `:color` with just a face argument will list the setting of that text face.

The meanings of the arguments are as follows:

gui
  This is the name of the user interface which should be affected by the command. If omitted, then the current user interface is assumed. All color settings are stored, whether they affect the current GUI or not, so that the `:mkexrc` command can build a `.exrc` file which works correctly on all GUIs. For example, it might have "color termcap.normal yellow on blue" and "color x11.normal black on linen".
face
  This describes the type of text to be affected. Eventually the html/man/tex display modes will be modified to allow you to define your own face names, and the syntax display mode already allows keywords to be assigned new face names. For this reason, any word is accepted as a face name by the `:color` command.

  The normal text face is the most important. It is the only text face used in the "normal" display mode, for the current window. Also, any other text face which for which a color or attribute has not been explicitly set will inherit that color or attribute from the `normal` text face. This inheritance happens when the screen is drawn, so any time you change the normal background color, the default background for all other text faces also changes.

  The idle text face is another special one. What `normal` does for the current window, `idle` does for all other windows. This means that if you give `normal` and `idle` different background colors, then the current window will always be highlighted. The default setting of `idle` is "color idle like normal" which avoids that behavior.

  Some other text faces are lnum for the line numbers displayed by `:set number`, hexheading for column headings in "hex" mode, hexcursor for the hexadecimal version of the current character in "hex" mode, and header for the page headers when printing in "normal" or "syntax" display mode.

  The "syntax" display mode will eventually be rewritten to allow users to specify faces in the "elvis.syn" file, but for now the following face names are hardcoded: comment, string, char, regexp, keyword, function, variable, other, number, prep for preprocessor directives, and prepquote for text in angle brackets in an #include directive.

  The markup display modes ("html", "man", and "tex") have not been modified to take advantage of the new color scheme yet, so there are no face names for them. This is a shame, really, because they could really benefit from the new attribute combination rules. That was a big influence in the design of the new color code.

like face
  All fonts inherit any unset colors or attributes from either the `normal` or `idle` face. The like face notation allows you to define an additional face for them to inherit from. For example, you could say "color char like string" to make character literals look like string literals; after that, any change to the "string" face would also automatically change the "char" face too.
bold
italic
underlined
boxed
graphic
  These turn on various attributes for the text. There is no way to force the attributes off (to prevent them from being inherited from `normal` or some other face).

  The boxed attribute is new; it draws a box around the text in the "x11" and "windows" GUIs. This is intended to draw boxes around individual words, not whole paragraphs. It is ignored by the "termcap" interface. When printing, the PostScript print drivers draw boxes around the text, and most other print drivers print a gray background instead of a box.

fixed
proportional
  The fixed and proportional attributes have no effect on screen, but when printing to a PostScript printer (`lptype=ps` or `lptype=ps2`) they select one of two different fonts. The fonts are configurable in the `lib/elvis.ps` file; by default fixed text is printed using a Courier font, while proportional is printed using a Times font.

  Printing with a proportional font is a bit quirky though. Elvis' text formatting always assumes fixed-pitch fonts are used, so to keep mixtures of fonts looking good, the PostScript printer driver adjusts the width of each chunk of proportional text to match the width it would have had in a fixed-pitch font. For long segments of proportional text you probably won't notice this, but when an individual word is printed in a proportional font it may be stretched noticibly.

color
on color
  These define the foreground and background colors, respectively. In each case, the color is a GUI-dependent string which may contain spaces. Any color that you don't explicitly set will be inherited from `normal` or some other face.

  The list of supported color names for each GUI is unchanged. Any color names supported by previous versions of elvis should still be supported. See the "User interface" section of the manual for details.

  The "windows" interface now allows any number of different colors to be used, via X11' "#rrggbb" notation. Previously, only a single foreground color plus a single background color could be set this way.

  The "termcap" interface is smart enough to leave colors unchanged if you never explicitly set any foreground and/or background colors. For example, if before starting elvis you set your terminal's background color to blue, and your :color settings only affect the foreground, then the termcap interface will never explicitly change the background color so it should remain blue. (This assumes that the ANSI "^[[0m" escape sequence won't turn off the color.)

#### 3.1.2 Obsolete options have been removed

The syntax display mode previously used options named commentfont, stringfont, prepfont, keywordfont, functionfont, otherfont, and variablefont to control the appearance of different parts of the language. Those options are no longer necessary since the `:color` command can directly assign attributes to text faces named "comment", etc. Consequently, those options have been deleted.

Similarly, the "windows" interface used to have options named boldstyle, emphasizedstyle, fixedstyle, italicstype, normalstyle, and underlinedstyle to control the attributes of fonts. The "x11" interface used to have an "underline" option. Those options have been eliminated, although the Options->Gui... menu item and its dialog remain. The dialog now issues :color commands instead of :set commands.

However, the "termcap" interface retains its ttyunderline option. That is still necessary because it helps the "termcap" interface avoid problems that occur when underlining and background colors are both used on CGA/EGA/VGA video cards.

#### 3.1.3 Incomplete code

I haven't tested any of the Epson-ish print drivers, but I'm pretty confident they'll work because I have verified that the "hp" driver works, and all of those drivers share 98% of their code (in lpescape.c).

When changing the `normal` background color of the "windows" GUI window, there are some areas around the outside of the text which aren't redrawn in the new color. If the window is resized, or PAINTed, they're redrawn with the new color, but I can't seem to make that happen automatically. Serge, please check my code at guiwin32/guiwin.c, line 1088, and see if you can figure out what I'm doing wrong.

I've modified the dialog associated with the Options->Gui... menu item., but it still needs work. In particular, it should be able to set the foreground and background colors, but I haven't been able to get the combo boxes to work correctly yet.

There is at least one screen glitch in the `boxed` text: If you delete the last character from boxed text, the right edge of the box is not redrawn.

I haven't attempted to convert the "vio" user interface. Herbert, that'll have to be your job. The arguments to the (*gui->draw)() and (*gui->color)() functions have changed, and there are two new functions inserted after (*gui->color)() named (*gui->freecolor)() and (*gui->setbg)().

The new function pointers, (*gui->freecolor)() and (*gui->setbg)(), can both be NULL for vio. The vio version of (*gui->color)() will probably be almost identical to the termcap version. The only function that might cause you grief is (*gui->draw)().

### 3.2 Options

Here's a list of the options added since version 2.1.

smartargs, sa
  This causes elvis to temporarily display the formal arguments for any function while you're typing in a function call. Specifically, when you input a function name followed by an open parenthesis, elvis performs a tag search on the function name, fetches the source line where the function is defined, and then simulates typing the argument portion of that line and backspacing over it. Since elvis doesn't immediately delete text that you backspace over, you can see the arguments and type over them. This has no effect on the keystrokes that you need to type; it is purely a visual effect.

  This is a global option, but it is only effective while you're in the syntax display mode, because the definitions of "function name" and "open parenthesis" may vary with on your programming language.

  Currently the tag search is performed via the `ref` program, but this may change in the future. Adding the search code into elvis should make it faster, and also gives the search mechanism access to elvis' tag heuristics.

  In expressions, "`feature("smartargs")`" will return True if your version of elvis which supports the smartargs feature, and False otherwise. The smartargs option itself always exists in elvis 2.2, even if its behavior isn't supported.

timestamp
  Each buffer now has a `timestamp` option. Its value is a string, which will normally be set via the new time function. Elvis doesn't use it for anything internally, but the `elvis.arf` and `elvis.awf` functions have been modified to set it, and `elvis.bwf` has been modified to test it.
bang
  This option only exists while running `elvis.bwf` or `elvis.awf`. It indicates whether the "!" flag was used in a "`:w`" command. This is important because `elvis.bwf` is responsible for detecting changes in the file's timestamp, and we want to be able to override that by adding the "!".
smartcase
  This is a useful option from Vim. When set, it causes `ignorecase` to be disregarded if the regular expression contains uppercase letters.
hlsearch
  Another Vim option. When set, executing any search command will cause all matching instances to be highlighted on the screen. (This is different from selections, as in elvis' `autoselect` option.) The instances will remain highlighted until you give a `:nohlsearch` command.

### 3.3 New functions & other calculator features

The following features have been added to the built-in calculator. This is used by `:if`, `:let`, and others.

Regular expressions
  The first argument to any function can be a regular expression. This is /-delimited, but is actually passed as a string which begins with a leading /, but without any ending /. This feature was added mostly for the benefit of the `current(`regexp`)` feature, described below.
current(regexp)
  In addition to all the special words that the `current()` function has previously supported, you can now pass it a regular expression. This can be either a string which starts with a / character, or a literal regular expression as described above.

  The return value will be the matching text. To find this text, elvis starts searching from the beginning of the line, for all non-overlapping instances of text which match the regular expression. When it finds a match which includes the cursor position, it returns that match. If there is no such match, then an empty string is returned.

  For example, `current(/./)` returns the current character, and `current(/\S*/)` returns the current whitespace-delimited word (or an empty string if the cursor happens to be on whitespace). Here's a subtle one: `current(/..../)` divides the line into 4-character chunks and returns the chunk containing the cursor, or "" if the cursor is located after the last complete chunk.

  Using strings instead of literal regular expressions, `current("/.")` would return the current character, exactly like `current(/./)`. In fact, the current() function can't tell the difference between them, because of the way that regular expressions are parsed.

ascii(string)
  Return the ASCII value (as a decimal number) of the first character in the string.
newbuffer(name)
  When invoked with the name of an existing buffer, this function returns "". However, if invoked with the name of a nonexistent buffer, then it creates that buffer and returns the name of it. If the requested name is "" (or is simply omitted) then elvis will create a buffer with a unique name, and return that.

  This is the first function to have a side-effect. I'm not sure I like that.

  Here's an example showing how this might be used.

      	alias man {
      		"Display a man page in a new window
      		local b report=0 nosaveregexp
      		let b = newbuffer()
      		(=b) set bufdisplay=man
      		(=b)r !!man !*
      		try (=b)1 s/^Reformatting.*ait\.\.\.$//
      		try (=b)% s/\\/\\\\/g
      		try (=b)% s/_\(.\)/\\fI\1\\fR/g
      		try (=b)% s/.\(.\)/\\fB\1\\fR/g
      		try (=b)% s/\\fR\\fB//g
      		try (=b)% s/\\fR\\fI//g
      		(=b)1 i .nf
      		(=b) set nomod
      		(=b) split
      	}

time(filename)
  Return the timestamp of a file, or the current time if filename is omitted or "". For invalid filenames (such as HTTP URLs), return "". Times are always in the format "YYYY-MM-DDThh:mm:ss"; this is an ISO-8660 time format.

  To implement this, I added a `dirtime()` function to all of the
  osXXXX/osdir.c files.

### 3.4 New ex commands, or changes to existing ones

The following ex commands are new, or have changed significantly from elvis 2.1.

:color `[`face `[`attributes`]]`
  Radically changed; see section 3.1, above.
:push `[`+line`]` `[`file`]`
  This is exactly like the `:edit` command, except that `:push` saves the cursor position on the tag stack.
:safely excmds
  This temporarily sets the "safer" option while it executes excmds.
:nohlsearch
  Turns off the highlighting from the hlsearch option.

### 3.5 New ports, and new GUI features

X11 support for scrollwheel
  The "x11" user interface supports mice with a scroll wheel. For instructions on how to configure the mouse under XFree86, start elvis and give the command "`:howto scroll wheel`".
Reduced the areas that are insensitive to mouse clicks.
  Clicking on a portion of the text window which doesn't contain text from the file -- for example, line numbers or HTML margins -- used to be totally ignored. Now when you click on those areas, elvis will search rightward to try and find text from the edit buffer, so it can move the cursor to the correct line.

  This is particularly important for WinElvis, since whole lines are selected by dragging the mouse in a narrow strip along the left edge of the window. Previously, this was very difficult to do if the "number" option was turned on. Now it should be easier.

Improved "windows" printer
  The "windows" lptype will now respect the lpcolumns and lplines settings. Previously, it would change lplines/lpcolumns in order to keep the on-screen font size; now it will change the font size to keep the lpcolumns and lplines values, just like the PostScript lptypes.

### 3.6 Miscellany

ref looks in elvispath
  The `ref` program has been modified to append elvis' elvispath onto the end of the normal tag path.

  This was done mostly to provide a clean way for `ref` to act as a reference to the standard C library. Elvis' lib directory now contains an "ansistub.c" file and a "tags" file derived from it. You can now obtain information about a standard C library function by running "`ref` function", or by moving the cursor onto the function name in an edit buffer and hitting `Ctrl-K`. It also works well with the new smartargs option.

Ex addresses can now contain buffer expressions
  When giving an explicit buffer name in an ex command line, you can now use an expression to compute that name. If the first character of the given name is '=' then the remainder of the name is evaluated; the result is used as the real name of the buffer to use.

  This feature was added because using `:eval` to evaluate buffer names was cumbersome since the parentheses have special meaning in both expressions and ex addresses, and also because `:eval` affects parentheses and backslashes throughout the line, not just in the buffer name. The following example demonstrates the two techniques, deleting any backspace sequences in the buffer whose name is stored in option x. Clearly, the "`:(=x)`" version is smaller and easier to understand.

      	:eval \((x)\)%s/.\\b\\\(.\\\)/\\1/g
      	:(=x)%s/.\b\(.\)/\1/g

Search support more flags
  The visual `/` and `?` commands now allow some new flags to be appended after the regular expression's closing delimiter. The c/i/s flags configure the options for case-sensitive, case-insensitive, and smart sensitivity, and w/x restrict matches to whole word or whole lines.
Improved printing
  As mentioned previously, the "ps" and "ps2" lptypes now support proportional fonts in a limited way. In addition, "ps", "ps2", and "html" now support the lpcolor option.

## Between 2.2b and 2.2c

Colors in other GUIs.
  The "open", "script", and "quit" user interfaces have been modified to support the same color names as the "termcap" interface. Previously, those user interfaces had no way to convert color names to RGB values. That didn't really matter, though, until the "lpcolor" option started to become more widely supported. Now that it works in PostScript and HTML, you'll want to do things like...

          elvis -Gquit -c "set lptype=html lpcolor||lp! foo.html" foo.c

  ... so the "quit" interface must support colors.

  All GUIs now support the "#RRGGBB" notation for colors. When used with the termcap/open/script/quit user interfaces, the requested color is rounded to the nearest available color.

Other color changes
  The attributes for `:color` commands can begin with "+=" or "-=" to alter existing attributes instead of completely replacing them. For example, ":color comment += bold" adds the bold attribute to comments without losing any other comment attributes, and ":color comment -= italic" removes the italic attribute.

  The "windows" GUI now supports colors named "gray1" through "gray99".

Binary files
  A "-b" command line flag and "binary" option are new. Invoking elvis with "-b" causes "binary" to be set. When binary is set, the default value of readeol is "binary" instead of "text".

  Previously, "-b blksize" was used to select the block size used in elvis' session file. This has been changed to "-B blksize". I decided to use "-b" for binary files because users rarely bother to change the block size, and because vim uses "-b" for binary files. I want to avoid unnecessary incompatibilities.

Printing
  Setting `lpout="-"` will cause the printer output to be sent to stdout. This can be handy when elvis is used noninteractively to format files...

          elvis -Gquit -c "set lptype=bs lpout=-|lp" ref.man | more

  There is a new "ansi" printer type, which outputs xterm escape sequences for changing attributes. This adds maybe 200 bytes to elvis. It works well in conjunction with the `lpout="-"` thing, described above.

Text objects
  This is a neat feature from Vim. The operator commands (d, y, c, <, >, and =) can now act on text objects, in addition to motions or visual selections.

  Text object names are two characters long. The first character is 'a' to include whitespace or delimiters surrounding the object, or 'i' for just the object itself. The second character identifies the type of object; it can be one of the following:

      .---------.----------------------------------------------------.
      | 2nd char| Description of the text object                     |
      |---------|----------------------------------------------------|
      | w       | word or punctuation string, like b e w commands    |
      | W       | whitespace-delimited word, like B E W commands     |
      | s       | sentence, like ( ) commands                        |
      | p       | paragraph, like { } commands                       |
      | S       | section, like [[ ]] commands                       |
      | { [ ( < | block, delimited by the previous char & its match  |
      | } ] ) > | block, delimited by the following char & its match |
      | b       | parenthesis block, like a( or i(                   |
      | B       | brace block, like a{ or i{                         |
      | %       | block, delimited by (, [, or { on left & its match |
      | L       | block, delimited by varying levels of indentation  |
      | l       | line                                               |
      | other   | field, delimited at both ends by the character     |
      ^---------^----------------------------------------------------^

  The use of uppercase S for sections, % for any brace-delimited block, L for indentation-delimited block, l for lines, and other punctuation for field delimiters are all extensions beyond vim's text objects.

  For block and field text objects, the 'a' version includes the delimiting characters, while the 'i' version excludes them. For the other text objects, the 'a' version includes trailing whitespace (or leading whitespace if there is no trailing whitespace), and the 'i' version is just the object itself without the surrounding whitespace.

  Text objects accept counts. For blocks, the count is the number of levels of embedded brackets to skip. For other text objects, the count is the number of consecutive objects to use, starting with the current one. For example, "`3daw`" deletes three words, while "`3da{`" moves out three level of braces, and then deletes that single large brace-delimited block.

  Although Vim allows text objects to be used as the first command while visually selecting text (e.g, "vas" selects a sentence), elvis does not support this.

Highlighting around the cursor
  Two new options have been added to allow text around the cursor to be highlighted: The "hlobject" option defines the type of text object to highlight, and the "hllayers" option indicates how many instances of that object should be highlighted.

  By default, `hlobject=al` so it will highlight lines. Setting `hllayers=1` will cause the current line to be highlighted. Another popular choice is `hlobject=a{ hllayers=9` to highlight up to nine layers of nested blocks.

  Each layer can be highlighted differently. The outermost highlighted layer is always highlighted using a font named "hlobject1", the next layer uses "hlobject2", and so on. If hllayers is set higher than the number of hlobjectn fonts, then elvis will loop back to the hlobject1 again when it runs out of defined fonts.

Folding
  Folding gives you a way to temporarily hide portions of your text file, without deleting it. For details, start elvis and give the command "`:help fold`". Briefly...
  - `:fold` creates a new folded region, or refolds an unfolded one.
  - `:unfold` creates a new unfolded region, or unfolds a folded one.
  - The `<Tab>` key toggles folding at the cursor position.
  - Each folded region is displayed on a single line containing the name of the folded region. Use "`:color fold ...`" to control its display attributes.
  - Two new functions, `fold()` and `unfold()`, test whether the current line is currently folded or previously folded.
  - A new `:foldc` alias folds the bodies of C functions.

  To play with this, start editing a C source file and give the command "`:foldc`". The body of each function should be reduced to a single line. To unfold one, move the cursor onto the folded line and hit the `<Tab>` key. To fold it again, hit the `<Tab>` key a second time.

Incremental search
  Elvis now supports incremental search. The command ":set incsearch" will cause the `/` and `?` vi commands to search incrementally as you type in the regular expression, instead of waiting for you to hit `<Enter>` before searching.

  To maintain compatibility with vim, the abbreviated name of "incsearch" is "is". The "initialstate" option used to have that abbreviated name; I had to change it to "init" to avoid a name clash.

:normal command
  Elvis now supports a vim-style `:normal` command. It allows ex scripts to execute vi commands. There are some differences between elvis' implementation and vim's:
  - Vim interprets maps in the keystrokes, unless invoked with a "!" modifier (`:normal!`). Elvis' version never interprets maps. In effect, elvis acts as though it always had a "!" modifier.
  - Elvis doesn't support vim's angle-bracket notation for special keys.

  For the sake of compatibility with earlier versions of elvis, when `:normal` is invoked without any arguments it will set the display mode to "normal", just as it always has.

Multiple tabstops, and guidelines
  The `tabstop` and `shiftwidth` options can now be set to a comma-delimited list of column widths, instead of merely a single column width. The last width is repeated, if necessary for long lines.

  In addition, a new `guidewidth` option uses the same type of width list to specify where vertical lines should be drawn on the screen. This is sometimes handy when you're editing text with a specific format, such as a dump of database records.

:for command
  A new `:for` (or, equivalently, `:foreach`) command has been added. Like the `:while` command, it supplies parameters which control a subsequent `:do` command. The first parameter of `:for` is the name of a looping variable, which can be any option. The remaining parameters (after an optional "in" keyword) is a list of values that the variable to take, for each iteration of the loop.

  To help generate the list of values, a new "..." operator has been added to the built-in calculator so you can do things like this:

      	:for i (1 ... 10)
      	:do set i?

User-defined URL protocols
  You can add support for new types of URL protocols, by defining aliases with names derived from the protocol name. For example, the following implement the "mailto:" protocol under Unix.

      	alias readMAILTO {
      	  "initialize a mailto: message

      	  "Normally, URLs are considered to be readonly and binary,
      	  "but since the whole purpose of the mailto: URL is to
      	  "write text out to the mailer, we need to change that.
      	  se noro reol=text

      	  "Read the .signature file, if there is one.
      	  if exists($HOME/".signature")
      	  then {
      	    read ~/.signature
      	    1 i --
      	  }
      	}

      	alias writeMAILTO {
      	  "send a mailto: message

      	  " This is a lot more complex that one would think.
      	  " The mail program forks off a spooler, and the spooler
      	  " inherits the stdout/stderr file descriptors.  This
      	  " has the unfortunate side-effect of making elvis wait
      	  " until the mail queue is emptied, after this message
      	  " and any other pending messages have been uploaded to
      	  " the mailserver.  Yuk!  To avoid that, we redirect the
      	  " mail program's stdout/stderr to /dev/null.
      	  w !!mail -s"!(no subject)subject=" !2 >/dev/null 2>&1
      	  se nomod
      	}

## Between 2.2c and 2.2d

Bug fixes
  The following bugs have been fixed:
  - The `:s` command wasn't always returning a failure status when it should. This caused some scripts to misbehave.
  - Folding interfered with the `PgUp` and `PgDn` keys. Actually, it interfered with any attempt to move by more than one line at a time. This has been fixed by making multi-line moves be split into multiple one-line moves, if there is a fold involved. I also cleaned up the parameters to the fold functions while fixing this.
  - Some combined fonts (most notably the hlsearch font) looked wrong when they were also highlighted. Elvis' display code wasn't handling the three-way combination of the text's base font, the hlsearch font, and the selection font correctly. This has been fixed.
  - In an arithmetic expression, using a regular expression as the argument of `current()` could cause core dumps or other weirdness. Fixed.
  - WinElvis didn't update the window correctly while scrolling, if part of the window was off screen.
  - The `J` command didn't work while in input mode (in conjunction with the `^O` key). Now it works, but it doesn't keep whitespace between the lines; I'm not sure why.
  - The `:make` command wasn't writing buffers even if `autowrite` option was set.
  - In "html" mode, the `$` command moved the cursor to the start of the following line, but looked like it was moving to the start of the current line. Both were wrong.
  - In visual mode, typing `:<Enter>` should do nothing, but instead it was moving down and printing a line (normal ex behavior that has no place in vi).
  - The command "`:vi +line`" was ignoring the line number when no filename was given.
  - The `showlink` option had the side-effect of making the current word be displayed on the bottom line in modes other than HTML.
  - The `:browse` and `:sbrowse` commands, and the `:kwic` alias, were broken.
  - Lots of little bugs in incremental searches:
    - They sometimes left confusing information at the bottom of the screen. I've eliminated that. While I was at it, I also added some extra feedback during the search.
    - they couldn't be used as the targets for operator commands. They still can't, but now elvis is smart enough to ignore the `incsearch` option in that situation; it'll use plain old searching instead.
    - Elvis wasn't setting the preferred column after a search, so if you started a search in column 20 and then found a match in column 40 (of the same line or a different one), then as soon as you used the `j` or `k commands the cursor would snap back to column 20 again.`
    - You couldn't use `^V` to quote characters while entering an incremental search string.
    - Typing `/<Enter>` should repeat the previous search, but didn't.
Changes to hlobject
  The default value of the `hlobject` option has been changed from "al" to nothing. This disables object highlighting, even if `hllayers` is set to a non-zero value.

  The "elvis.syn" file now allows language descriptions to contain "set" lines. These set the default value of options (i.e., they only change the value if you haven't explicitly set that option via a :set command). The idea here is that you can add language-specific lines such as "`set hlobject=a{`" to elvis.syn, and then you don't need to worry about setting hlobject in your own initialization scripts.

Improvements to "x11" user interface
  It now accepts font names of the form "font*size", so you can do things like "`elvis -fn courier*14`" or "`:set controlfont=times*14`". The "windows" user interface also supports this notation.
Improvements to "fmt"
  The version of "fmt" distributed with elvis is now installed as "elvfmt", to avoid name clashes with any existing "fmt" utility. "elvfmt" has been added to the default list of programs to compile/install; previously, neither "elvfmt" nor "fmt" (the elvis version) was compiled or installed.

  Some new option flags have been added. Invoking "elvfmt -c" will cause it to be smarter about crowns -- i.e., if the second line of a paragraph typically has different indentation than the first line, this flag causes "elvfmt" to read ahead, if necessary, to discover what a wrapped line's indentation should look like.

  A new "-i charlist" flag allows you to specify characters other than whitespace, which should be included in the indentation. For example, "-i'>'" allows the > character to be used in indentation; this is handy when adjusting email messages with quoted text.

  Two shorthand options have been added. "-C" is good for C/C++ comments, and is equivalent to "-c -i'/*'". "-M" is good for email messages, and is equivalent to "-i'>'".

Improvements to ":help"
  The `:help` command has been extended slightly. In addition to all the previous help topics that it supported, you can also now lookup a display mode via "`:help display` name".

  You can also look up an HTML tag via "`:help <`name`>`". However, please bear in mind that elvis' manual describes elvis' implementation of HTML tags, which might not be quite how a real browser uses them. Also, some common tags such as <center> aren't supported by elvis, so they aren't described in the manual. Still, it is better than nothing.

  When looking up an option via "`:help set` option", you can now append a "=" character after the option name if you like. This is handy because name completion (the `Tab` key) adds an "=" after the names of non-Boolean options. Previously you had to backspace over the "=", but now you can leave it.

  The "ex" and "options" chapters have been reformatted for improved readability and consistency.

Spell checker
  A nice little spell checker has been added to elvis. The checking rules are highly configurable. When editing source code, function names are checked against the "tags" file. Comments, embedded documentation, and non-source files are checked against a natural language dictionary -- by default elvis uses "/usr/dict/words" if it exists. Variables aren't normally checked, since most "tags" generators don't generate tags for local variables.

  A new font named "hlspell" is used to highlight misspelled words. New options named "hlspell", "showspell", "spelltags", "spelldict", "spellautoload", and "spellsuffix" influence the spell checker. A new ":check" command lets you define the spell check rules for each type of text. New ":words" and ":wordfile" commands manipulate the spelling dictionary. In visual command mode, `^K` moves the cursor forward to the next misspelled word. The built-in calculator has been extended with "spell()" and "spelltag()" functions, which attempt to guess the correct spelling of a word.

  The `^K` command may be replaced by a `g S` command by the time elvis 2.2 is officially released.

Built-in calculator
  The built-in calculator now allows you to use subscripts as a way to access substrings. You can also use subscripts on the left hand side of a `:let` command, to alter part of an option's value.

      	:let a="this is a subscripting example"
      	:calc a[3 4]
      	a subscripting
      	:let a[3 4] = "an indexing"
      	:calc a
      	this is an indexing example

  By default, subscripting uses whitespace to delimit the elements, but you can also specify a different delimiter, or divide the string into individual characters.

  The `&&` and `||` operators have been modified. They return their left argument if it is false or true, respectively; otherwise, they return their right argument. This is more powerful than simply returning a Boolean value. For example, you can use `||` to offer a default value for an expression.

      	:alias say calc "!$" || "What should I say?"
      	:say
      	What should I say?
      	:say hello
      	hello

  The `:` operator (when not part of a `?:` operator) has been defined as appending its arguments with an OS-specific path delimiter between them. That's ":" for Unix/Linux, and ";" for Microsoft OSes.

Initialization
  The behavior of the `:mkexrc` command has been refined. It should be easier to save your configuration now. Basically, a new "mkexrcfile" option has been created, which stores the name of a file which was previously generated via `:mkexrc`. If you later invoke `:mkexrc` without any arguments, elvis will overwrite that same file, without complaining that the file already exists.

  Two new options have been created to help control whether HTML documents are initially displayed in the "html" mode or "syntax html" mode. Each buffer has an "`initialsyntax`" option which indicates whether that particular buffer should start in "syntax" mode. A global "`prefersyntax`" option is used by the `elvis.arf` to set or clear `initialsyntax` as appropriate. Most people will want to set `prefersyntax` to either "always" or "never", but you can also set it to "local" or "writable".

Regular expressions
  Regular expressions have been extended in some Perl-compatible ways. The `\|` alternation operator is now supported. The closure operators (`*`, `\+`, `\?`, and `\{`m`,`n`}`) can now be applied to complex subexpressions, instead of just single-character expressions. You can make any closure operator be "non-greedy" by placing a `\?` operator after it.

  There are new `\h` and `\H` metacharacters that match the edge of a word, or a non-edge, respectively. There is also a new "`magicperl`" option that gives `\b` and `\B` the same meanings respectively. (Normally, `\b` is treated as a backspace character in regular expressions).

  A new "`magicchar`" option lists the metacharacters that don't need a preceding backslash. You can use this to tweak the regular expression syntax to be more like egrep or Perl.

  Regular expressions now support Perl-style variable interpolation, if you set the new "`magicname`" option. This also works in the replacement text of `:s//` commands. This means that if a regular expression contains `$`name, elvis will replace it with the value of the named option. The following example sets "c" to a regular expression that matches C++ comments, and then uses it in a substitution that converts them to C comments.

      	:let c="//\\(.*\\)"
      	:s/$c/\/*\1*\//

Printing
  The PostScript print driver (when `lptype=ps` or `lptype=ps2`) will now automatically sense the page size, and scale the printout accordingly. The `lppaper` option still exists, but you should only set it if you want to override the automatically sensed size.
Syntax coloring
  The `elvis.syn` file has been extended two ways. First, a new "mostly" line has been added which allows you to specify what color/attributes to use for words that aren't classified as keywords, functions, or anything else. Previously, any such word was considered to be a "variable" by default. But since spell-checking is normally disabled for "variable" words, this would have prevented the spell-checker from working when editing HTML source. The "mostly" line in HTML's syntax description gets around that by making such words be considered "formatted" instead.

  The other change is also related to spell-checking. Syntax entries can now have a "documentation" line to describe the delimiters of embedded documentation. Elvis then displays the documentation using the "doc" colors and attributes. More importantly, elvis can spell-check it using the "doc" spelling rules. This is specifically intended to support Perl's POD text, and currently Perl is the only language configured to use this feature... but hopefully it'll be versatile enough to support other languages too.

Miscellaneous extensions
  In the "windows" and "x11" user interfaces, you can now use <Shift-arrow> keys to select text.

  You can now use text objects as part of a v/V/^V selection.

## Between 2.2d and 2.2e

Work-around for an apparent bug in XFree86 4.0.3
  Some X servers (specifically XFree86 4.0.3 on a 3dfx Voodoo3, which is what I'm using) apparently have a bug: Their text rendering hardware isn't synchronized with their block copy hardware. In elvis, this shows up when you're moving the cursor over text that is being redrawn, such as when you're selecting text via the `v` command -- parts of some characters won't be drawn. If this bug bites you like it bit me, then try "`:set synccursor`" which will cause elvis to call XSync() at appropriate times, which seems to fix this.
Bug fixes
  The following bugs from 2.2d are fixed in 2.2e:
  - Couldn't yank from a buffer when "locked" option was set.
  - Odd things happened if you edited a filename which happened to be a number. E.g., "`:e 1`". This could clobber an existing buffer.
  - d/regexp/+0 wasn't including the line where the match was found.
  - The `:customize` alias didn't work with directory names that contain spaces. This was often a problem under Windows.
  - The `:<<` and `:>>>>` commands weren't shifting by multiple shiftwidths as they should.
  - The `:join` command didn't work with visual selections.
  - Elvis 2.2d would hang on `:%s/\( ,\)\+//g`, due to a bug in the way that non-greedy closure operators were added.
  - When "`incsearch`" was set, backward searches could dump core.
  - With "`hlsearch`" set, elvis would hang if you searched for a regular expression that could match 0 characters.
  - WinElvis wasn't updating its window correctly if it scrolled while part of the window was off-screen.
  - Under Unix/Linux, elvis could be confused by broken symbolic links with the same name as a session file. Also, there was a possible race condition in choosing session file names, which could (rarely and sporadically) prevent elvis from starting up.
  - In certain circumstances involving the `newbuffer()` function, `:file` command, and `:w` command, elvis could assign two different buffers the same name. This wasn't a huge problem, but it could make file recovery be a little awkward.
"g" commands
  Elvis now supports some vim-style "g" commands. A few of these are better described in following sections, but most of them are described here.
  - Vim-compatible "g" commands

        .-----.-------------------------------------------------------.
        | g0  | go to leftmost char in current row, for wrapped lines |
        | g^  | go to leftmost non-whitespace in current row          |
        | g$  | go to rightmost char in current row                   |
        | gj  | go down one row                                       |
        | gk  | go up one row                                         |
        | gd  | go to local definition of word at cursor              |
        | gD  | go to global definition of word at cursor             |
        | gI  | insert at start of line, like "0i"                    |
        | gJ  | join lines without space, like ":join!"               |
        | gU  | operator, makes text uppercase                        |
        | gu  | operator, makes text lowercase                        |
        | g~  | operator, toggles case                                |
        | ga  | show ASCII code of current char                       |
        ^-----^-------------------------------------------------------^

  - "g" commands that exist only in elvis

        .-----.-------------------------------------------------------.
        | gh  | move left, skipping hidden chars (for markup modes)   |
        | gl  | move right, skipping hidden chars                     |
        | g=X | operator, replaces text with equal number of X chars  |
        ^-----^-------------------------------------------------------^

    Note that vim uses `gh` to start its "Select" mode, which looks like a visual selection but behaves differently. I generally try to avoid unnecessary incompatibilities with vim, but I think this is justified since it means that `gh`, `gj`, `gk`, and `gl` are just WYSIWYG versions of the `h`, `j`, `k`, and `l` commands.
Auto commands
  Vim's `:augroup`, `:autocmd`, and `:doautocmd` commands have been added to elvis. This is still extremely experimental, but you're welcome to play with it if you want. The commands are described in elvis' online help.
Revised :map command
  The :map command's syntax has been extended. Previous versions of elvis supported a "visual" flag at the beginning of the rhs text, to indicate that the map should be interpreted in visual command mode even if the editor is in input mode. This has been extended as follows.
  - In addition to "`visual`", it now supports a "`noremap`" flag which prevents the rhs text from being rescanned for maps.
  - New flags have been added to indicate which contexts the map should be detected in: "`command`" for visual command mode,
    "`select`" for command mode when a visual selection is pending, "`motion`" for when a motion command or text object is expected, "`input`" for input mode or replace mode, and
    "`history`" for input or replace while entering an ex command.
  - The flags can appear before either the lhs or rhs text. Placing them before the lhs is often more convenient when you're writing an alias.
Changes to the spell checker
  - There was a big bug which caused core dumps if any word (correct or incorrect) contained character #255. This is now fixed.
  - With the "wrap" option turned off and the screen scrolled sideways, the spell checker was checking the partial words on the left edge of the screen and highlighting them if the partial word wasn't a valid whole word. Now, in 2.2e, those partial words will be unchecked.
  - The speller was ignoring leading digits in a word, and checking the remainder. Now it'll include the digits in the word, and avoid checking the remainder. This prevents things like "80x24" from being highlighted as an error.
  - The "move to next misspelled word" command has been changed from `^K` to `gs`. In addition, if you set the "`showspell`" option and the cursor is already on a misspelled word and you pass a count parameter to `gs`, it'll replace the current misspelled word with one of the suggested alternatives before moving to the next misspelled word. For example, `1gs` will replace the current word with the first alternative before moving to the next misspelled word.
  - A new `gS` (with an uppercase "S") has been added. It moves the cursor to the end of the current "word", as defined by the spell checker. The primary difference between `gS` and the plain old `e` command is that the spelling checker allows apostrophes between letters. This command was added mostly so you could use `cgS` word`<Esc>` to correct a misspelled word.
  - The `showspell` option was suggesting words from the wrong dictionary. Fixed.
Visual selections
  - The behavior of the `v`/`V`/`^V` commands has changed to be more vim-like. For example, if you've started a character-mode selection via the `v` command, you can hit `V` to switch to a line-mode selection.
  - During a rectangular selection, The `$` command will cause the rectangle to extend to the end of each line, even if the cursor is on a shorter line.
  - A new `g%` command has been added. During any type of selection, it moves to the other end of the selected range, like vim's `o` command. You can use "`:map select o g%`" to allow `o` to work this way in elvis too.
  - A new `g^V` command has been added. During a rectangular selection, it moves the cursor to the opposite side of the selection within same line, like vim's `O` command. You can use "`:map select O g^V^V`" to allow `O` to work this way in elvis too. (The first `^V` is necessary to protect the second one from the command line parser. When you're typing this interactively, you'll need to hit <Ctrl-V> four times!)
Miscellany
  - Incremental searches are now smart enough to defer searching if there are extra characters already in the type-ahead buffer. This allows incremental searching to keep up with your typing better, especially if you are searching through a large buffer.
  - A new `ex/likevim.ex` script has been written to emulate come of vim's commands that aren't natively supported in elvis.
  - The "x11" user interface now supports keyboard timeouts via the "`usertime`" option. It never needs timeouts for function keys, so the "`keytime`" option is still ignored.
  - The `:help` command is now clever enough to support multi-keystroke vi commands, such as `^Wd` and `g%`.
  - The built-in expression evaluator now allows (but does not require) a `$` prefix for option names. Also, you can use `_` or `$_` as a synonym for `line()`.
  - The "termcap" user interface now supports a "transparent" background color. This merely resets the video attributes without then specifying a new background color. However, not all terminal emulators reset colors when other video attributes are reset so the "transparent" background won't work for everybody.
  - The tag selection heuristic has been modified so that when two tags seem equally desirable, it will prefer the one which comes from a newer file.
  - The `showname` option has been renamed to `showfile`.
  - The `showfile` and `showtag` options will now display "file=" or "tag=" before their value. This was done because there are so many things that can be displayed on the status line that it was becoming confusing.
  - The `:mkexrc` command will now save aliases.

  ## Between 2.2e and 2.2f

  2.2f is the first beta-test version of elvis 2.2. All the previous prereleases were alpha-test. The significance of this is, I don't expect to add any major new features to beta-test versions, so what you see here is pretty much what the official release of 2.2 will be like.
  Bug fixes
    The following bugs have been hunted down and killed:
    - In arithmetic expressions, the precedence of the `[]` (subscript) operator was too low.
    - Also in subscripts, any non-numeric index was treated as an endless list of 0's, which generally caused 10 copies of the string's length to be returned.
    - When using multiple windows of different sizes, elvis could crash after reading an ex command line or search expression on the bottom line of the smaller window.
    - Elvis would sometimes hang when splitting HTML windows, particularly in the "termcap" user interface.
    - Script files weren't being recognized and syntax-colored, if the `magicchar` option was changed. See the following "Regular Expression" section for a description of why.
    - When pasting characters into an empty buffer, from the GUI's clip board, elvis wasn't adding a newline at the end of the text. This left the cursor in a funny place, and it also affected later cursor movement.
    - The termcap interface's "transparent" background color wasn't working very well.
    - When an external program was run in the termcap interface, elvis would revert to the editor colors before switching back to the editor screen, leaving the normal shell screen's colors looking like the editor colors.
    - The `locked` and `readonly` options should never be stored by `:mkexrc`.
    - With multiple windows, and one window inputting an ex command line, some of the character attributes could be drawn incorrectly.
  Minor tweaks and extensions
    - The :make command is now smarter about windows. Before switching buffers in the current window, elvis will first check to see if there's already some other window which is showing the erroneous buffer. If so, it'll just switch to that window and leave the current window unchanged.
    - A new `g<Tab>` command has been added to move backward to the previous link, when viewing HTML files. This is a nice counterpart to the normal `<Tab>` command for moving forward to a link. When possible, `<Shift-Tab>` is mapped to `g<Tab>`.
    - The built-in calculator's `absolute()` function is now smart enough to eliminate ".." in pathnames. Hopefully this is enough to make most aliases for a given file all resolve to the same exact string.
    - Buffer names now default to the absolute pathname of a file, instead of being identical to the name as you originally gave. This is intended to prevent elvis from creating multiple buffers for the same file... which is important because apparently the `javac` compiler likes to give long relative names for files, even if the file is in the current directory.
    - When searching for tags, both elvis and ref will now have a tendency to list functions before macros. This is handy if you often use macros as stubs or wrappers around real functions.
    - The font name "emphasized" has been removed from all syntax descriptions, in favor of names that better describe the intended purpose of that font.
    - The definition of a section (as used by the `[[`, `]]`, and `gd` commands) has been tweaked. Instead of requiring the '{' character to appear in column 1, it can now appear anywhere in an unindented line. This works better for Perl and some C/C++/Java coding styles. There's a new "`tweaksection`" option to control this.
    - There are more FEATURE_XXXX macros in "config.h", so you can selectively disable more features. The `:config` alias has been replaced by a similar `:feature` alias.
    - The script generated by `:mkexrc` will now avoid using the `:if` command, so that the script can be executed even if the `:if` command has been disabled by #undef'ing FEATURE_CALC.
    - The `showspell` option will now display numbers with the suggested spellings. This makes the `gs` command easier to use.
  Regular Expressions
    There are new metacharacters for controlling the way regular expressions are parsed. `\Q` causes all characters to be handled literally except for backslashes; i.e., all metacharacters require a backslash after `\Q`. `\V` causes it to use the traditional vi syntax, regardless of the setting of the `magicchar` option. `\E` uses the normal syntax, under the control of `magicchar`.

    The "elvis.arf" script has been modified to use \V so it will work even if you changed `magicchar`. Some users noticed that if they configured `magicchar` to make elvis use a Perl-ish regular expression syntax, elvis would no longer use syntax coloring when displaying Perl scripts. This was because "elvis.arf" uses regular expressions to recognize scripts, and changing `magicchar` broke those regular expressions.

  New :autocmd events
    `AliasEnter` and `ScriptEnter` are triggered when an alias or script is about to be executed. This is handy for setting local options.

    There are also `AliasLeave` and `ScriptLeave` events, mostly for the sake of symmetry. Perhaps they'll be useful for tracing alias calls or something like that.

    There is a new `Edit` event, which is triggered each time you modify the edit buffer.

  Regions
    This is a new feature. You can now add extra highlighting to regions of text. Here's an example that uses the new `Edit` autocmd event to highlight any lines that you change by setting the background to red.

        	:color changed on red
        	:au Edit * '[,']region changed
        	:au BufWritePost * unregion

  New mapmode option
    I've added a new `mapmode` option for buffers, and extended the `:map` command to support a `mode=`name context flag. Any maps defined with a `mode=`name flag will be used only for buffers whose `mapmode` is also set to name.

    For example, you can use this to set up different maps for HTML files and man-pages, and then set each buffer's `mapmode` to use the right set of maps.

        	:map mode=html select BB c<strong>^P</strong>^[
        	:map mode=html select II c<em>^P</em>^[
        	:map mode=man  select BB c\fB^P\fR^[
        	:map mode=man  select II c\fI^P\fR^[

  Aliases
    Many little changes to aliases.
    - Elvis now distinguishes between user-defined aliases and system-defined aliases. System-defined aliases are defined or listed using `:alias!` (with a "!" suffix); user-defined aliases use no suffix.
    - User-defined aliases are now saved by the `:mkexrc` command. System-defined aliases aren't saved, since they're defined in the standard initialization scripts.
    - When `:alias` displays the definition of an alias, it will now indent to the code to indicate program structure.
    - You can now use `!`n`*` in aliases to access all argument text from the nth word to the end of the arguments. For example, `!2*` will be replaced by all arguments text except the first word.

  ## Between 2.2f and 2.2g

  2.2g is almost entirely just a bug-fix update, mostly involving colors. I also completed a few features which were partially implemented in 2.2f.
  Miscellaneous bugs
    These bug fixes affect all versions of elvis, regardless of the operating system or the user interface.
    - It took me 6 years, but I finally found & fixed a bug in lowbuf.c which occasionally caused elvis to dump core when editing large files.
    - A much newer bug could cause core dumps when editing a C++ file that starts with a comment.
    - The `:mkexrc` command was changing the name of the "Elvis custom initialization" buffer. Internal buffers like that should never be renamed when written.
    - The `smartargs` option didn't allow any whitespace between the function name and the '(' character.
    - The `:let` command wasn't triggering `OptChanged` autocmd events.
    - "`:help ex`" and "`:help vi`" were failing to find the help files.
    - The "`:s///`" command's "`x`" flag was unreliable when used in aliases that switch buffers. In particular, it didn't work in readXXX and writeXXX aliases used to add new URL protocols.
    - Modelines didn't work near the bottom of a file.
    - The standard initialization scripts had errors when the "safer" option was set via the "-S" flag.
    - There was a weird bug involving highlighting of PERL "doc" lines. I can't describe it, but you'd know it if it bit you.
    - Guide lines (configured via the `guidewidth` option) were being drawn on ex command output at the bottom of the screen.
    - When "boxed" text was updated, the left & right edges weren't always being drawn, so the box appeared to be open-ended.
    - The `:r` command always displayed the number of lines read, even if `report=0`.
    - In "hex" mode, the line before the column headings was in a funny font. This only showed up when you did a ":sp file.bin" on a binary file; as soon as any event causes the screen to be redrawn, it looked okay.
    - The `elvtags/ctags` program was sometimes adding a bogus "class" hint.
    - The `show=link` setting (previously the "showlink" option) was slow in some situations. Also, it was displaying things in "syntax" mode, which is pointless; only the "html" display mode can have non-obvious links.
    - Some bugs in the Gnome interface were fixed by Klaus Elsbernd.
    - The `:mkexrc` command didn't save maps correctly if they used the new "mode=XXX" flag.
    - The spell-checker didn't like words that start with '_' even though tag names often do start with '_'. This caused those tags to be marked as errors.
  Color bugs
    These changes apply to all user interfaces, except where noted.
    - If the only difference between "normal" and "idle" was one of the bold/italic/underlined/boxed/graphic attributes, then elvis wasn't updating the screen correctly.
    - The PostScript print drivers ("ps" and "ps2") were using the video colors instead of the carefully chosen printing colors.
    - I added an "lpcontrast" option to help darken colors when necessary. (Not really a bug, but I wanted to list this near the preceding PostScript bug.) This affects the PostScript drivers and the "windows" print driver.
    - There were some problems with the "+=" and "-=" operators, and with partially specified normal/idle colors. These all sort of worked, but they couldn't be stored in a way that worked well with the :mkexrc file.
    - In the "termcap" interface under MS-DOS, you couldn't mix a bold or bright "normal" foreground with a bold or bright version of any other color for other fonts. If you tried, the other fonts would just use the dark version of the color.
    - In the "termcap" interface under Linux, using italics interfered with foreground colors. A new "`ttyitalic`" option has been created to disable italics in this situation.
    - In the "x11" interface, there was a bug which showed up when you used commands like "`color statusbar like toolbar`" -- the change wouldn't be reflected on the screen until the statusbar had an Expose event.
  Color & text face changes
    These changes apply to all user interfaces.
    - You can use `current("face")` in expressions to find the name of the text face at the cursor position. This value is only updated when the screen is updated, which normally means it won't change during the execution of an alias.
    - You can also use `current("background")` to determine whether the "normal" background is "light" or "dark". This result is computed by examining the actual background color, not by looking at the "background" option. If the background color hasn't been explicitly set, then it returns "".
    - There is a new `color()` function for examining the settings of text faces.
      - `color(`face`)` returns the entire :color setting.
      - `color(`face`,"fg")` returns the foreground color string. This may be a single color name, or a list of color names delimited by the word "or".
      - `color(`face`,"bg")` returns the background color string. This is usually a single color name, but in the "x11" user interface it could be a color name, an image name, or both.
      - `color(`face`,"like")` returns the "like" face name, if this face has one.
    - The `:autocmd` command has a new `BgChanged` event, which is triggered whenever the "normal" background color changes.
    - A new "bottom" text face has been added. It is used for ex commands and their output, and for search expressions and the ! operator's command line.
    - When the true background color isn't known (which can only happen with the "termcap" user interface, when you don't set a background color), changing the "background" option will cause elvis the reevaluate the colors, so it can choose foreground colors that contrast with the new background.
    - When printing, the attributes used for page headers are controlled by a new "header" face.
  Colors in X11
    I changed the way some minor features of the "x11" interface use colors. Also, you can now use images for some backgrounds.
    - The scrollbar now pulls its button colors from the background of a new "scroll" face. Previously it used the foreground of the "scrollbar" face. This change was made so that you could say "color scrollbar like toolbar" and "color scroll like tool" to have the scrollbar look like the toolbar.
    - The default colors for the statusbar and toolbar have been changed to be "like toolbar" (and "like tool" for the scrollbar buttons and status windows).
    - The resources have been changed. Previously, you could specify the scrollbar colors and some aspects of the toolbar; now you can specify toolbar colors.
    - You can now use XPM images as the background for "normal" or "idle" text, or the "toolbar", "scrollbar", or "statusbar" widgets. For example, "`color normal black on red tux.xpm`" will load an image from "tx.xpm", tint it red, and use that as the background of normal text. The image file can be located in the current directory, or in a "themes" subdirectory of any element of `elvispath`.
    - I added a `:theme` alias for loading whole sets of colors. The libs directory stores scripts and image files. When `:theme` is invoked without arguments, it lists the names of the theme scripts. When invoked with a theme name, it loads that theme by running the script.
    - I also added a `readTHEME` alias, which gives elvis an easy way to download new themes. Running "`:e theme:/`" will display a list of downloadable themes. You can them move the cursor onto one and hit `<Enter>` to download, install, and load it.
    - I added a rudimentary `:mktheme` alias to help you construct your own themes in the download format.
  Windows changes
    Lots of little things.
    - It can now read color names from a file named "rgb.txt" anywhere in the elvispath. Binary distributions will include an rgb.txt file derived from the colors available with XFree86. Hopefully this will make it easier to use the same color configurations for both Windows and X.
    - The Options->Gui dialog has several improvements. The list of text faces is now sorted. You can select "proportional" or "fixed" fonts. The colors are correctly shown in combo boxes, and the pull-down lists for those combo boxes are now taller.
    - The obsolete Options->Syntax menu item has been removed.
  Other changes
    - Many of the showXXX options have been replaced by a single versatile "`show`" option. Its value is a list of things to show at the bottom of a window.
    - For untitled buffers, the number in the "Elvis untitled #n" name will match the bufid. Previously they could be different numbers, which was confusing.
    - The "modified, not saved" error message will now display the file name (if known) instead of the buffer name. This is desirable since the buffer name is now the file's full absolute name (relative to root), which can be rather long.
    - The "x11" interface now recognizes "kvt" and "gnome" as types of X terminal emulators. This will allow elvis to automatically select the "x11" interface when run from inside Kvt or gnome-terminal. Previously you had to explicitly add "-Gx11" to make elvis run using its "x11" interface from inside those terminal emulators.
    - Installing elvis via "`make install`" should now create a tags file for the stubs in the lib directory. This will help `smartargs` and <Shift-K> work with standard library functions.
    - In the binary distributions, the contents of the "lib" directory are now marked as "readonly". This should allow the "`:set prefersyntax=writable`" setting to work better.
    - In the "x11" interface, the name of the "`normalfont`" option has been changed to just "`font`". This is intended to make the "x11" interface be a little more like the "windows" interface.
    - The "x11" interface was leaving pixels behind in some situations, mostly involving bold text that extends to the left of its character cell. Now, that text will be clipped on the left, which looks much better when it scrolls.
    - If you try to look up an option which isn't available in your current configuration (for example, ":help set ttyunderline" when you're not using the termcap interface), elvis will now assume you know what you're doing. Previously, elvis would always take to to the list of option groups when you did that.
    - Setting `nottyunderline` will no longer disable underlining, unless you also configure a background color. (If you don't like this, you can say ":color normal on transparent" to disable underlining without really changing the background color.)
    - The `smartargs` option used to be global but is now a buffer option. This was done mostly for the benefit of HTML, where tag parameters are highlighted as functions, but never appear in the "tags" file -- elvis used to spend a noticeable amount of time searching for them without finding them.
    - There was a bug in the `:map` command which prevented it from listing cursor key maps and sometimes other maps as well. I fixed that, but then decided that I liked not having the cursor maps be listed -- they're always mapped to the same things by default, and it's nice to avoid clutter. I eventually decided to make "`:map`" list all non-cursor key maps, and use "`:map all`" to list all maps including cursor key maps.
    - The `elvtags/ctags` program now has limited support for tagging enum values and struct/union fields.
    - In "html" mode, the `<Enter>` key was converted to `^]` via a hardcoded test. This has been reimplemented as a normal map using the "mode=html" flag that was introduced in elvis 2.2f-beta. While I was at it, I also added a similar map which converts `<Space>` to `^F` in "html" mode, so you can use the space bar to page forward while viewing HTML documents.

  # 4. The future of elvis

  One of the biggest tasks on my list is to rewrite the ctags program so that it will be able to parse C++ code better. It should read the language descriptions from "elvis.syn", and do at least a half-assed job of generating tags for any language described there. I'm also toying with the idea of a statistical tags generator, but that's still pretty nebulous at this point.

  Windowing will be more versatile. Currently the GUI versions of elvis always split detached windows; sometimes it would be nice if they could be attached to the existing window, as a horizontal or vertical pane.

  I intend to add a true extension language to elvis. The language interface will be general enough to support a variety of languages. The first language supported will probably be PERL, followed rapidly by Python and TCL.

  I'm thinking of modifying the markup display modes (man, tex, and html) to store the list of supported markups, and their effects, in a separate file. That way, you could create your own markups to display nroff -ms, RTF, SGML, and MIME "rich text" documents.

  I'd like to redesign the way elvis assigns buffer names. I have already modified it to use the full pathname of a file as the buffer name, so if you attempt to edit the same file as both "foo" and "./foo", elvis will use the same buffer for both. In addition, I'd like for elvis to store a "current working directory" for each window, and use that to convert a relative buffer name into the absolute pathname. A similar trick would be used for filenames. When running an external program, elvis would change the real current directory to that window's directory. The benefits of all this:

  - If you're editing "foo" and "./foo", they'll both use the same buffer. This sounds contrived, but a similar thing happens with tag files fairly often.
  - If you do a :cd command, then the old buffers will still write out to their old directories.
  - Different windows could have different directories.
  - The X-windows "-client" flag would behave in a more reasonable manner.
  - The "current directory" could be something other than a local directory. For example, there's no reason you shouldn't be able to ":cd ftp://ftp.sunsite.unc.edu/pub/incoming".

  # 5. Links to related files

  If the main site (ftp.cs.pdx.edu) is too slow, try the mirror site at ftp.false.com.

  Most of the following are binary files, not text or HTML files, so you can't view then with your Web browser. But you can use your browser to download the files. For Netscape, use <Shift-Click>; for MSIE, use <RightClick> and "download".

  untar.c
    This is the complete source code for "untar", a little program which extracts files from a gzipped tar archive. Comments near the top of "untar.c" describe how to compile and use it. If you already have the gzip and tar utilities, then you don't need this.
  untardos.exe
    This is an MS-DOS executable, produced from the above "untar.c" file. It can also be run under Windows 3.1, in a Dos-prompt window. For brief instructions on how to use `untardos,` run it with no arguments.
  untarw32.exe
    This is a Win32 executable, produced from the above "untar.c" file. It runs under WindowsNT and Windows95. It runs somewhat faster than the MS-DOS version. It also supports long file names. For brief instructions on how to use `untarw32,` run it with no arguments, in a text-mode window.

    NOTE: MS-Windows95 and MS-DOS use incompatible methods for mapping long file names to short ones. So if you extract the files under Windows95, DOS programs won't be able to find them with their expected names, and vice versa. Consequently, you must use `untardos.exe` to unpack `elvis-2.2g-msdos.tar.gz`, and `untarw32.exe` to unpack `elvis-2.2g-win32.tar.gz`.

  untaros2.exe
    This is an OS/2 executable, produced from the above "untar.c" file. For brief instructions on how to use `untaros2,` run it with no arguments.
  elvis-2.2g.tar.gz
    This is a gzipped tar archive of the source code and documentation for Elvis 2.2 and its related programs.

    The links below may be out of date, for this prerelease version. Binaries will certainly be supplied for the official release. They may also be supplied for some prerelease versions but I'm not making any promises. If any of the following links are broken, this is why.
  elvis-2.2g-msdos.tar.gz
    This archive contains the documentation and MS-DOS executables for Elvis 2.2.
  elvis-2.2g-win32.tar.gz
    This archive contains the documentation and Win32 executables for Elvis 2.2. These were compiled and tested under Windows95, but should work under WindowsNT 3.51 (or later) as well.
  elvis-2.2g-os2.tar.gz
    This archive contains the documentation and OS/2 executables for Elvis 2.2.
  ftp://ftp.fh-wedel.de/pub/fh-wedel/staff/herbert/elvis/00-index.html
    This is where the OS/2 maintainer stores his most up-to-date versions. It may be better than the `elvis-2.2g-os2.tar.gz` file, above.