Introduction to IVI


An Introduction

IVI is a full-screen editor which allows a user to create, view, modify and manipulate text and records. (Other editable objects such as mathematical formulae, tables and line drawings were present in earlier versions but have been now been removed.)

The role of IVI is to prepare and process files. It is not a word processor. It has no special markers for fonts, headers, layout, tables, and so on, though of course it may be used prepare html or LaTeX files. It incorporates a large repertoire of processing operations, including the operations of the VINCI system, described elsewhere in these pages, to generate natural language utterances.


The "terminal" version of IVI has the following appearance, expanded to fill the display window:

           Core: 1 (    1,    1)   fred.txt       Lines: 2      View:  TEXT
           This is line 1 of a piece of text.
         + And here is line 2, which is so long that it extends beyond the ri

         Expecting Command

The top two lines give status information about the editor and the file being edited, and show the tab and margin columns.

The bottom two lines are used for messages from IVI, and for entering IVI commands.

The leftmost two columns contain "flags". (The + symbol, for example, tells us that the second line of text extends beyond the right column of the text zone.)

The rest of the window, the text zone, displays a portion of the file being edited.

(There are "non-terminal" versions of IVI. We are not concerned with these here.)


The editing operations are carried out on one of 19 working files, numbered 0 to 18, referred to for historic reasons as corefiles. The user may switch back and forth between them, and may store them on or retrieve them from disk. Note that although the name of the file may appear in the status zone of the screen, the corefile is only a copy of this file, and changing it does not affect the disk version unless you explicitly save it or overwrite it.

Each corefile may be used for any purpose, but several have a special role; for example:

    corefile 0 is a repository of lines deleted from other corefiles, permitting a user to recover discarded material,
    corefile 7 receives activity and error messages from the various parts of the VINCI subsystem,
    corefile 14 receives preselection rules resulting from VINCI semantic transformations,
    corefile 15 receives the error report composed by the VINCI comparison operation,
    corefile 16 receives the output of the various "merge" operations,
    corefile 17 holds assignment statements for automatic record field assignment, and
    corefile 18 holds Boolean expressions used in record checking and selection.

A corefile 19 exists internally, but is not accessible to the user.

    NOTE: Throughout these webpages we use <DEL>, <ESC>, <RETURN>, <right> and <down> to refer to keys on the keyboard labelled DEL, ESC, RETURN (or ENTER), right-arrow, down-arrow, and so on. We use <CTRL C> to imply that the user must hold down <CTRL> while typing c (or C; it doesn't matter.) If the keyboard has no <ESC>, then <CTRL [ > can be used instead.


IVI's repertoire contains nearly 200 actions, divided into two groups: commands and operations. The former actions typically require the user to provide parameters, and are typed on the command line when IVI is in COMMAND mode. The latter usually require no parameters. They are triggered by short key sequences (one or more keys) when IVI is in TYPING/INSERT mode.


The prompt "Expecting Command" indicates that IVI is in COMMAND mode, waiting for the user to type a command. The command is entered on the bottom line of the display. The user types only the first two letters of the command name (in either upper- or lower-case), and IVI fills out the rest automatically. It then prompts for parameters, which are entered separated by the symbol | . During this stage, the <DEL> key may be used to delete characters from the end of the command string, while the <RETURN> key invokes the command action. Generally speaking, parameters can be left blank (just type | to go to the next one) or omitted (just type <RETURN> to trigger the action), in which case suitable defaults are supplied.

To change from COMMAND mode to TYPING/INSERT mode, the user presses the <RETURN> key without entering a command. The cursor will return to its previous position in the corefile. To change from TYPING/INSERT to COMMAND mode, <CTRL C> is pressed.


IVI is in this mode when one of the prompts "Expecting Typing" or "Expecting Insert" is displayed.

The principal activity in this mode is typing!! If character-keys are typed, the character appears at the cursor position, and the cursor moves right. (Note that the cursor always appears on a character or space, NOT between characters.) Whether the character at the cursor is overwritten or moves right to make room for the new one is determined by the submode: TYPING or INSERT. The editor can be toggled from one submode to the other using the <CTRL W> key.

In either submode, the <DEL> key deletes the character at the cursor, and closes up the gap. If the cursor is past the end of the typed line, the character before the cursor is deleted and the cursor moves left. If the cursor is at the beginning of an empty line, the line is deleted, and the gap closed up.

Other IVI operations are triggered in TYPING/INSERT mode by typing non-character keys, such as <CTRL R> or <right>, or by typing two- or three-key sequences in which the first or first two keys are <ESC>. (In effect, the <ESC> key acts as a shift affecting the immediately following keystroke.)

All of the operations and commands are described elsewhere in this document.

In the descriptions of IVI operations, we specify the default key or key-sequence assigned to each. These assignments can actually be altered using the KEy command.

Objects and Viewing Types

The editor currently manipulates two kinds of object: text lines and records.

A text line is sequence of (displayable) characters. The line may be arbitrarily long, and only a portion appears on the screen at any time. When the cursor "runs off the screen", to the right or left, the editor moves its "window" to display an adjacent portion. (There is an overlap of 19 columns.) The symbols - and/or + in the "flag" columns of the screen indicate that there is more material on the line to the left and/or right respectively.

A record is a sequence of fields, each of which is a sequence of characters. The number of fields and the maximum length of each is set by the user (or by default).

Text lines and records may be mingled within a file, but this is not recommended. It is expected (though not mandatory) that the records within a given file will be homogeneous, that is to say, each will have the same number of fields, and that corresponding fields will be used for similar purposes.

Records can be viewed in either template or text form. In template form only a single record can be seen at one time. Its fields are arranged on the screen inside a template which can be designed and established by the user. The maximum size of each field is shown by ^ symbols, which indicate unfilled spaces. In text form, each record is shown as a single text line, with its fields terminated by | symbols. Several records appear at one time (as in the case of text), and a record can "run off the screen" on to the next adjacent window.

In effect, there are three viewing types: TEXT, RECORD/TEXT and RECORD/TEMPLATE, which the user may specify/alter for each corefile independently. (There are several others which are hangovers from earlier versions of IVI.) The viewing type not only affects the view displayed for an object, but also determines the set of operations available. For example, in RECORD/TEXT view the delete operation works only on records, and does not permit deletion of the | symbol, which would damage the structure of a record. Similarly, with TEXT viewing type selected, editing of records is inhibited, again to prevent structural damage.

The currently selected object type (though not the viewing type) is shown at the top right of the screen.

Calling IVI

The calling command takes the form:

    ivi <filename>

The filename is optional. If it is present, the editor fetches the file (if it exists) or names an empty corefile (if it does not).

Computer, Operating System and Window Type

IVI has been written to run on Sun computers under the UNIX operating system, specifically Sun Solaris version 7 or later, and is freely downloadable in this form.

An almost complete version has been ported to PCs and runs under Windows 98 using Cygwin facilities. This will be made downloadable when some issues concerning open source-code have been resolved.

The Sun version of IVI expects to be run either from an Openwindows shelltool or from a program emulating a vt100 terminal such as Hyperterm used on a remote computer. For the latter, the TERM environment variable must be set to vt100; for the former, it should be set to sun or sun_cmd (currently anything except vt100.) In the vt100 case, there are a few differences in keys which invoke operations, as noted in the subsequent webpages.

Problems may be noted if IVI is run from an Openwindows commandtool, a CDE Terminal window, or any terminal simulator which does not emulate the shelltool keyboard and screen or a vt100.

In an Openwindows commandtool, the standard screen layout does not appear initially, but this is rectified by the GEnerate display command. Some strangeness may also arise in shell and driver operations.

In a CDE Terminal window, IVI seems to work correctly except for a few of the default key assignments, but it has not been thoroughly tested in this environment.

Return to IVI Reference Manual

Last revision: December 20, 2001.