µ          !(        ƒe#         σg$(        ╫j=         8▒?         B╢@         ∙╗@ FORMATS █╬@(        ╚qABS(      ±ACCEPT    8┌ACOS(     é∩APPEND    ▀APPEND BLAÄΓAPPEND FRO8µAPPEND TO ÷ASC(      uASIN(     P∩ASTERISK (.oAT(       ╨wATAN(     ┤∩AVERAGE   û°BIT(      ½zBLANK(    ÇBOX       ÿ■BREAK     BROWSE    ΓCANCEL    »CASE      $CEIL(     |≡CEN(      ÜâCHAIN     ╚CHR(      &åCLEAR     D#CLOSE     ü'CLOSE(    têCLS       '+COL(      JïCOLOR     \.COLOR ATTR-COMMAND AN▌COMMAND LIñ(COMMENT (*ï¡COMPILE   ╚9CONSTANTS OSCONTINUE  ù=COPY      @COPY STRUC╧HCOS(      εεCOSH(     ≡COUNT     ╩LCREATE    
QCURSOR    ╨]DATE INPUTÖ
DATE OUTPUûDATE(     âìDAYS(     cÿDBF(      ª₧DEBUG     /`DELAY     9cDELETE    1fDELETE FIL¡jDELETED(  ªDIM       JmDIR       vDIR(      ▄⌐DIRF      ë{DISPLAY   PéDO        VëDO CASE   ┐ÉDO WHILE  ÿEDIT      #¥EDITING KEl
EJECT     u½ELSE      *«END COMMANK»EOF       i»EOF(      ╦▓ERASE     ~│EXP(      ┼φEXPRESSION½ÜFIELD     │╢FIELD VARIáFIELD(    z╕FIELDS KEY╞FILE KEYWOFILE(     |╝FILES     £╣FILES ... ç┐FILES LISTW╟FIND      ß╚FLD(      ▒┐FLOOR(    «≡FLUSH     x╙FORMAT STRFUNCTION LCFUNCTIONS ▀bGET TABLESíGET(      Æ╞GLOBAL    ╓GO        ┘GOTO      τ▀HEADING KEzHELP      PµIF        ╠ΩIFF(      ┴═IN(       R╤INDEX     C≥INDEX KEYWmINKEY(    ╓INPUT     G²INPUT SCRE7╦INSERT(   ∙┘INT(      ß≡LEFT(     z▌LEN(      ßLENGTH KEY─4LIMIT     ╒LIST      nLIST FILESLIST MEMOR±LIST STRUC╡LIST SYSTE/LOC(      ╝πLOCATE    l!LOG(      ÷φLOG10(    'εLOOP      ë(LOWER(    ÅΦLTRIM(    >δMACROS    ≥"MATH      t±MAX       )*MAX(      MEMO FIELDn5MEMORY VARµªMENU(     ├MESSAGE KE█&MIN       ┼/MIN(      aMOD(      C±MODIFY    ^5MONTHS(   NOTE      Å?NOUPDATE  êBON ERROR  &EON ESCAPE ╗KON FIELD  ÷QOPERATIONS╣UOTHERWISE ΣaOUT(      U#OUTPUT PRO╨└PACK      dPERFORM   ±hPIC(      ¥(PICTURE KEèPOST      YnPOW(      ZεPRECEDENCEÅ¬PRINTER(  d,PROCEDURE τ|PUT(      ú1QUIT      ╞éRAND(     ~6RANK(     <READ      ╦çREAD(     <?RECALL    mïRECNO(    óDREINDEX   ▄ÅRELATION K┌+RELATIONS ¬ZRELEASE   ΣôREMARK    ¿ÜREMLIB(   ┐IRENAME    <¥RENAME FIEkáREPEAT    ▌úREPLACE   x¼REPLACE(  =MREPORT    ╗▒REPORT KEYI
RESET(    "QRESTORE   ╞╬RETURN    ╒RIGHT(    âURING      E╫ROPEN(    XROW(      ]RUN       ┘SAVE      !▄SCOPE     ▀SCREEN    ^πSCROLL    ~ΦSEEK(     A_SELECT    δSELECT KEY╥1SET       5≡SET ALTERNw8SET COLOR T;SET DATE  ∞ASET DEFAUL.FSET DIR   ÄJSET FILTER╟RSET FORMAT├WSET INDEX ╘[SET LENGTH╞bSET LIBRARÅfSET LINK  ⌠nSET MARGINùtSET RELATI∞vSET WIDTH ~SET(      ΓdSETS A-E  ì⌡SETS F-Z  ≡SETUP KEYW-SIN(      ╜εSINH(     µ∩SKIP      éSORT      ╕åSPACE(    wiSPOOL     ëSPOOL KEYWΩ.SQRT(     ïεSSEEK(    kSTATUS    <ôSTORE     ╜öSTR(      âpSUBSTR(   uSUBTOTAL K`#SUM       gùSYSTEM VAR├áTAN(      ∩TANH(     J≡TEST(     ÇyTEXT      û£TEXT MACRO9║TIME(     ·|TITLE KEYW£TOTAL     ╧╬TRIM(     ÑéTYPE(     àUPDATE    ▐┘UPPER(    ²çUSE       ¼ΣVAL(      GèVARIABLES éδWAIT      z≡WINDOW    ⁿ⌠WOPEN(    \ìWRAP(     (ÆWRITE     >WRITE(    )ûZAP       
GENERAL HELP
                               VP-Info Help

Use the arrow keys to move the lightbar and select a topic from the list
below, then press the <ENTER> key.  You may also move the lightbar to the
bottom of the screen and type the name of a specific command or function.

\\Command List
\\Function List
\\Color Attribute Table
\\Command and Field Redirection
\\Date Input Formats
\\Date Output Formats
\\Editing Keys
\\Format Strings
\\Get Tables
\\Macros
\\Report Keywords
\\TEXT
\\Memo Fields
\\Expressions
\\Precedence
.pa
COLOR ATTRIBUTE TABLE

 
 
The following values are used to select an attribute byte for use with the
COLOR and SET COLOR commands.
    BACKGROUND     ========CHARACTERS=========  BLINKING        BRIGHTNESS
    (color only)   (color)     (monochrome)
    ------------   ----------  ---------------  --------------  ------------
     0 - black     0 - black     0 - normal       0 - no blink  0 - normal
    16 - blue      1 - blue      1 - underline  128 - blink     8 - bright
    32 - green     2 - green   112 - reverse
    48 - cyan      3 - cyan
    64 - red       4 - red
    80 - magenta   5 - magenta
    96 - brown     6 - brown
   112 - white     7 - white
.pa
COMMAND AND FIELD REDIRECTION
     The # symbol can be used to redirect a single command or field to a
data file other than the selected file.
     To redirect a command, follow the first word of the command with the
# symbol and the file number; e.g.:
USE#2 members INDEX memno
     This command opens the "members.dbf" as file 2, without changing the
selected file number.  When command verbs consist of more than one word,
the redirection operator is appended to the first word:
LIST#2 STRUCTURE
     Redirection can also be used with field names in a list, e.g.:
DISPLAY trans_no#4, mem_no#2, inven_no#3
displays fields from the current records of three separate data files.
.pa
DATE OUTPUT FORMATS
     These are the output format numbers for use with the DATE() function.
 Number Name      Display
 
   1    YMD       yymmdd (6 characters: 860601)
   2    MDY       mm/dd/yy (8 characters: 06/01/86)
   3    CHAR      Month name, day, year (variable length: June 1, 1986)
   4    FULL      day of week, month name, day, year (variable length:
                        Sunday, June 1, 1986)
   5    Lchar     Last day of month (variable length: June 30, 1986)
   6    DMY       dd-mmm-yyyy (11 characters: 01-JUN-1986)
   7    VARIABLE  Format determined by the SET DATE command (variable length)
   8    LONG      yyyymmdd
   9    LAST      yymmdd or yyyymmdd, depending on format specified with
                        SET DATE
.pa
DATE INPUT FORMATS
     These are the valid formats for date strings used with the DATE(,
DAYS(, and MONTHS( functions:
          FORMAT        EXAMPLE (09/17/91):
          mmddyy           091791
          ddmmyy           170991
          yymmdd           910917
          mmddyyyy         09171991
          ddmmyyyy         17091991
          yyyymmdd         19910917
     Optionally, use a hyphen, slash or space to separate elements of the date
input string (e.g., 07-04-91, 12/25/91, 03 11 91).  If a date string
entered for the DATE() function is ambiguous (e.g., the string "110391"
could be March 11 or November 3), Info reads the string according
to the format set by the SET DATE command.
.pa
EDITING KEYS
     Use these editing keys to edit field contents during APPEND, EDIT, and BROWSE.
     Except as noted, these commands work identically with the above commands:
Moving the Cursor
     Within a field:  Left arrow or Ctrl-S    (one character left)
                      Right arrow or Ctrl-D   (one character right)
                      Ctrl-Left arrow         (to beginning of field)
                      Ctrl-Right arrow        (to end of field)
     Between Fields:  Up arrow or Ctrl-E      (to previous field)
                      Down arrow or Ctrl-X    (to next field)
                      ENTER                   (to next field)
     Between pages:   Ctrl-K                  (to previous page)
                      Ctrl-L                  (to next page)
     Between records: PgUp or Ctrl-R          (to previous record-EDIT/BROWSE)
                      PgDn or Ctrl-C          (to next record)
Entering and Editing Data
                      INS or Ctrl-V           (toggles insert/overwrite modes)
                      DEL or Ctrl-G           (deletes character at cursor)
                      BACKSPACE or Ctrl-H     (deletes character to the left)
                      Ctrl-Y                  (deletes to end of the field)
Saving and Ending
                      END or Ctrl-W           (save changes and end)
                      Ctrl-Q                  (cancel changes to this record)
Other keys
                      Ctrl-U                  (toggles deleted flag status)
                      Ctrl-HOME               (move to top of file)
                      Ctrl-END                (move to end of file)
                      Ctrl-PgDn               (append a new record)
                      Alt-E                   (skips backward in file as many
                                                records as can be displayed in
                                                current window - BROWSE)
                      Alt-X                   (skips forward in file as many
                                                records as can be displayed in
                                                current window - BROWSE)
.pa
FORMAT STRINGS
     Format strings determine how numbers and strings are displayed.  Format
strings are used in the PICTURE clause of @...GET, in the USING clause of
@...SAY, in the format lines in a TEXT block, in the REPORT keyword PICTURE,
in the PIC() function, and in the system variable :PICTURE.
     Format strings don't affect how Info stores information; only how it is
entered, displayed, or printed.  Format strings are made up of format
characters and background characters.  In most cases (except TEXT and
PICTURE in a report form), format strings are enclosed in quotes.
     Format characters work as placeholders for displayed data and as "masks"
to limit the kind of data that can be entered.  There are separate format
characters numbers and strings (listed in the next two help screens).
     Background characters are primarily decorative, added to make data easier
to read. They include all characters (including spaces) not listed in the
format character tables.  Background characters are displayed exactly
as they appear in the format clause, but are not stored as data.
(continues)
NUMERIC FORMATS
     These are the format characters for numbers:
  9 -- Displays or permits entry of any digit (0-9), the minus sign (-),
       or a decimal point (.).
  $ -- Displays any digit.  The leading digit of a value
       is preceded by a dollar sign (e.g., 182.34 is displayed as $182.34).
  comma (,) -- Determines placement of commas in a displayed number.
  period (.) -- Determines placement of the decimal point in a display or
       input number.
     Any other character in a numeric format clause is a background character
and is displayed "as is."  Here are some display examples (invalid for input):
   Number     Format         Display      Effect
   1123.89    "9,999.99"     1,123.89     Commas added
   100.89     "$9,999.99"    $  100.89    Fixed dollar sign
   100.89     "$$$$$$.99"    $100.89      Floating dollar sign
      Rule: Do not use formats for numeric field input; okay for variables.
STRING FORMATS
     These are the format characters for strings:
  X or x -- Any typed character.
  A or a -- Any letter, upper- or lowercase.
  9 -- Any digit or letter.
  ! -- Any character, but converts lowercase letters to uppercase.
     All other characters are regarded as background characters: they are
depicted literally when displayed and ignored upon input.
.pa
GET TABLES
     To set up a Get Table, use the @...GET command or the input macros
(@ and %) of a TEXT block to set up the layout of an input screen.  These
commands specify how the input screen will be "painted" and to which fields
or memory variables the entries are to be stored.  These variables are called
Get Variables.  A Get Table can contain as many as 64 variables.
     The READ, APPEND/EDIT OFF or BROWSE OFF commands cause Info
to "activate" the Get Table, allowing the user to view and edit the values of
the Get Variables.  During this time the command sequences in an ON FIELD
structure will execute as the user moves from one Get Variable to another.
     The CLEAR GETS command erases the current Get Table definitions, as will
any @...GET commands or text macros executed after the Get Table has been
activated.
.pa
MACROS
     One of Info's most powerful features is the rich variety of ways in
which macros can be used.  Unfortunately, some users encounter difficulties,
especially in the following areas:
1.  Putting a data file into use with a macro.  This technique requires a
data file to be put into use with the COMPILE keyword or the compiler will
not "know" that a data file is open.  Secondly, users of the file-as-a-vector
technique must reference the file only by the name of the COMPILE file.
2.  Using macros in TEXT blocks.  Only standard variables and fields may be
used as macros in TEXT.  Do not use system variables, matrix variables, or
functions.
3.  Using a macro in a command when what is intended is use of the variable
itself.  Remember:  a macro used in a command always contains the name of a
field or variable, and means that you intend to use the value of that field
or variable in the current command instead of the macro.
4.  Using macros with commands that do not allow their use.  The following
commands may not be used with a macro:
     @                   CLOSE                 CLS
     COLOR               DO                    DO WHILE
     ERASE               FIELD                 FILES...ENDFILES
     GLOBAL              GOTO                  HELP
     LOCK                ON                    PERFORM
     PROCEDURE           SELECT                SET INDEX TO <n>
     UNLOCK              VARIABLES
.pa
COMMAND LIST
     Commands may be spelled in full, or abbreviated to the first four
characters.
     (In the following list, commands marked [N] may be used in VP-Info
Professional Network Edition and VP-Info Professional II Network Edition
only. Commands marked [V] may be used in both VP-Info Professional and
VP-Info Professional Network Edition. Commands marked [2] may be used in
either VP-Info Professional II or VP-Info Professional II Network Edition.
Commands marked [obs] are obsolete and ignored by all versions. All unmarked
commands may be used in all versions.)
 
COMMENT (*)              =                        ?
@                        ACCEPT                   APPEND
APPEND BLANK             APPEND FROM              APPEND TO
AVERAGE                  BINLOAD [V]              BINSPACE= [V]
BINUNLOAD [V]            BOX                      BREAK
BROWSE                   CALL [V]                 CANCEL
CASE                     CHAIN                    CLEAR
CLOSE                    CLS                      COLOR
COMPILE                  CONTINUE                 COPY
COPY STRUCTURE           COUNT                    CREATE
CURSOR                   DEBUG                    DELAY
DELETE                   DELETE FILE              DIM
DIR                      DIRF                     DISPLAY
DO                       DO CASE                  DO WHILE
EDIT                     EJECT                    ELSE
END commands             ERASE                    FIELD [V]
FIELDS= [V]              FILES                    FILES ... ENDFILES
FILES= [V]               FILES LIST               FIND
FLUSH                    GLOBAL                   GO
HELP                     IF                       INDEX
INPUT                    LAST [V]                 LIMIT
LIST                     LIST FILES               LIST MEMORY
LIST STRUCTURE           LIST SYSTEM              LOCATE
LOCK [N]                 LOCK INDEXES [N]         LOOP
MAX [V]                  MEMORY= [V]              MIN [V]
MODIFY                   NEAREST [V]              NOEFFECTS [V]
NOTE                     NOUPDATE                 ON ERROR
ON ESCAPE                ON FIELD [V]             OTHERWISE
OVERWRITE TO [V]         PACK                     PERFORM
POST                     PROCEDURE                QUIT
READ                     RECALL                   REINDEX
RELEASE                  REMARK                   RENAME
RENAME FIELD             REPEAT                   REPLACE
REPORT                   RESTORE                  RETURN
RING                     RUN                      SAVE
SCOPE                    SCREEN                   SCROLL
SEEK [V]                 SELECT                   SET
SET ALTERNATE            SET COLOR                SET DATE
SET DEFAULT              SET DIR                  SET FIELDS [obs]
SET FILTER               SET FORMAT               SET INDEX
SET LENGTH               SET LIBRARY              SET LINK
SET MARGIN               SET MEMORY [obs]         SET NETWORK [N]
SET RELATION             SET WIDTH                SKIP
SORT                     SOUND                    SPOOL
STATUS                   STORE                    SUM
TEXT                     TOTAL                    UNLOCK [N]
UNLOCK INDEXES [N]       UPDATE                   USE
VARIABLES                WAIT                     WINDOW
WRITE                    ZAP
 
     The following lists are grouped by function to aid in finding the proper
command for any task:
 
Assignment Commands:
     =                        STORE
Binary Commands:
     BINLOAD [V]              BINSPACE= [V]            BINUNLOAD [V]
     CALL [V]
Calculate Commands:
     AVERAGE                  COUNT                    MAX [V]
     MIN [V]                  SUM
Display Commands:
     BOX                      CLS                      COLOR
     CURSOR                   DELAY                    DISPLAY
     EJECT                    ERASE                    FILES LIST
     LIST                     LIST FILES               LIST MEMORY
     LIST STRUCTURE           LIST SYSTEM              RING
     SCREEN                   SCROLL                   SET COLOR
     SET FORMAT               SET LENGTH               SET MARGIN
     SET WIDTH                SOUND [V]                WINDOW
Execute Commands:
     CHAIN                    COMPILE                  DO
     FILES ... ENDFILES       PERFORM                  RUN
File  Commands:
     APPEND                   APPEND BLANK             APPEND FROM
     APPEND TO                BROWSE                   CLOSE
     COPY                     COPY STRUCTURE           CREATE
     DELETE                   DELETE FILE              DIR
     DIRF                     EDIT                     FLUSH
     GO                       INDEX                    LIMIT
     MODIFY                   NOUPDATE                 OVERWRITE TO [V]
     PACK                     POST                     RECALL
     REINDEX                  RENAME                   REPLACE
     SCOPE                    SELECT                   SET DEFAULT
     SET DIR                  SET FILTER               SET INDEX
     SET LIBRARY              SET LINK                 SET RELATION
     SKIP                     SORT                     TOTAL
     UPDATE                   USE                      ZAP
Input Commands:
     @                        ACCEPT                   INPUT
     READ                     TEXT                     WRITE
Locate Commands:
     CONTINUE                 FIND                     LAST [V]
     LOCATE                   NEAREST [V]              SEEK [V]
Memory Commands:
     CLEAR                    DIM                      GLOBAL
     RELEASE                  RESTORE                  SAVE
     SET ALTERNATE            SET DATE                 VARIABLES
Output Commands:
     ?                        @                        REPORT
     SPOOL                    TEXT
Structure Commands:
     BREAK                    CASE                     DO CASE
     DO WHILE                 ELSE                     END commands
     FIELD [V]                FILES                    IF
     LOOP                     ON ERROR                 ON ESCAPE
     ON FIELD [V]             OTHERWISE                PROCEDURE
     REPEAT                   RETURN
VPI.SET Commands:
     BINSPACE= [V]            FIELDS= [V]              FILES= [V]
     MEMORY= [V]              NOEFFECTS [V]
Miscellaneous Commands:
     CANCEL                   COMMENT (*)              DEBUG
     HELP                     NOTE                     QUIT
     REMARK                   RENAME FIELD             STATUS
     WAIT
.pa
FUNCTION LIST
     (In the following list, functions marked [V] may be used in any of
VP-Info Professional and VP-Info Professional II, VP-Info Professional
Network Edition, and VP-Info Professional II Network Edition. All unmarked
functions may be used in all versions.)
 
!(                       #                        $(
@(                       ABS(                     ACOS(
ASC(                     ASIN(                    ASTERISK (*)
AT(                      ATAN(                    BIT(
BLANK(                   CEIL(                    CEN(
CHR(                     CLOSE(                   COL(
COS(                     COSH(                    CTONUM( [V]
DATE(                    DAYS(                    DBF(
DBFX( [V]                DELETED(                 DIR(
DIRX( [V]                EOF                      EOF(
EXP(                     FIELD(                   FILE(
FLD(                     FLOOR(                   GET(
IFF(                     IFKEY( [V]               IN(
INKEY(                   INSERT(                  INT(
LEFT(                    LEN(                     LOC(
LOG(                     LOG10(                   LOWER(
LTRIM(                   MAX(                     MENU(
MIN(                     MOD(                     MONTHS(
NDX( [V]                 NUMTOC( [V]              OUT(
PIC(                     POW(                     PRINTER(
PUT(                     RAND(                    RANK(
READ(                    RECNO(                   REMLIB(
REPLACE(                 RESET(                   RIGHT(
ROPEN(                   ROW(                     SEEK(
SET(                     SIN(                     SINH(
SPACE(                   SQRT(                    SSEEK(
STR(                     SUBSTR(                  TAN(
TANH(                    TEST(                    TIME(
TRIM(                    TYPE(                    UPPER(
VAL(                     WOPEN(                   WRAP(
WRITE(
 
     The following lists are grouped by function to aid in finding the proper
function for any task:
 
Conversion Functions:
     ASC(                     CHR(                     CTONUM( [V]
     NUMTOC( [V]              RANK(                    VAL(
Date Functions:
     DATE(                    DAYS(                    MONTHS(
     TIME(
File Functions:
     DELETED (*)              DBF(                     DBFX( [V]
     DELETED(                 DIR(                     DIRX( [V]
     EOF                      EOF(                     FILE(
     FLD(                     NDX( [V]                 RECNO(
Logical Functions:
     BIT(                     RESET(                   SET(
     TEST(                    TYPE(
Math Functions:
     ABS(                     ACOS(                    ASIN(
     ATAN(                    CEIL(                    COS(
     COSH(                    EXP(                     FLOOR(
     INT(                     LOG(                     LOG10(
     MOD(                     POW(                     RAND(
     SIN(                     SINH(                    SQRT(
     TAN(                     TANH(
Position Functions:
     COL(                     ROW(
Sequential File Functions:
     CLOSE(                   GET(                     IN(
     LOC(                     OUT(                     PUT(
     READ(                    ROPEN(                   SEEK(
     SSEEK(                   WOPEN(                   WRITE(
String Functions:
     !(                       $(                       @(
     AT(                      BLANK(                   CEN(
     INSERT(                  LEFT(                    LEN(
     LOWER(                   LTRIM(                   PIC(
     REPLACE(                 RIGHT(                   STR(
     SUBSTR(                  TRIM(                    UPPER(
     WRAP(
Miscellaneous Functions:
     FIELD(                   IFF(                     IFKEY( [V]
     INKEY(                   MAX(                     MENU(
     MIN(                     PRINTER(                 REMLIB(
     SPACE(
.pa
CONSTANTS
     There are three types of constants: numeric, logical, and string.
     A numeric constant is a number (the minus sign is a part of it):
12.78
0.00064
-3.14
     There are only two logical constants:  T (true, also written as t, Y,
and y) and F (false, also written as f, N, and n).
     A string constant is a string in quotation marks:
"This is a character constant."
'This is another one, delimited with single quotation marks.'
"Here's another one, enclosing a single quotation mark (apostrophe) within
double quotes."
"This is incorrect because the quotation marks do not match.'
.pa
OPERATIONS
     There are three types of operations: numeric, logical, and string.   Each
works with constants and variables of that type, and yields a value of that
type.
     The numeric operations are
+     addition
-     subtraction
*     multiplication
/     division
2+3.2          yields 5.2
10/4           yields 2.5
     All numeric operations require two numbers to act on.  - is also used to
indicate that a number is negative: -2, -3.14.  Instead of
 -QTY, write 0-QTY or -1*QTY.
     There are three logical operations:
.AND.
.OR.
.NOT.
     .AND. and .OR. take two logical values and yield a logical value:
T.AND.T        yields:  T
T.AND.F        yields:  F
F.AND.T        yields:  F
F.AND.F        yields:  F
T.OR.T         yields:  T
T.OR.F         yields:  T
F.OR.T         yields:  T
F.OR.F         yields:  F
     .NOT. takes a logical value and yields a logical value (the opposite):
.NOT.T         yields:  F
.NOT.F         yields:  T
     There is only one string operation:
+     concatenation (placing one string after another)
'This is a'+' sentence.'
yields the value:
This is a sentence.
     Note that one cannot mix numbers and strings:
2+'string'
will give a syntax error message (Error 1).
.pa
RELATIONS
     A relation takes two numbers or two strings (compares them), and yields a
logical value (true or false).
     There are six relations that compare numbers or strings:
=     equal
<     less than
<=    less than or equal to
>     greater than
>=    greater than or equal to
<>    not equal
     For numbers, these have their usual meaning:
1<2            is true
2<1            is false
1.2<>5         is true
1.2>=1         is true
     You should be careful when using = for numbers.  Two numbers may be
displayed as equal while, in fact, they differ in the third or fourth decimal
place.  Instead of
num1=num2
in many instances you could use
ABS(num1-num2) < 0.01
or
(PIC(num1-num2,'9999.99'))=0
     For strings, string1=string2 is true if string2 is of the same length as
string1, and the characters of string1 equal the corresponding characters of
string2; if string2 has more characters, string1=string2 is always false.
     However, the result of comparing strings of unequal length, in which all
of string2 is exactly the same as the beginning of string1, is affected by the
setting of the "exact switch."  If SET EXACT OFF, then such string1=string2 is
true; with SET EXACT ON, it is false.
     Although this definition of string1=string2 may at first sight seem
awkward, it may really be quite useful both in conversational Info
and in Info programs.
     For strings, string1 < string2 means: in a dictionary, string1 would come
before string2.  Single characters are compared by their ASCII value.
     string1 is compared to string2 by comparing their first characters; if
the first character of string1 is less than the first character of string2,
then string1 < string2;  if they are equal, then the second character of
string1 is compared to the second character of string 2, and so on.
     Note that in the ASCII sequence, all digits, 0 to 9, come before all
upper-case letters, A to Z, which, in turn, come before all lower-case
letters, a to z.
     Note that strings and numbers cannot be mixed in these relations.
.pa
FUNCTIONS
     A function is just like an operation; the addition operation (+) requires
two arguments (numbers) and returns their sum; a function requires some
arguments (0 to 3) and returns some value.
     Every function has a type: numeric, string, or logical, depending on the
values it returns.
     A function has arguments; the values put into the function between the
parentheses, separated by commas.  Info functions have at most three
arguments; a few have none.  Some arguments may be optional.
     The arguments can be variables or expressions of type string: <str var>
or <str exp>, or of type numeric: <num var> or <num exp>.  (Expressions are
discussed in Section 3.5.)
.pa
!(
Converts a string to upper case.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ !(<str exp>)                                                       ║
     ║                                                                    ║
     ║ <str exp>    the text to be converted to upper case                ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
.pa
#
Gets the current record number.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ #                                                                  ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function returns the record number of the current record of the
selected file.  Note that ? # displays the current record number in the form
specified by the system variable :PICTURE.  Info also has a more general form
of this function, RECNO(, which allows the user to specify file other than
the selected file.
.pa
$(
Gets a substring of a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ $(<str exp>, <start num exp>, <width num exp>)                     ║
     ║                                                                    ║
     ║ <str exp>         the string from which the new string is formed   ║
     ║ <start num exp>   the position from which the new string is        ║
     ║                     taken                                          ║
     ║ <width num exp>   the number of characters to place in the         ║
     ║                     new string                                     ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function takes the string in <str exp> from position <start num exp>
(fractions are thrown away); the number of characters taken is <width num
exp>. (In both numeric expressions, the fractions are disregarded).
.pa
ASTERISK (*)
Determines whether a record is deleted.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ *                                                                  ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     In the selected file, the current record pointer points at a record.  If
this record has been marked for deletion (in BROWSE or EDIT, or with the
DELETE command), then * gives the value T; otherwise, it is false.
.pa
@(
Gets the location of a substring.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ @(<find str exp>, <str exp>)                                       ║
     ║                                                                    ║
     ║ <find str exp>    the string searched for                          ║
     ║ <str exp>         the text to be searched                          ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function finds out whether a string: <find str exp> occurs in the
string: <str exp>.  If it occurs, the function returns the character position
of the first (left-most) substring of <str exp> which is the same as <find
str exp>; if it does not occur, the function returns a 0.
.pa
ASC(
Converts a character to its ASCII number.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ASC(<str exp>)                                                     ║
     ║                                                                    ║
     ║ <str exp>         the first character of this string is converted  ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
.pa
AT(
Gets the location of a substring . . . a synonym for @(
     ╔════════════════════════════════════════════════════════════════════╗
     ║ AT(<find str exp>, <str exp>)                                      ║
     ║                                                                    ║
     ║ <str exp>         the text to be searched                          ║
     ║ <find str exp>    the string searched for                          ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function is merely a synonym for @(.
.pa
BIT(
Bit-set function determines if a given bit is 0 or 1
     ╔════════════════════════════════════════════════════════════════════╗
     ║ BIT(<string>,<bit position>)                                       ║
     ║                                                                    ║
     ║ <string>          a string or string variable to test              ║
     ║ <bit position>    a numeric expression; position of a given bit    ║
     ║                      within <string>                               ║
     ╟─────────────────┐                                                  ║
     ║ Type: logical   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     When used with the SET( and RESET( functions, which turn specific bits to
1 or 0 respectively, the BIT( function can be used to access large amounts of
logical data much more compactly than in a set of logical variables.  BIT(
returns T (true) if the specified bit is set (0), F (false) if not set (0).
     Note: Bit positions are counted differently than in some other schemes.
In these functions, all bits are counted from the left of the string starting
at 1, so that each character contains bits numbered as follows:
 1. Bits 1 to 8.
 2. Bits 9 to 16.
 3. Bits 17 to 24.
  . . . and so on
.pa
BLANK(
Creates a string of blanks or other specified characters.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ BLANK(<num exp>[,<charnum>])                                       ║
     ║                                                                    ║
     ║ <num exp>    a number from 0 to 255                                ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║ <charnum>    the ASCII number of the character used to fill the    ║
     ║                blank string; default is 32, the blank character    ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
.pa
CEN(
Centers a line of text.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CEN(<str exp>,<num exp>)                                           ║
     ║                                                                    ║
     ║ <str exp>    the text to be centered                               ║
     ║ <num exp>    the line width                                        ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
.pa
CHR(
Converts an ASCII number to character.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CHR(<num exp>)                                                     ║
     ║                                                                    ║
     ║ <num exp>    a number from 0 to 255                                ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
.pa
CLOSE(
Closes a DOS file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CLOSE([filenum])                                                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
.pa
COL(
Gets print column position.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ COL()                                                              ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function gives the current column position of the cursor; if the
printer is on, it returns the column position of the printer head.
.pa
DATE(
Displays a date in a specific format.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DATE(<type>[,<str exp>])                                           ║
     ║                                                                    ║
     ║ <type>           one of 9 type basic date-output formats           ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <str exp>        the date to be converted                          ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function with only <type> specified rewrites the current system date
in :DATE in the format specified by the <type>, and displays the result.
     This function with two parameters  (the format and the date) returns the
given date in the specified format.  :DATE is not effected.
     The <type> can be given in either of two forms, a name or number (numeric
expression) as follows:
Type           Date-output format
1 or YMD       6-character format without slashes: yymmdd
2 or MDY       8-character format with slashes: mm/dd/yy
3 or Char      Spelled out: Month dd, yyyy
4 or Full      Spelled out: Weekday, Month dd, yyyy; valid only for years 1980-
2079
5 or Lchar     Last day of month spelled out in format 3 (Char)
6 or DMY       11-byte string in format dd-MMM-yyyy (example 03-NOV-1990)
7 or Variable  formatted without slashes according to SET DATE TO command
8 or Long      8-character format without slashes: yyyymmdd
9 or Last      Last day of month in format 1 (YMD) or 8 (Long), depending on
whether SET DATE TO command set year to YY or YYYY
Shortcut: When specifying type by name, only the first character is usually
required. The exception is for Lchar, Long and Last, which require two
characters to resolve ambiguity. If only one is given, Lchar is assumed.
     <str exp> must contain the date in one of the following formats:
          mmddyy     ddmmyy     yymmdd
          mmddyyyy   ddmmyyyy   yyyymmdd
     Optionally, a slash, a hyphen, or a space may be used to separate the
elements of these formats.
     There should be two digits each for month and the day, and two or four
digits for the year.  01 3 92 is not acceptable.  If <str exp> is not
acceptable, then DATE( returns a string of blanks.
     In the event of ambiguity, dates will be decoded in accordance with the
format set in the SET DATE TO command.
.pa
DAYS(
Computes dates and date differences in days.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DAYS(<str exp1>,<str exp2>)                                        ║
     ║ DAYS(<str exp>,<num exp>)                                          ║
     ║                                                                    ║
     ║ In the first form:                                                 ║
     ║      <str exp1> and <str exp2> are dates                           ║
     ║ In the second form:                                                ║
     ║      <str exp> is a date and <num exp> is a number                 ║
     ║─────────────────────────┐                                          ║
     ║ Type: numeric/character │                                          ║
     ╚═════════════════════════╧══════════════════════════════════════════╝
     In the first form, DAYS( returns the number of days between the two dates.
The result is an integer.
     In the second form, DAYS( returns the date (as a string) which is
<num exp> days past or before the date <str exp>.
     The string expressions containing dates can be of many different formats:
               yy/mm/dd    yy-mm-dd    yyyy mm dd
               mm/dd/yy    mm-dd-yy    mm dd yy
     There should be two digits each for yy, mm, and dd, and four digits for
yyyy.  01 3 90 is not acceptable.
     In the second form, the date is returned in the format set with the SET
DATE TO command (default: mmddyyyy).  If you wish a different format, use the
DATE( function.
.pa
DBF(
Allows access to data-file attributes of a file in use.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DBF(<type>[,<filenum>])                                            ║
     ║                                                                    ║
     ║ <type>      the information required from the data file header     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>   the data file number; default is the currently         ║
     ║               selected data file                                   ║
     ╟─────────────────────────┐                                          ║
     ║ Type: character/numeric │                                          ║
     ╚═════════════════════════╧══════════════════════════════════════════╝
     Each data file has a file head which contains information about its
structure, most of which is displayed with the LIST STRUCTURE command.
     Using the DBF(, DBFX( and FLD( functions provides users access to this
information in a programmable form suitable for display and use in expressions.
     The <type> can be given in either of two forms, a name or number (numeric
expression) as follows:
Type           Explanation                        Result
1 or Type      file type ("1", "2" or "3")        string
2 or Name      data file name                     string
3 or Fields    number of fields in structure      integer
4 or Records   number of records in file          integer
5 or Indexes   number of indexes currently open   integer
6 or Master    index number of master index       integer
Shortcut: When specifying type by name, only the first character is required.
.pa
DELETED(
Determines whether a record is deleted.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DELETED(<filenum>)                                                 ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>    the number of the data file to be checked             ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     In a specified data file, the current record pointer points at a record.
If this record has been marked for deletion (in BROWSE or EDIT, or with the
DELETE command), then DELETED( gives the value T; otherwise, it is false.
.pa
DIR(
Get file information from disk directory.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DIR([<filespec>])                                                  ║
     ║                                                                    ║
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filespec>    a string or string expression containing a file name ║
     ║                 (or skeleton using ? and/or * wildcards), with     ║
     ║                 optional drive and/or path specification           ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     Searches for specific files specified by the drive path, subdirectory
and/or filename and provides specific information on files found.
     If an argument is given, it must be a string or string expression naming
a file, with * and ? wildcards optional). Returns the first file name found
matching <filespec>. If no match was found, blank is returned.
     If no argument is given, the previous <filespec> is used to find the next
matching file. If no more matching file names are found, blank is returned.
.pa
EOF
Gives the end-of-file flag for the currently selected data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ EOF                                                                ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     If the current record pointer is on the last record of the file in use
and a SKIP is issued, EOF returns T (true); otherwise it is F (false).
Since SKIP n is treated as n SKIP commands, EOF returns true if SKIP n goes
past the last record.  Also, if a LOCATE or CONTINUE command is unsuccessful,
or if NEAREST does not find an index key equal to or greater than the FIND
string, EOF returns T.
.pa
EOF(
Gives the end-of-file flag for a specified data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ EOF([<filenum>])                                                   ║
     ║                                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>    the number of the data file to be checked             ║
     ╟─────────────────┐                                                  ║
     ║ Type: logical   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     For the data file number specified, if the current record pointer is on
the last record and a SKIP is issued, EOF( returns T (true); otherwise it is F
(false).  Since SKIP n is treated as n SKIP commands, EOF( returns true if
SKIP n goes past the last record.
     Also, if a LOCATE or CONTINUE command is unsuccessful, or if NEAREST does
not find an index key equal to or greater than the FIND string, EOF( returns T.
     An extended form of the EOF function which, since it takes no parameter,
works only on the currently selected data file.  If no <filenum> is specified,
the current file is assumed.
.pa
FIELD(
Get the number of the Get Table entry corresponding to a variable or field
name.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FIELD(<name>)                                                      ║
     ║                                                                    ║
     ║ <name>    the name of field or variable in a Get Table             ║
     ╟─────────────────┐                                                  ║
     ║ Type: numeric   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     While in full-screen editing mode (with READ, BROWSE, EDIT, etc.), each
input variable and field is put into a Get Table that can be controlled with
an ON FIELD structure.
     FIELD( returns the number from 1 to 64 of any editing field on screens
created with @ GET and TEXT macros.  This function is usually used on an ON
FIELD structure to redirect the sequence of data entry.
.pa
FILE(
Verifies whether a file exists.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FILE(<str exp>)                                                    ║
     ║                                                                    ║
     ║ <str exp>         file name                                        ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function looks up the file whose name is given by <str exp>; if the
file is found, the function returns T, otherwise it returns F.
     If no extension is given in the file name, DBF is assumed (a data file is
looked for).
.pa
FLD(
Get information about a field in a data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FLD(<type>,<fieldnum> [,<filenum>])                                ║
     ║                                                                    ║
     ║ <type>       one of the four attributes of a field                 ║
     ║ <fieldnum>   the number of the field to be checked                 ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>    the number of the data file to be checked             ║
     ╟─────────────────────────┐                                          ║
     ║ Type: character/numeric │                                          ║
     ╚═════════════════════════╧══════════════════════════════════════════╝
     Each field in a data file has four attributes as shown with the LIST
STRUCTURE command: name, type, width and (for numeric variables) number of
decimal places.
     These attributes can be retrieved in a form suitable for use in a program
with the FLD( function.
     The <type> can be given in either of two forms, a name or number (numeric
expression) as follows:
Type           Explanation                              Result
1 or Name      string containing field name             string
2 or Type      string containing field type             string
3 or Width     number containing width of field         integer
4 or Decimals  number of decimal places in field        integer
Shortcut: When specifying type by name, only the first character is required.
.pa
GET(
Gets a string from a DOS file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ GET(<str var>,<width num exp>[,filenum])                           ║
     ║                                                                    ║
     ║ <str var>          stores the string                               ║
     ║ <width num exp>    the width of the string requested;              ║
     ║                      must be in range 1 to 254                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ filenum            the DOS file number (between 1 and 4)           ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function imports a string of <width num exp> characters from a DOS
file opened with the ROPEN( function; the character number pointer is normally
positioned with the SEEK( function.
     If successful in getting all the bytes requested, GET( returns T (true)
and sets <str var> to the string imported from the file.  If <str var> does
not exist, GET( will create it.
     If the function is unsuccessful, it returns F (false).  This will be the
result if the GET( function tries to get data beyond the end of the file.
Note, however, that even if GET( returns F, one of more characters may still
have been imported from the file; it is wise to check the value and width of
<str var> to ensure part of a file is not lost.
     If filenum is not given, filenum=1 is assumed.
.pa
IFF(
Allows IF...THEN logic in expressions.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ IFF(<cond>,<exptrue>,<expfalse>)                                   ║
     ║                                                                    ║
     ║ <cond>       a logical expression                                  ║
     ║ <exptrue>    the expression to be returned if <cond> is TRUE       ║
     ║ <expfalse>   the expression to be returned if <cond> is FALSE      ║
     ╟─────────────────────────────────┐                                  ║
     ║ Type: character/numeric/logical │                                  ║
     ╚═════════════════════════════════╧══════════════════════════════════╝
     This function returns <exptrue> if <cond> is true, <expfalse> otherwise.
The type of the value returned is the same as the expression selected by the
condition.
.pa
IN(
Inputs a single character from a sequential file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ IN(<str var>[,<filenum>])                                          ║
     ║                                                                    ║
     ║ <str var>      stores the character                                ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function reads the next character of the DOS file (opened with the
ROPEN( function) into the string variable <str var>; if <str var> does not
exist, it will be created.  <str var> cannot be a matrix variable.
     If filenum is not given, filenum=1 is assumed.  IN( returns T if
successful, F otherwise.
.pa
INKEY(
Waits and gets numeric value of keyboard entry.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ INKEY()                                                            ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function suspends program execution until a key is pressed.  It
returns a number identifying the key.  Nothing is displayed on the screen.
Any key can be read (except Alt, Ctrl, and shift which merely affect the
characters produced by other keys) including all function keys, editing
keys, and alternate keys.  (Function keys F11 and F12 are not recognized
by many computers' BIOS programs, and are ignored by Info.)
     Standard keys are identified with their ASCII number.  Other keys
return values between 256 and 511.
.pa
INSERT(
Overwrites a string at a given position with another string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ INSERT(<str expover>,<str exp>,<num exp>)                          ║
     ║                                                                    ║
     ║ <str expover>   the string expression to overwrite                 ║
     ║ <str exp>       the string expression to overwrite with            ║
     ║ <num exp>       the position                                       ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function takes the string in <str expover> and overwrites the string
with <str exp> starting at position <num exp>.
.pa
LEFT(
Gets the left part of a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LEFT(<str exp>, <num exp>)                                         ║
     ║                                                                    ║
     ║ <str exp>   the string from which the new string is formed         ║
     ║ <num exp>   the number of characters to place in the new string    ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function takes the first <num exp> characters from the string
<str exp>.  It is equivalent to, but more efficient than, $(<str exp>, 1,
<num exp>).
     If <num exp> is greater than the width of <str exp>, this function
returns all of <str exp>.
.pa
LEN(
Gets the width (length) of a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LEN(<str exp>)                                                     ║
     ║                                                                    ║
     ║ <str exp>      the string                                          ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function returns the width (including trailing blanks) of the string
<str exp>.
.pa
LOC(
Gets the current byte position in a file opened with ROPEN( or WOPEN(.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LOC([<filenum>])                                                   ║
     ║                                                                    ║
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>    the number of the sequential or random file, 1 to 4   ║
     ║                (default 1)                                         ║
     ╟─────────────────┐                                                  ║
     ║ Type: numeric   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     Whenever a file is opened with the ROPEN( or WOPEN( function,
Info maintains a pointer at a current position, which is where any
PUT( or GET( function would take effect.  The position pointer is set with the
SEEK( and SSEEK( functions, and reset every time the IN(, OUT, READ(, WRITE(,
PUT(, and GET( function is used.
     If filenum is not given, filenum=1 is assumed.
.pa
LOWER(
Converts a string to lower case.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LOWER(<str exp>)                                                   ║
     ║                                                                    ║
     ║ <str exp>        the text to be converted to lower case            ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     All upper-case letters in the <str exp> are converted into lower case by
the LOWER( function.
.pa
LTRIM(
Trims blanks from the left-hand side of a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LTRIM(<str exp>)                                                   ║
     ║                                                                    ║
     ║ <str exp>        the string to be trimmed                          ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     Note: LTRIM(blank) is a single blank.
.pa
EXP(
Mathematical function. Do HELP MATH.
.pa
LOG(
Mathematical function. Do HELP MATH.
.pa
LOG10(
Mathematical function. Do HELP MATH.
.pa
POW(
Mathematical function. Do HELP MATH.
.pa
SQRT(
Mathematical function. Do HELP MATH.
.pa
SIN(
Mathematical function. Do HELP MATH.
.pa
COS(
Mathematical function. Do HELP MATH.
.pa
TAN(
Mathematical function. Do HELP MATH.
.pa
ASIN(
Mathematical function. Do HELP MATH.
.pa
ACOS(
Mathematical function. Do HELP MATH.
.pa
ATAN(
Mathematical function. Do HELP MATH.
.pa
SINH(
Mathematical function. Do HELP MATH.
.pa
COSH(
Mathematical function. Do HELP MATH.
.pa
TANH(
Mathematical function. Do HELP MATH.
.pa
CEIL(
Mathematical function. Do HELP MATH.
.pa
FLOOR(
Mathematical function. Do HELP MATH.
.pa
INT(
Mathematical function. Do HELP MATH.
.pa
ABS(
Mathematical function. Do HELP MATH.
.pa
MOD(
Mathematical function. Do HELP MATH.
.pa
MATH
Mathematical functions package.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ Logarithmic functions:                                             ║
     ║    EXP(            e-th power                                      ║
     ║    LOG(            natural logarithmic function                    ║
     ║    LOG10(          base 10 logarithmic function                    ║
     ║    POW(            power                                           ║
     ║    SQRT(           square root                                     ║
     ║                                                                    ║
     ║ Trigonometric functions:                                           ║
     ║    SIN(            sine                                            ║
     ║    COS(            cosine                                          ║
     ║    TAN(            tangent                                         ║
     ║    ASIN(           arc sine                                        ║
     ║    ACOS(           arc cosine                                      ║
     ║    ATAN(           arc tangent                                     ║
     ║                                                                    ║
     ║ Hyperbolic functions:                                              ║
     ║    SINH(           hyperbolic sine                                 ║
     ║    COSH(           hyperbolic cosine                               ║
     ║    TANH(           hyperbolic tangent                              ║
     ║                                                                    ║
     ║ Integer valued functions:                                          ║
     ║                                                                    ║
     ║    CEIL(           ceiling integer                                 ║
     ║    FLOOR(          floor integer                                   ║
     ║    INT(            integer part                                    ║
     ║                                                                    ║
     ║  Real valued functions:                                            ║
     ║    ABS(            absolute value                                  ║
     ║    MOD(            modulo value                                    ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     The mathematical functions are divided into five groups:
Logarithmic functions:
   EXP(<num exp>)               e to the power <num exp>
   LOG(<num exp>)               natural logarithm of <num exp>
   LOG10(<num exp>)             base 10 logarithm of <num exp>
   POW(<num exp1>,<num exp2>)   <num exp1> to the power <num exp2>
   SQRT(<num exp>)              square root of <num exp>
Trigonometric functions:
   SIN(<num exp>)               sine of <num exp> in radians
   COS(<num exp>)               cosine of <num exp> in radians
   TAN(<num exp>)               tangent of <num exp> in radians
   ASIN(<num exp>)              arc sine of <num exp>; returns a
                                  value in radians between -π/2 and π/2
   ACOS(<num exp>)              arc cosine of <num exp>; returns a value
                                  in radians between 0 and π
   ATAN(<num exp>)              arc tangent of <num exp>; returns a value
                                  in radians between -π/2 and π/2
Hyperbolic functions:
   SINH(<num exp>)              hyperbolic sine of <num exp>
   COSH(<num exp>)              hyperbolic cosine of <num exp>
   TANH(<num exp>)              hyperbolic tangent of <num exp>
Integer-valued functions:
    CEIL(<num exp>)             ceiling integer: the integer equal to or
                                  just above <num exp>
    FLOOR(<num exp>)            floor integer: the integer equal to or
                                  just below <num exp>
    INT(<num exp>)              the integer part of <num exp> (the
                                  fractional part is discarded)
           Note that for positive numbers, INT( and FLOOR return the same
           result, but for negative numbers, INT( and CEIL( produce the
           same result.  This is because discarding the decimal part of a
           real number reduces its distance from zero.
Real-valued functions:
    ABS(<num exp>)              absolute value of <num exp>
    MOD(<num exp1>,<num exp2>)  <num exp1> modulo <num exp1>: returns 0 if
                                  <num exp2> is 0; returns the value num with
                                  the same sign as <num exp1>, less than
                                  <num exp2>, satisfying
                                       <num exp1>=i*<num exp2>+num
                                  for some integer i.
.pa
MAX(
Compare two expressions of any type and return the larger.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ MAX(<exp1>,<exp2>)                                                 ║
     ║                                                                    ║
     ║ <exp1>    any expression                                           ║
     ║ <exp2>    any expression of the same type as <exp1                 ║
     ╟─────────────────────────────────┐                                  ║
     ║ type: character/numeric/logical │                                  ║
     ╚═════════════════════════════════╧══════════════════════════════════╝
.pa
MENU(
Lightbar menu function; allows point-and-shoot selection from an on-screen
menu.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ MENU(<choices>/<hotkeys>,<width>[,<timeout>])                      ║
     ║                                                                    ║
     ║ <choices>    the number of choices offered by the menu             ║
     ║ <hotkeys>    a string expression containing one letter for each    ║
     ║                option offered by the menu, including the           ║
     ║                zero option ('0')                                   ║
     ║ <width>      the width of the menu lightbar                        ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║ <timeout>    the number of seconds before MENU( stops waiting for  ║
     ║                a keystroke; if timeout occurs, MENU( returns 65    ║
     ╟─────────────────┐                                                  ║
     ║ Type: numeric   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     The MENU( function pauses program execution and superimposes a movable
lightbar (reverse-video line) over a menu of selections previously written to
the screen, usually with TEXT.
     The menu lightbar is moved up and down with the <Up> and <Dn> keys.  If
you press <Dn> while on the bottom, the lightbar cycles automatically to the
top.  Similarly, pressing <Up> while on the top cycles to the bottom.
     The user can select any item by moving the lightbar over it and pressing
<ENTER>, or entering its line number as a one-digit number, or by pressing
the option's "hotkey".  In any of these cases, the line number selected is
returned by the function, and the key pressed stored in the system variable
:KEY.  Both the function value and :KEY can be tested in a subsequent DO CASE
structure to determine the program's next actions.
     If the user presses 0 or the first letter in the <hotkey> list, MENU(
returns zero, although the first line covered by the lightbar is 1.  Options
over 9 can be accessed only by the lightbar or by pressing an applicable
hotkey.
     The <hotkey> list is a series of alphanumeric characters, either in the
form of a string or a string variable.  The first letter corresponds to 0
(zero), and each subsequent letter corresponds to the numbers 1, 2, 3
and so on.  The number of choices (that is, the range of the selection bar)
is one fewer than the length of the list.
     If any cursor key except <Up>, <Dn> and <Home> is pressed, MENU( returns
the number of the line highlighted by the lightbar, and :KEY contains the key
number that would be returned by the INKEY( function. (If SET FUNCTION OFF,
all function keys have the same effect as these cursor keys.)
    If no key is pressed, and the optional timeout parameter is set to a
number greater than zero, MENU( will return a value of 65 if no action is
taken for a longer time (in seconds) than the the timeout specification.
     While the MENU( function is active, all other typewriter keys are ignored.
     Examples:
     1. This is a program which shows specifically the values returned by
Menu( when any key is pressed:
CLS
@ 19,46 say 'Returns'
@ 19,64 say ':KEY'
DO WHILE t
   CURSOR 5,20
   var=MENU(10,20)
   @ 20,50 say var
   @ 20,65 say :KEY
ENDDO
     2. In a real-life program:
ERASE
WINDOW 1,2,23,77 double            ;draw frame around screen
@ 1,3 say DATE(full)
@ 3,3 say CEN(:company,74)
@ 5,3 say CEN('Payroll Menu',74)
WINDOW 8,25,22,75 blank            ;use WINDOW to position TEXT
TEXT paymenu                       ;menu text in external file
WINDOW
CURSOR 10,23
ans=MENU(8,35)
IF ans=0 .or. :key=335
   CHAIN MENU
ENDIF
@ ans+9,23 say CHR(16)             ; character as pointer
DO CASE
CASE ans=1
   ... etc.
     3. In a program incorporating both hotkeys and a time-out:
CLS
WINDOW 1,2,23,77 DOUBLE
@ 4,10 SAY CEN(:COMPANY,60)
@ 5,10 SAY CEN('MENU',60)
DO WHILE t
   WINDOW 8,30,22,66 BLANK
   TEXT
0. QUIT

1. ENTER DATA
2. RUN REPORTS
3. POST SALES
   ENDTEXT
   WINDOW
   CURSOR 10,28
   SEL=MENU('QERP',20,10)  ;selection bar will highlight 3 choices
   DO CASE
   CASE SEL=65     ;65 means menu timed out...no user input within 10 seconds
      RING
      @ 22,30 SAY 'NOTHING ENTERED'
   CASE SEL=0      ;or "Q"
      CLS
      CANCEL
   CASE SEL=1      ;or "E"
      CHAIN entry
   CASE SEL=2      ;or "R"
      CHAIN REPORTS
   CASE SEL=3      ;or "P"
      CHAIN post
   ENDCASE
ENDDO
.pa
MIN(
Compare two expressions of any type and return the smaller.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ MIN(<exp1>,<exp2>)                                                 ║
     ║                                                                    ║
     ║ <exp1>    any expression                                           ║
     ║ <exp2>    any expression of the same type as <exp1>                ║
     ╟─────────────────────────────────┐                                  ║
     ║ Type: character/numeric/logical │                                  ║
     ╚═════════════════════════════════╧══════════════════════════════════╝
.pa
MONTHS(
Computes date or date differences in months.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ MONTHS(<date1>,<date2>/<num exp>)                                  ║
     ║                                                                    ║
     ║ <date1>      a string expression containing a valid date           ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <date2>      a string expression containing a valid date; when     ║
     ║                <date2> is specified, MONTHS( returns number of     ║
     ║                months between the two dates                        ║
     ║ <num exp>    number of months before or after date1; when          ║
     ║                specified, MONTHS( returns date that many months    ║
     ║                away                                                ║
     ╟──────────────────────────┐                                         ║
     ║ Type: character/numeric  │                                         ║
     ╚══════════════════════════╧═════════════════════════════════════════╝
     MONTHS( computes the difference between the two dates in months, or
computes a date a given number of months before or after a specified date.
Fractional parts of months are discarded.
     If a computed date is after the last date of the month, the date will be
adjusted to the last day of the month.
.pa
OUT(
Outputs a single character to a sequential file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ OUT(<str var> [,<filenum>])                                        ║
     ║                                                                    ║
     ║ <str var>      contains the character                              ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ (filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function outputs the character in <str var> to the sequential file
(opened with the WOPEN( function).
     If filenum is not given, filenum=1 is assumed.  OUT( returns T if
successful, F otherwise.
     This function is especially useful to communicate over the standard COM1,
COM2 devices, for conversion of Word Star or other non-standard files to
standard ASCII files, to encrypt/decrypt a file through a translation table.
.pa
PIC(
Formats a number or string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ PIC(<exp>,<format>)                                                ║
     ║                                                                    ║
     ║ <exp>                 is the number or string to be formatted      ║
     ║ <format>              the format clause, a string expression       ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function returns the <exp> formatted with the format clause
<format>. See the command @ for the description of the format clauses.  PIC(
is especially useful in preparing numeric values for printing.
     PIC( always returns a string, even when a number or numeric expression is
being formatted.
.pa
PRINTER(
Test whether a printer is ready to print.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ PRINTER([<printernum>])                                            ║
     ║                                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <printernum>  the number of the LPT port (1 or 2)                  ║
     ╟─────────────────┐                                                  ║
     ║ Type: logical   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     Whenever a program has to print, it needs a printer turned on and
on-line. When it is unsuccessful in printing, Info intercepts the customary
DOS error (the infamous "Abort, Retry, Ignore?") and ends execution.
     The PRINTER( function gives programmers a way to ensure the printer is
correctly set up before sending output to the screen.  This makes it possible
to suspend execution under program control, prompt for correction action, or
even SPOOL the output to a disk file instead of the printer.
.pa
PUT(
Puts a string into a DOS file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ PUT(<str exp>[,filenum])                                           ║
     ║                                                                    ║
     ║ <str exp>         the string to overwrite with                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>         the DOS file number (between 1 and 4)            ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     A DOS file was opened with the WOPEN( function; the character number
pointer was normally positioned with the SEEK( function.  This function
overwrites the file from the character chosen by the character number pointer
with the string <str exp>.
     If filenum is not given, filenum=1 is assumed.  PUT( returns T if
successful, F otherwise.
.pa
RAND(
Gives a random number in the range 0<=n<1.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RAND([<seed>])                                                     ║
     ║                                  VP-Info Professional only         ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <seed>    a number used to initiate the random series              ║
     ╟─────────────────┐                                                  ║
     ║ Type: numeric   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     A series of successive calls to the RAND( function will return a uniform
distribution of random numbers.
     The first time RAND( is called, <seed> (any numeric expression) may be
specified. All subsequent calls should be without the seed.  If no initial seed is provided, a random seed is chosen by the program.
     RAND( always returns a number equal to or greater than 0 and less than 1.
If you need a random series of integers between zero and 5000, use 5000*RAND().
     Note: if you provide the initial seed, every execution of RAND() will
return the same series of numbers.
.pa
RANK(
Converts a character to its ASCII number.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RANK(<str exp>)                                                    ║
     ║                                                                    ║
     ║ <str exp>      the first character of this string is converted     ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     The characters in the character set used by the computer are numbered
from 0 to 255.  For the first character of the string <str exp>, RANK(
returns the corresponding number. See also the functions ASC( and CHR(.,
.pa
READ(
Reads a line of a sequential file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ READ(<str var>[,<filenum>])                                        ║
     ║                                                                    ║
     ║ <str var>      stores the line read in                             ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function reads the next line of the sequential file (opened with the
ROPEN( function) into the string variable <str var>.  If <str var> does not
exist, it will be created;  <str var> cannot be a matrix variable.
     A line is terminated by the carriage return character (ASCII 13).  Since
the line is read into a string variable, it cannot be longer than 254
characters.
     If filenum is not given, filenum=1 is assumed.  READ( returns T if
successful, F otherwise.
.pa
RECNO(
Gets the current record number in any open data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RECNO([<filenum>])                                                 ║
     ║                                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>    the number of any open data file; default is the      ║
     ║                selected data file                                  ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function returns the record number of the current record of any
specified data file; if no <filenum> is given, returns the record number the
selected file.
     Note that ? RECNO() displays the current record number in the form
specified by the system variable :PICTURE.
     Info also has a more limited form of this function, #, which applies
only to the selected data file.
.pa
REMLIB(
Removes a library entry.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ REMLIB(<volume>)                                                   ║
     ║                                                                    ║
     ║ <volume>        the number of the library entry to be removed.     ║
     ╟─────────────────┐                                                  ║
     ║ Type: logical   │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function deletes a library entry.  The function accepts the library
volume number you wish to delete as its argument and returns T (true) if the
delete operation was successful, F (false) if not.
     Once a library entry (volume) is deleted, its space in the library is
made available for new text.
.pa
REPLACE(
Replaces, in a string expression, all occurrences of a string with another
string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ REPLACE(<str exp>,<str exp1>,<str exp2>)                           ║
     ║                                                                    ║
     ║ <str exp>      replace in this string expression                   ║
     ║ <str exp1>     all occurrences of this string                      ║
     ║ <str exp2>     with this string                                    ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function looks up the first occurrence of <str exp1> in the string
<str exp>.  This occurrence is replaced with <str exp2>.  This process
continues as long as <str exp1> occurs in <str exp>.
.pa
RESET(
Sets a bit in a string to 0.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RESET(<str exp>,<bit position>)                                    ║
     ║                                                                    ║
     ║ <str exp>       the string or string expression on which the       ║
     ║                   function is to act                               ║
     ║ <bit position>  the number of the bit, numbered from the left      ║
     ║                   starting at 1, which is to be set to zero        ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     A bit is any of the eight binary digits in a character's ASCII number
representation.  Each bit can have only one of two possible values, 0 and 1.
     The SET( and RESET( functions are used to manipulate the bits within a
string or string expression.  SET( makes a bit 1, and RESET( makes a bit 0.
.pa
RIGHT(
Gets the right-hand part of a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RIGHT(<str exp>, <num exp>)                                        ║
     ║                                                                    ║
     ║ <str exp>   the string from which the new string is formed         ║
     ║ <num exp>   the number of characters to place in the new string    ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
.pa
ROPEN(
Opens a DOS file for reading.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ROPEN(<str exp> [,filenum])                                        ║
     ║                                                                    ║
     ║ <str exp>      the file name                                       ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ filenum        the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function opens <str exp>, a DOS file (in particular, a sequential
file or input device, such as COM1), for reading only.  The current position
pointer is set to the beginning of the file.
     If filenum is not given, filenum=1 is assumed.  If no file extension is
given, the extension TXT is used.
     ROPEN( returns T if successful, F otherwise.
.pa
ROW(
Gets print row position.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ROW()                                                              ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function gives the current row (line) position of the cursor; if the
printer is on, it returns the column position of the printer head.
.pa
SEEK(
Goes to a given character number in a DOS file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SEEK(<num exp> [,filenum])                                         ║
     ║                                                                    ║
     ║ <num exp>      the character number                                ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function repositions the character number pointer in the DOS file
(opened with the ROPEN( or WOPEN( function) to the value given by <num exp>.
     If filenum is not given, filenum=1 is assumed.  If no file extension is
given, the extension TXT is used.
     If SEEK( is successful, it returns T (true); otherwise F (false).  In a
Info program, SEEK( normally occurs in an IF or DO WHILE command.
     Once the character pointer is properly positioned, use the GET( and PUT(
functions to manipulate the characters.
.pa
SET(
Sets a bit in a string to 1.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET(<str exp>,<bit position>)                                      ║
     ║                                                                    ║
     ║ <str exp>       the string or string expression on which the       ║
     ║                   function is to act                               ║
     ║ <bit position>  the number of the bit, numbered from the left      ║
     ║                   starting at 1, which is to be set to 1           ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     A bit is any of the eight binary digits in a character's ASCII number
representation.  Each bit can have only one of two possible values, 0 and 1.
     The SET( and RESET( functions are used to manipulate the bits within a
string or string expression.  SET( makes a bit 1, and RESET( makes a bit 0.
The BIT( function tests the value of a specific bit.
.pa
SPACE(
Gets the amount of space left in the data space.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SPACE()                                                            ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function returns the available memory in the 64K data space.
.pa
SSEEK(
Goes to a given line number in a sequential file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SSEEK(<num exp> [,<filenum>])                                      ║
     ║                                                                    ║
     ║ <num exp>      the line number                                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function repositions the line number pointer in the sequential file
(opened with the ROPEN( function) to the value given by <num exp>.
     If filenum is not given, filenum=1 is assumed.  If no file extension is
given, the extension TXT is used.
     If filenum is not given, filenum=1 is assumed.  If no file extension is
given, the extension TXT is used.
.pa
STR(
Converts a number to a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ STR(<num exp>,<width num exp>[,<decimals num exp>])                ║
     ║                                                                    ║
     ║ <num exp>         the number to be converted                       ║
     ║ <width num exp>   the width of the string                          ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <decimals num exp> the number of decimals                          ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function gets a number by evaluating the <num exp>, and converts it
into a string of given width.  Optionally, the number of decimals can be
specified (the default is 0).
.pa
SUBSTR(
Gets a substring of a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SUBSTR(<str exp>, <start num exp>, <width num exp>)                ║
     ║                                                                    ║
     ║ <str exp>         the string from which the new string is formed   ║
     ║ <start num exp>   the position from which the new string is        ║
     ║                     taken                                          ║
     ║ <width num exp>   the number of characters to place in the         ║
     ║                     new string                                     ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function, a synonym for the $( function, takes the string in
<str exp> from position <start num exp> (fractions are thrown away); the
number of characters taken is <width num exp>.  (In both numeric
expressions, the fractions are disregarded).
.pa
TEST(
Tests a string whether it is a valid expression.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ TEST(<str exp>)                                                    ║
     ║                                                                    ║
     ║ <str exp>            the string to be tested                       ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function tests the string in <str exp> as to whether it is a valid
expression; in particular, all variables must be defined and must be of the
proper type.  It returns T if it is, F otherwise.  If the test is successful,
TYPE( can be used to find the type of the expression.
.pa
TIME(
Gets the system time.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ TIME([<type>])                                                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <type>      one of three types of information requested, as listed ║
     ║               below                                                ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function returns a string containing the current system time, and
changes the format of the system variable :TIME to this format.
     The <type> can be given in either of two forms, a name or number (numeric
expression) as follows:
Type           Explanation                        Example
1 or HMS       Hours,minutes,seconds,hundredths   17:26:36.07
2 or AMPM      Hours,minutes with AM/PM            5:36 pm
3 or Seconds   Seconds since midnight             62804.80
Shortcut: When specifying type by name, only the first character is required.
     The default parameter is 1, the time in the 24-hour format hh:mm:ss.hh.
.pa
TRIM(
Trims blanks from the right-hand side of a string.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ TRIM(<str exp>)                                                    ║
     ║                                                                    ║
     ║ <str exp>        the string to be trimmed                          ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
.pa
TYPE(
Gets the type of an expression.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ TYPE(<exp>)                                                        ║
     ║                                                                    ║
     ║ <exp>            any expression                                    ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     For an expression, <exp>, this function returns the type of the expression
as a one character string:
C    for character
L    for logical
N    for numeric
U    Undefined
.pa
UPPER(
Converts a string to upper case.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ UPPER(<str exp>)                                                   ║
     ║                                                                    ║
     ║ <str exp>    the text to be converted to upper case                ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
.pa
VAL(
Converts a string to its numeric value.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ VAL(<str exp>)                                                     ║
     ║                                                                    ║
     ║ <str exp>      the string to be evaluated                          ║
     ╟───────────────┐                                                    ║
     ║ Type: numeric │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function takes the string <str exp> which is a number, and returns
it as a number.  If the whole string cannot be interpreted as a number, it
takes as much of the front part as it can.
.pa
WOPEN(
Opens a DOS file for writing.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ WOPEN(<str exp>[,<filenum>])                                       ║
     ║                                                                    ║
     ║ <str exp>      the file name                                       ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function opens the DOS file, and in particular, the sequential file
<str exp> (or output device, such as COM1:) for writing; if the file does not
exist, it will be created.  If filenum is not given, filenum=1 is assumed.  If
no file extension is given, the extension TXT is used.  It returns T if
successful, F otherwise.
.pa
WRAP(
Wraps text for output.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ WRAP(<str var>, <num exp>)                                         ║
     ║                                                                    ║
     ║ <str exp>        the string to be wrapped                          ║
     ║ <num exp>        the line width                                    ║
     ╟─────────────────┐                                                  ║
     ║ Type: character │                                                  ║
     ╚═════════════════╧══════════════════════════════════════════════════╝
     This function returns one line of text with word wrapping from the string
in <str var>; <str var> now contains what is left of the string.  In other
words, the string returned will contain as many words as will fit in a line
(the line width is given by <num exp>).  If the whole contents of <str var> is
one line, <str var> becomes the blank string (of length 1)
.pa
WRITE(
Writes a new line into the sequential file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ WRITE(<str var>[,<filenum>])                                       ║
     ║                                                                    ║
     ║ <str var>      the line to be written                              ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <filenum>      the DOS file number (between 1 and 4)               ║
     ╟───────────────┐                                                    ║
     ║ Type: logical │                                                    ║
     ╚═══════════════╧════════════════════════════════════════════════════╝
     This function writes (appends) the contents of the string variable
<str var> to the end of a sequential file opened with the WOPEN( function.
     If filenum is not given, filenum=1 is assumed.  WRITE( returns T if
successful, F otherwise.
.pa
EXPRESSIONS
     Expressions can be formed from constants and variables using operations,
relations, and functions.  There are three types of expressions: numeric,
string, and logical.
     Numeric expressions are built up from numeric constants, numeric
variables, and from functions that give results of numeric type; they are
formed with the operations: +, -, *, /, and the parentheses: ( and ).
     String expressions are formed from string constants, string variables,
and from functions that give results of character type; they use the
operation + and the parentheses: ( and ).
     Logical expressions (also called conditions) are formed from logical
constants, logical variables, functions that give results of logical type, and
the results of relations; they use the logical operations: .AND., .OR., .NOT.,
and the parentheses: ( and ).
     Variables are expressions which are used to represent changeable information. The values they contain can be easily changed by using
Info's many commands and functions.
     A variable can stand for many different values; you can use the name
of a variable in place of all the specific values you want or expect it to
represent.
     In Info there are three main kinds of variables: fields,
memory variables, and system variables.
\\FIELD VARIABLES
\\MEMORY VARIABLES
\\SYSTEM VARIABLES
.pa
FIELD VARIABLES
     Fields are storage places for data in data files.  Fields make up each
record in a data file.  Each item in a record (e.g., name, address, amount)
is one field.
.pa
SYSTEM VARIABLES
     System variables are built into Info. They include the contents of
the function keys (F1 - F10), the date and time (from DOS), various default
values, and other information.
     A system variable is distinguished from other variables by having a
colon as the first character of its name -- e.g., :TIME.
     Each of the function keys contains a pre-defined string (shown with LIST
SYSTEM).  Using the = command, you can redefine any function key (e.g.,
:F2="SET DEFAULT TO b;" assigns the string "SET DEFAULT TO b;" to F2).
Function keys can be defined as commands or as frequently repeated entries
for use in full-screen editing.
     A semicolon (;) in a function key definition indicates a press of the
ENTER key. A function key definition that contains a semicolon will be
executed when you press the function key.
     A quick way to redefine function keys is to type the string to be stored,
then press ALT key along with the function key to store the string to.  To
capture a line of text to move in WRITE, place the cursor at the beginning
of the line, then press ALT and the function key to store the text; then
move to the new position and press the function key to insert it.
     These processes redefine function keys only during the current
Info session.
     To save changes to function keys  or other system variables enter the new
definitions in the CNF configuration file.
     In addition to the function keys, there are a number of other system
variables which can be viewed by typing LIST SYSTEM:
.pa
MEMORY VARIABLES
     Memory variables are temporary storage places cleared when you quit
Info (unless you write them to disk with the SAVE command).
     Create a memory variable by assigning a string, number, or logical value
to a name of 1 to 10 characters with the = or STORE command.  Memory variables'
data types are Character, Numeric, or Logical.  Text surrounded by quotes
creates a character variable.  A number with no quotes creates a numeric
variable.  Logical values (T,t,F,f, etc.) create logical variables.
     You can use 128 memory variables at a time. Matrix variables (defined
with the DIM command) can contain many values per individual variable.  Use
the LIST MEMORY command to see all currently defined memory variables.
     Memory variable names are 1 to 10 characters in length, with the first
character a letter; remaining characters can be letters, numbers, colons
(:), or underlines (_).
.pa
PRECEDENCE
     In an expression such as
2+3*4
Info has to decide whether to perform the + first (result: 20) or
the * first (result: 23).  The Rules of Precedence decide such questions.
     Functions have the highest precedence.
     Arithmetic operations have the second highest precedence; among
themselves:
*, /
then
+, -
     Relations are next; among themselves they all have the same precedence.
     Logical operations come last; among themselves:
.NOT.
then
.AND., .OR.
     When two or more of the above have the same precedence, they are
performed from left to right.
     The parentheses: ( and ) have higher precedence than functions,
operations, or relations.  Thus you can set the precedence explicitly using
parentheses.
.pa
COMMENT (*)
Place comments -- notes -- in programs.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ * [<string>]                                                       ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <string>   any text line: the comment                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command * (or NOTE) is used for placing comments in a program.
Info ignores any line that starts with * (or NOTE).  Since the
compilation removes all the comment lines, the number of comments has no
effect on the speed of the compiled program.
     Notes can also be added with semicolon(;) at the end of any
Info command line.
.pa
=
Assign value to a memory variable, or to a field when a record is referenced
as a vector of fields.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ <memvar>=<exp>                                                     ║
     ║ <file>[<num exp>]=<exp>                                            ║
     ╚════════════════════════════════════════════════════════════════════╝
     Assigning values to memory variables.  The first form of this command
assigns a value to a memory variable; if the variable does not exist, it will
be created.  This command is equivalent to the STORE command.
     Treating a data file as a vector.  The second form assigns a value to a
field of a data file.  In this form, [ and ] do not indicate an option, [
and ] have to be typed in.  For instance, EMPLOYEE[3] is the third field,
ADDR, of the EMPLOYEE data file.  This is the only way to assign a value to
a field with the = command.  Normally, field values are assigned with the
REPLACE command.
     Special care must be taken when using this second form when the data file
is opened with a macros.  Opening a file with a macro allows a standard
program to work with a wide variety of files, provided the compiler is told
the data file structure.
.pa
?
Display expression or expression list.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ? [<exp list>]                                                     ║
     ║ ?? [<exp list>]                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <exp list>   the expression or expressions to be displayed         ║
     ╚════════════════════════════════════════════════════════════════════╝
     The ? command evaluates the expression or expressions in the list
(remember the commas to separate the expressions in the list!) and displays
the results on a new line.  In particular, this command is often used to
display the contents of memory variables and fields.
     The displayed items are separated by blanks if SET RAW OFF (ON is the
default).  When SET RAW ON, they appear side by side.
     ? with no expression displays a blank line; it is used for spacing on the
screen and printer.
     While the ? command moves the cursor to the beginning of the next line
before the items are displayed, the ?? command displays the items at the
current cursor position.  The ?? command is used in programs to build lines of
text on the screen or on the printer from several pieces.
.pa
@
Display data and data input request at specific line and column position on
screen or printer, or erase the screen line starting at the specified
coordinates.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ @ <line,col> [SAY <exp> [USING <format>]] [GET <var> [PICTURE      ║
     ║      <format>]]                                                    ║
     ║                                                                    ║
     ║ line   the line number for the display, a numeric expression;      ║
     ║           the fractional part (if any) will be discarded           ║
     ║ col    the column number for the display, numeric expression;      ║
     ║           the fractional part (if any) will be discarded           ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ none    erase the screen line starting at the specified            ║
     ║            row and column position; when printing, move print head ║
     ║            to specified position                                   ║
     ║                                                                    ║
     ║ SAY <exp> [USING <format>]                                         ║
     ║                                                                    ║
     ║ SAY     displays the expression, <exp>; if there is a USING        ║
     ║            clause, <exp> is displayed using the format             ║
     ║            specification <format>                                  ║
     ║                                                                    ║
     ║ GET <var> [PICTURE <format>]                                       ║
     ║ GET     asks for an input into the variable <var>; the present     ║
     ║            contents of the <var> is displayed; if there is a       ║
     ║            PICTURE clause, <var> is displayed using <format>.      ║
     ║            The input request is activated by the READ command      ║
     ╚════════════════════════════════════════════════════════════════════╝
     The @ command is used in Info programs, first, to display
formatted data at specific locations on the screen or printer, and second, to
prompt the user to type in data (in conjunction with the READ command).  If
the SET FORMAT option is TO PRINT, then the (formatted) data is sent to the
printer and there can be no GET clause; otherwise the SET FORMAT TO SCREEN is
in effect, and the data is sent to, and can be obtained from, the screen.
     The keywords of the @ command: SAY, USING, GET, PICTURE cannot be in
macros.
     This command is often used for making input screens and reports in
Info.  See the command TEXT that contains many elements of the @
command, and is usually used in preference to @ for full-screen input and
output, and printed output.
     Line numbers go from 0 to 24, column numbers from 0 to 79.  For the
printer, the line number counter begins at 0 (line 1); it is reset to 0 by the
EJECT command.  If there are several @ commands for the printer, each @
command must display past the display of the previous @ command (that is, if
the first @ command displays at line1, col1, and the next at line2, col2, then
either line1<line2, or line1=line2 and col1<col2).  If the new print position
is less than the current print position, the printer head is not moved by the
@ command.
     If GET <var> is used, the variable, <var> must exist; it is not created
by this command.  The present value of <var> is shown on the screen; the new
value typed in by the user becomes the contents of <var>; if <var> is a field,
the field in the selected file is changed (a REPLACE is performed).
     If no option is used in screen output, for instance @ 10,0, the line is
cleared on the screen starting at the indicated column.  On the printer, the
print head is moved to the new position.
     If there is no <format> clause, the variable is displayed as follows:
fields are displayed with the width specified in the data file structure;
string memory variables are displayed as stored; numeric variables are
displayed as specified by the :PICTURE system variable.
     The GET clauses are activated by the READ command.  There can be no more
than 64 GET clauses for a READ command.  The GET clauses with their pictures
are stored in a Get Table, which remains in effect after a READ until another
GET clause is encountered or a CLEAR GETS command is encountered. It may also
be cleared when leaving the current program module, depending on the setting
of the SET GET command. For more on @ command, press <ENTER>.
\\@ FORMATS
.pa
@ FORMATS
     Format clause.  A format clause is a string composed of format characters
and background characters.  The format characters format the output, serve as
holding places for characters in output, and mask the input; the background
characters are placed in the output to make it prettier and in the input to
make the input easier.
     Formatting numbers.  Formatting numbers is very easy.  Specify the number
of decimals, the placement of commas, and perhaps a floating dollar sign.
     This is how the format works both with the SAY and the GET clause in
displaying numbers; extreme care, however, must be exercised in using format
with GET when inputting values to a numeric field, since the field and the
picture must have the same number of digits before the decimal point.
     The GET clause displays the number in the variable or field; after the
READ command, Info waits for input.  The input is typed in on top of
the displayed number, ignoring where the number is, the dollar sign, commas,
and the decimal point.  Only digits, the minus sign, and the decimal point are
accepted.  Once the input is complete (by filling the field or by pressing
<ENTER>), the new number is reformatted by the format clause, and redisplayed.
     Remember that in Info, all numbers in a field have a specified
width and number of decimals; these are recorded in the data file.  It is
important to understand that a GET command does not change the width or the
number of decimals for a field.  The field and the picture must have the same
number of digits before the decimal point.
     The number zero is displayed as a zero (in the specified format) or as
blanks depending on whether SET ZERO is ON or OFF (the default is ON).
     Formatting negative numbers.  In some applications, the negative number -
241.56 should appear as 241.56- or as <241.56>.  To achieve that, simply add -
or > to the end of the picture format string:
     Formatting strings.  For displaying strings, use four format characters:
9, X (or x), A (or a), and !.  Every other character is a background character.
     In GET format clauses, 9, X, A, and ! are also place holders to display
the present contents of the variable.  However, when Info receives
the input after the READ command, 9, X, A, and ! become place holders that
take only certain characters:
9 takes only digits (0 to 9), - (minus), blank, and . (period)
A takes only letters (a to z and A to Z)
X takes any character
! takes any character but converts lower-case letters (a to z) to upper case
letters (A to Z)
     The @ GET <var> command does not change the length of a string variable
<var>.  If the variable is a field, the width is defined when the file was
created; for a memory variable, the width is determined by the current value.
     Note that the format clause is also used by the PIC( function.
.pa
ACCEPT
Input request for strings.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ACCEPT ['<string>'] TO <str var>                                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ '<string>'  the prompt message                                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command is used in Info programs to request character
information to be placed into a memory variable.  The text in <string> will be
displayed as a prompt message.  Note that <string> has to be delimited by ' or
by ", and may not be either a macro or a string expression.  ACCEPT cannot be
used to input data into a field or element of a matrix.
     If the <memvar> does not exist, it will be created.
     The optional character string is used as a prompt.  A character
expression cannot be used, but a macro is permitted, provided the macro
expression includes quotation marks.
     To input numeric or logical data, use the INPUT command.
.pa
APPEND
Append record to data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ APPEND [FIELDS <field list> / TEXT <textfile>] / OFF ]             ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ FIELDS <field list>   the fields to be edited during APPEND        ║
     ║ TEXT <textfile>       erases the screen, displays the text         ║
     ║                         file, and then does APPEND OFF             ║
     ╚════════════════════════════════════════════════════════════════════╝
     A mode of the EDIT command that starts with a new, blank record instead
of the current record.  All other options and rules ae the same as for EDIT.
.pa
APPEND BLANK
Append a blank record to data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ APPEND BLANK                                                       ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ BLANK     append blank record, no full-screen editing              ║
     ╚════════════════════════════════════════════════════════════════════╝
     APPEND BLANK adds a blank record to the selected file, and sets the
current record number to this record.  The new record is not shown.  The
fields of such a record are usually filled by the user with the REPLACE, @ GET, or EDIT commands (or variants such as READ, =, TEXT, BROWSE).
     APPEND BLANK updates all index files in use. 
.pa
APPEND FROM
Append data to the selected file from another file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ APPEND FROM <file> [FOR <cond>] [SDF/SDF DELIMITED [WITH <char>]]  ║
     ║                                                                    ║
     ║ <file>         the name of the source file                         ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ FOR <cond>     select by condition (not with sequential source     ║
     ║                   files)                                           ║
     ║ SDF            sequential source file                              ║
     ║ SDF DELIMITED  sequential source file with delimited fields        ║
     ║ SDF DELIMITED WITH <char> sequential source file with fields       ║
     ║                  delimited with a specific character <char>        ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command appends records from the source file <file> to the selected
file.  Fields are copied from the source file to the selected file into fields
with the same name.  Deleted records are not appended.
     If a field in the source file has no matching field in the selected file,
then the field is ignored.  If a field in the selected file has no matching
field in the source file, then the field is set to blank.
     For character fields, if the field width gets smaller, then the field is
truncated on the right; if the field width gets larger, then the field is
padded with blanks on the right.
     For number fields, if a number will not fit in the new field,  digits are
lost on the left side of the number.  Be careful when moving numbers with
different field widths.  If the source field has more decimals than the target
field, decimals on the right will be dropped. If the target field has too few
positions to the left of the decimal point, the value will be lost and the
field filled with a zero followed by asterisks.
     The FOR clause is used to append a subset of the file specified. The
condition <cond> is made up of memory variables and the fields of the source
file; permitted only when the source is a data file.
     If the structure of two data files is identical in all respects, the
records are appended very quickly; otherwise the APPEND is done one field at a
time.  If a field name occurs only in the source file, its values will not be
copied into the target data file.  (To change the name of a field, use the
RENAME FIELD command.)
     APPEND FROM updates all index files in use.
     With any of the SDF options, Info reads the sequential file,
and each line is turned into a new record of the data file appended to the
end. Each line must end with a carriage return (character 13) or a
carriage return-line feed pair (characters 13 and 10).  The characters of
the line are placed in the new record one after another from the left.
See the related command: COPY TO ... SDF.
     APPEND FROM ... SDF assumes that fields are not trimmed or delimited.
     With the SDF DELIMITED option, the line of the sequential file is
regarded as a number of trimmed fields, separated by commas.  Strings can, in
addition, be delimited by quotation marks.  These fields are placed in the
fields of the data file from the left.  The remaining fields of the data
file (if any) are left blank; the remainder of the line (after all the
fields are filled), if any, is ignored.
     With the SDF DELIMITED WITH <char> option, the line of the sequential
file is regarded as a number of fields, separated by commas with all
character and logical values surrounded by <char>. Otherwise, this option is
identical to SDF DELIMITED.
     The functions to read and write sequential files give much better control
over sequential files.
.pa
APPEND TO
Append current record to another file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ APPEND TO <num const>                                              ║
     ║                                                                    ║
     ║ <num const>     append record to file in select area <num const>   ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command appends the current record from the selected file to the
file numbered <num const>.  The same rules apply as in APPEND FROM.
     You can also append to the same file by giving its file number.
.pa
AVERAGE
Average numeric expressions for selected records.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ AVERAGE <num exp list> [TO <memvar list>] [<scope>] [FOR <cond>]   ║
     ║                                                                    ║
     ║ <num exp list>    the numeric expressions to average               ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <memvar list>     store the results in these memory variables      ║
     ║ <scope>           select by scope (default scope: ALL)             ║
     ║ FOR <cond>        select by condition                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command AVERAGE adds up numeric expressions for selected records of
the selected data file and divides the result with the number of records
summed.  Up to 10 expressions can be averaged with one command.  Optionally,
the results can be stored in numeric memory variables; the expression list and
the numeric memory variable list should have the same number of entries.
<memvar list> cannot contain numeric matrix variables.
     Records flagged as DELETED are not averaged.
     Memory variables in <memvar list> need not exist; if any variable in the
<memvar list> does not exist, this command creates it.
.pa
BOX
Draw a box on the screen.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ BOX <line1>,<col1>,<line2>,<col2> [DOUBLE]                         ║
     ║                                                                    ║
     ║ <line1>,<col1>   the position of the upper-left corner of the box  ║
     ║ <line2>,<col2>   the position of the lower-right corner of the box ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ DOUBLE   use double line graphics, the default is single-line      ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command BOX draws a box on the screen using the character graphics of
the IBM non-graphics screen.  If line1=line2, a horizontal line is drawn.  If
col1=col2, a vertical line is drawn.
     line1, line2, col1, col2 can all be numbers or numeric expressions; any
fractional part will be disregarded
     This command is useful for making menus pretty, and for partitioning the
screen into different viewing areas.
     Note that commas are required between the numeric expressions used for
the corner specifications, but a comma is NOT permitted before DOUBLE.
.pa
BREAK
Exit to the bottom of a DO WHILE or REPEAT loop.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ BREAK                                                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The BREAK command is used only in programs, in a DO WHILE or a REPEAT
loop to exit at the bottom of the loop.  If there are nested loops, the exit
is at the bottom of the innermost loop.
     Contrast the command BREAK with the command LOOP which executes the
condition at the top of the DO WHILE loop.
     Caution: BREAK can be used only within a DO WHILE or REPEAT loop; use
anywhere else is an error with unpredictable results.
.pa
BROWSE
Edit fields in many records.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ BROWSE [FIELDS <field list>]/[OFF]/[TEXT <textfile>] [APPEND]      ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options (all versions):                                            ║
     ║                                                                    ║
     ║ FIELDS <field list>   specify the fields to be displayed           ║
     ║ APPEND    add a blank record and start BROWSE in that record       ║
     ║ OFF       rather than generate a BROWSE input screen, uses an      ║
     ║              exiting screen and its Get Table                      ║
     ║ TEXT <textfile> erases the screen, displays the text file, and     ║
     ║              then does BROWSE OFF                                  ║
     ╚════════════════════════════════════════════════════════════════════╝
     The BROWSE command displays the records (from the current record on)
horizontally, one at a line; it displays as many fields as will fit on a line.
A column represents a field.
     If the selected file is indexed, the records are displayed in the indexed
order.
     When the APPEND keyword is used, a blank record is appended to the data
file and BROWSE begins in that record. The user may alternate between normal
BROWSE and APPEND modes with the Ctrl-<PgDn> and <PgUp> editing keys.
     All the full-screen editing keys can be used.  Note that they have the
same meaning as in EDIT, but sometimes they look different.  For instance, the
next record command (<PgDn> or Ctrl-C) gives a new screen in EDIT; in BROWSE,
it simply moves the cursor down one line.
     Editing keys:
<Left> or Ctrl-S        moves the cursor back one character
<Right> or Ctrl-D       moves the cursor forward one character
Ctrl-<Left>             moves to the beginning of the field
Ctrl-<Right>            moves to the end of the field
<Ins> or Ctrl-V         puts you in insert mode: what you type gets
                           inserted  (normally, you are in overtype mode: what
                           you type overtypes the existing text); pressing
                           <Ins> or Ctrl-V again, puts you back into overtype
                            mode
<BACKSPACE>             deletes the character to the left of the cursor
<Del> or Ctrl-G         deletes the character on the cursor
Ctrl-Y                  deletes the rest of the field
<Up> or Ctrl-E          moves the cursor to the previous field
<Dn> or Ctrl-X          moves the cursor to the next field
Ctrl-<Pg Dn>            Enters APPEND mode; adds a blank record and places
                           the cursor in that new record
Ctrl-Q                  quits and does not update the current record
<End> or Ctrl-W         quits and updates the current record
<PgUp> or Ctrl-R        moves to the previous record; when in APPEND mode,
                           exist to normal BROWSE mode
<PgDn> or Ctrl-C        moves to the next record
Ctrl-L                  redraws the BROWSE screen with the next screenful of
                           fields, referred to as the next "page"; if the
                           file has no more fields, this key is ignored
Ctrl-K                  redraws the BROWSE screen with the previous screenful
                           of fields, referred to as the prior "page"; if the
                           screen is already at the first field, this key
                           is ignored
Alt-E                   skips one screenful of record toward the beginning of
                           the file and redisplays the BROWSE screen
Alt-X                   skips one screenful of record toward the end of the
                           file and redisplays the BROWSE screen.
     BROWSE should be used to edit columns of data in a data file; that is, to
edit a few fields of a number of records.  Use the command EDIT to edit many
fields of a single records at the same time.
     The option FIELDS <field list> selects the fields to be displayed on the
screen.
     SET MENU ON causes a small display at the top of the BROWSE screen,
giving the use of major editing key.
.pa
CANCEL
Leave Info program.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CANCEL                                                             ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command CANCEL aborts the Info program and enters the
interactive mode; the Info prompt appears.
.pa
CASE
The switch in the DO CASE program structure.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CASE <cond>                                                        ║
     ║                                                                    ║
     ║ <cond>  if this condition is satisfied, the following program      ║
     ║           segment should be executed                               ║
     ╚════════════════════════════════════════════════════════════════════╝
     CASE is the keyword in the DO CASE program structure.  Info
evaluates the condition; if the condition is true, the following program
segment is executed.  The program segment is terminated by the next CASE, by
OTHERWISE, or by ENDCASE.  After the execution of the program segment, the
program execution continues with the program line after the ENDCASE command.
If the condition is false, Info looks for the next CASE command.  If
no condition is true, Info executes the program segment following
the OTHERWISE command (if any).
     Note that when more than one <cond> is true in a DO CASE structure, only
the program segment for the first is executed.
.pa
CHAIN
Leave the current Info program and start running a new Info program.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CHAIN <program>                                                    ║
     ║                                                                    ║
     ║ <program>   the name of the Info program to be run                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command CHAIN is used for executing an Info program from
within another Info program or in the interactive mode from the
Info prompt.  The program name <program> should not have an
extension.  If there is a compiled program by this name (normal extension CPL;
runtime extension RPL), it will be run.  If there is none, Info will
run the uncompiled program (extension PRG).
     CHAIN does a CLEAR first, except that all global memory variables are
preserved and passed to the <program>; to use them, the <program> must have a
GLOBAL command declaring the variables.
     The CHAIN command does not return to the calling program;  the program in
memory is replaced by the program it chains to.
     CHAIN is the most efficient way for one program to call another.  The DO
command calls a subroutine from the disk.  DO can often be replaced by PERFORM
or by CHAIN.
     CHAIN allows the program name to be a macro.
.pa
CLEAR
Close all data files and index files, and clear memory variables.  Optionally
clear current Get Table or keyboard buffer.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CLEAR [GETS/KEYBOARD]                                              ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ GETS           clear the Get Table from memory                     ║
     ║ KEYBOARD       delete all characters from the keyboard buffer      ║
     ║                   buffer                                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     The CLEAR command with no options closes all open data files and index
files,  and releases all memory variables, including the matrix variables.
(Sequential files, DOS files, system variables, and in particular, function
keys, are not effected).
.pa
CLOSE
Close the selected file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CLOSE [ALL]                                                        ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ ALL            close all data files in use                         ║
     ╚════════════════════════════════════════════════════════════════════╝
     The CLOSE command closes the selected data file, updates all information
to the disk, and releases the data record buffer space used by this file. Any
index files attached to the data file are also closed, and any limits,
relations and filters associated with the data file are cleared.
     With the option ALL, all data files in use are closed.
.pa
CLS
Erase screen.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CLS [<line1>,<line2>]                                              ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <line1>,<line2>   erase from line1 to line2                        ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command erases the screen, and is a synonym for ERASE.
     If, optionally, two numeric expressions, line1 and line2, are given, it
erases line1 and line2, and all lines between, if any.  These expressions
should have values between 0 and 24.
.pa
COLOR
Set the color attributes of a box on the screen.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ COLOR <attrib>,<line1>,<col1>,<line2>,<col2>[,<fillchar>]          ║
     ║                                                                    ║
     ║ <attrib>       numeric expression between 0 and 255, the attribute ║
     ║ <line1>,<col1> the position of the upper-left corner of the box    ║
     ║ <line2>,<col2> the position of the lower-right corner of the box   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <fillchar>     the ASCII number of the character used to fill the  ║
     ║                 colored area; every character position enclosed    ║
     ║                 in the area described by the row and column values ║
     ║                 is changed to the fill character                   ║
     ╚════════════════════════════════════════════════════════════════════╝
     Every character displayed on the screen has an attribute byte that
determines how the character is displayed.  For monochrome monitors, the
character may be bold, underlined, reverse, and so on.  For color monitors,
both the background and the character has color.  These attribute bytes are
set for a rectangular area by this command.
     The area is given by four numeric expressions -- line1, col1, line2, col2
-- as in the BOX and WINDOW commands.  The values must be separated by commas.
     Compute ATTRIB by adding up (up to) four numbers (background+
foreground+blink+brightness) from the following tables:
    BACKGROUND     ========CHARACTERS=========  BLINKING        BRIGHTNESS
    (color only)   (color)     (monochrome)
    ------------   ----------  ---------------  --------------  ------------
     0 - black     0 - black     0 - normal       0 - no blink  0 - normal
    16 - blue      1 - blue      1 - underline  128 - blink     8 - bright
    32 - green     2 - green   112 - reverse
    48 - cyan      3 - cyan
    64 - red       4 - red
    80 - magenta   5 - magenta
    96 - brown     6 - brown
   112 - white     7 - white
     When filling an area with a fill character, as is often done in designing
sign-on screens for example, the pattern characters 176 to 178 and the solid
reverse character 219 are especially useful.
     See also SET COLOR TO <num exp> and :COLOR=<num exp>, which set the
attribute bytes of the characters displayed.  SET COLOR TO 0 turns the command
off: the attribute bytes remain unchanged at the displaced locations.  If a
part of the screen already has attributes set by the COLOR command and SET
COLOR TO 0, the newly displayed characters will keep the attributes set by the
COLOR command.
.pa
COMPILE
Compile an Info program.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ COMPILE <file> [LINK]                                              ║
     ║                                                                    ║
     ║ <file>  the name of the program file                               ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ LINK    If SET DO OFF, causes COMPILE to work as if SET DO ON      ║
     ╚════════════════════════════════════════════════════════════════════╝
     The COMPILE command may be given in interactive mode, or in a program:
1>COMPILE prog
where PROG is a file with PRG extension, the source program to be compiled.
<file> cannot be a macro, and should not have any extension specified.
.pa
CONTINUE
Continue to LOCATE from the current record.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CONTINUE                                                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     CONTINUE will carry on locating from the current record using the
condition of the last LOCATE command.
     Note that the standard strings stored in function key F8 combines a
CONTINUE and an EDIT command.  Once a LOCATE has been executed (function key
F8), each additional matching record can be edited by pressing F8.
.pa
COPY
Copy selected records of the selected file into a new file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ COPY [<scope>] TO <file> [FIELDS <field list> [FOR <cond>] [SDF/   ║
     ║       SDF DELIMITED [WITH <char>]]                                 ║
     ║                                                                    ║
     ║ <file> is the name of the file the records are copied to           ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>                     select records by scope                ║
     ║                                (default scope: ALL)                ║
     ║ FIELDS <field list>         copy only selected fields              ║
     ║ FOR <cond>                  select records by condition            ║
     ║ SDF                         copy into sequential file              ║
     ║ SDF DELIMITED               separate fields by commas              ║
     ║ SDF DELIMITED [WITH <char>] separate fields by specified character ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command COPY is used for moving records from the selected file to a
new file, <file>; if a file by the name <file> already exists, it will be
overwritten.
     If the SDF option is not used, the result will be a data file with the
default extension DBF and the same structure as the source file, unless the
FIELDS keyword is used with a fields list.
     When the SDF option is used, the result is a text file, with the default
extension TXT.  When the DELIMITED keyword is not used, each record (or its
selected fields) becomes one line in a sequential file; the fields are all
merged.
     With the SDF DELIMITED option, the fields are separated by commas, and
strings are enclosed in single quotes ('). A different string delimiter can be
specified with the WITH clause: example WITH |.  The specified delimiter
character is not enclosed in quotes.
     For a discussion of the SDF option, see the command APPEND FROM.
.pa
COPY STRUCTURE
Create a new file with the structure of the selected file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ COPY STRUCTURE TO <file> [FIELDS <field list>]                     ║
     ║                                                                    ║
     ║ <file>      the name of the new file                               ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ FIELDS <field list>     copy only these fields                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command COPY STRUCTURE creates a new data file with the same fields
as the selected file, but with no records.  The default extension is DBF.
     If the FIELDS option is used, the new structure will contain only the
fields listed.
.pa
COUNT
Count selected records.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ COUNT [<scope>] [TO <memvar>] [FOR <cond>]                         ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>      select by scope (default scope: ALL)                  ║
     ║ TO <memvar>  store result in memory variable                       ║
     ║ FOR <cond>   select by condition                                   ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command counts the number of records that meet the selection
criteria.  Selection is by scope and/or by condition.  The result may be
stored in a numeric memory variable; if the variable does not exist, this
command creates it.
     <memvar> cannot be a numeric matrix variable.
     The result of the command COUNT is displayed if SET TALK ON.
.pa
CREATE
Create a new data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CREATE <file>                                                      ║
     ║                                                                    ║
     ║ <file>       the data file to create                               ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command CREATE is used to make a new data file, <file>; <file> cannot
be a macro.  (Do not use COMP for the first four letters of a data or index
file; Info is unable to open such a file.)
     File creation is a special form of full-screen editing.  Each field is
represented by four editing fields.
     Editing keys:
<Left> or Ctrl-S        moves the cursor back one character
<Right> or Ctrl-D       moves the cursor forward one character
Ctrl-<Left>             moves to the beginning of the editing field
Ctrl-<Right>            moves to the end of the editing field
<Ins> or Ctrl-V         puts you in insert mode: what you type gets
                           inserted  (normally, you are in overtype mode:
                           what you type overtypes the existing text);
                           pressing <Ins> or Ctrl-V again, puts you back
                           into overtype mode
<BACKSPACE>             deletes the character to the left of the cursor
<Del> or Ctrl-G         deletes the character on the cursor
Ctrl-Y                  deletes the rest of the editing field
<Up> or Ctrl-E          moves the cursor to the previous editing field
<Dn> or Ctrl-X          moves the cursor to the next editing field
Ctrl-Q                  quits and does not create the file
<End> or Ctrl-W         quits and creates the file
Ctrl-K                  moves back to the top of the previous page
Ctrl-L                  moves to the top of the next page
Ctrl-N                  inserts a line for a new field
Ctrl-T                  deletes the line describing a field
     Info supports four separate type of data files as follows:
√ Type 0 - The default type; can have up to 256 fields in SR-Info and up to 500 fields in VP-Info Professional.  Allows unlimited number of records in
VP-Info.  Not compatible with dBASE or early VP-Info and SR-Info versions.
√ Type 1 - Compatible with VP-Info and MAX Type 1 files.  (MAX is an earlier
versions of SR-Info and VP-Info Professional, also created by Sub Rosa Inc.)
Type 1 files can have up to 256 fields in SR-Info and up to 500 fields in
VP-Info Professional.
√ Type 2 - Compatible with dBASE II data files, and are limited to 32 fields.
√ Type 3 - Compatible with dBASE III, dBASE III+ and dBASE IV data files.  Type
3 files can have up to 256 fields in SR-Info and up to 500 fields in VP-Info
Professional, although dBASE III and dBASE III+ cannot read a data file with
more than 128 fields, and dBASE IV cannot read a data file with more than 255
fields.
     When all the fields are specified using the full-screen input display of
the CREATE command, the user is asked to specify which type of file to create;
the default is Type 3.
     If the data file already exists, you will be given the opportunity to
delete it.
.pa
CURSOR
Move the cursor to a given screen position.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ CURSOR <row>,<col>                                                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     CURSOR moves the current cursor position to a given point on the screen.
Combined with the ?? command, it gives the user all the absolute positioning
control of the @ SAY command without its restrictions.
     CURSOR is usually employed when the MENU( function is used, to place the
selection bar correctly.
.pa
DEBUG
Print expression or expression list for debugging purposes.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DEBUG <exp list>                                                   ║
     ║                                                                    ║
     ║ <exp list>   the expressions to be displayed                       ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command displays the expressions exactly as does the ? command.
However, if SET DEBUG OFF, the expressions are not displayed.  This may save
the programmer the trouble of having to place the DEBUG commands in the
program when debugging, and having to take them out for the regular running
of the program.
.pa
DELAY
Suspend execution for a specified number of seconds.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DELAY <num exp>                                                    ║
     ║                                                                    ║
     ║ <num exp>    the number of seconds execution is to be delayed      ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command suspends program execution for a specified number of seconds.
     The delay can be any length from .06 seconds upward. For programmers,
this command can replace complex loops which often have the deficiency of
varying in length depending on what type of computer the program is run on.
.pa
DELETE
Delete selected records from the selected data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DELETE [<scope>] [FOR <cond>]                                      ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>        select by scope (default scope: current record)     ║
     ║ FOR <cond>     select by condition                                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     The DELETE command is used to set the DELETED flag for records in the
selected data file.
     These records can be recovered by the RECALL command or with Ctrl-U in
the BROWSE and EDIT commands, provided SET DELETE is OFF.
     Deleted records are not "seen" by certain Info commands
irrespective of SET DELETE status, including: COPY, POST, UPDATE, SUM,
AVERAGE, COUNT.
     To remove all the records with the deleted flag set, use the PACK command.
.pa
DELETE FILE
Remove files from disk.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DELETE FILE <file>                                                 ║
     ║                                                                    ║
     ║ <file>      the name of the file to be deleted                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     The DELETE FILE command deletes a file from the disk.  This command
should be used with care because, once deleted, the file cannot be recovered.
If no extension is given, the extension DBF is assumed.  Wildcards are not
permitted.
.pa
DIM
Define a memory variable as a matrix.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DIM CHAR [<width>] <memvar>[x1,x2,x3],<memvar2>[y1,y2,y3],...      ║
     ║ DIM NUM <memvar>[x1,x2,x3],<memvar2>[y1,y2,y3],...                 ║
     ║ DIM LOG <memvar>[x1,x2,x3],<memvar2>[y1,y2,y3],...                 ║
     ║                                                                    ║
     ║ <memvar>, <memvar2>  the names of the memory variables that        ║
     ║                         are defined as matrixes                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <width>   the width of the character variables                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     Matrixes of up to 3 dimensions can be defined for each of the three data
types (CHARACTER, NUMERIC, LOGICAL).  The width of the entries of CHAR
matrixes is fixed; it is 10 if not specified by the user.
     Note that in the syntax description of DIM, [x1,x2,x3] does not indicate
an option.  [ and ] must be present in a DIM command.  x1, x2, x3 are integer
numbers greater than zero, not variables, up to three in number; at least one
must be specified.
     Matrix variables can be used just like all other memory variables except
that only = and STORE can assign values to them.  Commands and functions that
create memory variables (such as the command COUNT) or store values in
existing memory variables (such as the command READ or the function READ()
cannot directly use matrix variables. Matrix variables cannot be used in a
TEXT structure or TEXT file.
     Matrix variables are stored in high memory.  The size of a matrix is at
most 64K.  Use the STATUS command to find out how much high memory is
available.  Numeric variables take 8 bytes and logical variables take 2 bytes
of memory for each entry.
     Notes: The numbering is from 1.  Matrixes can be redimensioned in a
program.  No part of a DIM command can be a macro.
.pa
DIR
Directory listing.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DIR [<pathname>][<file specification>]                             ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <pathname>            DOS directory name, with optional drive      ║
     ║                          letter and colon                          ║
     ║ <file specification>  a file name, with optional DOS windcards;    ║
     ║                          extension is required if present          ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command is similar to the DIR command of the DOS operating system:
it displays the list of files on the current disk, together with file size
and date and time created or last modified.  Total size of all matching files
is also given along with the bytes remaining on the disk.
     If a file name is given in full, the directory will show only that one
file.
     A partial listing of the directory can be specified by giving a <file
specification> with wild card characters.
     The wild card character ? may be replaced by any single character; the
wild card character * allows any string.
.pa
DIRF
Directory listing, following redirection commands of the current FILES
structure.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DIRF [<file specification>]                                        ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <file specification>  a file name, with optional DOS windcards;    ║
     ║                          extension is required if present          ║
     ╚════════════════════════════════════════════════════════════════════╝
     Info provides for a FILES structure which lets you specify default drive
letters and/or directories for the various files used by the programs.
Usually file types are grouped into individual directories according to
"skeletons" constructed with wildcards.
     The DIRF command is similar to the DIR command, except that the file
specification is compared to the existing FILES structure and, if a match is
made, the redirection in the structure is applied to the file specification,
so that the directory displayed is of the redirected directory, not the
current directory.
     It displays a list of all matching files in that directory, together with
file size and date and time created or last modified.  Total size of all
matching files is also given along with the bytes remaining on the current
disk.
     If a file name is given in full, the directory will show only that one
file.  The wild card character ? may be replaced by any single character; the
wild card character * allows any string.
.pa
DISPLAY
Display information, memory variables, system variables, file structure.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DISPLAY [<scope>] [FOR <cond>] [<exp list>] [OFF]                  ║
     ║ DISPLAY FILES [LIKE <skeleton>] [ON <drive letter>]                ║
     ║ DISPLAY MEMORY                                                     ║
     ║ DISPLAY STRUCTURE                                                  ║
     ║ DISPLAY SYSTEM                                                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options (for displaying data file records):                        ║
     ║                                                                    ║
     ║ <scope>            select by scope (default: the current record)   ║
     ║ FOR <cond>         select by condition                             ║
     ║ OFF                do not display the record number                ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options (for listing directories):                                 ║
     ║                                                                    ║
     ║ LIKE <skeleton>    the file specification, with optional wildcards ║
     ║ ON <drive letter>  a drive designation, with optional colon        ║
     ╚════════════════════════════════════════════════════════════════════╝
     These commands are exactly the same as the LIST commands except for the
following differences: the default scope of the DISPLAY command is the current
record rather than the whole file; the listing is stopped at the bottom of the
screen or current window (about every 20 lines when displaying data file
contents).
.pa
DO
In a program, execute a subroutine and, on completion, return to the next
command in the calling program; in Conversational Info, equivalent to CHAIN.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DO <file>                                                          ║
     ║                                                                    ║
     ║ <file>   the name of the program called                            ║
     ╚════════════════════════════════════════════════════════════════════╝
     In Conversational Info, DO is the same as CHAIN: it begins the
execution of the compiled program with the name <file> with extension CPL;
otherwise, the uncompiled Info program <file> will be compiled "on
the fly" and executed, and the compiled file immediately deleted from the disk.
     Note that an uncompiled program with a GLOBAL statement cannot be
compiled on the fly if it needs to import variable values, since compile
step includes a CLEAR command.
     In a program, the command DO <file> causes the program <file> to be
compiled as a subroutine of the current program.  No matter how many
subroutines are called, all will be compiled into the same CPL file as the
calling program.  The subroutines become overlays; they are called into memory
when needed.
     When the called program executes a RETURN command, the execution resumes
in the current program with the line following the DO command.
     The called program can itself DO other subroutines.  There can be
subroutines up to 10 levels.
     The name of the PRG file used with the DO command cannot be a macro.
     When a subroutine is compiled, all information about data files and
memory variables is coded in the compiled form: the environment is compiled
with the subroutine.  Contrast this with the CHAIN command that starts with
a clean slate.
.pa
DO CASE
Switch the program flow to a number of cases.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DO CASE                                                            ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command DO CASE provides for the processing of a number of options
without the use of nested IF commands.  It is used in conjunction with the
CASE, OTHERWISE, and ENDCASE commands.
     The DO CASE program structure is as follows:
DO CASE
CASE <cond1>
   <program segment1>
CASE <cond2>
   <program segment2>
...
CASE <condn>
   <program segmentn>
OTHERWISE
   <program segment>
ENDCASE
where <cond1>, <cond2>, <cond3>,..., <condn> are conditions,  <program
segment1>, <program segment2>,..., <program segmentN> and <program segment>
are program segments, that is, any number of Info program lines.
     Execution is as follows:
     After the DO CASE is encountered, Info looks for the first CASE
command and evaluates the condition; if the condition is true, the following
program segment is executed, terminated by the next CASE, by OTHERWISE, or by
ENDCASE.  After the execution of the program segment, the program execution
continues with the program line after the ENDCASE command.
     If the condition is false, Info looks for the next CASE
command.  If no condition is true, Info executes the program segment
following the OTHERWISE command (if any).
     The OTHERWISE command is optional.  Note that if more than one condition
holds, only the segment after the first true condition is executed.
     DO case commands can be nested up to 10 levels.
     When editing with the internal Info programming editor, Alt-F reformats
the file with all structures properly indented, making it easy to see
unbalanced structures.
.pa
DO WHILE
The standard program loop command.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ DO WHILE <cond>                                                    ║
     ║                                                                    ║
     ║ <cond>      the condition controlling the loop                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command DO WHILE starts the program loop.  The structure of the loop
is as follows:
DO WHILE <cond>
   <program segment>
ENDDO
     Execution is as follows:
     After the DO WHILE is encountered, <cond> is evaluated.  If <cond> is
true, the Info program segment (terminated by the ENDDO) is
executed; then <cond> is evaluated again.  If <cond> is false, execution
continues with the command following ENDDO.
     There can be a DO WHILE command within a DO WHILE command; this is called
nesting.  Many level of nesting is permitted; however, too many levels of
nesting will give a compile-time error message: Stack overflow.
     There are two commands that facilitate moving to the top and the bottom
of the loop: LOOP moves the execution to the top of the loop, and BREAK exits
the loop.
     There is one more looping command in Info: REPEAT.
.pa
EDIT
Edit records in a data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ EDIT [<recnum>] [FIELDS <field list> / OFF / TEXT <textfile>]      ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options                                                            ║
     ║                                                                    ║
     ║ <recnum>              begin EDIT on record number <recnum>         ║
     ║ FIELDS <field list>   the fields to be edited                      ║
     ║ TEXT <textfile>       erases the screen, displays the text file,   ║
     ║                          and then does EDIT using the text file    ║
     ║                          layout and embedded format pictures       ║
     ╚════════════════════════════════════════════════════════════════════╝
     The EDIT command without either the OFF or TEXT option allows the user to
view and modify records in the selected file.  Once the command is given, the
screen shows the current record (or the record optionally specified with
<recnum>) in full-screen editing mode.
     If the FIELDS keyword and a fields list is specified, only those fields
will be available during EDIT; otherwise, Info builds an input
screen using all fields in the current data file.
     To exit from EDIT, use <End> (or Ctrl-W) once you have filled in the
fields of the last record desired.  To switch from EDIT to APPEND mode, press
Ctrl-<PgDn>, while <PgUp> switches back from APPEND into EDIT mode.
     Note that APPEND is actually a special mode of EDIT; the only difference
is that EDIT begins by displaying the current record, while APPEND adds a new
blank record to the data file and displays that. All the editing fields are
the same for both EDIT and APPEND.
     EDIT updates all index files in use.
     The command SET MENU ON displays the most important editing keys at the
top of the screen, except if OFF or TEXT keyword is used, or if the current
window is less than 80 characters wide or 10 rows deep.
     Editing keys:
<Left> or Ctrl-S        moves the cursor back one character
<Right> or Ctrl-D       moves the cursor forward one character
Ctrl-<Left>             moves to the beginning of the field
Ctrl-<Right>            moves to the end of the field
<Ins> or Ctrl-V         puts you in insert mode: what you type gets inserted
                            (normally, you are in overtype mode: what you type
                            overtypes the existing text); pressing <Ins> or
                            Ctrl-V again, puts you back into overtype mode
<BACKSPACE>             deletes the character to the left of the cursor
<Del> or Ctrl-G         deletes the character on the cursor
Ctrl-Y                  deletes the rest of the field
<Up> or Ctrl-E          moves the cursor to the previous field
<Dn> or Ctrl-X          moves the cursor to the next field
Ctrl-Q                  quits and does not update the current record
<End> or Ctrl-W         quits and updates the current record
<PgUp> or Ctrl-R        edits the previous record; if in APPEND mode, exits to
                           EDIT mode
<PgDn> or Ctrl-C        edits the next record
Ctrl-<Pg Dn>            Enters APPEND mode; adds a blank record and places the
                           cursor in that new record
Ctrl-K                  moves back to the top of the previous page (not with
                           OFF or TEXT keywords)
Ctrl-L                  moves to the top of the next page (not with
                           OFF or TEXT keywords)
.pa
EJECT
Start a new page on the printer.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ EJECT                                                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The EJECT command sends a form feed (eject page, top of form) signal to
the printer.
     This also resets the line and column counters to 0 for the @ commands.
     EJECT will attempt to advance the printer whether printing is on or off.
If your printer is on but off-line, your program may appear to hang; either
put the printer on-line, or turn off the printer to release Info to
continue processing.
.pa
ELSE
The optional part of an IF program structure.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ELSE                                                               ║
     ╚════════════════════════════════════════════════════════════════════╝
.pa
END commands
Terminate a command structure.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ENDCASE                                                            ║
     ║ ENDDO                                                              ║
     ║ ENDIF                                                              ║
     ║ ENDFILES                                                           ║
     ║ ENDON                                                              ║
     ║ ENDPROCEDURE                                                       ║
     ║ ENDREPEAT                                                          ║
     ║ ENDTEXT                                                            ║
     ╚════════════════════════════════════════════════════════════════════╝
     All Info structures are terminated with a matching END command
as shown above.  When editing with the internal Info programming
editor, Alt-F reformats the file with all structures properly indented,
making it easy to see unbalanced structures.
.pa
ERASE
Erase screen.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ERASE [line1,line2]                                                ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ line1, line2   erase from line1 to line2                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command erases the screen, and is a synonym for CLS.
     If, optionally, two numeric expressions, line1 and line2, are given, it
erases line1 and line2, and all lines between, if any.  These expressions
should have values between 0 and 24.
.pa
FIELD
Initiates a program segment module in an ON FIELD structure
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FIELD <fieldname>/<fieldnum>                                       ║
     ║                                                                    ║
     ║ fieldname       name of a field in a Get Table                     ║
     ║ fieldnum        number of a field in a Get Table                   ║
     ╚════════════════════════════════════════════════════════════════════╝
     Each field in a Get Table may have a program segment in a program's ON
FIELD structure which will be executed when the cursor leaves that field, or
optionally when READ or the current record is exited.
.pa
FILES
Lets you specify drive letters, directories, and/or default file modes for
various files used by Info.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FILES                                                              ║
     ║ FILES <specification> [,[<file direction>]                         ║
     ║                                                                    ║
     ║ specification    any file name or "skeleton" (using the * and ?    ║
     ║                    wildcards                                       ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ file direction   any legal DOS path, consisting of drive letter    ║
     ║                    and colon and/or directory path                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     There is always a FILES Table in memory, set up by the active FILES ...
ENDFILES structure.  (This table is empty if there is no active FILES ...
ENDFILES structure.)  The FILES command allows on-the-fly additions and
changes to the FILES Table from either Conversational Info or programs.
     Macros are allowed with the FILES command itself, either in programs or
in Conversational Info, although macros are not permitted in the FILES
... ENDFILES structure.
.pa
FILES ... ENDFILES
Lets you specify drive letters, directories, and/or default file modes for
various files used by Info.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FILES                                                              ║
     ║ <specification> [,[<file direction>]                               ║
     ║ ENDFILES                                                           ║
     ║                                                                    ║
     ║ specification    any file name or "skeleton" (using the * and ?    ║
     ║                    wildcards); must not be indented                ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ file direction   any legal DOS path, consisting of drive letter    ║
     ║                    and colon and/or directory path                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     (Programs and CNF file only)  There is always a FILES Table in memory,
set up by the active FILES ... ENDFILES structure.  (This table is empty if
there is no active FILES ... ENDFILES structure.)
     A FILES ... ENDFILES structure may be created in a program at any time,
and may have any number of specification lines between the FILES and ENDFILES
lines.  All existing entries are immediately cleared and a new FILES Table
constructed.
     No macros are permitted in the FILES ... ENDFILES structure, although
macros are allowed with the FILES command itself, either in programs or in
Conversational Info.
     Caution: There is no way to add a comment inside a FILES ... ENDFILES
structure, and no line should be indented.  The contents of FILES ... ENDFILES
structures are not affected by the reformatting facility Alt-F of the WRITE
command.
.pa
FILES LIST
Display the current contents of the FILES ... ENDFILES structure
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FILES LIST                                                         ║
     ╚════════════════════════════════════════════════════════════════════╝
     The current FILES ... ENDFILES structure are displayed with this command.
.pa
FIND
Find a record by its index in the selected data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FIND <string>                                                      ║
     ╚════════════════════════════════════════════════════════════════════╝
     FIND is one of a family of commands that finds a record in an indexed
data file by matching a given string with key values in the index file.
     In Conversational Info, just type FIND and the key. If <string> evaluates
the same for two records, the second record will never be found with FIND.
     If SET DELETE ON, deleted records will not be found.
     Numbers must always be treated as strings, even if the key expression is
a numeric field.  If NUM is a numeric field of width 2, FIND 1 will not find
1, but FIND &STR(1,2) or FIND &' 1' will work.
     For the users' convenience, Conversational Info converts all
command lines to upper case before execution.
     If FIND is successful, the value of the current record pointer (as shown
by the # and RECNO( functions) is set to the current record number, and the
system variable :NEAR is set to the same number.
     If the record is not found, the current record pointer will be set to 0
and the value of :NEAR will be set to the number of the first record in the
index with a key greater than the FIND string; if the index contains no key
greater than the FIND string, :NEAR is set to the bottom of file, and EOF is
set to T (true).
     The command for "if not found" is:
IF #=0  or
IF RECNO()=0
     In Conversational Info or in programs with SET TALK ON,
Info sends the message "NO FIND" when a search is unsuccessful.
     Notes applicable to FIND, SEEK, LAST and NEAREST:
1.  FIND only works on the active index of the selected data file. If that
index was created with a selection condition, some records may be excluded
from the index.
2.  With SET EXACT ON, only exact matches are found. The FIND string must be
the same length as the index key, and match exactly; if SET EXACT OFF, the
find string may be shorter.
3.  An index may be made insensitive to capitalization by using the uppercase
functions !( or UPPER( in index creation.  This makes use of the FIND command
much easier in Conversational Info.
4.  The macro symbol (&) has a wider definition when used with FIND, LAST,
NEAREST and SEEK than with other Info command.  With this group of
commands only, it alerts Info that the string expression following
is to be evaluated and used as the FIND string.  (Macros in all other commands
are limited to fields and variables; dimensioned variables, functions and
concatenation are not allowed.)
.pa
FLUSH
Update the selected data file on the disk.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ FLUSH                                                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The current record of the selected data file is updated on the disk.
This may prevent accidental loss of data due to power failure.
     This command updates only the selected data file; it does not update other data files in use, nor does it safeguard index files, text files, or DOS files. After a power failure it may be necessary to reindex the selected file.
.pa
GLOBAL
Declare global variables.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ GLOBAL <memvar list>                                               ║
     ║                                                                    ║
     ║ <memvar list>  the list of memory variables to be declared global  ║
     ╚════════════════════════════════════════════════════════════════════╝
     When a program is chained to another program, all the variables that were
defined as global by the GLOBAL command will be passed to the new program.
     The GLOBAL command should be the first command of any program.  It should
definitely precede any command that involves a memory variable.
     There can be only one GLOBAL command in a program.  No part of the GLOBAL
command can be a macro.  A matrix variable cannot occur in a GLOBAL command.
.pa
GO
Set current record pointer to new value.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ <num const>                                                        ║
     ║ GO <num exp>                                                       ║
     ║ GOTO <num exp>                                                     ║
     ║ GO RECORD <num exp>                                                ║
     ║ GOTO RECORD <num exp>                                              ║
     ║ GO TOP                                                             ║
     ║ GOTO TOP                                                           ║
     ║ GO BOTTOM                                                          ║
     ║ GOTO BOTTOM                                                        ║
     ║                                                                    ║
     ║ <num exp>/<num const>   the number to be assigned to #             ║
     ╚════════════════════════════════════════════════════════════════════╝
     The commands GO and GOTO are identical.  They assign a new value to #,
the current record pointer.  The data file is repositioned to the record with
the new record number.
     If the selected file is indexed, the index is adjusted accordingly.
     GO TOP, GOTO TOP and GO BOTTOM, GOTO BOTTOM are used to position the
current record pointer to the top and bottom of the current data file.  If
there is no index in use, the TOP is Record 1, and BOTTOM is the last record.
If an index is in use, then the TOP and BOTTOM are the first and last records
according to the index.
.pa
GOTO
Set current record pointer to new value.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ <num const>                                                        ║
     ║ GO <num exp>                                                       ║
     ║ GOTO <num exp>                                                     ║
     ║ GO RECORD <num exp>                                                ║
     ║ GOTO RECORD <num exp>                                              ║
     ║ GO TOP                                                             ║
     ║ GOTO TOP                                                           ║
     ║ GO BOTTOM                                                          ║
     ║ GOTO BOTTOM                                                        ║
     ║                                                                    ║
     ║ <num exp>/<num const>   the number to be assigned to #             ║
     ╚════════════════════════════════════════════════════════════════════╝
     The commands GO and GOTO are identical.  They assign a new value to #,
the current record pointer  The data file is repositioned to the record with
the new record number.
     If the selected file is indexed, the index is adjusted accordingly.
     GO TOP, GOTO TOP and GO BOTTOM, GOTO BOTTOM are used to position the
current record pointer to the top and bottom of the current data file.  If
there is no index in use, the TOP is Record 1, and BOTTOM is the last record.
If an index is in use, then the TOP and BOTTOM are the first and last records
according to the index.
.pa
HELP
Request for information on Info commands and related topics.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ HELP [<string>]                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <string>   the topic for which help is wanted                      ║
     ╚════════════════════════════════════════════════════════════════════╝
     The HELP command provides information on the syntax (format rules) and
use of the commands of Info, and some related topics; it is available
only in Conversational Info.
     The command
1>HELP
displays all the topics for which HELP is available.  Or type HELP and the
topic description.
     The text is contained in the file SRI.HLP or VPI.HLP, which must
be in the same directory as your version's MSG file, either in the current
directory or on the DOS path.  If the file is not found, Info will
so advise the user.
.pa
IF
Conditional execution of Info program segment.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ IF <cond>                                                          ║
     ║                                                                    ║
     ║ <cond>     the condition to be evaluated; if true, segment is      ║
     ║            executed                                                ║
     ╚════════════════════════════════════════════════════════════════════╝
     The IF command allows conditional execution of a program segment.  The
general form of this command is:
IF <cond>
   <program segment>
[ELSE
   <ELSE program segment>]
ENDIF
     This works as follows: When the IF command is found, the condition <cond>
is evaluated.  If <cond> is true, the <program segment> (a number of program
lines) is executed.  The end of the <program segment> is at the ELSE or at the
ENDIF (whichever comes first).
     If <cond> is false, Info looks for ELSE.  If ELSE is found, the
<ELSE program segment> is executed.
     The execution continues with the program line following the ENDIF.
     Note that ELSE is optional.
     There can be an IF command within an IF command; this is called nesting.
Many level of nesting is permitted; however, too many levels of nesting will
give a compile-time error message: Stack overflow.
     Care should be taken to nest the IF commands properly in a DO WHILE, DO
CASE, or REPEAT program structure.  When editing with the internal
Info programming editor, Alt-F reformats the file with all structures properly
indented, making it easy to see unbalanced structures.
     IF may not take a macro.  Since a line with a macro is not compiled until
runtime, Info will be unable to handle nesting properly if a macro
is used, resulting in the error message "ENDIF implies IF" or "ELSE implies
IF."
.pa
INDEX
Create an index file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ INDEX ON <str exp> TO <file> [FOR <cond>]                          ║
     ║                                                                    ║
     ║ <str exp>  the expression providing the key                        ║
     ║ <file>     the name of the index file                              ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ FOR <cond> a selction; only records for which <cond> is true are   ║
     ║               included in the index.                               ║
     ╚════════════════════════════════════════════════════════════════════╝
     The INDEX command creates an index file.  Index files are used:
1.   To organize records into an apparent order according to some key for
listing, reporting, browsing, editing, etc.
2.   To locate records quickly using the FIND, POST and UPDATE commands.  Each
key must have a separate index file.
3.   To make the file act as though it had only records matching a given
selection condition and had an apparent order according to some key.
     The expression <str exp> must evaluate to a string of length at most 60;
otherwise, an error message is sent.  In addition, the condition itself must be no more than 100 characters long.
     (Do not use COMP for the first four letters of an index file;
Info is unable to open such a file.)
     Once an index file exists, the data file can be opened for use with the
index file; see the USE <data file> INDEX <index file> command.  The commands:
APPEND, BROWSE, CHANGE, EDIT, REPLACE, READ automatically update the index
files in use.  There can be many index files in use; all are updated by these
commands, but only one index file works with FIND.
     If SET TALK ON, INDEX will output progress reports showing the completion
of each 100 records, and the total number of records indexed.  Large files
create temporary files which are then merged to create the ultimate index.
     Index expressions should be of type string, but a numeric field (not a
numeric expression) can also be used.  If you wish to index on a numeric
expression, use the key STR(<num exp>) or PIC(<num exp>, <format)) to convert
the values to strings.
     It is often helpful to use the upper-case functions, !( or UPPER(, for
string expression that mix upper-case letters and lower-case letters, such as
names, addresses, and so on.  This way, the data is arranged in alphabetical
order instead of the ASCII code order which is often confusing.
     See also the REINDEX command.
.pa
INPUT
Input request for data of any type.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ INPUT ['<string>'] TO <memvar>                                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ '<string>'     prompt message                                      ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command INPUT is used to enter string, numeric, or logical data into
a memory variable, <memvar>.  It works the same way as the command ACCEPT,
except that string input needs quotation marks.
     The type of the <memvar> is determined as follows:
     If the data typed in is in quotation marks, it is a string; <memvar> is
of character type.
     If the data is a number, <memvar> is of numeric type.
     If the data is Y, y, N, n, T, t, F, or f, <memvar> is of logical type.
     The optional character string is used as a prompt.  A character
expression cannot be used, but a macro is permitted, provided the macro expression includes quotation marks.
     ACCEPT is the preferred way to enter strings, since ACCEPT does not
require quotation marks as delimiters.
     <memvar> cannot be a matrix variable.
.pa
LIMIT
Limit the records available within the current master index to those matching
all or part of the current record's index key.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LIMIT <num exp>                                                    ║
     ║ LIMIT <key exp>                                                    ║
     ║ LIMIT                                                              ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <num exp>    the number of characters in the key expression of     ║
     ║                 the current master index                           ║
     ║ <key exp>    the string expression to match in the current master  ║
     ║                 index                                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     When the current file has an index, Info can be made to treat
the file as though it includes only those records matching the current
record's key expression, or some leftmost part of it.  When a LIMIT is in
effect, no Info command can access a record outside that limit.
     You can most quickly implement this command by using the <num exp>
option.  The effect is to have Info set the LIMIT to the leftmost <num exp>
characters of the key expression of the master index.
     If <num exp> exceeds the length of the key, the effect is identical to
setting the LIMIT to the entire index expression.  (Maximum index-key length
is 60 characters.)
     When LIMIT is used with no option, or when <num exp> is zero, the limit
is deactivated.
     Using LIMIT with <key exp> requires precision in its use to avoid
problems that may become extremely serious. Note that the <key exp> expression
must be the same as the master index key in use at the moment, or some LEFT(
portion of it. Do not attempt to use an expression that does not meet this
requirement.
Cautions:
1.  FIND should not be used on a file with an active limit.  If you choose to
do so, be certain that the FIND will be successful.  An unsuccessful FIND
places the record pointer on record 0 which is by definition not in the index.
This causes an error, suspends operation of a program, and turns off the LIMIT.
2.  Do not use REPLACE ALL on a field included in an active limit expression,
since upon completion, no records will be included in the limit; the result is
the same as above.
3.  Do not use APPEND, APPEND BLANK or BROWSE APPEND, or enter "append mode"
in EDIT, while a limit is active unless you are sure to make all new records
equal to the current LIMIT key before leaving the new records.  Doing so
causes the record pointer to move outside the LIMIT; the result is the same
as above.
4.  LIMIT should be used with extreme care, and left in effect for the minimum
number of commands possible.  For instance, if used with BROWSE, LIMIT should
be invoked immediately before the BROWSE command and canceled immediately
afterward.
5.  LIMIT is automatically canceled when the index or the file with which it
is active is closed, or the master index is changed with SET INDEX TO n.
6.  LIMIT cannot be used with a string constant instead of a <key exp>.  The
<key exp> can be implemented with a macro.
.pa
LIST
List expressions from selected records.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LIST [<scope>] [FOR <cond>] [<exp list>] [OFF]                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>        select by scope (default scope: ALL)                ║
     ║ FOR <cond>     select by condition                                 ║
     ║ <exp list>     items to list                                       ║
     ║ OFF            do not print the record numbers                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command lists the whole selected data file (including the records
flagged as DELETED, unless the command SET DELETE ON is given).  If the data
file is indexed, the listing is by the indexed order.
     The records to be listed can be selected by scope and/or by a condition.
To list only selected fields of the records, use an expression list.
.pa
LIST FILES
List files from the directory.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LIST FILES [LIKE <file format>] [ON <drive letter>]                ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ LIKE <file format>   limit to those files matching the file format ║
     ║                         specification (default .DBF)               ║
     ║ ON <drive letter>    show only files on named disk (colon optional)║
     ╚════════════════════════════════════════════════════════════════════╝
.pa
LIST MEMORY
List the memory variables.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LIST MEMORY                                                        ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command LIST MEMORY displays a listing of all non-matrix memory
variables and their contents, and a separate listing of the matrix variables
and their dimensions.
.pa
LIST STRUCTURE
List the structure of the selected file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LIST STRUCTURE                                                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command LIST STRUCTURE displays the structure of the selected data
file.
.pa
LIST SYSTEM
List the function key definitions and system variables.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LIST SYSTEM                                                        ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command LIST SYSTEM displays the current contents of the 10 function
keys and system variables.
     Example:
1>LIST SYST
Name          Type    Width    Contents
:F1             C       5      HELP
:F2             C      10      LIST STRU;
:F3             C       6      WRITE
:F4             C      10      LIST MEMO;
:F5             C       7      BROWSE;
:F6             C       5      STAT;
:F7             C      12      ^wCONT;EDIT;
:F8             C      11      LOCATE FOR
:F9             C       5      FIND
:F10            C       5      EDIT;
:TIME           C       8      22:53:43
:DATE           C      24      Thursday, March 19, 1991
:VERSION        C       4      520
:SERIAL         C      10      5208796982
:COMPANY        C      34      Sub Rosa Publishing Inc.
:PICTURE        C      10      9999999.99
:TITLE          C       1
:UNDOC          C       1
:KEY            N       8      13
:AVAIL          N       8      0
:FIELD          N       8      0
:ERROR          N       8      0
:MESSAGE        C       1
:RETRY          N       8      25
:USER           N       8      1
:DIR            C      11      C:\VPI
:NEAR           N       8      0
:COLOR          N       8      48
** Total ** 28  variables... 244  bytes
.pa
LOCATE
Search for a record that satisfies the condition.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LOCATE [<scope>] FOR <cond>                                        ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <scope>   search only within the scope (default scope: ALL)        ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command LOCATE searches for records by a condition.  This command
works quicker if there is no index file.
     If a match is found with SET TALK ON,
Record n
informs the user of the record number (n).
     The LOCATE command line cannot be more than 128 characters.  The keyword
FOR cannot be in a macro.
     The CONTINUE command continues the search after the current record using
the condition of the last LOCATE.
     Normally, the selected file should not be indexed.  The command LOCATE
executes several time slower in an indexed file.  If an index file is in
use, the search will take place in the indexed order.
     The preferred way to locate a record in an indexed file is with the FIND
command.
     With the default scope ALL, LOCATE starts at the top of file and scans
either until the first record matching the condition is found, or the end of
file is reached; an unsuccessful LOCATE sets the EOF flag to T (true).
     You can use an alternate scope, NEXT or WHILE, to have LOCATE begin with
the record after the current record.  Unlike all other uses of scope in
Info, however, LOCATE does not require anything other than the
keyword to make the scope act in this way.
.pa
LOOP
Jump to the top of the DO WHILE loop.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ LOOP                                                               ║
     ╚════════════════════════════════════════════════════════════════════╝
     When the LOOP command is found in a DO WHILE <cond> loop, program
execution jumps to the top of loop (evaluates the condition).
.pa
MAX
Scan selected records for the highest values of one or more numeric
expressions.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ MAX [<scope>] <num exp list> [TO <memvar list>] [FOR <cond>]       ║
     ║                                                                    ║
     ║ <num exp list>    the numeric expressions to sum                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>           select by scope (default scope: ALL)             ║
     ║ <memvar list>     store the results in these memory variables      ║
     ║ FOR <cond>        select by condition                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command MAX evaluates numeric expressions for selected records of the
selected data file, determining the highest value encountered for each
expression.  Up to 10 expressions can be scanned with one command.
     Optionally, the results can be stored in numeric memory variables; the
expression list and the numeric memory variable list must have the same number
of entries.  <memvar list> cannot contain numeric matrix variables.
     Records flagged as DELETED are not scanned.
.pa
MIN
Scan selected records for the lowest values of one or more numeric expressions.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ MIN [<scope>] <num exp list> [TO <memvar list>] [FOR <cond>]       ║
     ║                                                                    ║
     ║ <num exp list>    the numeric expressions to sum                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>           select by scope (default scope: ALL)             ║
     ║ <memvar list>     store the results in these memory variables      ║
     ║ FOR <cond>        select by condition                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command MIN evaluates numeric expressions for selected records of the
selected data file, determining the lowest value encountered for each
expression.  Up to 10 expressions can be scanned with one command.
     Optionally, the results can be stored in numeric memory variables; the
expression list and the numeric memory variable list must have the same number
of entries.  <memvar list> cannot contain numeric matrix variables.
     Records flagged as DELETED are not scanned.
.pa
MODIFY
Modify the structure of a data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ MODIFY [STRUCTURE]                                                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command MODIFY (or MODIFY STRUCTURE) modifies the structure of the
selected file.  The display is the same as in CREATE, the keys retain their
meaning.  Each field is represented by four editing fields.
     All records in the file will be automatically appended.  If any types or
names are changed, the contents of the affected fields will be lost.
Restrictions:
1.   Do not use MODIFY in a program
2.   Do not use MODIFY merely to change the name of a field.  Fields may be
renamed instantaneously with the RENAME FIELD command.
     Editing keys:
<Left> or Ctrl-S        moves the cursor back one character
<Right> or Ctrl-D       moves the cursor forward one character
Ctrl-<Left>             moves to the beginning of the editing field
Ctrl-<Right>            moves to the end of the editing field
<Ins> or Ctrl-V         puts you in insert mode: what you type gets inserted
                           (normally, you are in overtype mode: what you type
                           overtypes the existing text); pressing <Ins> or
                           Ctrl-V again, puts you back into overtype mode
<BACKSPACE>             deletes the character to the left of the cursor
<Del> or Ctrl-G         deletes the character on the cursor
Ctrl-Y                  deletes the rest of the editing field
<Up> or Ctrl-E          moves the cursor to the previous editing field
<Dn> or Ctrl-X          moves the cursor to the next editing field
Ctrl-Q                  quits and does not modify the file
<End> or Ctrl-W         quits and modifies the file
Ctrl-K                  moves back to the top of the previous page
Ctrl-L                  moves to the top of the next page
Ctrl-N                  inserts a new line
Ctrl-T                  deletes the line
     To be safe, make a back up copy of the file to be modified before the
MODIFY command is given.  After the MODIFY, the new fields will be blank, the
deleted fields disappear.  All deleted records will also be lost.
     If <Esc> or Ctrl-Q is pressed at any time in MODIFY before the appending
of records is completed, MODIFY will be aborted and the data file closed.  No
changes already made will be saved.
     Changing the characteristics of a field (say the width) effects the field
the same way as in APPEND FROM.
.pa
NOTE
Add notes to Info programs.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ NOTE [<string>]                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <string>   any text line: the comment                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     This is the same as the command *.  Any Info command line that starts
with NOTE is ignored by Info.
     Notes can also be added with semicolon(;) to any Info command
line.
.pa
NOUPDATE
Do not write changes made to the current record back to the disk.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ NOUPDATE                                                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     Whenever a change is made to the current record in an open data file,
leaving the record or closing the file causes the changes to be written to the
disk.  This automatic action can be overridden by the NOUPDATE command, which
tells Info to ignore the changes.
     This is essentially what happens when Ctrl-Q is pressed during EDIT and
BROWSE.
.pa
ON ERROR
Tell Info what to do if an error is encountered during program execution.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ON ERROR                                                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command ON ERROR starts the ON ERROR/ENDON structure.  There can be
any program segment between ON ERROR and ENDON, except that no data files
should be opened or closed, and no new variables created or released.  This
program segment is executed whenever the program encounters an error.
     The ON ERROR is in effect in the program from the point where it is
located.  It remains in effect until another ON ERROR structure is found, or
until execution leaves the current module, either on a RETURN or DO command.
     ON ERROR has no effect within a subroutine called by the DO command; if
the subroutine needs the same ON ERROR structure, repeat the structure in the
subroutine.
     Since the ON ERROR structure has no effect after returning to a calling
program from a subroutine, you should consider putting this structure
(possibly together with the ON ESCAPE structure) into a procedure that is
performed at the beginning of the program, and after every DO command.
     ON ERROR should normally include a RETURN, CHAIN, CANCEL, or QUIT command
to allow execution to leave the current program.  Do not RETURN from a main
return, or CHAIN from a subroutine.
     When editing with the internal Info programming editor, Alt-F reformats
the file with all structures properly indented, making it easy to see
unbalanced structures.
.pa
ON ESCAPE
Tell Info what to do if the user presses <Esc>.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ON ESCAPE                                                          ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command ON ESCAPE starts the ON ESCAPE/ENDON structure.  There can be
any program segment between ON ESCAPE and ENDON, except that no data files
should be opened or closed, and no new variables created or released.  This
program segment is executed whenever the user presses <Esc>.
     The ON ESCAPE is in effect in the program from the point where it is
located.  It remains in effect until another ON ESCAPE structure is found, or
until execution leaves the current module, either on a RETURN or DO command.
     ON ESCAPE has no effect within a subroutine called by the DO command; if
the subroutine needs the same ON ESCAPE structure, repeat the structure in the
subroutine.
     Since the ON ESCAPE structure has no effect after returning to a calling
program from a subroutine, you should consider putting this structure
(possibly together with the ON ERROR structure) into a procedure that is
performed at the beginning of the program, and after every DO command.
     ON ESCAPE should normally include a RETURN, CHAIN, CANCEL, or QUIT command
to allow execution to leave the current program.
     When editing with the internal Info programming editor, Alt-F reformats
the file with all structures properly indented, making it easy to see
unbalanced structures.
.pa
ON FIELD
Control the processing of data input during execution of the full-screen
editing commands: READ, EDIT, APPEND, and BROWSE.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ON FIELD                                                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command ON FIELD starts the ON FIELD/ENDON structure.  There can be
any program segment between ON FIELD and ENDON, except that no data files
should be opened or closed, and no new variables created or released.
     Inside the ON FIELD structure is a number of FIELD statements, each
telling Info what to do when the user leaves a specific field,
enters a new record, or leaves the record.  There can be one FIELD statement
for each input field in a Get Table, in addition to the two FIELD statements
controlling entry and exit from READ (or the current record in EDIT and
BROWSE).
      (Note that the term editing field does not refer in this case only to
fields, but to the on-screen area where you're expected to enter or edit data;
an editing field may be a "window into" a data-file field, a memory variable,
or a system variable.  An element in a matrix cannot be accessed with the
full-screen editing commands, so cannot be tied to an editing field.)
     ON FIELD is used primarily for the following three functions:
1.  To verify data input.  If the value entered does not meet a condition, the
cursor can be directed back to the current field with the
:FIELD=FIELD(fieldname) command.
2.  To do data lookups from the selected or other files.
3.  To change the order in which the cursor goes to the next field.
     The form of the ON FIELD structure:
ON FIELD
FIELD 0
   <initiating command sequence>   ;The FIELD 0 code is executed when READ is
entered or whenever a new record is entered in BROWSE OFF, EDIT OFF, etc.
Field 1
   <command sequence 1>            ;The FIELD 1 code is executed when the
cursor leaves the first editing field (and again when the current record is
exited provided SET EXECUTE ON).
Field 2
   <command sequence 2>            ;The FIELD 2 code is executed when the
cursor leaves the second editing field (and again when the current record is
exited provided SET EXECUTE ON).
Field <n>
   <command sequence <n>>          ;The FIELD <n> code is executed when the
cursor leaves the nth (final) editing field (and again when the current record
is exited provided SET EXECUTE ON).
Field 65
   <command sequence 65>           ;The FIELD 1 code is executed when the
cursor leaves READ or when the current record is exited in BROWSE OFF, EDIT
OFF, etc.
ENDON
     Fields 1 through 64 may be referenced either by number of by the name of
the field or variable being edited.  Names are usually more understandable and
always more flexible, since a field can later be added or omitted without
having to renumber the entire ON FIELD structure.
     You can force Info to execute the entire set of FIELD commands
from 1 through 64 by SET EXECUTION ON.  The default is OFF.  Do not use ON if
there is a possibility of creating an endless loop which doesn't allow a
graceful exit.
     The Get Table is usually canceled as soon as execution leaves the current
program, even when just executing a subroutine with the DO command.  You can
SET GET ON to maintain the Get Table, provided it is not cleared in the sub-
program.  (A Get Table is cleared either with the CLEAR GETS command, or by
creating a GET with TEXT or an @ GET command after a READ command.)  The
default is SET GET OFF.
     When editing with the internal Info programming editor, Alt-F reformats
the file with all structures properly indented, making it easy to see
unbalanced structures.
     Note the placement of the three elements: the TEXT with its input macro
and the ON FIELD come before the READ or other full-screen editing command,
and are usually outside the DO WHILE loop unless the screen is rewritten
elsewhere inside the loop.
.pa
OTHERWISE
Introduce the optional clause in a DO CASE program structure.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ OTHERWISE                                                          ║
     ╚════════════════════════════════════════════════════════════════════╝
     In a DO CASE program structure, if no condition is true, Info
executes the program segment following the OTHERWISE command, if any.
Only one OTHERWISE command is permitted within any DO CASE structure; it
is equivalent to CASE t (true).
.pa
PACK
Remove deleted records from the selected file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ PACK [TRUNCATE]                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ TRUNCATE   reduce the DOS size of the file                         ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command removes records that have been marked for deletion by the
DELETE command or the Ctrl-U of the EDIT and BROWSE commands.
     All the index files in use are automatically reindexed after PACK.
     Make sure you have a back up copy of the file before packing it.  If PACK
is interrupted, the file may be corrupt or contain duplicate records.
     PACK does not release disk space unless the TRUNCATE option is used. If a
file frequently gets large, has many records deleted and then grows again, it
may be more efficient to PACK without TRUNCATE, so that DOS is not constantly
adding disk clusters and recovering them again.
.pa
PERFORM
Execute a procedure.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ PERFORM <procedure>                                                ║
     ║                                                                    ║
     ║ <procedure>      the name of the procedure                         ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command PERFORM is used to execute a procedure, <procedure>, defined
in the current program; <procedure> cannot be a macro.  The procedure is
defined with the PROCEDURE command.
     The procedure is compiled where it is first called with PERFORM.  If the
procedure makes references to fields, the structure and order of the files in
use must be the same any time the procedure is used.  The same comment also
applies to memory variables.  Normally, procedures perform tasks that are
independent of the environment (files in use and memory variables) or they are
always invoked in the same environment.
     If you need the same procedure in different environments, write the
procedure as a separate program, and invoke it as a subroutine with the DO
command.
     Performing procedures is a very fast way of executing the same program
segment from many places in the program.  The procedures themselves must be at
the end of the program.
.pa
POST
Post the FROM (transaction) file to the POSTING file (selected file with
index).
     ╔════════════════════════════════════════════════════════════════════╗
     ║ POST ON <str exp> FROM <file> [FIELDS <mixed field list>] [<scope>]║
     ║      [FOR <cond>]                                                  ║
     ║                                                                    ║
     ║ <str exp>   the expression that is the key for finding the records ║
     ║                in the FROM file                                    ║
     ║ <file>      the FROM file                                          ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ FIELDS <mixed field list>  the fields to be totalled in the        ║
     ║                       FROM file and added to the fields            ║
     ║                       in the POSTING file (the selected file);     ║
     ║                       <field> WITH <num exp> can add an expression ║
     ║ <scope>            selection restricted by scope                   ║
     ║                       (default scope: ALL)                         ║
     ║ FOR <cond>         selection restricted by <cond>                  ║
     ╚════════════════════════════════════════════════════════════════════╝
     The selected file, called the POSTING file, must be indexed by <str exp>,
an expression formed from fields of the FROM file, called the FROM file, and
constants and memory variables.
     This procedure takes all the appropriate records (that is, the first
record satisfying the <cond> and within the scope) of the FROM file, one at a
time.  It picks the first appropriate record, and evaluates <str exp> in the
FROM file.  Next it finds the matching record in the POSTING file.  If the
find is not successful, an error message POST ERROR" is sent.
     If the find is successful, the procedure posts.  Posting consists of one
of two actions, depending on whether a field name is listed alone in the mixed
field list, or if a field name has a WITH clause attached.
1.  If the field is named alone, the value of that field in the FROM file is
added to the value already in the POSTING file.; that is, it adds the fields
in the <field list> of the current record of the FROM file to the fields of
the same name in the current record of the POSTING file.
2.  In a mixed field list, the clause <field> WITH <num exp> allows adding any
numeric expression <field> to the field in the POSTING file.  <num exp> is
formed using the fields of the FROM file, and optionally fields from other
files (including the POSTING file), variables, and constants.
     If a find is unsuccessful and SET ADD ON, a record will be appended
to the POSTING file, the non-numeric fields of the POSTING file record will
be replaced by the matching fields in the FROM file record, and, finally,
the procedure posts as above.
     The procedure continues with the next appropriate record of the FROM file.
     If there is no FIELDS clause, POST simply checks whether there is a
record in the POSTING file for each value of <str exp> in the FROM file.  This is valuable to check whether every record in the FROM file has a matching record in the POSTING file without changing any fields.
     If SET PRINT OFF (the default), the error messages appear on the screen;
otherwise, they are echoed to (printed on) the printer (or to the alternate
text file, if SET ALTERNATE ON).
     Deleted records are not posted, irrespective of SET DELETED.
.pa
PROCEDURE
Procedure (subroutine) definition.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ PROCEDURE <procedure>                                              ║
     ║                                                                    ║
     ║ <procedure>   the name of the procedure                            ║
     ╚════════════════════════════════════════════════════════════════════╝
     The PROCEDURE command indicates the start of a procedure definition, the
ENDPROCEDURE command indicates the end of the procedure:
PROCEDURE <procedure>
  <program segment>
ENDPROCEDURE
     Procedures should be used for all Info program segments that
are used more than once in a program.  However, if the procedure makes
references to fields, the structure and order of the files in use must be the
same any time the procedure is used.  The same comment also applies to memory
variables.  Normally, procedures perform tasks that are independent of the
environment (files in use and memory variables) or they are always invoked in
the same environment.
     If the whole program will not fit in memory, then replace the procedures
by subroutines invoked by the DO command.
     The procedure name <procedure> follows the same rules as variable names;
<procedure> cannot be a macro.   Procedures must be placed at
the end of the program.  A procedure can perform other procedures.
     A procedure is compiled at the first PERFORM invoking it.
.pa
QUIT
Leave Info.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ QUIT [<errorlevel>]                                                ║
     ║                                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║ <errorlevel>    a value passed to DOS, which allows batch files    ║
     ║                   to control their execution with the              ║
     ║                   IF ERRORLEVEL command                            ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command QUIT exits from Info.  It closes all the files and
gives you the prompt of the operating system.
     If Info is running unattended in a batch file, a program can
pass an "errorlevel" to DOS indicating if some condition was encountered
during execution.  For instance, if there is an error reading a data file, you can QUIT to DOS with an errorlevel of 1, which the batch file can detect so that the tape backup is not run.  The command in this case wound be QUIT 1. Consult your DOS reference manual for the IF ERRORLEVEL batch program command.
.pa
READ
Enter full-screen editing and data entry specified by the @ GET and TEXT
commands.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ READ                                                               ║
     ╚════════════════════════════════════════════════════════════════════╝
     The READ command activates the input aspect of the @ GET commands
(including the @ and % macros in a TEXT).  The @ GET command displays the
variable at the specified location and format.  The READ command puts the
screen in full-screen editing mode with the current values of all fields and
memory variables shown, and the new values of all the variables in the @ GET
(and the @ and % macros in TEXT) commands can be entered.
     If the READ changes any key of a record in an index file in use, then the
index files are updated.
     The READ command clears all the pending GET commands.
.pa
RECALL
Undelete selected deleted records in the selected file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RECALL [<scope>] [FOR <cond>]                                      ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>       select by scope (default scope: current record)      ║
     ║ FOR <cond>    select by condition                                  ║
     ╚════════════════════════════════════════════════════════════════════╝
     Records are flagged as DELETED either with Ctrl-U in BROWSE, or EDIT, or
with the DELETE command.  The command RECALL reverses the DELETED flag.
     The command PACK physically removes all records flagged for deletion.
After a PACK, the records can no longer be recalled.
     Note that if SET DELETE ON, then RECALL will work only on a deleted
record only if it is also the current record.  Normally SET DELETE OFF before using RECALL.
.pa
REINDEX
Reindex all index files in use.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ REINDEX [FOR <cond>]                                               ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ FOR <cond>    select by condition                                  ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command takes all the index files currently in use for the selected
data file, and rebuilds each index file.
     In Conversational Info, and in programs with SET TALK ON, REINDEX will
output the key, the progress of the indexing procedure, showing the completion
of each 100 records, and the total number of records indexed.
     A FOR clause can be used to limit the records in the index(es) to those
for which <cond> is true.
.pa
RELEASE
Erase memory variables.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RELEASE [<memvar list>/EXCEPT <memvar list>/ALL]                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <memvar list>          the memory variables to be released,        ║
     ║                           separated by commas                      ║
     ║ EXCEPT <memvar list>   the memory variables not to be released,    ║
     ║                           separated by commas                      ║
     ║ ALL                    release ALL                                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command RELEASE erases memory variables; it releases memory space for
new memory variables.  You can make a list of the memory variables you want
removed, use the parameter ALL to remove them all, or use the parameter EXCEPT
<memvar list> to remove all except those on the list.
     This command should be used in programs only with the utmost care.
Compiled programs set pointers to memory variables.  If the memory variables
are released, the release must be absolute, not dependent on some conditions.
     Since 128 memory variables can be used at any one time, and any number of
them may be matrix variables, it is best not to RELEASE during a program.
When programs are chained, Info will do a CLEAR, which includes a RELEASE ALL.
     RELEASE does not affect the values of the function keys and the system
variables.
.pa
REMARK
Display message on screen or printer.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ REMARK ['<text line>']                                             ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ '<text line>'       the text line to be displayed                  ║
     ╚════════════════════════════════════════════════════════════════════╝
     Same as the command ?.  <text line> may be an expression list.
.pa
RENAME
Rename a file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RENAME <file> TO <new file>                                        ║
     ║                                                                    ║
     ║ <file>        the file name to be changed (default extension DBF)  ║
     ║ <new file>    the new name for the file   (default extension DBF)  ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command is similar to the RENAME command of the operating system: a
file is renamed.  No wild card characters are allowed.
     If the file name has no extension, the extension DBF is assumed.  (Do not
rename a data or index file to a name starting with the letters COMP;
Info is unable to open such a file.)
.pa
RENAME FIELD
Rename a field in a data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RENAME FIELD <field> TO <new fieldname>                            ║
     ║                                                                    ║
     ║ <field>          the field name to be changed                      ║
     ║ <new fieldname>  the new name for the field                        ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command allows you to change the name of a field in a data file
without doing a MODIFY, which potentially endangers the file and removes all
deleted records, often necessitating a REINDEX.
     Caution: All programs, report forms and index files that reference the
old field name must be revised before they will work properly after a field is
renamed.
.pa
REPEAT
Repeat program segment a specified number of times.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ REPEAT <num exp> TIMES [VARYING <num var>]                         ║
     ║                                                                    ║
     ║ <num exp>    a numeric expression; repeat the loop this many times ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ VARYING <num var>   loop counter                                   ║
     ╚════════════════════════════════════════════════════════════════════╝
     The REPEAT command introduces the program structure:
REPEAT <num exp> TIMES [VARYING <num var>]
   <program segment>
ENDREPEAT
     The program lines in the <program segment> are repeated <num exp> times.
The end of the program segment is indicated by ENDREPEAT.
     The optional VARYING clause is used to vary a memory variable from 1 to
<num exp>; at the start of the first loop, <num var> is initialized as 1;
<num var> is incremented by 1 each time the top of the loop is reached.
     This command is especially useful to manipulate matrix variables.
     Repeats can be nested.
     The BREAK command is used in a REPEAT loop to exit at the bottom of the
loop.  If there are nested loops, the exit is at the bottom of the innermost
loop then being executed.
     The Info keywords: TIMES and VARYING should not be in macros.
<num var> cannot be a matrix variable.
     Note that, if <program segment> contains commands that move the current
record pointer (for instance, a SKIP command), REPEAT does not terminate if
EOF becomes true.  Thus displaying a record and skipping in a file with 50 records, using REPEAT 100 TIMES, will display the last record in the file 51 times.  DO WHILE .NOT. EOF is the better construction for such a task.
     When editing with the internal Info programming editor, Alt-F reformats
the file with all structures properly indented, making it easy to see
unbalanced structures.
.pa
REPLACE
Replace field(s) in the selected data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ REPLACE [<scope>] <field1> WITH <exp1> [,<field2> WITH <exp2> ... ]║
     ║      [FOR <cond>]                                                  ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║ <scope>                 select by scope                            ║
     ║                            (default scope: current record)         ║
     ║ <field> WITH <exp>...   list fields and expressions for replacement║
     ║ FOR <cond>              select by condition                        ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command is used for changing some records in the selected data file.
The number of <field> WITH <exp> is only limited by the length of a command
line (254 characters).
     The scope ALL can be used to change all the records in the data file.
This could be dangerous.  Consider backing up your data file before you use
this command.
     This command is very useful, especially in conjunction with SET RELATION
TO, so that the fields from which <exp> is formed may come from a number of
data files.
.pa
REPORT
The report generator.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ REPORT [FORM] <form file> [<scope>] [FOR <cond>]                   ║
     ║                                                                    ║
     ║ <form file>       the name of the form file                        ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ FOR <cond>         select by condition                             ║
     ║ <scope>            select by scope (default:ALL)                   ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command REPORT is a very versatile report generator.  With a minimum
of effort the user can generate a great variety of columnar reports.  The
command takes care of the width of the report, the arrangement of the date,
page numbering, title(s), the columns, the data in the columns, headings,
subtotals (two levels), totals, and many other parameters.
     This command reports on the file(s) in use according to the format in the
report form file <form file>.  The form file can be created with the
Info editor (WRITE) or with any word processor; the default
extension is FRM.
     Info computes the necessary width as the minimum required to
accommodate the title(s), headings, the expression list, and the company name.
     The report is automatically centered over 80, 112, or 132 characters
wide, whichever is equal to or greater than the width of the report body.  The
SET WIDTH TO command also affects the heading, but not the width of the body.
     In a report form file, the first word of a line has to be a keyword,
followed by any modifiers separated from the keyword by a hyphen (-).  There
are currently 18 keywords.
     Only the FIELDS line is required; all the others are optional.  Some
keywords can occur more than once.
COMPRESS                           Sends code 15 to the printer for compressed
                                     printing on Epson and IBM Proprinter
                                     printers, sends code 18 after completion
                                     of the report to restore normal-width
                                     mode. For non-compatible printers, use
                                     SETUP.)
DOUBLE                             Prints double spaced lines.
EJECT                              Ejects a page after each subtotal.
FIELDS - <exp1>,<exp2>,...         The expressions for the columns of the
                                     report.
FILE - <file> [INDEX <index file>] Opens the data file <file> and, optionally,
                                     the index file.
HEADING - string1,string2,...      The headings for the expressions in the
                                     report.
INDEX - <exp> TO <index file name> [FOR <cond>]
                                   Indexes on the expression <exp> to the
                                     specified file the last data file opened
                                     with the FILE keyword; a FOR clause is
                                     permitted.
LENGTH - <num exp>                 Number of printed lines per page.
MESSAGE - <str exp>                Introduces the message to be displayed for                                       a subtotaled group (2 allowed).
NODETAIL                           Shows only the totals and subtotals. Should
                                     not be used without SUBTOTAL keyword.
PICTURE - <picture list>           Which expressions (in the FIELDS line) are
                                     to be totaled.
PRINT                              Sends the report to the printer.
RELATION - <exp> TO <file number>  Sets a relation between file 1 and the file
                                     <file number>.
SELECT - <cond>                    Selects the records by condition <cond>.
SETUP - <setup string>             A list of control codes to be sent to the
                                     printer before beginning page 1 (do not
                                     use without PRINT or SPOOL keywords).
SPOOL - <file name>                Sends the report to the file <file name>
                                     (PRINT must not be used).
SUBTOTAL - <exp>                   Subtotals be printed when the expression
                                     <exp> changes (2 allowed).
TITLE - string or <str exp>        The title of the report (2 allowed).
     The REPORT command is influenced by the commands previously given, such
as USE, INDEX, SET PRINT ON.  Most of these can also be done from within the
report form file.
     COMMANDS INFLUENCING REPORT.  The REPORT command works on the  selected
file (if any). So
1>SELECT 3
3>REPORT salary
means: report on file 3 using the report form file SALARY.FRM.  If no file is
in use as file 3, the report form file will have to specify (with the FILE
keyword) the data file(s) to use.
     Similarly, specifying the index file(s) to use with the data file(s) and
reindexing can be done before the REPORT command is given.
     The system variables :COMPANY, :TITLE, and :DATE influence the report.
The company name in :COMPANY appears centered in the second line of the
report.  The text in :TITLE becomes the title of the report unless the report form file specifies otherwise (with the keyword TITLE).  The date on the first line of the report comes from :DATE.
     The three system variables may be changed before REPORT.
     Much of what can be accomplished by setting the environment of REPORT
before the command is given, can also be done in the report format file.
There are some exceptions: for instance, since SPOOL adds to the top of an
existing file with the same name as the spool file, you may want to delete the
existing file before doing the report, or alternately using the SPOOL command
outside the report and the keyword PRINT inside the report.  You may also want
to set page depth with SET LENGTH TO, the number of character over which the
heading will be centered with SET WIDTH TO, the left margin with SET MARGIN
TO, etc.
     THE FORM OF THE REPORT COMMAND.  The selection criteria can be placed in
the REPORT command and/or in the report form file.  If the REPORT command
contains a FOR clause, and the report form file has a SELECT line, then the
FOR clause of the REPORT command overrules the SELECT line of the report form
file.
     You may restrict the range of records in the report by the LIMIT command
or a scope; both must be invoked outside the REPORT form.  The WHILE <cond>
form of the scope may be very useful when reporting on a very big file.
     The lines in the report form file can be separated by any
number of blank lines to increase readability.
     A * can be put at the front a line to comment out (temporarily) that line.
     The lines can appear in just about any order.  The INDEX keyword must
appear after the FILE keyword, and the MESSAGE keyword must appear after the
SUBTOTAL keyword.
     Keywords that take no arguments are described above. Details on others
are available by pressing <ENTER>:
\\REPORT KEYWORDS
.pa
RESTORE
Restore memory variables from file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RESTORE FROM <file> [ADDITIVE]                                     ║
     ║                                                                    ║
     ║ <file>             name of memory variable file                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ ADDITIVE           add new variables, update old ones              ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command is used for restoring the memory and system variables that
had previously been saved by the SAVE TO command.  This command erases all the
variables that are currently in memory.
     The ADDITIVE clause inhibits clearing of memory variables.  It adds the
memory variables from the file to the memory variable table.  If a memory
variable occurs both in the table and the file, its value gets updated from
the file.  With the ADDITIVE clause, the position of the existing variables in
the memory variable table does not change, so pointers to them remain correct.
       ╔═    In general, the ADDITIVE clause is not needed in Conversational
       ╚═ VP-Info, but must ALWAYS be used in programs.
             This command should be used with the utmost care.  Compiled
          programs set pointers to memory variables.  If the memory
          variables are restored, the restore must be absolute, not
          dependent on some conditions.
.pa
RETURN
Return to the calling program.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RETURN                                                             ║
     ╚════════════════════════════════════════════════════════════════════╝
     The RETURN command returns the current program to the program from which
it was called with the DO command.
     There may be any number of RETURN commands in a program.
.pa
RING
Sound a beep on the computer speaker.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RING                                                               ║
     ╚════════════════════════════════════════════════════════════════════╝
     RING sends character 7 (the ASCII bell character) to the screen at the
current cursor position.  If there is already a character in that position, it
will be overwritten (erased).
.pa
RUN
Execute DOS commands or run a program outside Info.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ RUN <command file>/<DOS command>                                   ║
     ║                                                                    ║
     ║ <command file>   an EXE, COM or BAT file to be executed            ║
     ║ <DOS command>    an internal DOS command (COMMAND.COM must be      ║
     ║                    in the current directory or in the PATH         ║
     ╚════════════════════════════════════════════════════════════════════╝
     Provided your computer has sufficient memory available, the RUN command
allows you to execute DOS commands and run small programs outside
Info without leaving Info.
.pa
SAVE
Save the memory variables to a file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SAVE TO <file>                                                     ║
     ║                                                                    ║
     ║ <file>           the name of the memory variable file              ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command is used to save the memory variables to a file.  These can
later be restored using the RESTORE FROM command.
     If no extension is given to the file name, the file will have extension
MEM.
     During debugging, you may save the memory variables to a file for later
analysis.
.pa
SCOPE
Limit the records available within the current master index to those matching
all or part of the current records index key.  A synonym for LIMIT command.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SCOPE <num exp>                                                    ║
     ║ SCOPE <key exp>                                                    ║
     ║ SCOPE                                                              ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <num exp>     the number of characters in the key expression to    ║
     ║                 to match                                           ║
     ║ <key exp>     the string expression to match in the current master ║
     ║                 index                                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     See LIMIT command.
.pa
SCREEN
Save and restore screen images between the displayed screen and up to three
additional background screens.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ One of two forms:                                                  ║
     ║ 1. SCREEN <source>,<destination>                                   ║
     ║ 2. SCREEN <destination>                                            ║
     ║                                                                    ║
     ║ <source>      the number of the screen to be transferred to        ║
     ║                 destination in form 1                              ║
     ║ <destination> screen number to which all screen output in to be    ║
     ║                 directed in form 1; the "active" screen in form 2  ║
     ╚════════════════════════════════════════════════════════════════════╝
     Screen 1 is the screen the user can see, although screen output can be
directed to any of three background screens, numbered 2 through 4, and images
can be transferred directly from any one to any other.
     In its default mode, color attributes and cursor positions are stored and
restored automatically.  SET SCREEN OFF to allow color attributes and cursor
position to be unaffected by the SCREEN command.
.pa
SCROLL
Scroll a part of the screen.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SCROLL <line1>,<line2>                                             ║
     ║                                                                    ║
     ║ <line1>      from this line number                                 ║
     ║ <line2>      to this line number                                   ║
     ╚════════════════════════════════════════════════════════════════════╝
     Scroll the screen up one line from line number line1 to line number
line2; line1 and line2 are numeric expressions. If line1 is less than line2,
the scrolling is reversed.  line1 cannot equal line2.
     This command is used to scroll text on the screen.
.pa
SELECT
Select the file number to work with.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SELECT <num const>/PRIMARY/SECONDARY                               ║
     ║                                                                    ║
     ║ <num const>    a file number between 1 and 6 SR-Info or between    ║
     ║                     1 and 10 VP-Info                               ║
     ║ PRIMARY          same as 1                                         ║
     ║ SECONDARY        same as 2                                         ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command selects a file number, <num const>.  Once this number has
been selected, the data files opened with the USE command will be referred to
as file <num const>.
     (For compatibility with older VP-Info programs, file 1 is also called the
PRIMARY file and File 2 is also called the SECONDARY file.)
     In SR-Info, there can be six data files open at the same time; each must
have a different file number.
     SELECT 1, SELECT 2, and so on are regarded as command verbs; no part of
the command can be in a macro.
.pa
SET
Set up environmental controls.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET <param> ON/OFF                                                 ║
     ║                                                                    ║
     ║ <param>   is chosen from the list:                                 ║
     ║               ADD, ALTERNATE, ANSI, BELL, CARRY, CONFIRM,          ║
     ║               CONSOLE, DEBUG, DELETED, DELIMITER, DISPLAY,         ║
     ║               DIVZERO, DO, ECHO, EJECT, END, ERROR, ESCAPE,        ║
     ║               EXACT, EXECUTION, FUNCTION, GET, HEADING,            ║
     ║               INTENSITY, KEEP, LINE, LOCK, MENU, MONO,             ║
     ║               PRINT, PROMPT, RAW, SAVE, SCREEN, SOUND,             ║
     ║               STEP, TALK, TEXT, TRIM, UPPER, ZERO                  ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Switch:                                                            ║
     ║ ON or OFF                                                          ║
     ╚════════════════════════════════════════════════════════════════════╝
     These parameters enable and disable certain features of Info.
The features are explained in screens selected below, grouped alphabetically:
\\Sets A-E
\\Sets F-Z
.pa
SETS A-E
     Info comes with some of these features ON, and some OFF; an
asterisk marks the default.
 
     Parameter   Switch  Explanation:
 
     ADD         ON      When doing a POST, and the find is unsuccessful, a
                            record will be appended to the Master File, the
                            non-numeric fields of the Master File record
                            will be replaced by the matching fields in the
                            Transaction File record, and, the posting is
                            done to the new record.
                *OFF     When doing a POST, and the find is unsuccessful,
                            an error message is sent.
 
     ALTERNATE   ON      An alternative to SET PRINT ON and SET FORMAT TO
                            PRINT commands: output that would be sent to
                            the printer is sent to a disk text file
                            instead.  The name of the disk file is
                            specified in the SET ALTERNATE TO <file>
                            command (see also SET ALTERNATE TO).  SET PRINT
                            ON is ignored when SET ALTERNATE ON.
                *OFF     Stop sending output to the disk file. (NOTE: SET
                            PRINT OFF also sets ALTERNATE OFF if ALTERNATE
                            ON. Do not mix SET PRINT and SET ALTERNATE
                            commands, however; only use these commands in
                            ON/OFF pairs.)
 
     ANSI        ON      ANSI.SYS is no longer supported for terminal
                            emulations by Info, but the SET ANSI
                            command is allowed for compatibility with
                            programs written for earlier versions. It has
                            no effect.
                *OFF     SET ANSI has no effect in Info.
 
     BELL       *ON      The computer rings the bell whenever illegal data
                            is entered or when data input goes from an
                            editing field to the next editing field.
                 OFF     Bell is turned off.
 
     CARRY       ON      When in APPEND or the append mode of EDIT, make
                            the appended record identical to the current
                            record.
                *OFF     Appended records are blank.
 
     CONFIRM     ON      In full-screen editing, data entry into an editing
                            field must be terminated by pressing <ENTER>.
                            (When filling a numeric field, this condition
                            will drop the last numeric character, the one
                            under the cursor.  The remedy is to make the
                            input picture one character wider.)
                *OFF     Once an editing field is filled, data entry
                            proceeds to the next editing field.
 
     CONSOLE    *ON      The output directed to the screen goes to the
                            screen.  This flag is always set when <Esc> is
                            pressed or Info stops execution on
                            an error.
                 OFF     All output directed to the screen is suppressed.
                            (Note, however, that scrolling is not
                            suppressed by this command, so existing
                            material on the screen can be scrolled off the
                            top of the screen.  Consider directing screen
                            output to a background screen instead of SET
                            CONSOLE OFF.)
 
     DEBUG       ON      Activate all the DEBUG print commands and force Info
                            to recompile all programs; does not use pre-
                            existing CPL files.
                *OFF     Ignore all the DEBUG print commands and use CPL
                            files when present.
 
     DELETED     ON      All records with the DELETED flag are ignored by
                            all the commands except the GOTO command.
                *OFF     Records with the DELETED flag are listed, found
                            with FIND, etc., but marked as DELETED
                            (however, these records are never appended,
                            averaged, copied, counted, summed, totalled, or
                            reported).
 
     DELIMITER   ON      The editing fields in the @ GET, EDIT, BROWSE,
                            TEXT (@ and % macros) commands are bounded by
                            colons.
                *OFF     These editing fields are not bounded by colons.
 
     DISPLAY    *ON      Displayed macros are immediately updated in a TEXT
                            during READ when their values are changed in an
                            ON FIELD structure.
                 OFF     Displayed TEXT macros are not updated during READ.
 
     DIVZERO      ON      Division by zero is permitted and does not cause
                            execution of a program to cease with an error
                            message; the result of division by zero is
                            arbitrarily set at zero.
                *OFF     Division by zero is not permitted and causes
                            program execution to abort with an error
                            message.
 
     DO         *ON      Subroutines are compiled as overlays to the
                            calling program
                 OFF     Subroutines are not compiled in the calling
                            program. Instead, the compile produces files
                            containing the compiled environment for the
                            subroutines (with the extension ENV).  May be
                            useful in developing and debugging very complex
                            applications.
 
     ECHO        ON      When compiling an Info program
                            (including the compiling done on-the-fly before
                            running an uncompiled program), the program
                            lines are shown on the screen as they are
                            compiled; it has no effect while programs are
                            actually being executed.
                *OFF     Program lines are not shown.
 
     EJECT      *ON      In a report form file, the EJECT line will send a
                            form feed character after each subtotal.
                 OFF     In a report form file, the EJECT line will send
                            enough carriage returns to move the paper in
                            the printer to the form depth set by the SET
                            LENGTH TO command (default is 66).
 
     END        *ON      During READ while SET FUNCTION OFF, pressing any
                            function key has the same effect as pressing
                            <End>; READ is exited and the function key
                            number is stored into :KEY.
                 OFF     If SET FUNCTION OFF, then all function keys give a
                            carriage return and line feed combination
                            (leave input field) and the function key number
                            is stored in :KEY.  READ is not exited, but
                            action can be controlled in an ON FIELD
                            structure.
 
     ERROR      *ON      If an ON ERROR structure is in effect, it is
                            executed in event of an error.
                 OFF     An active ON ERROR structure is ignored and
                            Info reacts as though the structure
                            did not exist.
 
     ESCAPE     *ON      Hitting <Esc> aborts program execution, or if an
                            ON ESCAPE structure is in effect, program
                            execution jumps to the start of the structure.
                 OFF     <Esc> is ignored.
 
     EXACT       ON      Whenever strings are compared for equality (in
                            conditions, or when invoking FIND), all
                            characters in both strings, including trailing
                            blanks, are compared, and only perfect matches
                            are true.  Thus 'ABCD'='ABC' is false, and FIND
                            ABC will not find 'ABCD'.
                *OFF     Whenever strings are compared for equality,
                            trailing blanks are ignored, and only the
                            number of characters to the right of the = sign
                            are compared.  Thus 'ABCD'='ABC' is true, and
                            FIND ABC will find 'ABCD' (if 'ABCD' is the
                            first record key starting with 'ABC').
 
     EXECUTION   ON      All FIELD modules in an ON FIELD structure are
                            executed before exiting READ (or the current
                            record in BROWSE OFF and EDIT OFF), as well as
                            when leaving their respective input fields.
                *OFF     FIELD modules are executed only when leaving their
                            respective input fields.
.pa
SETS F-Z
     Info comes with some of these features ON, and some OFF; an
asterisk marks the default.
 
     Parameter   Switch  Explanation:
 
     FUNCTION   *ON      Function keys display values stored in them when
                            pressed.
                 OFF     Disable the usual functions of the function keys
                            <F1> to <F10>.  Pressing a function key will
                            produce a Ctrl-W (or a carriage return/line
                            feed if SET END OFF); the number of the
                            function key pressed is available to the
                            programmer in the :KEY system variable.
 
     GET         ON      A Get Table is maintained when calling a sub-
                            program; it is, therefore, still in effect upon
                            return from the sub-program, provided it is not
                            cleared in the sub-program.  (A Get Table is
                            cleared either with the CLEAR GETS command, or
                            by creating a get with TEXT or an @ GET command
                            after a READ command.)
                *OFF     A Get Table is cleared whenever program execution
                            leaves a sub-program.
 
     HEADING     ON      Field names are displayed over each column during
                            LIST and DISPLAY command execution.  If fields
                            names are longer than column width, the name is
                            truncated as in BROWSE.  Headings are not
                            displayed if an expression list is given on the
                            LIST or DISPLAY command line.
                *OFF     Field names are not displayed with LIST and
                            DISPLAY.
 
     INTENSITY  *ON      The editing fields in full-screen editing are
                            shown in reverse video.
                 OFF     Editing fields are shown in normal video.
 
     KEEP        ON      When a TEXT file is read from the disk, it is
                            stored in memory so that subsequent calls for
                            the same TEXT will use the version in memory
                            instead of reading it in from the disk again.
                *OFF     The disk is accessed every time the TEXT file is
                            called.  Note: If the TEXT filename is a macro
                            or variable name, Info always goes
                            to the disk for the text whether SET KEEP is ON
                            or OFF.
 
     LINE       *ON      Place line numbers in compiled program to be used
                            with error messages.
                 OFF     No line numbers in compiled program.
 
     MENU        ON      Display the meaning of the editing keys for EDIT
                            and BROWSE, and displays a help box when Info
                            starts and whenever the screen is cleared.
                *OFF     No editing keys or help box are displayed.
 
     MONO        ON      A monochrome monitor is used. (Has no default.
                            Not required unless both monochrome and color
                            adapters are present in your computer; put the
                            appropriate command in your CNF file.)
                 OFF     A color monitor is used.
 
     PRINT       ON      Output produced such by relative display commands
                            as LIST, DISPLAY, ?, and ?? is sent to a
                            printer (or to a text file if SPOOL is in
                            effect).  In the interactive mode, the effect
                            of SET PRINT ON is turned off when the prompt
                            appears, so that the commands will not be
                            printed.  Info will continue
                            printing the results of the commands.
                *OFF     The output is sent to the screen.  This flag is
                            always set OFF when <Esc> is pressed or an
                            error is encountered while running a program.
 
     PROMPT      ON      A dot prompt, as in dBASE.
                *OFF     The n> prompt, where n is the current work area.
 
     RAW         ON      No blanks separate the expressions when the
                            DISPLAY or LIST command is used with an
                            expression list
                *OFF     Blanks are placed between expressions.
 
     SAVE       *ON      Changes are saved to disk when the user leaves a
                            changed record or closes the data file.
                 OFF     Changes are not written to disk.
 
     SCREEN     *ON      SCREEN command works as described under SCREEN
                            command.
                 OFF     When screens are switched with SCREEN command,
                            cursor position and color attributes are not
                            saved or restored.  (Provided only to allow
                            user to force compatibility with early versions
                            of VP-Info.)
 
     SOUND      *ON      In VP-Info Level 1 only, turns on both sound
                            effects and screen effects (see SCREEN). In all
                            other VP-Info versions, affects only sound.
                 OFF     In VP-Info Level 1 only, turns off both sound 
                            effects and screen effects (see SCREEN). In all
                            other VP-Info versions, affects only sound.
 
     STEP        ON      Execute an Info program a line at a time
                            (SET LINE ON must have been in effect when
                            the program was compiled.)  The line number is
                            displayed on the top line of the screen
                            display.
                *OFF     Execute Info programs continuously.
 
     TALK       *ON      Info messages from commands are
                            displayed.  This flag is always set when <Esc>
                            is pressed and when the conversational mode is
                            entered.
                 OFF     Messages are not displayed.
 
     TEXT       *ON      The TEXT display macros created with & and # are
                            put into the Get Table; usually required for
                            input screens created with TEXT.
                 OFF     Display macros are not put into the Get Table;
                            usually required when using TEXT for printer
                            output, as in mail-merge programs.
 
     TRIM       *ON      The & macro in TEXT trims string variables.
                 OFF     The trimming is turned off.
 
     UPPER       ON      All keyboard-input characters from "a" to "z" are
                            forced to upper case "A" to "Z"; a software
                            "Caps Lock".
                *OFF     Lower-case keyboard entry is not altered.
 
     ZERO       *ON      Display zeros whenever the numeric value zero must
                            be displayed.
                 OFF     If the value zero has to be displayed, display
                            blanks instead.
.pa
SET ALTERNATE
Specify text file for output.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET ALTERNATE TO <file>                                            ║
     ║                                                                    ║
     ║ <file>          text file name                                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command SET ALTERNATE specifies the text file to be used when the SET
ALTERNATE ON command is given.  The default extension of the file is TXT.  If
the file already exists, the new data is appended at the end.
     All data that would normally go to the printer is sent to this file.
.pa
SET COLOR
Set the attribute byte of the characters to be displayed.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET COLOR TO <attrib>                                              ║
     ║                                                                    ║
     ║ <attrib>   numeric expression, the attribute byte: 0 to 255        ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command sets the attribute byte of all characters to be displayed on
the screen, and updates the system variable :COLOR with <attrib>.  SET COLOR
TO 0 returns to the normal mode.  An alternative way of getting the same
result is:
:COLOR=<attrib>
     These commands work with standard IBM monochrome and color monitors.
     Every character displayed on the screen has an attribute byte that
determines how the character is displayed.
     Compute ATTRIB by adding up (up to) four numbers (background+
foreground+blink+brightness) from the following tables:
    BACKGROUND     ========CHARACTERS=========  BLINKING        BRIGHTNESS
    (color only)   (color)     (monochrome)
    ------------   ----------  ---------------  --------------  ------------
     0 - black     0 - black     0 - normal       0 - no blink  0 - normal
    16 - blue      1 - blue      1 - underline  128 - blink     8 - bright
    32 - green     2 - green   112 - reverse
    48 - cyan      3 - cyan
    64 - red       4 - red
    80 - magenta   5 - magenta
    96 - brown     6 - brown
   112 - white     7 - white
     See also the COLOR command for setting the attribute bytes for a
rectangular part of the screen.
.pa
SET DATE
Set the default form for dates.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET DATE TO <str exp>                                              ║
     ║                                                                    ║
     ║ <str exp>     the default date format                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command, in conjunction with the date function DATE(7, <str exp>), is designed to give control over input of dates.  The order of the day, month,
and the year, and the number of digits in year (2 or 4), is controlled as
follows:
    SET DATE TO                 formats '12/31/1991' as follows:
     'mmddyy'                             123191
     'ddmmyy'                             312191
     'yymmdd'                             911231
     'mmddyyyy'                           12311991
     'ddmmyyyy'                           31121991
     'yyyymmdd'                           19911231
     These are the six available options.
.pa
SET DEFAULT
Set the drive letter of the default disk drive for data and index files.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET DEFAULT TO <drive letter>                                      ║
     ║                                                                    ║
     ║ <drive letter>  the drive letter of the default drive              ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command sets the drive letter of the default drive for data and
index files.  If this drive letter is, say, C, every data and index file
will be searched for on drive C, unless the file name contains an explicit
drive letter.
     This command will rarely be used, but is provided for compatibility
with older versions of Info.  Most users will prefer the extra flexibility
of the FILES command, the FILES ... ENDFILES structure, and the SET DIR
command.  The first two allow you to specify exactly where specific files
and groups of files are to be found, and the third actually "logs" you
onto any disk and/or directory.
.pa
SET DIR
Change drive and/or current directory.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET DIR TO [<drive>:][<directory>]                                 ║
     ║                                                                    ║
     ║ <drive>         the drive letter of the new default drive          ║
     ║ <directory>     the directory name (according to DOS rules)        ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command changes the current drive and/or the current directory;
equivalent to combining the DOS commands change drive and CHDIR (CD)..
     Contrast this with the FILES and SET DEFAULT TO commands, which only tell
Info where to look for certain categories of files without changing
the user's current position on the disk.  Exit from Info after SET
DIR is in the new directory on the new drive.
     If <drive> is not specified, the new directory is on the same drive.  If
directory is not specified, the new directory will be the last directory DOS
changed to on the target drive or, if no directory has been changed to, the
root of that drive.
     If <directory> begins with a backslash (example \DATA), the directory
will be off the root; if not, the directory will be off the directory onto
which the user is currently logged.
     If the <drive> is invalid, no message will be given, but the change will
not take place. If no <drive> is given and the <directory> is invalid, again
no change will occur.  However, if <drive> is valid and <directory> is
invalid, the drive will change and the user will be logged into the current
directory on that drive.
     The current drive and directory can be checked with the :DIR system
variable, which always contains the current drive and directory.
     Caution: If you change directories within Info, you may lose
track of where some of your files are.  This is particularly likely if you have a FILES structure in use without full path names giving both drive letter and leading backslash on the directory.
.pa
SET FILTER
Set a condition which applies to all subsequent data-file commands.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET FILTER TO [<cond>]                                             ║
     ║                                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <cond>    the condition applied to all subsequent data-file        ║
     ║             commands                                               ║
     ╚════════════════════════════════════════════════════════════════════╝
     Most command that use data files (LIST, REPLACE, REPORT, etc.) allow a
selection condition to be specified with a FOR clause.
     Info also allows a global condition to be attached to all data-
file commands, including many that do not allow a FOR clause, including SORT,
EDIT, and BROWSE.
     The filter is turned off with  FILTER TO without a condition.
     While a filter is in effect, a FOR clause can be used with commands to
limit further the records subject to the command.
.pa
SET FORMAT
Directs the @ SAY commands to screen or printer.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET FORMAT TO SCREEN/PRINT                                         ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Switch:                                                            ║
     ║                                                                    ║
     ║ SCREEN     send output to screen; the default                      ║
     ║ PRINT      send output to printer                                  ║
     ╚════════════════════════════════════════════════════════════════════╝
     SET FORMAT TO SCREEN or PRINT is used to send data formatted with the @
SAY command to the screen or the printer (but not to both).  The default is
SCREEN.  The default is always set when <Esc> is pressed.
     IF SPOOL or SET ALTERNATE TO has redirected print output to a disk file,
SET FORMAT TO PRINT will cause output to go into the disk file.
.pa
SET INDEX
Specify index files.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET INDEX TO                                                       ║
     ║ SET INDEX TO <file>                                                ║
     ║ SET INDEX TO <file list>                                           ║
     ║ SET INDEX TO <num const>                                           ║
     ║                                                                    ║
     ║ <file>        the name of the index file                           ║
     ║ <file list>   a list of up to 7 index files                        ║
     ║ <num const>   a number between 1 and 7                             ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command SET INDEX TO specifies the index file(s) to be used with the
selected data file.  If more than one index file is given, the first index
file will be used as the Master Index.  The Master Index is used by the FIND
command, and all the display type commands (BROWSE, LIST).  However, all the
index files specified in the list are maintained by the commands that add or
edit records (APPEND, EDIT, @ GET, and so on).
     The Master Index can be changed with the SET INDEX TO <num const>
command. The index files are assigned numbers when they are activated in a file list. Say, SET INDEX TO 3, makes the third on the list the Master Index.  This involves no disk action; no file is opened or closed.
     Index files can also be opened with the USE command.
     SET INDEX TO with no file name, closes all the index files for the
selected data file, but the data file is not closed.  Index files  are also
closed when the data file is closed.
.pa
SET LENGTH
Set page depth for the printer when the printer does not support a standard
formfeed control character.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET LENGTH TO <num exp>                                            ║
     ║                                                                    ║
     ║ <num exp>   the page depth                                         ║
     ╚════════════════════════════════════════════════════════════════════╝
     The page depth is the number of lines from the top of the page to the
very bottom of the page.  If the SET LENGTH command is not used, page depth
is assumed to be 66.
     Warning: SET LENGTH does not set how many lines will be printed on a page
but the physical size of the page.  This command is used if the page depth is
unusual (e.g., filling in a preprinted form), or if the usual 6 line per inch
printing is changed, say, to 8 lines per inch.
.pa
SET LIBRARY
Set the drive letter of the default disk drive for data and index files.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET LIBRARY TO <library>                                           ║
     ║                                                                    ║
     ║ <library>     a library file, default extension LIB                ║
     ╚════════════════════════════════════════════════════════════════════╝
     This opens a special form of file called a library, which contains up to
65,000 library entries each of 256 bytes.  Library entries are automatically
combined into volumes of up to about 20,000 characters by creation of an
internal linked list, analogous to the way DOS links disk clusters together to
make large disk files.
     If the <library> does not exist, it will be created.  The default
extension for library files is LIB.
     Library volumes can be created only with the WRITE command, and output
only with the TEXT command (although a programmer can also access the data
through use of the sequential file functions SEEK(, GET(, and PUT( if
sufficiently skilled).
     Both WRITE and TEXT distinguish between standard disk files and volume
numbers in their command lines by preceding volume numbers with a period.  Do
not mistake this usage for a decimal number.
     Technical information for experienced programmers: the structure of a
library file is as follows:
Header:
  Bytes 0 and 1        next volume to be added, an unsigned integer
  Bytes 2 and 3        next available volume, an unsigned integer; may be
                            less than next to be added because existing
                            volumes may have been released with
                            REMLIB( function or shortened with WRITE
  Bytes 4 through 15   unused
Each volume:
  Bytes 0 through 253  the text contents of the volume; end of file indicated
                            by 1A hex
  Bytes 254 and 255    a pointer to the next part of the volume, an unsigned
                            integer; if no next part, pointer is null
.pa
SET LINK
Set up a physical link between two data files.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET LINK TO <num const>                                            ║
     ║ SET LINK OFF                                                       ║
     ║                                                                    ║
     ║ <num const>  the selected file is linked to the file with          ║
     ║                   this file number                                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command SET LINK TO sets up a link between two files by record
number. After the link is set up between the selected file and another file,
as the record pointer is moved in the selected file (for instance, with GO,
FIND, or LIST), the record pointer in the other file is similarly moved.
If the selected file has more records, once the record number is too large
for the other file, its current record number pointer will stay on the last
record.
     SET LINK OFF turns off the linkage (if any) from the selected file.
     SET LINK TO can "chain" many files together.  There can be only one SET
LINK TO command from any one file. It is the user's responsibility to make
sure that there are no "loops" such as in:
1>SET LINK TO 2
1>SELECT 2
2>SET LINK TO 1
     If SET LINK is used, SET RELATION should be avoided.
.pa
SET MARGIN
Specify text margin for printer.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET MARGIN TO <num exp>                                            ║
     ║                                                                    ║
     ║ <num exp>   the margin                                             ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command SET MARGIN sets the left margin for the printer.  This
command can be used in conjunction with any command that sends output to the
printer.
.pa
SET RELATION
Set up a relation between the selected file and another indexed data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET RELATION ON <str exp> TO <num const>                           ║
     ║ SET RELATION OFF                                                   ║
     ║                                                                    ║
     ║ <str exp>      the key of the relation                             ║
     ║ <num const>    the relation is set between the selected file       ║
     ║                     and file <num const>                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     <str exp> is an expression made up of fields (of character type) of the
selected file, string constants, and string variables.
     Any time the current record pointer is changed for the selected file,
<str exp> is evaluated, and a FIND is made with the result in the file
<num const>.
     A file can be related to a number of other files: 1 is related to 2, 1 is
related to 3, 1 is related to 4 (file 1 has 3 fields on which additional
information is available in files 2, 3, and 4); 1 is related to 2, 1 is
related to 3, and 3 is related to 4 (the information linking 1 and 3 has additional data on file 4).
     Relations can also be chained: 1 is related to 2, 2 is related to 3, and
3 is related to 4.
     However, only one file can SET RELATION TO a given file: you cannot have
both 1 related to 6 and 2 related to 6.
     It is the user's responsibility to make sure that there is no loop, such
as 1 related to 2, 2 related to 3, and 3 related to 1.
     To disable a relation, SET RELATION OFF, close either the selected file
or the target file, of close the indexes on the target file.
.pa
SET WIDTH
Specify text width for printer.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SET WIDTH TO <num exp>                                             ║
     ║                                                                    ║
     ║ <num exp>     page width                                           ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command SET WIDTH sets the page width (number of characters per line)
for the TEXT and REPORT commands.  The WIDTH is the width of the text from the
left margin; the default is 80.  So if the commands:
SET MARGIN TO 10
SET WIDTH TO 50
are given, TEXT will wrap the words at character position 60.
     When a matrix variable is displayed, it is wrapped by the value set by
SET WIDTH.
     The only aspect of a report that is affected by SET WIDTH TO is the
number of characters over which its heading is positioned. It has no effect on
the report columns themselves.
.pa
SKIP
Move ahead or back in data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SKIP [<num exp>]                                                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ <num exp>   by this many records; may be positive (forward) or     ║
     ║               negative (backward); default 1 record forward        ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command SKIP moves the current record pointer ahead or back in the
selected data file.
     SKIP by itself advances the record pointer to the next record.
     If you SKIP ahead more records than there are records left in the data
file, then the current record becomes the last record.  Skipping past the last
record sets the function EOF true.
     If you SKIP too many records back, the current record pointer will be set
to 0.
     If there is an index file, ahead and back is understood in the indexed
order.
.pa
SORT
Sort the selected data file into another data file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SORT ON <str exp> TO <file>                                        ║
     ║                                                                    ║
     ║ <str exp>     the key of the sort                                  ║
     ║ <file>        the data file to contain the result of the sort      ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command sorts the selected data file to the data file specified.  The
sort is done by evaluating the <str exp>, creating a temporary index, and
copying the file to <file>.
.pa
SPOOL
Redirect printer output to disk file, or send disk file to printer.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ Four forms:                                                        ║
     ║ 1.  SPOOL <filename>                                               ║
     ║ 2.  SPOOL                                                          ║
     ║ 3.  SPOOL <filename> TO <device> [PAGE <num exp>]                  ║
     ║ 4.  SPOOL/T                                                        ║
     ║                                                                    ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ Form 1:      Create file <filename> and direct print output to     ║
     ║                that file; default extension TXT                    ║
     ║ Form 2:      Close any open spool file and stop redirection        ║
     ║ Form 3:      Do background printing of <filename> on <device>,     ║
     ║                usually PRN but can be any DOS device               ║
     ║     PAGE <num exp>  start printing on page <num exp>               ║
     ║ Form 4:      Stop background printint started with Firm 3          ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command allows printer output to be captured into a disk file, and
optionally spooled out to disk while other processing continues.  This command
has four forms as follows:
1.   Used with a filename, it creates a new spool file with the name of
filename (default extension TXT).
2.   Used without a filename, SPOOL closes any open spool file and restores
printer as standard print device..
3.   Used with both filename and device name, <filename> is spooled to the
specified DOS device, such as PRN, LPT1, etc.  If PAGE option is used with a
page number (can be an expression) prinnting starts with the top of that page
number.
4.   Used with a slash-T (/T), spooling is terminated. This is same symbol as
used with the DOS PRINT command for the same purpose.
     If SPOOL is used to create a file, and a file already exists with that
name, the user in Conversational Info is required to confirm that
the file should be overwritten; in programs, the existing file is overwritten
without prompting.
.pa
STATUS
Display status information.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ STATUS                                                             ║
     ╚════════════════════════════════════════════════════════════════════╝
     If used in the interactive mode, this command displays two screens of
information on the status of Info.
.pa
STORE
Assign value to a memory variable.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ STORE <exp> TO <memvar>                                            ║
     ║                                                                    ║
     ║ <exp>      the value assigned                                      ║
     ║ <memvar>   name of memory variable                                 ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command assigns a value to a memory variable; if the variable does
not exist, it will be created.  An equivalent way of assigning value is with
the = command.
.pa
SUM
Sum numeric expressions for selected records.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ SUM [<scope>] <num exp list> [TO <memvar list>] [FOR <cond>]       ║
     ║                                                                    ║
     ║ <num exp list>    the numeric expressions to sum                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>           select by scope (default scope: ALL)             ║
     ║ <memvar list>     store the results in these memory variables      ║
     ║ FOR <cond>        select by condition                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command SUM adds up numeric expressions for selected records of the
selected data file.  Up to 10 expressions can be summed with one command.
Optionally, the results can be stored in numeric memory variables; the
expression list and the numeric memory variable list must have the same number
of entries.  <memvar list> cannot contain numeric matrix variables.
     Records flagged as DELETED are not summed.
.pa
TEXT
Send text to screen or printer.  Optionally incorporate variables as macros.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ TEXT [<file>/.<volume>/M.<memo>]                                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <file>    the name of the text file to use                         ║
     ║ <volume>  the number of a volume in the current library; a         ║
     ║             numeric constant                                       ║
     ║ <memo>    the name of a field of type M (MEMO) in the current      ║
     ║             data file                                              ║
     ╚════════════════════════════════════════════════════════════════════╝
     The TEXT command has two forms.  The first form is the TEXT/ENDTEXT
program structure:
TEXT
   <text>
ENDTEXT
     All lines following the TEXT command up to ENDTEXT are displayed on the
screen or if the command SET PRINT ON was given, then also sent to the printer.
     The second form is:
TEXT <file>/.<volume/M.<memo>>
where the text is taken from the file <file> (default extension TXT) or from
the numbered volume in the current library (see SET LIBRARY TO command) or
from a memo field.
This is the same as
TEXT
   the text from <file> or .<volume> or M.<memo>
ENDTEXT
     The second form is preferable in many circumstances, since it:
1.   Keeps the size of the program module down
2.   Allows manipulation of the text in <file> or in .<volume>
3.   Allows the choice of text to be used, since <file> can be a macro, and
<volume> can be a numeric expression
     Note that library volumes are addressed by placing a period in front of
the volume number, which can be either a numeric constant or a numeric
expression.  Do not confuse this usage with a decimal designation.
 
Formats in TEXT.
     TEXT formats let you control the display on fields and variables used in
TEXT macros.  They are similar to the formats used in the PICTURE and USING
clauses of the @ command (see @ for format rules and examples).
     In TEXT blocks and files, formats must appear at the beginning of the
block, with a separate line for each formatted variable.  Each line must begin
with two periods and a space, followed by the name of the field or variable, a
comma, and the format picture.  Examples:
.. cust,!!!!-!-99
.. today,99/99/99
.. balance,$$$$$$$$$9,99>
.. price,$$,$$$.99
.. codes#3,' xxx xxx xxx '
.. exception,'First: "xxxxxxxxxx"'
     Format lines may not contain comments, and need no quote marks unless the
format itself includes leading or trailing blanks (not recommended) or quote
marks of the other type; see last two example above.
     If a field is not in the selected data file, be sure to use field
redirection as in CODES#3 above.
 
Effect of SET TEXT ON/OFF and CLEAR GETS.
     A Get Table with room for up to 64 gets is available for full-screen
editing commands, like READ, EDIT, and BROWSE.  Whenever a GET is issued
(either by TEXT or @ GET), it is entered into the Get Table so that
Info can rapidly ascertain its position and format during later
processing.
     When SET TEXT ON, the TEXT display macros created with & and # are put
into the Get Table. This setting is usually required for input screens created
with TEXT.
     When SET TEXT OFF, display macros are not put into the Get Table.  This
setting is required when using TEXT for printer output, as in mail-merge
programs, to avoid trying to create a 65th entry in the Get Table.  Over-
filling the Get Table is an error that causes termination of a program.
     It is good practice to place a CLEAR GETS command before the TEXT command
to ensure that the Get Table is empty before starting to fill it again.
 
Examples:
     1.   A text file used in data input with EDIT TEXT (see screen output in
EDIT command section):
.. zip,!9! 9!9
.. phone,999-9999 (999)
.. wphone,999-9999 (999)
.. training,99/99
      NAME...........  %FNAME  %NAME
      ADD_1..........  %ADD_1  %AREA
      ZIP............  @ZIP
      PHONE..........  @PHONE
      WPHONE.........  @WPHONE
      EXPERIENCE.....
          @EXPERIENCE
      COMMENTS
          @COMMENT1
          @COMMENT2
     2.   A program that does formatted output from a data file, including
multi-line output from certain fields:
SET PRINT ON
SET TEXT OFF
SET MARGIN TO 0
SET WIDTH TO 80
IF row()>1                     ;if current row not at top of form,
   SPOOL junk                   ;  eject into throw-away spool file
   EJECT
   SPOOL
ENDIF
USE customer INDEX customer
page=1
PERFORM heading
DO WHILE .not. eof
   IF ROW()>50                  ;start new page if past line 50
      EJECT
      PERFORM heading
   ENDIF
   nameline=TRIM(fname)+' '+TRIM(name)
   address=TRIM(addr:1)+' '+TRIM(addr:2)+' '+TRIM(city)
   remarks=comments
   nameline2=WRAP(nameline,15)  ;WRAP( function trim long strings,
   address2=WRAP(address,17)    ;  leaving remainder for next line
   remarks2=WRAP(remarks,20)
*  text for main line includes customer number, formatted with picture
   TEXT
.. cust,xxx-x-xx
#cust    #nameline2      #address2         #remarks2
   ENDTEXT
*  test in next line depends on fact that concatenating several fields
*    of blanks and then trimming the result leaves a single blank
   DO WHILE ' '<>TRIM(nameline+address+remarks)
      IF ROW()>55               ;start new page if past line 55
         EJECT
         PERFORM heading
      ENDIF
      nameline2=WRAP(nameline,15)
      address2=WRAP(address,17)
      remarks2=WRAP(remarks,20)
*     text same as main text except customer number omitted
      TEXT
         #nameline2      #address2         #remarks2
      ENDTEXT
   ENDDO
   ?                           ;skip line after every customer
   SKIP                        ;get next customer record
ENDDO
EJECT
SET PRINT OFF
*
PROCEDURE heading
   ? DATE(full)
   ?? BLANK(52-col()),'Page '+LTRIM(STR(page,5))
   ? CEN(:COMPANY,60)
   ? CEN('Current Customer Listing',60)
   ?
   ? 'Number   Name            Address           Comments'
   ? '======== =============== ================= ===================='
   ?
   page=page+1
ENDPROCEDURE heading
*
PROCEDURE heading
   ?
   ?? DATE(full)
   ?? BLANK(52-col()),'Page '+LTRIM(STR(page,5))
   ? CEN(:COMPANY,60)
   ? CEN('Current Customer Listing',60)
   ?
   ? 'Number   Name            Address           Comments'
   ? '======== =============== ================= ===================='
   ?
   page=page+1
ENDPROCEDURE heading
     Sample output:
Saturday, March 31, 1990                             Page 1
                  Computer Resellers Corp.
                  Current Customer Listing
Number   Name            Address           Comments
======== =============== ================= ====================
ALB-A-65 Arthur          876 Main Street   Develops LAN-based
         Albredge        Suite 987A San    software
                         Francisco
BRO-W-53 Walter          Freeridge         Hard-disk
         Brownstone      Company 8765      controller and
                         Corvis Drive San  cache expert
                         Jose, CA
 
 
 
 
 
TEXT related topics:
 
\\TEXT MACROS
\\OUTPUT PROCESSING
\\MACROS
\\INPUT SCREENS
.pa
TEXT MACROS.
     Contents of fields and variables can be merged into text blocks for data
input, reporting, listing and mail-merge applications.  Info
provides four special macro symbols for this purpose as follows:
                                Fixed position    Floating position
   Input macros (display/edit)         @                   %
  Output macros (display only)         #                   &
     When a text macro symbol is encountered, Info does the
following:
1.   Checks whether the following characters are the name of a field in the
selected file.  If it is, the current contents of the field replaces &<var> in
the text.
2.   If not a field name, then the characters following the macro symbol are
assumed to be a memory variable name.  If that name is valid, the contents of
the memory variable replaces <var> in the text.
3.   If <var> is neither a field nor a variable, it is assumed not to be a
macro, and both the macro symbol and <var> are output as a literal.
     When the macro symbol & is used and SET TRIM ON, <var> is trimmed before
it is merged.  The position of all text to the right of <var> in the same line
is adjusted so that the number of spaces after <var> in the output is the same
as in the TEXT, no matter how wide <var> is.
     Caution: In a TEXT macro, <variable> must be terminated by blank, tab,
punctuation mark, or a macro symbol; it cannot be terminated by a graphics
character (since in many non-English character sets these characters are
normal or accented alphanumeric characters).  It also cannot be terminated by
a colon or an underscore, since these are valid parts of a field or variable
name.
.pa
OUTPUT PROCESSING
     The TEXT command can be used to do output or list processing.
     Any variable (field, memory variable, or system variable) can be merged
into the document and output by using &<var> or #<var> in the text.
     As described above, the & macro will trim the contents of <var> when
output when SET TRIM ON, and always adjusts the material to its right on the
same line depending on the width of the contents of <var>.  Sometimes, it is
more useful to output at an absolute location with a variable (as opposed to
merging); to do this use the #<var> form.  #<var> does not trim or adjust the
position of other items on the line, creating the possibility that later items
in the line may be overwritten.
     A paragraph is a portion of the text between two carriage returns
(obtained by hitting <ENTER>).  A paragraph is formatted by the TEXT command
using word wrap (if there is not enough room for a word on a line, it is
displayed/printed at the start of the next line).  The page width and the left
margin are set by the SET WIDTH and the SET MARGIN commands (see SET WIDTH and
SET MARGIN).
     Control codes can be sent from the text using the symbols ^ (caret) and \
(backslash).
     The caret.  When Info comes across a ^, it checks for the next
character.  If the next character is also a ^, the two characters are sent as
a single ^.  If the next character is not a ^, it is sent as a control
character; for instance, ^C is sent as Ctrl-C.
     Examples for ^:
         ^^        sent as ^
         ^C        sent as Ctrl-C
         ^^C       sent as ^C
     The backslash.  When Info comes across a \, it checks for the
next character.  If the next character is also a \, the two characters are
sent as a single \.  If the next character is not a \, Info checks for
digits; it grabs as many digits as there are, up to three.  The digits are
converted into a number, and the number is sent as a code between 0 and 255.
     Examples for \:
         \\        sent as \
         \2a       sent as code 2, followed by a
         \0020     sent as code 2, followed by the character 0 (002 is
                     the 2)
         \27x\000  sent as code 27 (escape), x, code 0
     Examples:
TEXT
This text will be sent to the screen or the printer.  You can set the left
margin and the text width.  The text is automatically word wrapped.
ENDTEXT
     Now the same in letter quality mode on the Epson LQ-1500 printer:
TEXT
\27x\001This text will be sent to the screen or the printer.  You can set the
left margin and the text width.  The text is automatically word wrapped.
ENDTEXT
.pa
INPUT SCREENS
     The TEXT command can be used "to paint" input screens.  @<var> is a GET,
activated by a READ command.
     @<var> also has a floating-position form, %<var>, which adjusts the
material to its right on the same line depending on the width of the contents
of <var>.
     Neither @<var> nor %<var> trims the present contents of the variable.
     Examples:
TEXT
     @fname              @name               @dept
ENDTEXT
TEXT
     %fname  %name  %dept
ENDTEXT
     Both create a one-line input format that can be used with BROWSE OFF (or,
if the macro line is placed in a text file, with BROWSE TEXT.  The second form
is easier to use, since there is no concern about the width of the various
fields. For example, the maximum width available for NAME in the first form is
20 characters; if it is 20, it runs into DEPT, and if more than 20, it will
suppress DEPT input completely.
.pa
TOTAL
Summarize the information from the selected file (indexed) to a new file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ TOTAL [<scope>] ON <str exp> TO <file> [FIELDS <field list>]       ║
     ║      [FOR <cond>]                                                  ║
     ║                                                                    ║
     ║ <str exp>    trigger expression                                    ║
     ║ <file>       new file to contain summary information               ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>               selection of records by scope                ║
     ║                          (default scope: ALL)                      ║
     ║ FIELDS <field list>   the fields to be totalled                    ║
     ║ FOR <cond>            selection of records by <cond>               ║
     ╚════════════════════════════════════════════════════════════════════╝
     The selected file must be indexed or sorted on <str exp>.  The records of
the selected file can be grouped by the value of <str exp>: in each group
<str exp> has the same value.
     This command creates a new file <file>; for each group of records of the
selected file, a record is entered in the new file.
     This new record is the same as the first record of the group, except that
the numeric fields in the <field list> are replaced by their total for all the
records in the group.  (Specifying a logical or a character field in the
<field list> will cause an error.)
     Deleted records are ignores irrespective of SET DELETED command.
     The following steps describe in detail how this command works:
     Step 1. Copies the structure of the selected file to <file>.
     Step 2. Appends the first record which satisfies the FOR clause (note
also scope, deleted records are disregarded) from the selected file to the new file.
     Step 3. Evaluates <str exp> and saves it in a temporary variable.
     Step 4. Takes all subsequent records (if any) for which <str exp> does
not change. Adds up the fields in the FIELDS clause (if any) and stores the sum in the record appended to <file> while <str exp> continues to match the value saved in the temporary variable.
     Step 5. Continue with Step 2, using the first record for which <str exp>
has a new value.
     If no FIELDS clause is in the command line no addition is performed, and
the resulting file consists only of the first record encountered for each
different value of <str exp>.  A frequent use of this feature is to purge the
file of records with duplicate keys.
.pa
UPDATE
Update the selected file from an indexed file by replacing selected fields.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ UPDATE FROM [<scope>] <file number> ON <str exp> [REPLACE <field1> ║
     ║      WITH <exp1>,...,<fieldn> WITH <expn>] [FOR <cond>]            ║
     ║                                                                    ║
     ║ <file number>     the location of the FROM file                    ║
     ║ <str exp>         the expression that is the key for finding       ║
     ║                      the record in the FROM file                   ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <scope>         selection restricted by scope (default scope: ALL) ║
     ║ REPLACE <field1> WITH <exp1>,...,<fieldn> WITH <expn>              ║
     ║                 where field1,..,fieldn are fields of the file      ║
     ║                    in use                                          ║
     ║                 <exp1>,...,<expn> are expressions involving fields ║
     ║                    of both files                                   ║
     ║ FOR <cond>      selection restricted by <cond>                     ║
     ╚════════════════════════════════════════════════════════════════════╝
     The selected file need not be indexed.  This procedure takes all the
appropriate records of the selected file one at a time.
     The FROM file has to be indexed by <str exp>; the expression,
<str exp>, is made up of character fields shared by the two files, and by memory variables and constants.
     This procedure works as follows:
1.   Takes the first appropriate record (that is, the first non-deleted record
satisfying the <cond> and within the scope).
2.   Evaluates <str exp> in the selected file.
3.   Finds the first matching record in the FROM file.
4.   If the FIND is not successful, an "UPDATE ERROR" message is sent showing
both the record number and the value of <str exp> in the selected file.  If
SET PRINT ON, messages are sent to the printer.
5.   If the FIND is successful, the procedure replaces the fields of the
selected file with the expressions, <str exp>, made up of fields of both
files.  All fields names are assumed to be in the updating file, so make sure #n is attached to any field names from the FROM file.
6.   Procedure continues with the next appropriate record as long as records
remain within the <scope>.
     If there is no REPLACE clause, UPDATE simply checks whether all the
expected records of the FROM file are present.
.pa
USE
Open data file for use, optionally, with index files.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ USE <file> [INDEX <file list>] [COMPILE]                           ║
     ║                                                                    ║
     ║ <file>    the data file to use                                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ INDEX <file list>    list of index file names to use               ║
     ║ COMPILE              open data file at compile time only           ║
     ╚════════════════════════════════════════════════════════════════════╝
     The command USE opens a data file for use.  To open one or more index
files with the data file, use INDEX and the index file name(s).  The first
index file is the Master Index; this one is in use with the FIND, LIST, SKIP,
etc. commands.  All other index files named will be updated by all commands.
     The option COMPILE is used to open a data file at compile time only.
It is used in situations where the data file to be used at run time is not
available at compile time.  One remedy is to put the name of the data file
in a macro, but then all the field names must be in macros.  COMPILE offers
a better solution if a data file with the same structure is available at
compile time.
     Caution: Avoid using data and index file names that start with the
letters "COMP", since the compiler may mistake the file name for the COMPILE
keyword and make it impossible to use the file in a program.
.pa
VARIABLES
Enters a list of memory variable names into the variables table.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ VARIABLES <variables list>                                         ║
     ║                                                                    ║
     ║ <variables list>  list of memory-variable names                    ║
     ╚════════════════════════════════════════════════════════════════════╝
     Info allows up to 128 variables to be defined at a time.  Their
names are listed in a variables table, which is displayed with the LIST MEMORY
command.
     When a program is compiled, each time Info encounters a name
not already in the table, it is added.  As a programmer, you can control the
order of variables in the table by naming them in the variables list with the
VARIABLES command.  This is not only good practice in general, but it can help
in debugging, and makes it possible to be sure every variable you use is being
defined, and that no others are being inadvertently created.
     The variables command should never be used in a subroutine, and can be
used only once in the main routine.  It should come after any GLOBAL command,
but before any other variable is defined.
.pa
WAIT
Accept one character from the keyboard.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ WAIT [TO <memvar>]                                                 ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Option:                                                            ║
     ║                                                                    ║
     ║ TO <memvar>    store the character into this variable              ║
     ╚════════════════════════════════════════════════════════════════════╝
     When Info encounters the WAIT command, the program execution
stops, the message: WAITING is displayed; Info waits for a character
to be entered at the keyboard.   When a key is hit, program execution
continues.
     If the option: TO <memvar> is used, the character is stored in the string
memory variable <memvar>; this cannot be a matrix variable.  If the variable
<memvar> does not exist, it will be created.
     This command is useful to suspend the program execution so that the user
can read a message on the screen, and maybe make a choice.
.pa
WINDOW
Defines the active window, that part of the screen to which relative output
can be sent.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ WINDOW                                                             ║
     ║ WINDOW <row1>,<row2> [COLOR <windowcolor> [<bordercolor>]]         ║
     ║ WINDOW <row1>,<col1>,<row2>,<col2> [COLOR <windowcolor>            ║
     ║     [,<bordercolor>]] [BLANK/DOUBLE]                               ║
     ║                                                                    ║
     ║ <row1>,<row2>  the top and bottom of the window to be created;     ║
     ║                  with no column numbers given, the window is       ║
     ║                  full width with no border permitted               ║
     ║ <row1>,<col1>  the coordinates of the top-left corner of the window║
     ║ <row2>,<col2>  the coordinates of the bottom right corner of the   ║
     ║                  window                                            ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ COLOR <windowcolor>   the color of the area inside the window      ║
     ║       <bordercolor>   the color of the window border               ║
     ║ BLANK                 the window has no border                     ║
     ║ DOUBLE                the window double-line borders (default      ║
     ║                         single-line borders)                       ║
     ╚════════════════════════════════════════════════════════════════════╝
     Unlike the BOX command, WINDOW erases the area within the coordinates
given, and if corners are specified, displays an optional border one space
outside the border coordinates.
     Although the fixed-position display commands like @ SAY can write either
inside or outside the window, all the relative display commands like ?, ??,
LIST, DISPLAY, TEXT, etc., are restricted to the active window.
     The window can be deactivated (i.e., reset to the entire screen size) by
the WINDOW command alone.
     The rows are numbered 0 to 24. Since a row is always allowed above and
below the window coordinates, the actual range of row numbers for the WINDOW
command is 1 through 23.
     The columns are numbered 0 to 79. Since a column is always allowed to the
left and right of the window coordinates, the actual range of column numbers
for the WINDOW command is 1 through 78.
     Note that commas are required between coordinates, but are not permitted
before the keywords COLOR, BLANK, and DOUBLE.
     In programs, WINDOW is often used to position TEXT and may be useful in
setting up BROWSE, EDIT, WRITE and other input/output displays.
.pa
WRITE
Activate the program editor.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ WRITE [<file>/.<volume>] [OFF]                                     ║
     ╟────────────────────────────────────────────────────────────────────╢
     ║ Options:                                                           ║
     ║                                                                    ║
     ║ <file>     name of file to be created or edited                    ║
     ║ <volume>   number of a volume in the current library; a numeric    ║
     ║              expression                                            ║
     ║ OFF        omit header and opportunity to rename file or volume    ║
     ╚════════════════════════════════════════════════════════════════════╝
     A simple program editor is provided to make it possible to write and edit
programs in Info.  If <file> or <volume> is not specified, the last
file used is understood to be the file to edit.  If no extension is specified,
PRG is assumed.  This editor is very useful for debugging programs and reports.
     Note that library volumes are addressed by placing a period in front of
the volume number, which can be either a numeric constant or a numeric
expression.  Do not confuse this usage with a decimal designation.
     OFF causes WRITE to omit the top three lines of the screen (file name and
ruler, etc.) and places the cursor at the beginning of the file in the top
left corner of the current window (the entire screen if no window is active),
and to save the file immediately upon sensing the <End> key without giving an
opportunity to change the file name.    WRITE OFF is used primarily inside
programs under program control, and with an active window.
     The editing keys are the same as in full-screen editing.  WRITE uses an
80 character "window" for its 254 character lines.
     The maximum size of a text file is about 20,000 characters with no data
files open.  Using data and index files reduces space available for WRITE, as
does running WRITE inside a program; consider running WRITE from a subroutine
instead of the main routine if maximum file size is required.
     Editing keys are displayed by WRITE when you press Alt-H.
     To break a line into two, press <Ins> to get into insert mode, and press
<ENTER>.  To merge two lines, delete the end of line character.  When you
leave the line (with a cursor key or <End>), the two lines merge.
     Alt-F formats program files; it indents the lines according to the
program structures and capitalizes the first command verb on every line.
     When using WRITE, Alt-H displays a screen of information (press any
key, and the help screen disappears).
.pa
ZAP
Erase all records in the selected file.
     ╔════════════════════════════════════════════════════════════════════╗
     ║ ZAP                                                                ║
     ╚════════════════════════════════════════════════════════════════════╝
     This command erases all the records.  This is not a DELETE.  The records
cannot be recalled!  Use this command with care!
     If the selected file is indexed, it is automatically reindexed after ZAP.
     ZAP releases the disk space previously used by the records of the data
file.
.pa
REPORT KEYWORDS
     Keywords that take no arguments are described under REPORT command. Others:
\\FIELDS Keyword
\\FILE Keyword
\\HEADING Keyword
\\INDEX Keyword
\\LENGTH Keyword
\\MESSAGE Keyword
\\PICTURE Keyword
\\RELATION Keyword
\\SELECT Keyword
\\SETUP Keyword
\\SPOOL Keyword
\\SUBTOTAL Keyword
\\TITLE Keyword
.pa
TITLE KEYWORD
              TITLE - string/<str exp>
     This keyword is followed by the title of the report; the title appears
centered as the third line of the report.  If no title is specified in the
text file, then the string in the system variable :TITLE (if any) is used
for the title.
     If a <str exp> is used, it will be evaluated, and used as the title.  If
an invalid expression is used, it will be printed as a literal.
     Info looks at the TITLE line; what appears to the right of the
hyphen is evaluated as an expression.  If it is valid, then it is used as an
expression.  If it is not, then it is printed "as is."
     So to get Annual Report as the title, simply use the line
TITLE - Annual Report
No quotation marks are needed.
     The TITLE keyword may be used twice:
TITLE - string1
TITLE - string2
Then the title is in two lines, both centered.
     If ASOF is a variable containing the date of the last accounts-receivable
aging in the standard format, then
TITLE - 'Accounts receivable as of '+DATE(FULL,asof)
will display
        Accounts receivable as of Thursday, September 19, 1991
.pa
FILE KEYWORD
              FILE - <data file> [INDEX <index file>]
     This keyword opens the data file (as file 1, if there was a file open as
file 1, it is first closed) and, optionally, the index file.
     This keyword may occur a number of times.  The second time it opens file
2, then file 3, and so on.  Since the reporting is done on the first data file
opened by FILE, more than one file should be opened only if relations are used.
     If there is no FILE line, REPORT uses the current data file.  If none is
open, an error message (usually: 2. Variable not found.) is given.
.pa
INDEX KEYWORD
              INDEX - <exp> TO <index file name> [FOR <cond>]
     This keyword will index the last data file opened with the FILE keyword
on the expression <exp> to the specified index file.  If this is only a temporary index, then you should specify a name such as TEMP.  A condition can be specified to limit the index to only those records matching the condition; this is almost always faster than using SELECT or a FOR clause on the REPORT
command.  (Note: it is faster to index a file using the INDEX ON command
outside REPORT, whether a condition is specified or not.)
.pa
FIELDS KEYWORD
              FIELDS - <exp1>,<exp2>,...
     This is the expression list; these expressions fill the columns of the
report.  Often, these expressions are just field names, though they may be
arbitrary expression including fields (from various data files), variables,
and constants.
     If all the expressions do not fit on one line, then leave a comma at the
end of the line and continue on the next line.
.pa
HEADING KEYWORD
              HEADING - string1,string2,...
     These are the column headings for each expression in FIELDS line.
Separate the strings with commas.  The spacing of each column is done by the
program based on the largest of the following: the length of the heading, the
width of the field, and the picture clause in the PICTURE line.  Blanks on the
left and on the right of a heading are counted in the width.
     To move a column to the right, put spaces in front of the column heading.
To make a column wider, put spaces at the end of the column heading.  To move
the column heading of a numeric field to the left, put spaces at the end of
the column heading.
     If no heading is required for a column, it may be omitted, but its comma
is required if any later columns are to have a heading; no trailing commas are
permitted, since they would be understood as continuation characters merging
the next keyword to the HEADING line..
     If the strings in the HEADING line do not fit on one line, then leave a
comma at the end of the line and continue on the next line.  Do not break a
heading with a comma.
     Multi-line headings.  In the HEADING line, a semicolon (;) breaks the
heading into more than one line.  At most three lines are permitted.
.pa
PICTURE KEYWORD
              PICTURE - <format list>
     The PICTURE keyword is used to indicate which expressions (in the FIELDS
line) are to be totaled.  The PICTURE line also shows how the expressions and
totals (and subtotals) are to be displayed.
     A format is some 9s and, optionally, a decimal point or other special
characters used in the format clause for numbers (see the command @).
     A format list is a number of formats separated by commas.  Some formats
may be missing, but the commas have to be there as long as formats are required
to reach the last field requiring accumulation.  No trailing commas are
permitted, since they would be understood as continuation characters merging
the next keyword to the picture line.
     Negative values can be displayed in any of three ways.  The default is to
use a leading minus sign.  It is possible to surround negative values with
pointed brackets, or to use trailing minus signs.
     If a format includes a comma, that format must be enclosed in quotes.
     There can be no format for character fields in the PICTURE line, since no
strings are carried from record lines to total lines.  To format a character
field, use PIC( or other functions.
.pa
SUBTOTAL KEYWORD
              SUBTOTAL - <exp>
     This keyword causes subtotals to be printed when the expression <exp>
changes.  Subtotaling is done only for numeric expressions that are specified
in the PICTURE line.
     Two levels of subtotaling.  If there are two SUBTOTAL lines:
SUBTOTAL - <exp1>              "inside level"
MESSAGE - string1              message for the "inside level", footer
SUBTOTAL - <exp2>              "outside level"
MESSAGE - string2              message for the "outside level", header
two levels of subtotaling is done.  <exp1> is the "inside" level (the sub-
subtotal) and <exp2> is the "outside" level (the grand subtotal).
     Subtotaling produces erratic result if the data file is not
sorted or indexed in a way to group all the items with the same <exp> in one
group.  The command REPORT works whether or not this is the case.
.pa
MESSAGE KEYWORD
              MESSAGE - <str exp>
     This keyword introduces the message to be displayed on the report lines
at the start of a subtotaled group; e.g., 'Salesman - '+salesm.
     When two levels of subtotaling are specified, the message for the outside
level appears as a header; the message of the inside level appears with the
sub-subtotal.  String1 is printed from the start of the line.  Make sure that
there is enough room for string1 before the start of the first totaled column.
     For instance, if the file is indexed on salesman+style, then salesman is
exp2, the outside level, and salesman+style is exp1, the inside level.  Thus
one obtains a sales report grouped by salesman (outside level), and within
salesman by style (inside level):
SUBTOTAL - salesman+style
MESSAGE - 'Style '+style
SUBTOTAL - salesman
MESSAGE - 'Salesman '+salesman
     Note that the inside subtotal expression in on salesman+style instead of
by style alone; this is done because the last record for one salesman might be
the same as the first record for the next salesman, thus giving confusing
results.  Both subtotal expressions should be some leftmost part of the index
expression, with the inside expression longer than the outside expression.
.pa
RELATION KEYWORD
              RELATION - <str exp> TO <file number>
     This keyword sets a relation between file 1 and the file <file number>.
     There can be a number of these lines.  File 1 can be in relations to file
2, file 3, and so on.  The relations are always between file 1 and another
file.
.pa
SETUP KEYWORD
              SETUP - <setup string>
     SETUP establishes a string of control characters to be sent to the
printer when printing begins.  It should not be used if neither printing nor spooling is in effect.
     The setup string is a list of character descriptors, separated by commas.
Each descriptor may be a number (the ASCII value of a character), a hex number
followed by an "h" (the hex value of a character, or any alpha character.
.pa
SPOOL KEYWORD
              SPOOL - <file name>
     This is an alternative to the PRINT keyword and SET PRINT ON, and should
not appear if either of the others is present.  It sends the report to the
file <file name> (default extension TXT).
     Spool a report if you want to pretty it up with your word processor, or
include it in a document, or print it some other time.  The Info
command SPOOL finename TO PRN or the operating system command PRINT can later
print the report in the background mode from this file.
     Note that if <file name> already exists, the report will be added at its
end; it will not be overwritten.  (Do not confuse the SPOOL keyword with the
SPOOL command, which does overwrite existing files.)
.pa
SELECT KEYWORD
              SELECT - <cond>
     Select by condition <cond>; the same as a FOR clause in the REPORT
command.  If a FOR clause is used in the REPORT command, it overrides the
selection of the SELECT line.  If a FILTER is in effect, only records which
match both the filter and the select condition are included in the report.
Caution:  Do not use SELECT or SET FILTER when running a report with a SUBTOTAL; create a special index with the required records instead.
     Note that NODETAIL can be used only when SUBTOTAL is also used. NODETAIL
modifies a report with subtotaling: only the totals and subtotals are shown.
The expressions from the FIELDS line and the column headings from the HEADING
line are not displayed.
.pa
LENGTH KEYWORD
              LENGTH - <num exp>
     This sets the number of printed lines per page.  For instance,
LENGTH - 40
will set the page length at 40.
.pa
MEMO FIELDS
     Memo fields may be specified in the structure of any data file of any
type.  This may be done in either CREATE or MODIFY.  The field width is
automatically 10 characters, but what you see when the field is displayed or
edited is either "memo" if the memo has been attached to the record, or
"MEMO" if a memo is present.
     All memos associated with a data file are stored in a file of the same
name, but with a DBT extension (standing for data base text).
     Since memo fields were originated in dBASE III, many database programs
still use its standard format, which is not compatible with dBASE IV.  Info
handles either format when a DBT file is created externally, but all DBT
files created by Info itself use the same format as dBASE IV version 1.1.
This format has the advantage of reusing space that becomes available inside
the DBT file, in much the same way as Info's libraries have always dome; the
original memo-file format grew endlessly.

1. Writing & Editing Memos.
     Memos may be written and edited in two ways:
WITH THE WRITE COMMAND:
     Whenever a data file with one or more memo fields is open, you may
create or edit a memo attached to any memo field in the current record by
entering WRITE with the name of the field, preceded with the letter M and a
period.  For example, WRITE M.COMMENT will open the memo associated with the
field COMMENT and allow you to edit it.  If it does not already exist, it
will be created.
INSIDE FULL-SCREEN EDITING
     You are in full-screen editing whenever you are executing READ, EDIT,
BROWSE or APPEND commands.  If a memo field is on the screen, you may move
your cursor to the memo field and press Alt-W to enter WRITE in read/write
mode, or Alt-R to enter WRITE in read-only mode (no changes are saved).
Again, if no memo already exists, it will be created.
     Memos may be copied to or from DOS files and library entries inside
WRITE.  For example, to write M.COMMENT out to disk, merely change its name
before storing it for a valid DOS name, such as COMMENT.DAT.

2. Displaying Memos.
     Memos are displayed with the TEXT command.  Just as you can display a
DOS file or library entry by naming it after the TEXT command (examples:
TEXT comment.dat or TEXT .123), you may name a memo field using the same
"M." convention used by WRITE (example: TEXT m.comment).
     TEXT's margins and width are controlled by the SET MARGIN and SET WIDTH
commands.  When writing to the screen, positioning may also be controlled by
setting a WINDOW, with or without a border.
     Be aware when printing to the screen that TEXT stops the display when
it reaches the last line of the window, or of the current screen if no
window is in effect.  It waits for a keystroke before proceeding, but no
prompt is displayed.  Pressing <Esc> is not recommended.
     Example programs:
     1. Using a DO WHILE loop to control movement between records, memo
fields are successively displayed:
USE memodemo                   ;a data file with memo fields
WINDOW                         ;these two lines initialize the screen
CLS
DO WHILE t                     ;do endlessly, or until <Esc> is pressed
   WINDOW 1,2,9,77             ;single-line window in top half of screen
   TEXT
   NOTE_NUM #NOTE_NUM
   NOTE_NOTE #NOTE_NOTE
   press a key:
     - (minus) for previous memo
     <Esc> to exit
     any other key for next memo
   ENDTEXT
   WINDOW 12,2,23,77           ;window over botton half to display text
   TEXT m.note
   dummy=inkey()               ;wait for a keystroke
   IF dummy=asc('-')           ;compare to minus sign...if it is, skip back
      IF #>1                   ;skip -1 only if we're past top of file
         SKIP -1
      ENDIF
   ELSE
      SKIP                     ;otherwise, skip forward
   ENDIF
ENDDO
     2. Use EDIT OFF with an ON FIELD structure to control display of
memo fields and allow memos to be created and edited.
USE memodemo                    ;same file as in previous example
SET text on                     ;we want non-editable display to update
recnum=#                        ;variable to show record number
WINDOW                          ;initialize screen
CLS
WINDOW 2,2,9,77                 ;window for top half of screen
TEXT
.. recnum,9999
                                            Record #recnum

         NOTE_NUM.... @NOTE_NUM
    Use the standard EDIT keys, including PgUp and PgDn between records.
    To edit MEMO, place cursor in this field and press Alt-W: @note

         NOTE_NOTE... @NOTE_NOTE
ENDTEXT
SCREEN 1,2                      ;save screen as it is to screen 2
ON FIELD                        ;set up ON FIELD
FIELD 0                         ;on entry to record...
   recnum=#                     ;get current record number
   SCREEN 2,1                   ;restore original screen and window
   WINDOW 12,2,23,77            ;new screen to put TEXT into
   TEXT m.note
FIELD note                      ;when leaving memo field
   WINDOW 12,2,23,77            ;display memo again to ensure changes shown
   TEXT m.note
ENDON
EDIT off                        ;edit the records
WINDOW                          ;cancel the window
CLS                             ;erase the screen
