home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Shareware 1 2 the Maxx
/
sw_1.zip
/
sw_1
/
DBASE
/
REXL210.ZIP
/
REXL.DOC
< prev
next >
Wrap
Text File
|
1992-05-16
|
236KB
|
5,647 lines
RExL Version 2.10
A Rule-based Applications Development Environment
From
The Software Loft,
Lough Guitane,
Killarney,
Co. Kerry,
Ireland. Tel: [+353] 64-54014
Internet: softloft@iruccvax.ucc.ie
Compuserve: 100042,1237
-- Part I -- The Main Manual --
Information in this document is subject to change without
notice and does not represent a commitment on the part of
The Software Loft. The software described in this manual
may be used and copied within the terms of the license
agreement.
Turbo C, Turbo Pascal and Sidekick are registered trademarks
of Borland International. dBase III+ and dBase are
registered trademarks of Ashton-Tate.
(C) Copyright, The Software Loft, 1992. All rights
reserved. If you have any difficulties, please contact us
at the following address:
The Software Loft
Lough Guitane
Killarney
Co. Kerry
Ireland Telephone: [+353] 64-54014
Internet: softloft@iruccvax.ucc.ie
Compuserve: 100042,1237
Contents
Chapter 1 Introduction 3
1.1 What is RExL . . . . . . . . . . . . . . 3
1.2 System requirements . . . . . . . . . . 4
1.3 Installation . . . . . . . . . . . . . . 4
1.4 Features . . . . . . . . . . . . . . . . 4
1.4.1 Editor . . . . . . . . . . . . . . 5
1.4.2 Runtime-Debugger . . . . . . . . . 6
1.4.3 Language . . . . . . . . . . . . . 6
1.5 The Manual . . . . . . . . . . . . . . . 7
Chapter 2 Language 9
2.1 Variables . . . . . . . . . . . . . . . 9
2.2 Constants . . . . . . . . . . . . . . 10
2.3 Arrays . . . . . . . . . . . . . . . . 11
2.4 Operators . . . . . . . . . . . . . . 12
2.4.1 Mathematical Operators . . . . . 12
2.4.2 Comparison Operators . . . . . . 14
2.5 Functions . . . . . . . . . . . . . . 14
2.6 Expressions . . . . . . . . . . . . . 16
2.7 Assignments . . . . . . . . . . . . . 18
2.8 Statements . . . . . . . . . . . . . . 19
2.9 Inference . . . . . . . . . . . . . . 19
2.10 Rules and Execution . . . . . . . . . 20
2.11 Subrules . . . . . . . . . . . . . . 21
2.12 Rule Modifiers . . . . . . . . . . . 22
2.12.1 BackTo . . . . . . . . . . . . . 23
2.12.2 Not . . . . . . . . . . . . . . 23
2.12.3 While . . . . . . . . . . . . . 23
2.12.4 Multi . . . . . . . . . . . . . 24
2.12.5 Single . . . . . . . . . . . . . 24
2.12.6 Zap . . . . . . . . . . . . . . 24
2.13 Other Modifiers . . . . . . . . . . . 24
Chapter 3 Quick Start 27
3.1 Introduction . . . . . . . . . . . . . 27
3.2 Creating an Application . . . . . . . 28
3.3 Running the Application . . . . . . . 29
3.4 Expanding the Application . . . . . . 30
i
3.5 Debugging the Application . . . . . . 32
Chapter 4 The Editor 35
4.1 Introduction . . . . . . . . . . . . . 35
4.2 Interface Conventions . . . . . . . . 36
4.3 Editor Basics . . . . . . . . . . . . 39
4.3.1 File menu . . . . . . . . . . . . 41
4.3.2 Edit menu . . . . . . . . . . . . 43
4.3.3 Run menu . . . . . . . . . . . . 43
4.3.4 Lists menu . . . . . . . . . . . 44
4.3.5 Options menu . . . . . . . . . . 46
4.3.6 Import menu . . . . . . . . . . . 47
4.4 Using the Editor . . . . . . . . . . . 49
4.4.1 Entering Statements . . . . . . . 50
4.4.2 Entering Rules . . . . . . . . . 51
4.4.3 Entering Screens . . . . . . . . 52
4.5 Editor Lists . . . . . . . . . . . . . 52
4.5.1 Reference List . . . . . . . . . 53
4.5.2 Rule List . . . . . . . . . . . . 53
4.5.3 Screen List . . . . . . . . . . . 53
4.5.4 Unused Rule List . . . . . . . . 54
4.5.5 Unused Screen List . . . . . . . 54
4.5.6 Variable List . . . . . . . . . . 54
4.5.7 Function List . . . . . . . . . . 55
4.6 Other Functions . . . . . . . . . . . 56
4.6.1 Graphic Rule Display . . . . . . 56
4.6.2 Miscellaneous keystrokes . . . . 57
4.6.2.1 Cut and paste . . . . . . . 57
4.6.2.2 Editing keys . . . . . . . . 57
4.6.2.3 Other keys . . . . . . . . . 58
Chapter 5 Screens in RExL 59
5.1 Introduction . . . . . . . . . . . . . 59
5.2 Fields . . . . . . . . . . . . . . . . 60
5.2.1 Introduction . . . . . . . . . . 60
5.2.1.1 Field Properties . . . . . . 60
5.2.2 Output Fields . . . . . . . . . . 61
5.2.3 Input Fields . . . . . . . . . . 61
5.2.4 Toggle List Fields . . . . . . . 61
5.2.5 Check Box Fields . . . . . . . . 62
5.2.6 Radio Button Fields . . . . . . . 62
5.2.7 Menu Fields . . . . . . . . . . . 63
5.3 Screen Types . . . . . . . . . . . . . 63
5.3.1 Dialog Screen . . . . . . . . . . 65
5.3.2 Display Screen . . . . . . . . . 65
5.3.3 Help Screen . . . . . . . . . . . 66
5.3.4 Menu Screen . . . . . . . . . . . 66
5.3.5 Print Screen . . . . . . . . . . 67
ii
5.3.6 Subscreens . . . . . . . . . . . 67
Chapter 6 Using the Screen Designer 69
6.1 Starting the Screen Designer . . . . . 69
6.2 Basic Design . . . . . . . . . . . . . 70
6.3 Fields in the Screen Designer . . . . 71
6.3.0.1 Output . . . . . . . . . . . 73
6.3.0.2 Input . . . . . . . . . . . 73
6.3.0.3 Toggle . . . . . . . . . . . 73
6.3.0.4 Check . . . . . . . . . . . 74
6.3.0.5 Radio . . . . . . . . . . . 74
6.3.0.6 Menu . . . . . . . . . . . . 74
6.4 Block Operations . . . . . . . . . . . 75
6.4.1 Block Painting . . . . . . . . . 75
6.4.2 Align . . . . . . . . . . . . . . 76
6.4.3 Box . . . . . . . . . . . . . . . 76
6.4.4 Delete . . . . . . . . . . . . . 77
6.4.5 Move . . . . . . . . . . . . . . 77
6.4.6 Copy . . . . . . . . . . . . . . 78
6.4.7 Fill . . . . . . . . . . . . . . 78
6.4.8 Save . . . . . . . . . . . . . . 79
6.4.9 Under shadow . . . . . . . . . . 79
6.5 Sub-screens . . . . . . . . . . . . . 79
6.6 Field control menu . . . . . . . . . . 80
6.6.0.1 Active color . . . . . . . . 81
6.6.0.2 Inactive color . . . . . . . 81
6.6.0.3 Delete . . . . . . . . . . . 82
6.6.0.4 Expression . . . . . . . . . 82
6.6.0.5 Recalc . . . . . . . . . . . 82
6.6.0.6 Justify . . . . . . . . . . 82
6.6.0.7 Width . . . . . . . . . . . 82
6.6.0.8 Necessary . . . . . . . . . 83
6.6.0.9 Precision . . . . . . . . . 83
6.6.0.10 Validation . . . . . . . . 83
6.7 Miscellaneous Functions . . . . . . . 83
6.7.0.1 Changing Field Types . . . . 83
6.7.0.2 Field Utility Keys . . . . . 84
6.7.0.3 Line Drawing . . . . . . . . 84
6.7.0.4 Other Editing Keys . . . . . 86
6.7.0.5 Lists in the Screen
Designer . . . . . . . . . . 86
6.7.0.6 Miscellaneous Keys . . . . . 87
Chapter 7 The Runtime-Debugger 89
7.1 Introduction . . . . . . . . . . . . . 89
7.2 Debugger Basics . . . . . . . . . . . 89
7.2.1 File menu . . . . . . . . . . . . 91
7.2.2 Debug menu . . . . . . . . . . . 91
iii
7.2.3 Lists menu . . . . . . . . . . . 92
7.2.4 Options menu . . . . . . . . . . 94
7.3 Using the Debugger . . . . . . . . . . 95
7.3.1 Step . . . . . . . . . . . . . . 96
7.3.2 Trace . . . . . . . . . . . . . . 97
7.3.3 Watch . . . . . . . . . . . . . . 97
7.3.4 Expression Evaluate . . . . . . . 98
7.3.5 Animation . . . . . . . . . . . . 98
7.3.6 To Here . . . . . . . . . . . . . 99
7.4 Miscellaneous keystrokes . . . . . . . 99
7.5 Command Line Parameters . . . . . . . 100
iv
Tables
Table 2.1: Valid and Invalid Variable Names . .10
Table 2.2: Numeric and String Constants . . . .11
Table 2.3: Array Subscription . . . . . . . . .12
Table 2.4: RExL Math Operators . . . . . . . . .13
Table 2.5: Logical Operators . . . . . . . . . .14
Table 2.6: Comparison Operators . . . . . . . .14
Table 2.7: Function Families . . . . . . . . . .15
Table 2.8: Some Expressions . . . . . . . . . .16
Table 2.9: Operator Precedence . . . . . . . . .17
Table 2.10: Examples of Operator Precedence . .18
Table 2.11: Examples of Assignments . . . . . .19
Table 2.12: Rule Modifiers . . . . . . . . . . .23
Table 2.13: Other Modifiers . . . . . . . . . .25
Table 2.14: Expression Truth Values . . . . . .25
Table 4.1: ASCII Color Translation Table . . . .48
Table 4.2: Function Parameter Abbreviations . .55
Table 5.1: Screen Types . . . . . . . . . . . .64
Table 5.2: Valid Combinations of Screen and Field
Type . . . . . . . . . . . . . . . .64
Table 6.1: Screen Designer Cursor Keys . . . . .71
Table 6.2: Valid Field Sizes . . . . . . . . . .72
Table 6.3: Valid Field Attributes . . . . . . .81
Table 6.4: Keys in Line Draw Mode . . . . . . .86
v
- Main Manual. Page: 3 -
Chapter 1
Introduction
This chapter provides a brief introduction to RExL, its
system requirements, installation and capabilities and quick
signpost to the rest of the manual.
1.1 What is RExL
RExL, short for Rule-base EXpert Language is a fourth
generation language product for PC compatible computers
which is based upon the `expert system' programming
paradigm. It allows the applications developer to prototype
applications rapidly and easily, while producing code which
is easy to follow and understand. RExL comprises an editor
for creating and modifying applications and a runtime module
with incorporated debugger for testing and running the
resulting application.
RExL was developed with the following goals in mind:
o Ease of use: Menus and pop-up lists are available
times through hotkeys for experienced users, and via
pulldown menus for those not so familiar with RExL.
Online context-sensitive, cross referenced help is
available at all times to the user.
o Integrity: RExL was conceived as a single unit, with
all features intimately connected together, unlike
traditional languages where editors and debuggers
are general purpose tools and not tailored for
specific languages.
o Power: RExL not only has a powerful internal language
with 178 functions available but also has a fully
integrated screen designer and dBase compatible
database module.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 4 -
1.2 System requirements
RExL will run on the IBM PS/2, PC/AT, PC/XT, PC, PC/Jr, and
on IBM PC clones. The minimum requirements are:
o 256 KB of memory, although RExL can use as much low
DOS memory as is available.
o PC-DOS 3.0 or greater or MS-DOS 3.0 or greater.
o One high density 5.25" or one 720k 3.5" diskette
drive, although a hard drive with at least 600k free
is recommended.
o An 80-column video card and monitor.
o REXL.EXE, the editor and REXLRD.EXE, the runtime-
debugger module.
1.3 Installation
If you are installing the Shareware version, installation of
RExL is accomplished easily. Copy the single executable
file, REXL200.EXE into the directory where you want to keep
it and run the file by issuing the DOS command
rexl200
The installation will proceed automatically and will require
about 1Mb of disk space.
If you are installing the full registered version, insert
the first distribution disk in your disk drive, log onto it,
issue the DOS command
install
and follow the prompts.
1.4 Features
The RExL package comes in three main parts:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 5 -
o The editor which is used for creating and modifying
applications written in RExL,
o The runtime-debugger module which is used to run and
debug applications.
o The supplementary utilities, not available in the
Shareware version, which complete the suite of
development tools.
The next two sections provide a brief overview of both these
modules. The final section in this chapter gives a quick
introduction to RExL's internal language.
1.4.1 Editor
RExL's editor uses the concept of `folding text' to make the
programmer's job easier. In any computer language,
applications are built up in a pyramidal manner, using
procedures within procedures: this gives the program a two
dimensional structure which has been ignored by traditional
flat file editors. RExL on the other hand understands this
structure and allows the programmer to access procedures
immediately, without having to do searches or large cursor
movements. Lists of all entities defined in your
application are available at all times within the editor,
and most entity lists have cross reference facilities.
The screen designer is an integral part of the editor and
features the following:
o Block mark, copy, move, delete, color, fill and
alignment,
o Box and line drawing,
o Subscreen manipulation,
o IO fields : numeric input and output, character input
and output, radio buttons, check boxes, toggle lists
and menus,
o Screen compression within single screen files.
The cross referenced help system is available at all times
while within the editor and contains almost six thousand
lines of context sensitive help. All RExL functions are
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 6 -
fully explained in the help and come complete with examples
of their use.
1.4.2 Runtime-Debugger
RExL's debugger and runtime module feature line step, trace
and instruction animation using industry standard
keystrokes. A full watch facility and comprehensive
expression evaluator can be used to check variables and
expressions during execution of an application. As with the
editor, all features are available via debugger hotkeys and
pull down menus.
As in the editor, on-the-fly macro definition, store and
retrieval is also featured.
1.4.3 Language
RExL's internal language has been designed to resemble
BASIC. It supplies all the normal mathematical operators of
division, multiplication, addition, subtraction, negation,
exponentiation and logical OR, AND and NOT. The language has
one hundred and seventy-eight functions which are grouped
under the following headings:
o Database: The integral database is dBase III
compatible and supports the use of standard index
files. There are thirty-nine functions controlling
the database module. The number of data files and
index files open concurrently is limited only by DOS.
o Date-Time: There is a full set of date and time
handling functions. These can use the three most
common date and time formats of the USA, Europe and
Japan. There are eighteen functions in this category.
o DOS: The thirteen DOS interface functions perform the
most commonly required procedures, such as file copy,
rename, delete, directory maintenance and system
identification.
o Math: There are forty mathematical and financial
functions (not including the math functions which
operate on arrays and databases). The math functions
cover all the standard trigonometric functions, as
well as random number generation, boolean algebra and
ASCII character manipulation. The financial functions
cover the areas of loans and annuities.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 7 -
o Array handling: There are nine functions which
operate on RExL arrays. Arrays may be numeric or
string in type and can have up to three dimensions.
o Miscellaneous: There are forty-six other
miscellaneous functions which control character
string manipulation, error handling, simple numeric
and string screen IO and keyboard handling, binary
and logical operations and arithmetic.
The language itself is based upon the concept of rules,
which are equivalent to procedures in more conventional
programming languages. Rules are made up of logical blocks
of lines, known as AND-blocks, which execute in much the
same manner as Prolog predicates. The lines themselves
within the rule can be built up of executable statements, in
RExL's internal language, or be made up of other rules.
Screens generated using the screen designer are accessed in
much the same manner as rules. The screen designer allows
numeric and character IO, dialog screen generation, online
help and printer access.
1.5 The Manual
Where keystrokes are specified, the shift, alt or ctrl
segment is written first with the combination key second.
For example, to call up language help, the keystroke is as
follows: Press down the <Ctrl> key and while it is down,
press the <F1> key. This keystroke is written as <Ctrl-F1>.
The plan of the manual is :
o General introduction to RExL
o General guide to RExL's language
o Quick start guide
o In-depth guide to the editor
o In-depth guide to the screen designer (two chapters)
o In-depth guide to the debugger
o Appendices
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 8 -
- Guide to Function Families
- Database Programming
- Function reference
- Keystroke reference
- Afterword
It is recommended that at the very least, you should read
the language guide and the quick start guide.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 9 -
Chapter 2
Language
RExL's language was designed to resemble BASIC, so that
users who had experience in this language would have little
difficulty in switching to RExL. This chapter will
introduce all of the basic concepts which you'll need to
understand before you can begin to program in RExL.
If you have programmed before, then a quick read through
this chapter should be adequate, since the concepts
presented are common across most programming languages.
2.1 Variables
A variable is a name which is used to refer to a location in
memory which stores a retrievable value. In RExL, there are
two types of variable:
* Numeric variables which contain numeric information.
These variables can range in absolute value from
2.225074x10^-308 to 9.7693x10^308 and can hold
numbers accurate to about fifteen decimal digits of
precision.
* String variables which contain character information.
These have a maximum length of eighty characters.
RExL variable names follow the standard conventions for
variable names in most languages. These are that they must
consist of a letter followed by an unbroken sequence of
letters, digits or the underscore character, _. Note that
for compatibility with future RExL products, an underscore
is not allowed as the initial letter of a variable name. To
distinguish between string and numeric variables, all string
variable names have a dollar sign, $, as the last letter in
their name.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 10 -
The following list gives some typical variable names:
Table 2.1: Valid and Invalid Variable Names
name$ String variable
my_age Numeric variable
1st Invalid : initial character is not a letter
my age Invalid : space included in the middle of the name
co$t Invalid : characters after the dollar sign
addr$$ Invalid : double dollar at end
2.2 Constants
A constant is an invariable numeric or string value. Numeric
constants are simply numbers such as 0, 10, 123.456 and so
on. They have the same range of value as the numeric
variables above. For large numbers above one million
trillion, RExL uses the standard computer format scientific
notation. This format is almost identical to that of
scientific notation and consists of a mantissa which can be
up to fifteen digits long and contains the significant
digits of the number, expressed as a number between one and
ten. The mantissa is followed by the letter E (or e,
standing for exponent) followed by a plus or minus symbol
followed by a number between 15 and 308, representing the
power of ten with which the mantissa is to be multiplied.
There are no spaces in between the different sections of the
number and a plus sign is assumed if the plus or minus
symbol is omitted. Thus the average distance from the sun
to the earth can be expressed in this format as 5.8925E+12 =
5.8925x10^12 inches.
String (or character) constants are simply lists of
characters. They are delimited at either end by the double
quotation mark ", and may contain any ASCII character except
that of zero, used internally.
The following table lists a few typical string and numeric
constants.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 11 -
Table 2.2: Numeric and String Constants
1e+6 Numeric value of one million
5e-3 Numeric value of five thousandths
1e+-376 Illegal: confusion over plus/minus and the exponent
is greater than 308
"Hello" The string `Hello'
"Whoops Illegal: no closing double quotation mark
2.3 Arrays
Some applications require lists of string or numeric
information. For example, the list of monthly sales figures
for a single year would require a list of twelve numeric
variables, one for each month. RExL supports the use of
arrays of string and numeric variables to store this type of
information. An individual number or string item in an
array is known as an element of that array.
Arrays more complex than simple lists are also possible, in
fact arrays may have up to three dimensions specified. For
example, if the sales figures for a single year for a number
of different departments were stored, although they could be
stored as above in a one dimensional list, it is more
convenient to store them as a two dimensional list or array:
one dimension to locate the month and one dimension to
locate the department number. Similarly three dimensional
arrays could be used to store the monthly sales figures for
different departments across different years. Two
dimensional arrays can be thought of as a (numeric or string
type) grid with the dimensions specified relating to the
rows and columns of the grid. Three dimensional arrays can
be thought of as a stack of these grids. It is clearly
immaterial to RExL whether the any particular dimension
refers to the row number, column number or depth of a
particular element, however, to keep things clear in your
mind, you should adopt a standard method of reference. We
suggest the convention that the first dimension is column
number, the second is the row number and the third dimension
is the depth. This convention is used elsewhere in RExL and
conforms to the standard (x,y,z) notation used in Cartesian
geometry.
To reference a particular element in an array, RExL needs to
know its position within the array. This is specified by
placing the `co-ordinates' of the element of interest in
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 12 -
square brackets immediately after the array's name. The
co-ordinates of a particular element are known as the array
element subscripts and are based at zero, meaning that the
first element of an array is indexed by a subscript of zero,
the second by a value of one and so on.1In two and three
dimensional arrays, the separate subscripts are separated by
commas. Note that an array must by subscripted by the
correct number of subscripts.
The following table give a few examples of addressing
individual elements of arrays.
Table 2.3: Array Subscription
name$[0] Returns first element in name$[]
age[6] Returns seventh element in age[]
sales[3,0] Returns the number in the first row of the fourth
column of the two dimensional array sales[]
____________________________________________________________
1. This behaviour is compatible with the C language and is
adhered to throughout RExL where all co-ordinates, string
indexes and so on are zero based.
By default, all arrays are dimensioned to ten elements.
This can be changed through the variable dictionary,
described in the chapter on the editor. When you are using
three dimensional arrays, be aware that large amounts of
memory are consumed. As a guide to determining the exact
amount used, each element of a numeric array of any
dimension uses eight bytes of storage. For string arrays,
each element uses four bytes (when the application starts)
and a further eighty-one bytes when an element is first
accessed. This behaviour for string arrays helps to
conserve memory if not all elements in an array are used, as
is usually the case.
2.4 Operators
2.4.1 Mathematical Operators
An operator is a symbol which performs some action upon an
operand (or operands) and returns a value. The standard
mathematical symbols + - x and / with which most people are
familiar are supported in RExL, along with number of extra
ones.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 13 -
They are listed in the following table:
Table 2.4: RExL Math Operators
* Multiplication ^ Exponentiation
/ Division & Logical AND
+ Addition | Logical OR
- Subtraction ! Logical NOT
Note that the minus sign can also be used to denote a unary
minus, that is one which changes the sign of its immediate
operand.
The four operators in the right hand column may not be
familiar to you. The first operator, the exponentiation
operator a caret, ^, is used to raise the first operand to
the power of the second. Thus, 2^2=4 and 3^2=9.
The logical AND operator, the ampersand symbol &, returns
the result of a logical AND of the both operands. This is
equal to one if both operands are non zero, otherwise the
result is zero. So, 1&1 gives 1 but 1&0 returns 0.
The logical OR operator, the piping symbol |, returns the
result of a logical OR of both operands. This is equal to
one if either of the two operands are non zero, otherwise it
is zero. So, 0|1 gives 1 but 0|0 gives 0.
The final logical operator symbol, the exclamation mark !,
performs a logical inversion of its single operand. This
means that it will reverse the logical meaning of the value
to which it is applied. Thus !1 returns 0 and !0 returns 1.
When dealing with the logical operators &, | and !, it may
help you to think of a value of zero meaning False and a
non-zero value meaning True. Thus, !1 is equivalent to
!True, giving False and 1&0 is equivalent to True & False
giving False.
The following table lists the results of the logical
operations of Not, Or and And applied to a pair of True and
False operands.
These logical operators are sometimes referred to as boolean
operators, after the Irish mathematician, George Boole, who
developed the algebra of logic. A number of more complex
logical operations are available as function calls,
including exclusive-or, implication and equivalence.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 14 -
Table 2.5: Logical Operators
A B !A A&B A|B
0 0 1 0 0
0 1 1 0 1
1 0 0 0 1
1 1 0 1 1
2.4.2 Comparison Operators
The final set of RExL symbols are the comparison operators,
which are used to compare one string or number value with
another value of the same type. There are six comparison
operators which are listed below:
Table 2.6: Comparison Operators
= Test for equality
> Test for greater than
<> Test for inequality
<= Test for less than or equal to
< Test for less than
>= Test for greater than or equal to
These operators are defined for both string and numeric
types. When applied to string type operands, RExL uses the
ASCII character set to determine if one string is `less
than' or `greater than' another. Refer to appendix F for an
table of ASCII characters.
2.5 Functions
A function is an in-built part of RExL's internal language
which performs some action, or calculation on some values,
and then returns a value of some specific type. Like
variables, the type of the value they return is indicated by
the presence or absence of a dollar sign. In general, the
return type of a function is not related to its parameters,
the value or values which the function operates upon. The
process of using a function is generally referred to as
calling that function. The values which are given (or
passed) to the function are known as parameters.
You are probably familiar with some functions already: the
mathematical functions log, tan, cos and so forth, are
functions (and available in RExL), since they are passed
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 15 -
some value and return the value of the function at that
particular point. Thus, the value of the tan function at pi
radians evaluates as zero. This could be coded in RExL as
tan(3.1416).
Every RExL function uses a fixed number of parameters,
generally of fixed type. For example, the math functions
above require the use of numeric parameters since trying to
find the logarithm of a string is meaningless. The DISPLAY()
function will write a string on the screen to the current
cursor location. This function takes only one parameter, a
string. To write the string "Hello, world" on the screen,
we could write a RExL line such as DISPLAY("Hello, world").
Passing arrays to functions is rather more complex: Because
some functions taking arrays require arrays of a specific
dimension, dummy subscripts must be passed in place of
numeric ones (the dummy subscript used is the hash symbol,
#). The dummy subscripts are mainly for the benefit of the
internal syntax checker which checks to make sure that you
are not passing a one dimensional array to a function which
requires a two dimensional array. For example, to call the
function ARavg(), which averages the values of a one
dimensional array and requires the name of an array and two
numbers, the function call could be written as
ARavg(numarr[#],0,9).
RExL's function list is divided into six `families' of
functions, each of which is used for some different aspect.
To make the functions easier to locate and remember, every
function in a particular family (except for the
miscellaneous functions family!) start with the same two
letters, both of which are capitalised.
The following table lists the function families:
Table 2.7: Function Families
Letter Abbreviation Uses of Family
AR Array handling
BT Binary bit operations
DB Database handling
DT Date operations
ER Error handling
KB Keyboard handling
OS Operating system functions
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 16 -
In the current release of RExL, there are one hundred and
seventy-eight functions available. The miscellaneous
functions have no special initial letters.
2.6 Expressions
An expression combines constants, variables and function
call return values using RExL's mathematical operators to
produce a single result. For example, the expression 2+2
produces the result 4.
As a general rule, the type (string or numeric) of the
result of an expression is the same as that of the elements
of the expression, although there is one exception to this
rule. This is as follows: when strings are compared, or
more properly, operated upon by the comparison operators,
the return result is a numeric value. This at first may
seem strange, but it makes sense when you apply the earlier
suggestion that non-zero values can be thought of as being
`true' and zero values being False . Thus, if two strings
are compared for equality, we would expect a `true' to be
returned if they were equal and a `False ' otherwise. The
same convention holds true for comparison of numeric values.
In RExL, a true expression is assigned the value of one and
a False expression is assigned a value of zero.
When using numeric expressions, all the operators previously
defined are valid. When using strings however, the only
valid mathematical operator is the + sign, used for string
concatenation or addition. It should be obvious that
attempting to subtract, multiply, divide, take powers or
perform logical operations upon strings has no meaning.
Examine the following expressions and satisfy yourself that
they do what they say they do:
Table 2.8: Some Expressions
a*10 Returns the result of the multiplication of
the numeric variable a and the number 10
time[0]*speed[0] Returns the result of the multiplication of
the first element of the array time[] and
the first element of the array speed[]
a$+"end" Returns the value of a$ with the string
constant "end" appended to it.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 17 -
There is, however, a problem in evaluating expressions when
there is more than one operator: This is to determine the
order in which the sub-expressions (within the expression as
a whole) are to be evaluated. For example is the expression
1+2*3 to be evaluated as 1+(2*3) or (1+2)*3? To overcome
this problem, every operator has a precedence, so that sub-
expressions having operators of higher precedence are
evaluated before those of low precedence. When two
operators have the same precedence, the expression will be
evaluated from left to right, as you would expect. The
complete list of operator precedence is given at the end of
this section.
There is one final operator, the assignment operator which
is denoted by the symbol of colon followed by an equals sign
:=. It is used for assigning a variable to some value.
This will be covered in the next section and is introduced
here so that it can be included in the table of operator
precedence.
Table 2.9: Operator Precedence
Precedence Operator Meaning
8 () Bracketing of sub-expressions
7 ! ^ Logical NOT and exponentiation
6 * / Multiply and divide
5 + - Add and subtract
4 < > <>
= <= >= String and numeric comparison
3 & Logical AND
2 | Logical OR
1 := Assignment
From the table above it can be deduced that for the example
given earlier, the expression would be evaluated as 1+(2*3)
rather than the simple left-to-right parsing of (1+2)*3.
The following table gives some examples of expressions
without brackets and the equivalent bracketed expressions to
demonstrate how the operator precedence table is used to
determine the exact order of evaluation.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 18 -
Table 2.10: Examples of Operator Precedence
Expression Evaluated as Result
1+2*3 1+(2*3) 7
1*2+3 (1*2)+3 5
1+2*3^4 1+(2*(3^4)) 163
2*TAN(3.1416/4) 2*TAN(0.786) 2
2*(10=20) 2*(0) 0
2*10=20 (2*10)=20 1
"a"="b" 0
"a"<"b" 1
Don't proceed until you understand all of the results above,
since the basic ideas presented there are present throughout
RExL. Note particularly, the final two expressions which
are not intuitively obvious since they depend on the
comparison operators, and thus return numeric results. The
second of the two examples involving string constants
requires knowledge of the ASCII character set. For more
information on this, consult the ASCII table given in
appendix F.
2.7 Assignments
An assignment is a special case of an expression. It
assigns the value of some expression to a variable, which
can be either be simple or array type, using the assignment
operator :=. The return type of an expression must be the
same type as the variable whose value is being assigned.
Thus it is not possible to assign a string to a numeric
variable or vice versa. The general format of an assignment
is as follows:
<variable> := <expression>
The <variable> above is sometimes referred to as an LValue,
short for Left hand Value. When using non-array variables,
the LValue is simply the name of the variable. However,
when using array type variables, you must tell RExL what
element you are trying to assign a value to. Thus, you must
include the relevant array element subscripts in brackets
after the array variable's name.
The following table gives some examples of variable
assignment statements:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 19 -
Table 2.11: Examples of Assignments
Expression Result of operation
a:=5 a is assigned the value of 5
t$:="test" t$ is assigned the string "test"
a:=a+1 a is assigned the value of a plus 1, ie: 6
t$:=t$+" string" " string" is appended to the old value of t$
to give a new t$ value of "test string"
ar[0]:=10 The first element of the numeric array ar[]
is assigned a value of 10
ar[a]:=a+4 The seventh element of ar[] is assigned 10
str$[1]:=t$ The second element of str$[] is assigned
the string "test string"
Note particularly, the third and fourth statements which
seem rather counter-intuitive. Recall from the table of
operator precedence that the assignment operator has the
lowest precedence, and thus will be evaluated after
everything else. Thus, the meaning of the statement becomes
`add one to the variable a and assign the result of this
addition to the variable a.' An assignment will always
returns a `true' value of one.
2.8 Statements
`Statement' is a generic term for a complete expression or
assignment in RExL. In other words, it forms a complete
RExL `sentence' which can be interpreted and executed.
When an application is created, it consists of a list of
executable statements, each of which returns some value
(since they are expressions). RExL uses this return value
from a statement to determine its next action: Whether to
execute the next statement in the current list or to jump to
some other location in the application. This will be more
fully explained in the section on rules.
2.9 Inference
Inference is the process of drawing a conclusion from a set
of propositions, each of which can be either true or False .
RExL operates using an inference engine: This is used to
execute the application and to draw conclusions from its
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 20 -
individual lines, each of which will evaluate as either true
or False and are therefore equivalent to propositions.
2.10 Rules and Execution
A rule is the fundamental building block of all RExL
applications and is roughly equivalent to a procedure in
conventional programming languages. Rules are made up of
blocks of lines which may be executable statements, or
further rules.
Every non-blank line in a RExL application has a leading
connector. This is a logical `preposition' which tells the
inference engine how to link up this line with the previous
and following lines in its rule. In the current release,
there are three connectors: AND, If and OR. The use is an
application of these connectors is best illustrated by a
simple example.
If The temperature is ok
And It is not raining
And Tell user to go for a walk
Or Tell user to stay inside and play a game of chess
The meaning of this should be fairly clear: The computer
will tell the user to go for a walk if the temperature is ok
and it is not raining, or else, the computer will tell the
user to play chess. What actually happens during execution
is this: the inference engine starts on the first line and
asks the user `Is the temperature ok ?' (for the moment,
don't worry about how the computer asks this question or how
it gets the reply). If the answer to this question is yes,
that is True, then the inference engine will let execution
pass to the next line and ask the question `Is it raining?'
If the answer is again true, then the computer will `draw
the conclusion' (or more properly, execute the line) that
the user should go for a walk. If on the other hand, the
user had replied no, or False, to either of the questions
then the inference engine would have determined that the
conditions for a walk were not present, passed execution to
the or clause and therefore suggested that the user play
chess instead.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 21 -
Whether the user is advised to stay inside or to go out, the
result of the rule as a whole is the same: It succeeds,
since it has successfully drawn a conclusion.
RExL inserts the connectors itself. The rules for connectors
can be generalised as follows: The first line in an unbroken
sequence of lines will have the connector OR, unless it is
the first non-blank line in a rule, which will always have
the connector If (the meaning of If and OR is functionally
identical). All other lines in the rule will have the
connector AND. It is for this reason that the blocks of
lines are sometimes referred to as And-Blocks.
The rules which the inference engine follows for execution
are as follows: In any rule, execution will begin at the
first non-blank line of the first AND-block within the rule,
that is the line with the If as its connector. It continues
sequentially through the block until one of two conditions
occur: Either a line returns the value zero (for False), in
which case execution will jump and continue at the start of
the next AND block in the rule. Or else execution
successfully reaches the end of an AND block, in which case
the rule returns the value True without any further
statement execution within that rule. If, on the other
hand, a line returns False, and execution tries to continue
at the beginning of the next AND block when there is none
present, then the rule will return False.
2.11 Subrules
If we decided to make the application objective in assessing
the temperature, rather than relying on the user to do so,
we could as the user whether the temperature is within a
certain range to find out whether it is really `ok' or not.
We would therefore expand the definition of the The
temperature is ok rule. Instead of being a simple
unexpanded line, this rule would then `contain' subrules
such as the following:
If The temperature is more than 10 degrees
And The temperature is less than 40 degrees
Therefore, when the application is started, instead of RExL
simply asking the question `Is the temperature ok?', it
would instead ask the two more specific questions to
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 22 -
determine if the temperature is between ten and forty
degrees (Celsius!).
During execution what actually happens is that RExL checks
to see if the rule being executed can be expanded. If so,
then execution passes to the expanded portion, but remembers
where the rule was `called' from. It then executes the
lines within the expanded rule and eventually returns a True
or False value to the original caller of the rule.
So, going back to the example, when execution reaches the
rule `Is the temperature ok?', it expands the definition and
asks `Is the temperature more than 10 degrees ?' If the
answer is `yes' or True, then the next question is asked,
`Is the temperature less than 40 degrees?' If the answer is
again True, then both conditions in the expanded rule are
True and so the the rule would succeed, return True and RExL
will then ask whether it is raining or not, continuing from
where it left off in the parent rule. If, on the other
hand, the user replies `no' or False, to either of the
questions about temperature, then the expanded rule fails
and returns False to the parent rule, thus making the
conditions for a walk unavailable, and therefore suggesting
that the user play chess.
Every application has a master rule (sometimes known as a
`main rule') which is called by RExL when the application
starts. In the current release of RExL, this rule is called
Main Program and cannot be changed. All other rules can
therefore be considered as subrules of the main rule.
It is very important that you understand thoroughly the
action of the inference engine in RExL, and how it executes
rules and returns values. All RExL applications are based
upon the ideas presented in this and the previous section.
You should reread them if you are not happy with them.
2.12 Rule Modifiers
The rules in the previous two sections were basic rules.
That is, that they acted as rule calls and were executed
every time the application called them. There are, however,
a number of different variations upon this theme. These
rule modifiers perform some action other than a simple rule
call. The six rule modifiers are as follows:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 23 -
Table 2.12: Rule Modifiers
Abbreviation Used for
BackTo Rule recall
Not Return inversion of rule call
While Continuously execute rule while true
Multi Make rule multi-pass
Single Make rule single-pass
Zap Reset status of single-pass rule
In the editor, the modifiers are placed between the line's
connector and the name of the rule. The function of the six
modifiers are explained in the next six subsections.
2.12.1 BackTo
Whenever a rule is called by an application, RExL stores the
place in the listing where the rule was called from in a
special area known as the call stack (so called because rule
calls are `stacked' there). The BackTo modifier is used to
clear the call stack back to the last instance of some
previous rule. This can be used when for example, when the
user selects a menu option to restart an application, the
application could contain a line such as:
And BackTo Main Program
BackTo may also come in useful when an error occurs and the
program needs to restart the execution from some point.
Note that if the rule specified doesn't exist in the call
stack, then the application will end, since it can't locate
any place to restart from.
2.12.2 Not
When Not is applied to a rule, it reverses the logical
return value of the rule. Thus, if rule call returns True,
but the rule is modified by the Not, then the rule will
evaluate as False. The Not modifier is mostly used for
logical tests which are easier to evaluate as True than
False (and vice versa).
2.12.3 While
The function of the While modifier is to execute a rule
continuously while its return value is True. This could be
useful for doing some work in a database, where the rule is
designed to fail when the end of the database is reached. A
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 24 -
rule call which is prefixed by While will always fail
because of the nature of the modifier.
2.12.4 Multi
By default, all RExL rules are multi-pass rules. This means
that a rule is expanded and evaluated each and every time it
is called (although this is not standard for expert systems,
where all rules are single-pass). However, it is sometimes
useful to have rules which are not reevaluated every time
they are called, but save their status from one call to the
next. These rules are known as single-pass rules. The Multi
modifier is used to make a single-pass rule a multi-pass
rule.
2.12.5 Single
The Single modifier performs the reverse of what the Multi
modifier does: It makes a multi-pass rule (the RExL
default) into a single-pass rule.
2.12.6 Zap
When a one-pass rule is set up and has been evaluated, but
for some reason, needs to be to be reevaluated (because, for
example, of some changed condition) then the Zap modifier
can be used to reset the status of the one-pass rule to
unknown, and thus the rule will be reexecuted when it is
next called.
2.13 Other Modifiers
Every line, other than a simple rule call, must have a
modifier attached to it. We have already some across the
list of the six modifiers for rules in the previous section.
That list is now completed with the list of modifiers for
the other line types:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 25 -
Table 2.13: Other Modifiers
Modifier Applicable to
[Expr ] Statements
[Dialg] Input and output
[Dsply] Screens
[Help ] Screens
[Menu ] Screens
[Print] Screens
Note that all non-rule modifiers are surrounded in square
brackets. This is to help the programmer distinguish at a
glance whether the line is a rule or screen/statement. The
final five modifiers in the table are applicable only to
screens and are dealt with in the chapter on the screen
designer.
The [Expr] modifier at the beginning of a line indicates
that the line is a statement (either an assignment or
expression). Expressions, as noted before, can return
either a zero value for False or a non-zero value for True,
while assignments will always return True. Examine the
following list of statements and satisfy yourself that they
return the values indicated.
Table 2.14: Expression Truth Values
Statement Returns
1 True
0 False
123*23 True
10-10 False
a:=10 True
a=10*("h"="h") True
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 26 -
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 27 -
Chapter 3
Quick Start
3.1 Introduction
In this chapter, we'll go through the process of creating a
small application in RExL. First, we'll use the editor to
create it, and then the runtime module to run it. In the
final section, we'll use the integrated debugger to debug
the application. If you haven't read the chapter on RExL's
language, you should do so now, since the application
developed there will be created here, and the editor won't
make much sense unless you understand the language.
Every RExL application is stored on disk in two parts, the
first part is the application image. This is the listing
which you can edit using the editor. The second part is the
screen file which stores the screens used in the
application. The application image file has a file
extension of ".RXL" while the screen file has one of ".SCR".
Changes to the screen file are included immediately, while
those to the application listing are saved only when RExL is
instructed to do so. It is for this reason that you should
not modify any screens in an application without updating
the application image on disk, since the two files may go
out of synchronisation.
The RExL system also comes in two parts. The first part,
the editor, is used for creating and maintaining the
application and for designing the application's screens.
The second part is the runtime-debugger which is used to
execute and debug the application. This two part approach
is used because it maximises the amount of memory available
to each module. The two modules are linked, so that you can
run and debug you application without having to exit from
the editor and explicitly run the debugger.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 28 -
3.2 Creating an Application
Start the editor by typing rexl at the DOS prompt and press
<Enter>. After a second or two, the editor screen appears.
If any error messages appear, just press a key and ignore
them.
The menu bar across the top of the screen uses the standard
menu keys of <Left Arrow> and <Right Arrow> to move the
hilite bar and <Enter> to select an option. The hilited
letters in the menu titles (ie `F' in File) can be used to
select an option as can a combination of the Alt key and the
letter (ie <Alt-O> to select the options menu). We want to
edit the application, so select the Edit option from the
main menu and press <Enter>.
The first line in the central edit window will be hilited in
gray, the connector `If' will appear at the left end of the
hilite bar and the cursor will be placed a few characters in
from this. The first line of our application was `The
temperature is ok', so just type this in to the editor and
press <Enter>. The cursor and hilite bar will then jump to
the next line and an `And' connector will appear at the
start, in the same position as the `If' of the previous
line. The rules for the automatic insertion of connectors
will be explained shortly.
Enter in the next line of text, `It is not raining' and
again press <Enter> to go to the next line (You can press
<Down-Arrow> to proceed if you want to, just be careful not
to insert blank lines, since these will change the meaning
of the rule as we will soon see). The final line of this
And-Block is `Tell the user to go for a walk', so enter
this.
The first And-Block of our mini-application has now been
finished. We now need to enter the final line, telling the
user what to do. Place the hilite bar over the `Tell the
user to go for a walk' rule and press the <Tab> key. This
will expand the rule. Note that the rule name is now
displayed on the line underneath the main menu bar. To
display the RExL's advice, we'll use the `DISPLAY()'
function which we met earlier. We'll need to tell RExL that
what we are entering is a statement, so press the <F4> key.
This will generate the `[Expr]' line modifier and place it
immediately after the `If' line connector. If the modifier
were omitted, RExL would assume that the line was a rule and
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 29 -
not an expression. With the modifier in place, enter the
expression `DISPLAY("You should go out and have a walk")'
This completes the first section of our application. Press
<Shift-Tab> to return from the sub rule to the parent rule
(note that the rule name display area now displays the name
`Main Program').
Press <Down-Arrow> (or <Enter>) twice, so that a blank line
now exists between the first AND-block and the hilite bar.
You'll notice that the connector at the beginning of the
line has now become `Or'. The rule which RExL follows for
generating connectors is simple. Every line begins with
`And', unless one of two conditions is true: The first line
of an AND-block will have the connector `Or', unless the
line is the first line in the rule, in which case the
connector will be `If'. All other non-blank lines will have
the connector `And', while blank lines have no connector.
Type in the text for the `Or' condition: `Tell the user to
stay inside and play a game of chess'. Press <Tab> to
expand the rule and then enter the expression `DISPLAY("Stay
inside and play a game of chess")', not forgetting to press
<F4> to specify the `[Expr]' modifier.
3.3 Running the Application
The application is now ready to run. Press <F2> to save it
and select the `Run' option from the main menu (by pressing
<Alt-R>, or <Esc> to return to the main menu and using the
cursor keys to select). Select the first option in that
menu, `Run', and press <Enter>. Within a few seconds, the
application should begin running.
The screen will change to a light gray background with two
cyan boxes in the center of the screen. The upper of the
two boxes will contain the name of the first rule in the
application, `The temperature is ok'. Underneath this,
there is a small menu with two options, true and false.
When one of these options is selected, its value returned to
RExL directly. Recall from the explanation of the
application in the previous chapter, that the user would be
advised to go for a walk if `the temperature was ok' and `it
is not raining'. Therefore, for this conclusion to be drawn,
the first reply must be true (select the `True' option from
the menu) as well as the second option (`True' again). When
both conditions have been satisfied, RExL will display the
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 30 -
string `You should go for a walk' on the monitor. Selecting
a value of false for either of the conditions will cause
RExL to draw the other conclusion, that the user should play
a game of chess. When RExL has printed its advice, the
application will terminate and you will be returned to the
editor. If this happens too quickly to see the result,
press <Alt-F5> from within the edit window in the editor to
display the user screen, the screen as it existed before the
editor was loaded.
You should run this application a few times and satisfy
yourself that you understand what it is doing.
3.4 Expanding the Application
We will now expand the application using custom screens
designed using the screen designer.
Recall from the language chapter that we wished to make a
more objective assessment of whether the temperature was ok
by adding two sub rules to that rule. Instead of doing
this, we shall instead add an input screen to get the actual
temperature from the user and to perform numeric comparisons
upon it directly.
Expand the definition of the `The temperature is ok' rule
and type in the following `Input a value for temperature'
and press <F10>. A small menu will appear with six options
on it (these are the different screen types available). We
want the program to perform some input and output, or
dialog, with the user, so select the `Dialog' option and
press <Enter>. The editor screen disappears and you will
see the start up screen of screen designer which is filled
with the quarter tone character `░'. Move somewhere
slightly to the left of the center of the screen and type
`Enter the temperature :'
We now want to define an input field, so that the user can
input a value to RExL. Press <Ctrl-I> to start the field
definition, press <Tab> once to make the field ten
characters wide, and press <Enter> to accept that size. A
box will appear asking for an `input expression'. As with
assignments, this must be an proper LValue. Type in
`Temperature'. This will the name of the variable which
we'll use to store the value of the temperature in (note
that the variable doesn't end in a dollar sign and is
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 31 -
therefore a numeric variable, suitable for storing
temperature values). Press <Enter> to accept this input
expression. The field will now be replaced by a series of
ten question marks which are used to indicate an input
field. Press <F2> to save the screen and <Esc> to exit from
the screen designer and return to the editor. Note that the
line's modifier has now become `[Dialg]' to indicate a
dialog screen.
Move to the next line and enter the expression
`Temperature>10' and on the following line, the expression
`Temperature<40', remembering to press <F4> each time.
Press <Shift-Tab> to return to the main rule, enter the
`Tell user to go for a walk' rule, place the hilite bar over
the `DISPLAY()' statement and press <Ctrl-Y> (or <Alt-D>) to
delete the line. Type the string `Go for walk screen',
press <F10> and select the `Display' option from the screen
menu. The `Display' screen type is used to display a screen
and then wait for a key to be pressed, it's useful for
displaying some information and then pausing until the user
has read it. When in the screen designer, press <Alt-M> to
begin marking a block. Move to the bottom right hand corner
of the screen using the arrow keys (<End> and <PgDn> can
also be used to do it in two keystrokes) and press <Enter>
to select the block. The block menu will now appear: Select
the `Paint' option to color the marked block. Use <Up-
Arrow> and <Down-Arrow> to change the foreground (text)
color and <PgUp> and <PgDn> to change the background (paper)
color. Change it to something that looks nice on your
monitor. When you have finished painting the block, press
<Enter> to accept. Press <Alt-R> to remark the block,
select the `Box' option from the menu and select one of the
box types from the new menu which appears. Make sure that
the first option on this menu is `overlay' and not
overwrite, otherwise the text you typed in earlier will be
deleted. You might like to try this a few times to see the
different types of box available.
Move to the center of the screen, type the string `You
should go for a walk' and save the screen using <F2> as
before. Using the same procedure again, delete the other
occurrence of `DISPLAY()' and replace it with a display
screen.
When you have done this, run the application again. This
time, instead of RExL asking you `Is the temperature ok?',
it will ask for a temperature value. Enter some value. If
the value was between 10 and 40 then both of the comparison
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 32 -
expressions entered after the screen in the temperature rule
will be evaluated as true and hence the rule will succeed.
RExL will then enquire, using the true/false menu, about the
next condition for a walk, whether it is raining or not. As
before, if true is selected, RExL will display the `Go for a
walk' screen, otherwise it will display the other result.
Run this application a few times to make sure that you
understand how it works.
3.5 Debugging the Application
When you are developing an application in RExL, it is very
useful to be able to follow the thread of execution to make
sure that the application is doing what is you expect it to.
The debugger, which is incorporated into the portion of RExL
which runs the applications (known as the runtime module),
can be used to do just that.
Run your application again, but this time, instead of
selecting the `Run' option from the run menu, select the
`Debug System' option. After a few seconds, the debugger
will appear. The interface is much the same as that of the
editor and where the comparison is meaningful, the
keystrokes are the same, so you shouldn't have any
difficulty using it.
The screen layout is slightly different from the editor.
The main differences are as follows:
o To the immediate left of the connector of every non-
blank line, there is a status character. This can
assume one of three values, `?', `√' and `X',
depending upon what the logical status of the line
is. `?' for unknown or unevaluated, `√' for logical
true and `X' for logical false.
o The line about to be executed by RExL is indicated by
an arrow between the line modifier and the line's
text.
Press <F7>. This will trace the application. Depending on
the current line type, tracing has different results: If it
is over a rule, then the debugger will enter the rule, as if
you had pressed <Tab>, and it will place the debugger on the
first non-blank line of that rule. If the line is a screen,
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 33 -
then the screen will be activated and control will be
returned to the debugger when the screen terminates. If the
line is an expression, then the line will be evaluated and
control again returned to the debugger afterwards. There are
a few more conditions which trace controls, these will be
covered in the chapter on the debugger.
When you pressed <F7>, the hilite bar entered the rule and
was placed over the first line in it (which is the screen).
Press <F7> again to execute the screen. Enter some value
for the temperature in the prompt box which appears (try
30). When you press <Enter>, the screen terminates and the
debugger regains control of execution. We will now place a
watch on the variable `temperature'. A watch is an
expression which is evaluated (or watched) every time that
RExL executes a line of code. The watch can be entered in
one of two ways: The easiest is to place the cursor
somewhere in the word `temperature' on the debugger's screen
and then press <Ctrl-W> (<Ctrl-F7> also works). When there
is one present, the debugger will pull a word from
underneath the cursor and place it into whatever box you
call up, in this case the watch expression box. If the word
appears, just press <Enter> to accept it, otherwise, type in
the word `temperature' and press <Enter>. The expression
will be placed in the `watch window', the box on the lower
portion of the screen. Following the expression you
entered, there will be a colon followed by the current value
of that expression, in this case, the value you typed in in
the screen. You can set a watch on any valid string or
numeric expression.
Press <F7> again to execute the line. If you entered a
value of 30 for the temperature above, then this line will
be true, and the line status indicator at the left edge of
the line will display a `√', if you entered some other value
causing the line to fail, then the status will be false as
indicated by a `X'. Assuming you entered 30, the debugger
places the hilite bar on the final non-blank line in the
rule which you can now trace. The hilite bar should now be
beyond the last line, to indicate that the rule has been
evaluated and that execution is about to return to where the
rule was called from. Trace again and see this happen. The
status indicator of the first rule in the main program
should now be `√' to indicate that it was evaluated as true.
We will step the next two lines. Stepping is much the same
as tracing, the only difference being that if the line being
stepped is a rule, then the debugger will not enter the rule
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 34 -
definition, it as it does in trace. Press <F8> to step the
application. You'll now be presented with the familiar
true/false menu screen. Select false and note that the
debugger has filled in an `X' as the logical status of the
failed rule and left the status of the last rule in the
first AND-block as unspecified, using `?'. The hilite bar
will now be placed upon the first line of the alternative,
the second `AND'-block, so press <F8> to step it. The
debugger will not immediately regain control of the
application since the screen type being displayed is a
`display' screen and so requires a key press to end it.
The hilite bar will now be on the final (empty) line of the
application. Press one of the execute keys (<F7>, <F8> or
space) to terminate the application and return to the
editor.
Debug the application a few more times to make sure that you
understand how stepping, tracing and watching work. If you
want to delete a watch expression, press <F6> to switch to
the watch window and then <Del> or <Alt-D> to delete the
watch. Press <F6> again to return to the code window.
There are three other useful features in the debugger which
were not covered above. These are the `Execute To' key,
<F4>, the `Evaluate Expression' key, <Ctrl-E>, or <Ctrl-F4>
and the `Breakpoint' key, <Ctrl-F8>. When you press <F4> on
a non-blank line, the application will run until it reaches
that line. This is useful when you are somewhere within an
application in the code window and you wish to set a
temporary breakpoint. For a full discussion of the features
in the debugger, consult the chapter on the debugger.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 35 -
Chapter 4
The Editor
This chapter covers the functions and capabilities of the
editor in depth. Because of its size, the screen designer is
documented in a chapter of its own, rather than in this
chapter. You should have read the chapter on RExL's
language before you use the editor, since the two are linked
very closely.
4.1 Introduction
RExL's editor uses the concept of `folding text' to make the
programmer's job easier. As was explained in the previous
chapter on the structure of RExL programs, applications are
built up in a pyramidal manner, using rules which call
further rules and so on. This gives the application a two
dimensional structure which has been generally ignored by
traditional `flat file' editors. RExL, on the other hand,
understands this hierarchical structure and allows the
programmer to access procedures immediately, without having
to do searches or large cursor movements. You must
understand this folding-text approach before you progress to
the more complex aspects of the editor.
The editor `understands' RExL's language: Whenever a line
of RExL code is entered, RExL will check the line's syntax
to determine if the line is syntactically valid. If it is,
then the text will be scanned for variables which are then
be placed into the variable list. The syntax analyser checks
not only for errors such as incorrect parameter lists and
invalid mathematical operations, but also for less obvious
mistakes such as arrays with incorrect number of dimensions.
When a new rule is defined, it is placed into the rule list,
which can then be used to locate it rapidly. A similar
procedure applies to screens which also have their own list.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 36 -
RExL's editor user interface is based loosely on Borland's
integrated editor, as present in Turbo Pascal versions 4.0
to 5.5 and Turbo C, versions 1.0 to 2.01. Anyone who has
used these editors should have no difficulty using RExL.
4.2 Interface Conventions
There are a number of keystrokes and conventions which RExL
adheres to throughout the system. These are documented here.
o Cursor: The cursor can assume one of two shapes,
depending on whether it is in insert or overwrite
modes. When in insert mode, the cursor will be the
same size as the character block and text entered
will be inserted into the current cursor location,
pushing the text to the right of the cursor off to
the right, possibly losing some at the end of the
input area. When in overwrite mode, the cursor will
be two pixels high and placed at the bottom of the
character box. Text entered will erase any text
which was previously present at the cursor position.
The <Ins> key is used to toggle between insert and
overwrite modes.
o Cursor Movement: The <Left> and <Right> arrow keys
move one character left and right respectively.
<Ctrl-Left> and <Ctrl-Right> move one word left and
right. <Home> and <End> move to the beginning and
end of the input area, unless in the screen designer,
where they move to the left hand edge and the right
hand edge of the screen. <PgUp> and <PgDn> move up
and down by the size of the current window, unless in
the screen designer, where they are used to move to
the top and bottom of the screen. <Backspace> will
delete the character to the left of the cursor,
moving the text to the right (and the cursor) one
character to the left. <Del> will delete the
character underneath the cursor, moving the text to
the right one character to the left.
o Input: When RExL requests string input, there is
generally a default value which is hilited in yellow
text on magenta background within the dialog box.
RExL interprets the first keystroke pressed in the
dialog box as follows: Pressing one of the cursor
movement keys will deselect this default so that it
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 37 -
may be edited. A non-extended keystroke (these are
the letters A to Z, the digits 0 to 9, punctuation
marks and all characters whose ASCII codes are
greater than 128) will cause the selected string to
disappear and the keystroke entered to appear as the
first character of the string. Any other keystroke
(<Up>, <Down>, <PgUp>, <PgDn>, the function keys,
<Alt-> and <Ctrl-> keystroke combinations and so
forth) will terminate the dialog and return you to
the place from where it originated. Once the dialog
has been deselected, input can continue using the
standard editing keys. In the current release of
RExL, the string entered cannot be wider than its
input area.
o Scrap Buffer: The scrap buffer is a small one line
buffer which can be used to copy and paste small
chunks of text from one input area to another. The
contents of the scrap buffer are displayed between
the curly brackets {} on the status line at the
bottom of the editor screen. If the buffer area
would overflow on account of the length of the string
placed in it, RExL will display the first six
characters of the string followed by an ellipsis
(three dots) followed by the last six characters of
the text.
Text is entered into the scrap using <Shift-Enter>
and pasted from the scrap using <Shift-Ins>. The
scrap may be used, even when it not displayed, such
as when in the screen designer. Note that when you
terminate RExL lists by pressing <Enter>, the
previously hilited item will be pasted into the
scrap. Terminating by pressing any other key will
not perform the paste. Note that inserting text from
the scrap will overwrite any text to the right of the
cursor.
o Undo: In all string input areas, you can press
<Ctrl-U> to undo any changes to the original string.
o Help: On line help is available at all times in RExL.
There are two forms of help. The first is context-
sensitive, meaning that the help which appears is
relevant to whatever you are currently trying to do.
This help is activated by pressing the <F1> key.
Language help will bring up a help screen related to
the language keyword which the cursor is placed over.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 38 -
This is activated by pressing <Ctrl-F1>. At any
time, the last help screen to be displayed can be
re-displayed by pressing <Alt-F1>.
o Window Move: Most windows in RExL are movable using
the standard arrow keys when <Scroll-Lock> is active.
This key is normally located at the top right of your
keyboard. Note that no windows may be moved over the
status line at the bottom of the screen nor the menu
bar at the top of the screen.
o Macro Recording: You can record macros `on-the-fly'
from anywhere within RExL. A macro is a series of
keystrokes which can be `recorded' and `played back'.
To switch on the macro recording facility, press
<Alt-Equals>. A dialog box will pop up requesting
the name of the macro which you are about to start
recording. If you don't want to assign it a name,
just press <Enter>. RExL will then ask for a
keystroke to attach the macro to (press <Esc> to
abort the record). While you are recording, an `R'
will appear in the top left hand corner of the
display, press <Alt-Equals> again to turn the macro
record off. You can save the macros to disk using
the Options/Save macros menu option. Macros can
record and replay up 512 keystrokes.
The list of macros defined can be displayed by
pressing <Alt-Minus>. To play back a macro, hilite
the name with the hilite bar and press <Enter>.
While a macro is playing, a `P' will appear in the
top left corner of the display.
o Helix Searching: When using menus in RExL, there are
two methods which can be used to select options
quicker than using the cursor keys.
- Initial letter: Most fixed size menus in RExL
have initial letter searching. In this mode,
all you need do is type the initial letter of
the menu option and it will be automatically
selected. The initial letter is usually
hilited in light blue.
- Helix searching When the number of items in a
list or menu is variable, for example as in
the rule list, the hilite bar can be brought
to an option incrementally by typing the name
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 39 -
of the item you are searching for. The
portion of the item entered is hilited in a
slightly differrent color from the normal
hilite bar. The hilite bar will move to the
next item which matches the letters entered
already, with those letters being colored
black on a light gray background. Press
<Backspace> to delete letters from the helix
search list.
For example, if you had a menu with three
items in it, One, Two and Three, when the
letter T is pressed, the hilite bar moves to
the second option, and the first character in
the menu bar becomes black on gray. When h is
then pressed, the menu bar moves to the next
option and hilites the letters Th.
o File Name Input: Whenever RExL requests a file name,
such as when selecting a file to load into the
editor, you may either enter a proper file name,
otherwise you can enter a file specification
including any of the wild-card characters, ? or *.
When using the wild-cards, RExL will give you a menu
listing those files which match the file
specification entered. Any directories in the
current search directory are also displayed in the
list and you can change to any one by selecting it
from the list. The list of files matching the file
specification will be regenerated from the new
current directory. For all directories other than the
root (when performing wild card file selections) the
first option on the menu will be "..\". Selecting
this directory will being you to the directory
directly above the current one.
You can terminate the menu file name select by
pressing <Enter> to select a file name, or <Esc> to
abort the selection.
4.3 Editor Basics
The editor is started by typing `rexl' at the DOS prompt.
You can optionally supply a filename for RExL to load
immediately into the editor. Ther is one command line
option which may be passed to the editor, the `-l' option.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 40 -
This is used to tell the editor that it is running on an LCD
display. Once the `-l' option has been specified, it will
be saved to the configuration file, so it need not be
specified again.
The editor does two things before it becomes ready for
input. Firstly, it attempts to load the RExL configuration
file, REXL.CFG. If there is no configuration file present,
RExL proceeds without comment. Secondly, if the
configuration is so set up, the editor will load the index
for the help file, if it is unable to do so, an error will
be displayed. The configuration file stores information
about the position and colors of the windows in \rexl, the
beeping, help, function case, window explosion, bracket
matching, list size, LCD and DOS screen storage status
flags. When searching for the help file, RExL will first
search the current directory and then the directory
specified by the REXL environment variable.
The editor uses only one command line parameter, -l. This
is used to tell RExL that an LCD monochrome screen is
attached to the computer which it is running on and to set
the screen colors accordingly. Note that the editor can
autodetect a standard monochrome screen, but not an LCD
monochrome since the hardware does not permit it. Once the
-l option has been specified once, RExL will store it in its
configuration file along with the rest of the colors and
various other configuration data.
Once the above procedure has been completed, you will be
presented with the main editor screen (note that you can't
have all the menus pulled down at once, as they are in this
figure! The dots indicate where the menu is normally
displayed):
[Figure omitted in disk manual]
The bar at the top of the screen has five pull down menus.
These can be activated by pressing the left and right arrow
keys to move from one to the next, and pressing the enter
key to select the hilited menu. Once selected, the menu will
drop down and a standard selection menu appears. To the
right of the six menu titles, is the name of the RExL file
which is currently being edited. If the editor has been
started with no application name given on the command line,
then this file name will be NONAME.RXL. Note that if a file
of this name exists in the current directory exists already,
then it will be loaded.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 41 -
The bottom line of the screen is the status line, and it is
here that RExL posts the status of the editor as well as any
error messages which are generated. On the left hand end of
the status line, between the braces {} is the scrap buffer
display, as explained earlier in this chapter.
The `Memory :' display on the status line shows the amount
of available memory in the editor. If this becomes lower
than about 20000 bytes, you may run into lack-of-memory
problems.
The `Level :' field displays the current rule `depth' which
the editor has reached. We will cover rule depth in detail
further ahead in this chapter. This has a maximum of 100
levels which is more than enough for most applications.
The six menus on the main horizontal menu bar have contents
as follows:
4.3.1 File menu
┌───────────────┐
│ Load │
│ New file │
│ Save │
│ Write to │
│ Remove │
│ Change dir │
│ Default drive │
│ OS shell │
│ Quit │
└───────────────┘
The file menu has the following nine options:
1. Load: This option controls the loading of
applications into RExL. When this is selected, a file
name dialog box (as explained above) appears. This
will have as an initial value, the string "*.RXL".
2. New file: This option is used to clear the contents
of the editor, as if the editor had been restarted
from the DOS prompt. `NONAME.RXL' will be loaded if
is present in the current directory.
3. Save: When this option is selected, the application
currently in memory will be saved under the name
displayed on the top line of the screen. As a short
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 42 -
cut keystroke, you can press <F2> from within the
main editor window.
4. Write to: This option allows the name of the current
application to be changed. When it is chosen, a
dialog box will appear requesting a name for the
current application to be written to. If a valid name
is entered, the application in memory will be saved
to disk under the new name and the screen file will
be copied.
If there is not enough disk space on the current disk
drive for the new files, then the operation will
fail. The next menu option may be used to remove
unwanted files from disk.
5. Remove: This choice allows you to delete a file from
disk. You may need to do this is you want to save a
file on disk, but are unable to do so through a lack
of disk space.
6. Change Dir: This option will allow you to change the
active directory. The format used here is much the
same as that used in the file name input routine, the
only differences being that no file names are
displayed in the list and that the current active
path (drive name with full directory) will be
displayed on the status line at the bottom of the
screen.
7. Default Drive: When this option is chosen, a menu
will pop up displaying the list of available DOS disk
drives. As with the directory selection above, the
current active path is displayed on the status
display line at the bottom of the screen.
8. OS Shell: If you want to run a DOS command, but do
not wish to exit from the editor permanently, choose
this option to go into a DOS shell. While you are in
the shell, you should not, under any circumstances,
run any T&SR programs (such as Sidekick, ScrGrab and
so forth), since these programs change critical area
of the computer's memory which may cause it to crash
unpredictably when you return to RExL.
When you are finished in the shell, type `exit' at
the DOS prompt to return to RExL.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 43 -
9. Quit: This option terminates RExL and returns you to
DOS. If the application currently in memory has been
altered, then RExL will prompt you to see if it
should be saved. Selecting either of the options will
perform the action and then return you to DOS,
pressing any other key will return you to the menu.
4.3.2 Edit menu
┌────────────────────────────────┐
│ Edit │
│ Default screen: <None> │
└────────────────────────────────┘
The edit menu contains two options. Selecting the first
option, `Edit' will bring you directly into the edit window
to begin creation or editing of your application. The edit
window will be covered in detail further ahead in this
chapter.
The second option, `Default screen:' is used for setting the
name of the screen which is to be preloaded into the screen
designer. When this option is selected, the screen list
will be generated and a screen may be chosen to be made the
default. If a valid choice is made, then the screen designer
will be started so that the default screen itself may be
edited. Default screens are most useful when all screens in
an application must have the same set of colors, have a few
fixed fields or whatever.
To clear name of the default screen from the listing, the
first option in the screen list, `Clear default screen',
should be selected.
4.3.3 Run menu
┌───────────────────┐
│ Run │
│ Debug application │
└───────────────────┘
The run menu has the following two options:
1. Run: When this option is selected, you will be
requested to save the application which is currently
in memory (if necessary) and the runtime module will
be called to run it. Unlike the function of the next
option in this menu, the debugger will not be enabled
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 44 -
when the application starts. Note that you can enter
the full screen debugger at any time during the
running of an application by pressing the <Alt-D>
keystroke (stands for Debug).
When attempting to locate the runtime module, the
editor first searches the current directory, then the
directory specified by the RExL environment variable,
and finally, the entire DOS path, if one exists. If
the editor is unable to locate the runtime module, an
error to this effect will be generated and the editor
will continue running.
2. Debug application: As with the previous menu option,
the application in memory will be saved and the
runtime module called if possible. The only
difference from the previous menu is that the
debugger will be started in full screen debug mode,
as if <Alt-D> had been pressed upon initiation of the
application within the runtime.
4.3.4 Lists menu
┌────────────────────┐
│ Rule list │
│ Screen list │
│ Unused rule list │
│ Unused screen list │
│ Variable list │
│ Function list │
└────────────────────┘
This menu gives you access to all the lists of entities
which are defined the current application. Most of the lists
have special `hot-links' to other, more specific, lists.
These are mentioned briefly at the end of this subsection
and covered in more detail further on. All of these lists
are also available via hot-keys from within the main editor
window. Consult the section on editor keys for more
information on this.
The lists run menu has the following six options:
1. Rule list: This list contains the names of all of the
rules which are currently defined in your
application.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 45 -
2. Screen list: This list contains the names of all
screens defined in the currently active screen file.
3. Unused rule list: This list shows all rules which,
although defined in the normal way, are not actually
referenced by the application. Pressing <Alt-D>
within this list will delete the unused rule from the
application.2
4. Unused screen list: This list gives all screens which
are not referenced in the current application. As
with the unused rule list above, press <Alt-D> to
delete the unused screen from the list and free up
the space it occupies within the screen file.
5. Variable list: This list contains all variables. The
status line at the bottom of the screen displays the
type of the variable, whether numeric or string, and
whether it's an array or a simple variable.
6. Function list: This list contains all the functions
available in RExL. Press <Ctrl-F1> for help on the
hilited function.
7. Graphic rule display: This displays the rule call
tree for the current rule. This is covered in more
detail in its own section.
All the list windows are movable by pressing <Scroll-Lock>,
using the arrow keys to position and pressing <Enter>,
<Scroll-Lock> or <Esc> to terminate the window move. Note
that all lists in RExL feature helix searching. You can also
output the contents of any list to a file (or the printer)
by pressing <Ctrl-P>, as in DOS.
If you terminate any of the lists by pressing <Enter>, then
the choice which you selected from that menu will be placed
into the scrap buffer, ready for pasting using the <Shift-
Insert> keystroke.
____________________________________________________________
2. Note that deeply recursive rules (those which do not have
a reference to themselves in the immediate rule
definition) which are not used by other rules are not
currently detected as being unused.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 46 -
4.3.5 Options menu
┌───────────────────────┐
│ Load macros │
│ Save macros │
│ Beep off │
│ Function lower case │
│ Exploding windows off │
│ Dictionary size: 500 │
│ Help fast │
│ Bracket match on │
└───────────────────────┘
The options menu controls various system parameters and
features not directly connected to the editor per se.
1. Load macros: Any macro definitions you define in the
editor may be saved to disk for later retrieval using
this menu option. The macro file format is constant
across the RExL product range, so that macros defined
in the editor may be used in the debugger or in the
database manager and so on. Macros are explained in
more detail at the beginning of this chapter.
2. Save macros: This option allows you to save macros
which can then be reloaded at some future time using
the load option above.
3. Beep off: By default, RExL beeps whenever it
encounters an error. This beeping can be toggled on
and off by selecting this option.
4. Function lower case: By default, all functions in
RExL are displayed in their natural case. This is
that functions which are members of families are
displayed with the first two or three letters
capitalised, while the miscellaneous functions are
entirely capitalised. This option is used to toggle
between upper (or partially upper) case function name
display and lower case.
5. Exploding windows off: In its default state, all
windows in RExL open instantaneously upon activation.
This option can be used to make windows `grow' to
full size on the screen. This is only a visual
effect and has no effect upon the application.
Selecting the option a second time will turn the
option off again.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 47 -
6. Dictionary size: The dictionary size is the size of
all lists in RExL. This defaults to a list size of
500 items, but can be changed by using this option.
Each list entry consumes four bytes of memory. If
you are dealing with a particularly large
application, you may want to make this list size
smaller to conserve memory.
7. Help fast: As explained earlier in this chapter, the
editor loads in the help file index when it starts.
This is done so that the help can respond instantly
to requests. However, the help file index requires
about 9000 bytes of memory, so again, if developing
large applications, you may wish to disable the
automatic loading. The help will then load the index
for every request which will slow it down somewhat.
8. Bracket match on: When entering expressions, RExL
will automatically hilite matching brackets. This is
to help you locate incorrect bracketing in complex
expressions. You can toggle this feature by
selecting this option.
4.3.6 Import menu
┌─────────────────┐
│ Save to ASCII │
│ Load from ASCII │
│ ASCII Options │
└─────────────────┘
RExL will import and export properly formatted RExL source
files in ASCII format. This is mainly done for purposes of
documentation and hard copy archival. All attributes of an
application are saved, including screen colors, text and
screen fields. The ASCII file can become large because of
the amount of information contained in it, typically, the
size of the listing file is seven to ten times the size of
the combined listing and screen files.
The foreground and background colors of screens in the
application are saved in the ASCII listing file as letters
which map directly to colors. The colors are mapped as
follows:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 48 -
Table 4.1: ASCII Color Translation Table
Letter Color Letter Color
0 Black 1 Dark gray
B Blue b Light blue
G Green g Light green
C Cyan c Light cyan
R Red r Light red
M Magenta m Light magenta
Y Brown y Yellow
W Light gray w White
The listing file will save the contents of screens
correctly, but certain characters, such as the ASCII end-
of-file marker, character 26, may confuse other DOS programs
which read and write ASCII files, notably Sidekick, WordStar
and so on, although RExL will load the file correctly.
Furthermore, the ASCII newline and carriage return
characters, characters 10 and 13 respectively, may
unsynchronize the listing file so that it will not load
properly.
There are two active options and one sub-menu within the
Import Menu. These are as follows:
o Save to ASCII: The application currently in memory
will be saved to disk as an ASCII listing file. The
file name will be the same as that of the parent
application, but with an extension of .LST. While
the listing is being saved, its progress will be
posted on the screen.
o Load from ASCII: A standard file name input box will
pop up when you select this option. The default
input string is "*.LST" which you can edit in the
usual manner. When you have selected a file to load,
RExL will being to process the file. Note that the
format of the file is very strict and you shouldn't
edit the ASCII listing, in case the editor doesn't
accept it. The listing file will be saved in the
current directory (irrespective of where the listing
file is) under the same file name, but with an
extension for the application image of .RXL and one
for the screen file of .SCR. If either of these
files already exist, then they will be backed up:
The application image being given an extension of
.BAK and the screen file one of .BKS.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 49 -
o During the loading process, all executable lines
(that is screen fields and lines in the application
image) will be displayed in a box underneath the
progress box which also displays the percentage of
the lising file loaded, for your convenience. This
is done so that when an error occurs, it can be
displayed on screen and edited.
o ASCII Options: This is a sub-menu which contains the
following two options related to ASCII loading and
saving.
- Strip unused vars: This is a yes/no toggle
option. When set to yes all variables which
are listed in the ASCII listing file, but
which are not used in the actual code of the
application, are discarded and not placed in
the newly generated variable list. When set to
no, these unused variables are not removed.
- Emit screen codes: This is another yes/no
toggle option. When it is set to yes, the
color codes for the screens in the listing are
emitted along with the text of the screen.
For purposes of system documentation, this
information is generally not needed, and this
option can therefore be set to no.
4.4 Using the Editor
Once you have selected the Edit option from the main menu,
RExL is ready for you to start creating your application.
All lines entered are either statements, rules or screens.
The rules for entering each line type are laid out in the
next three sections.
The editor will automatically assign the line connectors,
If, AND and OR according to the rules for block connection.
That is, the first non-blank line in a rule uses If, the
first lines in the remainder of the and-blocks use OR, while
all remaining non-blank lines use AND. Blank lines have no
connector.
A rule may be declared as one pass by pressing <Ctrl-O>
within the edit window. Since the one-pass modifier applies
to the rule as a whole, the modifier [OnePass] is displayed
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 50 -
in the rule name box at the top of the edit window. As with
the rule type modifiers, <Ctrl-O> toggles its modifier.
4.4.1 Entering Statements
Statements, which include both assignments and logical
expressions, are the simplest to specify, by pressing <F4>.
However, before RExL will accept a statement, it must be
syntactically valid. The statement syntax checker scans the
line for invalid syntax, incorrectly dimensioned arrays and
incorrectly used functions and variables. When it encounters
an error, it signals the location of the error on the input
line with an red indicator. A keystroke will clear the
error and return control to the editor, where the error can
be corrected.
If the line is syntactically correct, the syntax checker
will recover all variables from the line and add them to the
variable list, available on <Alt-V>. Any new arrays found
in the statement will be dimensioned to ten elements in all
their declared dimensions, although this can be changed
through the variable list, explained shortly.
In certain cases, when comparing strings and using the
logical return values, you may need to bracket the string
sub-expression to avoid incorrect parsing. For example, an
expression such as a:=10+"a"=a$ will require bracketing
since the sub-expression 10+"a" will be evaluated first,
since addition has a higher precedence than equality.
When the line has been passed as correct, the syntax checker
then converts the text into symbolic tokens which are stored
more efficiently in memory than text alone. This has a
number of side effects:
o Variables are converted to internal variable
reference numbers: It is for this reason that when a
variable is entered a second time, the case in which
it finally appears will be the same as that in which
was first entered. For example, if you enter an
expression such as MyAge:=10 (where MyAge has not
been defined previously) and later on enter the
expression myaGE=12, then the string myaGE will be
converted to the earlier occurrence of MyAge.
o Numbers are stored in one of four forms, depending on
their size. Whole integers between -127 and +127
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 51 -
inclusive are stored exactly as one byte numbers,
whole integers between -32767 and +32767 are stored
exactly as two byte integers, whole integers between
-2147483647 and +2147483647 are stored exactly as
four byte numbers. All other numbers are stored as
as eight byte double precision real numbers, to an
accuracy of approximately fifteen digits.
When you enter a number, it will be converted into
the appropriate internal format. Any superfluous, or
unstorable decimal places will be discarded.
4.4.2 Entering Rules
Rules are the simplest entities to enter in RExL: Any line
without a modifier defaults to a rule. When an unknown rule
is entered, it is entered into the rule list immediately.
As with variables, rules are stored by reference, so that
once a rule has been entered, its case cannot be changed.
The text of rules themselves may be edited, and the editor
will change all references to reflect the new edition of
that rule.
Rules can take any of the modifiers, BackTo, Not, While,
Multi, Single, Zap or a blank modifier. Each modifier
modifies the meaning of the rule as explained in the chapter
on the language, a blank modifier simply means `call the
rule' and do not modify its return value.
To set the line's modifier, press <Ctrl-> followed by the
initial letter of the modifier. Thus <Ctrl-Z> will generate
a Zap modifier. Pressing the key again will remove the
modifier and return the rule to its unaltered state. The
full list of modifiers and keystrokes is given at the end of
this chapter in the key reference.
To expand the definition of a rule to include subrules,
statements, screens and so forth, press <Tab>. The name of
the expanded rule will be placed in the rule name box at the
top of the edit window and the hilite bar placed on the
first line of the rule. Press <Shift-Tab> to return to the
parent rule.
Since all rules are stored by reference, the capitalization
of a rule name is set when the rule is initially entered, it
cannot be changed after this. Whenever the name of a rule is
changed (by editing it), all references to it are
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 52 -
automatically updated. The editor will not allow the name
of a rule to be changed to one which exists already, since
it can't determine which rule is referred to.
4.4.3 Entering Screens
A screen can be one of five types, [Dialg], [Dsply], [Help],
[Menu] or [Print]. The meanings each of these modifiers is
explained in the chapter on the screen designer.
As with rules, the name of a screen can be changed and will
be updated automatically in the screen file as will all
references to it in the application being edited. As
before, the new name cannot be one which already exists.
To enter a screen, press <Tab> or <F10> when hiliting the
name of the screen in the edit window. If the named screen
does not exist in the screen file already, then you will be
prompted to select a screen type from a pop up menu.
Because the screen designer is a major and large feature in
RExL, it is documented in a chapter of its own.
4.5 Editor Lists
At all times, the editor maintains lists of all entities
defined within RExL. These are the lists of used and unused
rules, used and unused screens and variables. Most of the
lists have `hot-links', or special keystrokes which produce
lists specific to the item hilited in the first list. The
following three subsections tell how these lists are used.
When a list is activated, a window, the width of the screen
is displayed. The window extends to the second last line of
the screen if there are enough elements to fill it,
otherwise it sizes itself to produce a window large enough
to hold all items. If all the elements cannot be displayed,
a scroll bar will be displayed on the right hand edge of the
list. The <Scroll-lock> key can be used to move the window
using the arrow keys while the contents of the window may be
written to a file or the printer using the <Ctrl-P>
keystroke. All lists containing rules have a hot-link tied
to the <Tab> key. When this is pressed, the editor will quit
the list and enter and expand the definition of the hilited
rule. This keystroke is present in the normal and unused
rule lists, the screen list, and all rule reference lists.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 53 -
If a list is terminated by pressing <Enter>, the last
hilited item in the list will be pasted into the scrap
buffer. Terminating the list any other way (say by pressing
<Esc>, <Left-Arrow>, <Right-Arrow> and so on) will not alter
the contents of the scrap.
4.5.1 Reference List
The reference list of a rule is the list of the rules which
reference, or call, the rule currently being edited. The
only hot-link in the reference list is the <Tab> key, used
to enter a rule's definition. Reference lists are available
in the screen list, the rule list and the variable list.
All reference lists are generated by pressing <Ctrl-R>.
The <Ctrl-R> keystroke can also be used to generate the list
of rules which call the current rule. This list performs
the same operations as the generic rule reference list
above.
4.5.2 Rule List
The rule list is the most commonly used list of all and it
is for this reason that it is attached to the keystroke of
<Alt-Z> or <Shift-F2>. The rule list contains two hot-
links, the first is the <Tab> link as explained above, and
the second link, tied to <Ctrl-R>, which generates the rule
reference list, the list of rules which reference the
hilited rule.
4.5.3 Screen List
The screen list gives the names of all screens defined in
the application and is generated by pressing <Alt-S> or
<Shift-F3>. This list includes both used and unused
screens. This list has two hot links, the first tied to
<Ctrl-R>, generates a screen reference list, the list of
rules which use the hilited screen. This reference list has
the normal hot-link key of <Tab> to enter a rule's
definition. The second hot-link in the screen list is tied
to <Tab>: When pressed, the editor will immediately jump to
the first occurrence of the hilited screen within the
application.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 54 -
4.5.4 Unused Rule List
The unused rule list gives the list of rules which are
unused in the current application and is generated by
pressing <Alt-U> or <Shift-F4>.
There are a few minor quirks which you need to be aware of
when using this list. Firstly, the list will not contain
rules which are used by unused rules but are unused
elsewhere within the application. Secondly, rules which are
recursive, or use the modified rules from deeper than the
first call level of the rule will not be included. To
clarify the last point, if a rule called Top Rule called a
rule Second Rule which then called Top Rule, all of which
were unused by the rest of the application, the unused rule
list would not determine that neither Top Rule nor Second
Rule were unused. On the other hand, if Second Rule did not
call Top Rule, then Top Rule alone would be found to be
unused and placed in the list.
If you wish to remove unused rules from the application
altogether, press <Alt-D> (or <Ctrl-Y>). The hilited rule
will be removed from memory and `forgotten' by RExL. If
there are rules which were only used by newly deleted unused
rules, then these can be listed by exiting from and re-
entering the list.
To enter the definition of an unused rule, press <Tab> when
hiliting the rule. When you are finished editing the
definition of an unused rule, press <Shift-Tab> to return to
the main rule.
4.5.5 Unused Screen List
The unused screen list is generated by pressing <Shift-F5>
and is much the same as the unused rule list, with the
exception that screens which are used by unused rules are
said to be used. Press <Alt-D> or <Ctrl-Y> to delete the
screen from the screen file.
4.5.6 Variable List
The variable list, on <Alt-V> and <Shift-F6> lists all
variables defined within your application. When the list is
active, the status line at the bottom of the screen will
display the type of the variable and its dimensions, if the
hilited variable is an array.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 55 -
There is one hot-link in the variable list: Pressing
<Ctrl-R> will generate a list of the rules which reference
the hilited variable. Note that the variable reference list
does not list the rules which contain screens which
reference the variable. As with all reference lists, you
can go directly to a hilited rule by pressing <Tab> from
within the reference list.
You can alter the size of an array variable from within the
variable list by pressing <Tab> when hiliting the array.
The cursor will reappear on the variable status line in the
first of the array's dimensions, where the value there can
edited. By default, all arrays are dimensioned to a size of
ten in all the array's dimensions.
4.5.7 Function List
This list contains all internal RExL functions and is
generated by pressing <Ctrl-F> or <Shift-F7>. The arguments
which the function requires are listed on the status line at
the bottom of the screen. There are twelve abbreviations
which are used for the twelve different parameter types
which may be passed to RExL's function.
Table 4.2: Function Parameter Abbreviations
Abbreviation Meaning
number Numeric expression
string String expression
variant Numeric or string expression
arraynv Variable size string or numeric array
array1v One dimensional string or numeric array
array2v Two dimensional string or numeric array
array3v Three dimensional string or numeric array
arrayn$ Variable size string array
array1$ One dimensional string array
array2$ Two dimensional string array
array3$ Three dimensional string array
arrayn Variable size numeric array
array1 One dimensional numeric array
array2 Two dimensional numeric array
array3 Three dimensional numeric array
Press <Ctrl-F1> to get language help on the function
currently hilited.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 56 -
4.6 Other Functions
The editor has a number of other functions which do not
easily fall into any of the categories listed before. These
are given here.
4.6.1 Graphic Rule Display
The graphic rule display, generated by pressing <Alt-G>,
lists the dependencies of rules upon each other in an easy-
to-understand graphic format. When in the display, you can
move the hilite bar up and down by in the normal way.
Pressing <Tab> will expand the currently hilited rule's
definition while pressing <Enter> will paste the name of the
hilited rule into the scrap buffer.
The easiest way to understand the graphic rule display is to
look at an example.
[Figure not available in disk manual]
When the graphic rule display was called, the editor was in
the main rule, the root of the application, so therefore the
entire dependency tree will be displayed. In this case,
the Main Program consists of three rules linked as follows:
If First rule
And Second rule
And Restart the application
In the graphic display, rules connected by AND's are linked
by vertical bars, hence the bar on the extreme left of the
display connecting these three rules. First Rule contains
the following:
If First sub rule of 1st rule
And Second sub rule of 1st rule
Or Or This sub rule of the 1st rule
As with the main rule, the first two lines in the first
and-block are linked by a vertical bar. When the display
generator reaches an OR connector, it terminates the
vertical bar and begins a new one. In the case of the First
rule, there is only one line in the second and-block, so the
vertical bar cannot extend beyond the current line, so it
will collapse to give a horizontal bar. The same procedure
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 57 -
applies to the Second rule which has the same format as the
previous one.
Normal rules are colored light gray, while recursive rule
calls or rules prefixed with the BackTo modifier are hilited
in yellow. In the example above, all rules are colored
light gray, except for the third last rule and the final
rule in the display, both of which are prefixed by BackTo
and are therefore colored yellow.
As with all lists, this can be printed to a file or device
by pressing <Ctrl-P> and entering a file name.
4.6.2 Miscellaneous keystrokes
4.6.2.1 Cut and paste
Beginning with version 2.10 of RExL, blocks of text can be
moved around in the editor using the concept of the line
buffer. The line buffer operates in a similar way to the
scrap buffer on the bottom line of the screen.
To copy a block of text, it must be selected and then
inserted into the line buffer. The <Alt-M> keystroke is
used to set the `anchor' point and further movements of the
cursor keys will extend the block in the direction moved.
When the desired block has been marked it can be deleted, or
cut, to the line buffer by pressing <Shift-Del> or copied to
the line buffer by pressing <Alt-M> again.
When the line buffer contains text, the triple bar character
_≡_, is placed at the left hand end of the editor status
bar, just to the left of the normal scrap buffer. Text is
copied to, or pasted from, the line buffer by pressing
<Alt-C>.
The editor will not allow text to be deleted to the scrap
buffer if the current rule exists already in the rule stack.
4.6.2.2 Editing keys
<Alt-B> places a blank line before the current line, pushing
those lines after the current line, down one line. The
connector on the line pushed down will change to OR, in line
with the rules for connectors.
<Alt-D> will delete the current line, pulling all lines
after the current line up one line. The line's connector
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 58 -
will be changed if necessary. The more normal keystroke of
<Ctrl-Y> performs the same function as <Alt-D>
<Enter> will act in the same manner as <Down-Arrow>.
<Ctrl-Home> moves the hilite bar to the top of the screen,
while <Ctrl-End> moves it to the bottom of the screen or the
last line in the rule, whichever is nearer. <Ctrl-PgUp>
moves the hilite bar to the first line in the rule.
4.6.2.3 Other keys
<Alt-X> will attempt to terminate the editor and return you
to DOS. If the file being edited has been changed since it
was last saved, then you will be prompted to save the file.
<Alt-F5> displays the DOS screen, as it was when the editor
first started up.
<Ctrl-F8> toggles a runtime breakpoint at the current line.
The breakpoint will be signalled by a breakpoint character,
≡.
<F2> will save the current application while <F3> will load
a new one.
<F9> runs the application and calls up the debugger,
prompting the user to save the application if it has not
already been done. <Ctrl-F9> runs the application without
calling up the debugger.
<F10> will enter the screen designer, popping up a screen
type selection menu if the screen specified on the line does
not already exist in the screen file.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 59 -
Chapter 5
Screens in RExL
5.1 Introduction
This chapter documents the screen designer and the
capabilities of screens in RExL. Screens are an integral
part of RExL as a whole and are used for input, output and
dialog in general with the outside world. The documentation
on the screen designer is divided up into two chapters, the
first dealing with the different types of screens available
and their specific purpose with the system, while the second
deals with the specifics of using the screen designer to
produce the screens.
Any modifications to a screen in an application are written
immediately to disk in the disk based screen file. This
allows for screen files which can be arbitrarily large.
However, if changes are made to the screen file, and in
particular, if the position of a screen changes within the
screen file, then the old backup copy of the application
image on disk (the ".RXL" file) will not hold a valid copy
of your application. The reason for this is that screens
are stored in application image files using reference
numbers. If a screen's position is changed within the
screen file, then the reference number for the screen will
be invalidated, and because of the algorithm for squeezing
screens into screen files, other screens may be invalidated
also. The upshot of this is that whenever a change has been
made to a screen file, you should press <F2> from within the
edit window to update the application image on disk. This
is not strictly necessary, but if you live in an area with
frequent power outages, a `dirty' power supply or just
simply wish to keep a valid backup at all times, then you do
it.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 60 -
5.2 Fields
5.2.1 Introduction
A screen field is an area of the screen which has some
special property or meaning when the screen is activated in
the application. There are five different types of field,
some of which are possible in only some types of screen. A
table at the end of this section gives the legal and illegal
combinations of fields and screens. All fields have certain
properties associated with them which modify the behaviour
of the field in some manner. The various properties are
covered in the next few paragraphs.
5.2.1.1 Field Properties
Fields have two colors attached to them. The first is the
active color, the color in which a field will appear when it
becomes the active field on a screen. The second color is
the inactive color which is the color in which they will be
displayed at all other times, when they are inactive. By
default, all fields have the same active and inactive colors
(except for menu fields where one color is the `reverse' of
the other, and output fields, which can have no active
state). The combination of foreground and background color
of a location on screen is generally known as its attribute,
to avoid confusion with the less precise term `color' which
can be used to refer to the foreground color, the background
color or the combination of both.
All fields which can display changing information can be
specified as left justified (the default), in which case the
information to be displayed will be placed flush against the
left hand end of the field, or right justified where the
information is placed flush right. The justification mode
can be selected from the field control menu.
The controlling variable of all fields must be a proper
LValue, except for output fields where it can be any valid
expression. While the screen is being run by the runtime
module, the values of the various fields is rigorously kept
up to date by global recalculation of all field values. The
result of this is that whenever a value is specified for a
field, the value is stored immediately and all the
expressions in the fields in the screen are recalculated.
However, if an application contains a screen with a large
number of fields, this recalculation may slow down the
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 61 -
screen. To get around this problem, there is a
recalculation flag attached to fields to specify whether
that field should be recalculated every time. As with field
justification, the recalculation state can be selected from
the field control menu.
In the screen designer, the different field types are
displayed using special characters which are removed before
display during execution. The following six paragraphs
outline briefly the functions of each of the different field
types and how they are displayed on screen in the screen
designer.
Where possible, the initial value of a field will be the
value of the field's LValue upon entry to the screen.
5.2.2 Output Fields
Output fields are the most common form of fields. They are
used to output either string or numeric information at fixed
positions and within fixed boundaries. For numeric output,
the decimal precision of the output can be specified and
defaults to zero places of decimals. Output fields are
displayed on the screen using hash symbols, #. The output
field expression can be any valid numeric or string
expression. Note that string results are output without
quotation marks unlike the debugger expression evaluator and
watch facility.
5.2.3 Input Fields
Input fields are used for input of string and numeric
information. Like all other fields except output, the input
field expression must be a proper LValue. Numeric input
fields can have a decimal precision specified for input. By
default, the precision is zero places of decimals but it can
be altered via the field control menu.
Input fields can be specified as being required, meaning
that for strings a non-blank string must be entered, while
for numbers, a non-zero number must be entered. Input
fields are displayed on screen as a series of question
marks, ?, extending to the width of the input area.
5.2.4 Toggle List Fields
A toggle list field is a list of string constants through
which the end-user can move by pressing <Space> or <Right>
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 62 -
to go to the next, or <Backspace> or <Left> to move to the
previous choice. There can be a maximum of 100 choices in a
single toggle list. Toggle lists are preferable to string
input where there are only a small number of valid strings
which may be entered. Toggle list fields can use either
numeric or string LValues. Toggle lists are displayed on
screen as a series of piping symbols, |, extending to the
width of the field.
5.2.5 Check Box Fields
A check box is a field which only take on a True or False
value. Check boxes are useful when you have to implement a
boolean choice, for example: whether the user wants to back
up some data. String and numeric LValues are valid
expressions for check boxes. The value returned to RExL for
a checked check box is 1.0 for a numeric LValue and "Y" for
a string LValue, while an unchecked check box returns 0.0 to
a numeric LValue and "N" to a string LValue.
If the check box expression is of string type, then the
initial character in the string is used to determine the
initial value of the check box field. The characters "Y",
"T", "y" and "t" are all taken to mean True and all others
are taken as False.
A check box is displayed on screen as an open square bracket
followed by a space and a close square bracket character: [
]. When a check box is checked, the space in the center
will be replaced by a tick mark √. The value in a check box
is toggled by pressing <Space>.
5.2.6 Radio Button Fields
A radio button field is a vertical list of choices, one of
which must be chosen (it is for this reason that the field
is known as a radio button). This field type is used for
input of information similar to that in a toggle list field.
Radio button fields are displayed as a three character wide
column, each line consisting of an opening parentheses
followed by a space and a closing parentheses. The current
choice of the radio button is denoted by a solid dot placed
between one of the sets of parentheses: ().
When activated, <Up> and <Backspace> are used to move to the
previous member of the radio button list, while <Space> and
<Down> are used to move to the next member. Alphanumeric
keystrokes (letters and digits) bring the cursor to the
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 63 -
first button whose label's initial letter matches the
keystroke. Labels are considered to be to the right of the
radio button list.
Consider the following radio button list:
( ) First Choice
( ) Second Choice
( ) Third Choice
( ) Fourth Choice
On entry the radio button will indicate the label First
Choice. Pressing the letter `S' will bring move the cursor
to the second choice, since the initial letter of the label
is `S'. Pressing `F' once brings the indicator to the
fourth choice, while pressing it again brings it back to the
first choice.
5.2.7 Menu Fields
Menu fields are the simplest type of field available in RExL
and can only occur in menu screens. They are defined as
retangular areas of any size. When in use, the user switches
from one field to the next in the same manner as in input,
check box, toggle list and radio button fields. As with
radio buttons above, entering letters will move the hilite
bar to the first field after the currently hilited one to
contain the letter pressed in its uppermost and left
position.
Unlike the other field types, menu fields may contain other
fields. You can thus create menus with variable items by
placing menu fields over output fields which display the
item values. If you so wish, you can place menu fields
within one another to give a moving bar type display.
Menu screens return a value to the LValue attached to that
screen. Internally, the LValue is stored as the first field
in the menu screen and can only be changed when you are
entering the screen designer, and not from within the screen
designer itself.
5.3 Screen Types
There are five different types of screen, each designed for
a specific purpose. As explained in the Language chapter,
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 64 -
each screen has an associated modifier which instructs RExL
what to do with the screen when it encounters it in the
application.
Table 5.1: Screen Types
Abbreviation Used for
[Dialg] Basic input and output
[Dsply] Output with pause
[Help ] On-line user application help display
[Menu ] Menu choice display
[Print] Hard copy output
Because modifiers are attached to individual lines rather
than to the screens per se, a single screen can be used with
more than one modifier. A typical example is a results
output screen which can be displayed as a dialog screen,
using the [Dialg] modifier and then printed as a print
screen using [Print].
As noted above, not all field types are valid in all
screens. The following table lists the valid combinations
of field types and screen types.
Table 5.2: Valid Combinations of Screen and Field Type
Output Input Toggle Check Radio Menu
Dialog Yes Yes Yes Yes Yes
Menu Yes Yes
Print Yes
Help Yes
Display Yes
If you try to use a field in a screen which does not support
that field type, you may get spurious results. As noted
above, menu screens store their LValue in the first field in
the screen, thus if you try to convert a non-menu screen to
a menu screen, the menu's LValue will become the expression
entered for the first field in the non-menu screen. In
general, you should only mix screen types which have the
same field types available.
The next five subsections give details on the use of each
screen type.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 65 -
5.3.1 Dialog Screen
The dialog screen is the most used of all the screen types.
It is the only screen which can contain numeric and string
input, check boxes, radio buttons and toggle lists.
Input starts from the top of the screen and proceeds to the
right and down the screen. When in the screen designer,
pressing <Ctrl-S> displays the field sequence number of the
field underneath the cursor. The sequence numbers are
updated whenever a field is moved, created or copied.
<Tab>, <Down-Arrow> and <Enter> are used to move forward one
field and <Shift-Tab> and <Up-Arrow> to move back one field.
If there is a field directly above and touching the current
field, then <Up-Arrow> will move to that field, instead of a
field to the right of the upper field. <Down-Arrow> works in
the same way. This makes block areas of input more
intuitive to use.
To terminate the dialog screen, press <Enter> when the final
field on the screen is active, or <Ctrl-Enter> from any
field.
In numeric and string input fields, <End> moves the cursor
to the right hand end while <Home> moves to the left hand
end. <Ctrl-Left> and <Ctrl-Right> move the cursor one word
to the left and right respectively while <Ctrl-U> undoes any
changes to numeric and string input areas.
If there are a large number of fields on the screen, then
you may want to turn off automatic field recalculation to
speed up processing of the screen.
If there are any string or numeric input fields which are
defined as being necessary but are not filled (non-zero for
numeric fields), then a message to this effect will be
displayed at the bottom of the screen and the missing field
will be filled with X's which are removed with the error
message when a key is pressed.
5.3.2 Display Screen
Display screens are used to display information and to pause
for a keystroke. This is to get around having to use a
dialog screen with no active fields in it followed by a
KBread() statement. The keyboard buffer is not emptied when
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 66 -
this screen type is used, so you may need to precede the
screen with a KBclear() statement.
5.3.3 Help Screen
Help screens are used to implement context sensitive help
during screen dialog. The number of help screens available
to the user is not limited, although there can only be one
help screen available at any one time. Whenever the runtime
module encounters a help screen, an internal variable saves
the name of the screen, then any subsequent <F1> keystrokes
will cause this screen to be displayed. When the help
screen has been displayed, RExL waits for a keystroke and
then restores the contents of the screen as they were before
<F1> was pressed.
Once a screen has been saved as the current help screen,
that screen will remain current until the next occurrence of
a help screen.
5.3.4 Menu Screen
Menu screens return a value to a numeric variable attached
to the screen and can be used to implement block menus.
Menu fields, which can only be used in this type of screen,
can be of any size and may be nested inside one another
unlike other field types. When a menu field is defined, the
field's inactive color is set as described above but the
field's active color is set to the `reverse' of the inactive
color (for the computer literate, the active color is xor'ed
with 7Fh to generate the reverse attribute). This is done
so that the end-user of the system can tell which menu field
is currently active.
When a menu area has been defined on screen, a vertical line
of piping symbols, |, is placed on the left hand and right
hand sides of the area. When the menu is active on the
screen, the piping symbols are replaced by blanks, to give a
margin one character wide at either end of the area.
When in use, the keys of <Up>, <Down>, <Tab> and <Shift-Tab>
may be used to switch between menu fields in the normal way.
As with the radio button field as explained above, pressing
letters will move the active menu to the field whose first
character (starting from the top left of the field and
moving right and down) matches the keystroke typed.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 67 -
If there are no menu fields in a menu screen, then the
screen is displayed and execution continues without pause.
As mentioned above, the first field in a menu screen is
reserved for the menu screen's LValue. you should bear this
in mind when trying to turn a menu screen into another type
of screen (or vice versa).
5.3.5 Print Screen
Print screens are used to send output to the printing device
attached to your computer, which by default is the DOS file
PRN file. This default can be changed by using the OUTPUT()
command. A print screen may only contain output fields.
Although RExL has no intrinsic support for printer effects
such as italics, bold and so forth, you can send control
sequences to the printer by using output fields which
output the required characters.
When RExL is printing a screen, it omits all lines
containing spaces from the bottom of the screen, to avoid
having large blank spaces in the printout. If you want to
have print screens of fixed lengths, then you should place
some nonblank character at the final line of the screen.
For example, if you wish to print out labels of fixed
height of (say) 9 lines, irrespective of the contents of
the screen, then you should place some unprintable but
nonblank character on the final line. The tab character,
CHR$(9), is ideal for this and could be placed in its own
output field on the last line of the label, or in the
inter-label space.
5.3.6 Subscreens
Subscreens are identical in function to ordinary screens,
the only difference being that they do not occupy the full
size of the screen. Subscreens are slightly cumbersome to
define: By default, when the screen designer is asked to
design a new screen, it assumes that the full screen is
required. To get around this, a temporary screen (which
will be dumped later) must be created and then the
subscreen designed and saved as a block using the !Save!
option in the block menu.
The procedure to define a subscreen is as follows. Type in
some temporary and unique screen name into the editor and
press <F10> to select the screen type. The screen can then
be designed as normal. When the design has been completed,
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 68 -
the area of the subscreen can be marked out and saved to
disk as the appropriate screen type. As this point, the
screen designer can be terminated and control returned to
the editor. Since the screen was not saved, the line will
have reverted to being a rule which can then be deleted,
since it was only temporary anyway. The subscreen saved
from within the screen designer is now present in the
screen list and can be inserted into the application
listing as a normal screen. To force the screen type, the
screen designer will have to be re-entered by pressing
<F10> on the screen name and by selecting the appropriate
screen type.
If changes are made within the screen designer to a
previously defined subscreen, then upon exit or saving of
the screen, the screen designer will ask if the screen is
to be saved at its previous size or at full screen size.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 69 -
Chapter 6
Using the Screen Designer
6.1 Starting the Screen Designer
The screen designer is fully integrated into the editor and
can be accessed through the <F10> key.
Before you can enter the screen designer and create a
screen, you must supply a screen name for the screen so that
it can be entered into the screen file on disk immediately.
Once a new screen name has been entered, the screen type
must be defined using the screen type menu on <F10>. This
is a five item pop-up menu which lists the five different
screen types. The items are listed in the order in which
they are most commonly used.
┌───────────┐
│ Dialog │
│ Menu │
│ Print │
│ Help │
│ Display │
└───────────┘
The screen type is selected in the normal manner by using
the up and down arrow keys and pressing <Enter>.
When a screen has been saved and the screen designer
terminated, the normal editor screen will reappear and the
screen name previously entered will be prefixed with one of
the five screen modifiers as described above. The action of
the <F10> key is slightly different when applied to a line
containing the name of a screen and the type of the screen
as reported by the line's modifier. In this situation, the
screen designer is activated directly without going through
the screen type menu. In order to change the type of a
screen (for example from a display screen to a print
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 70 -
screen), you must enter the name of the screen with no
modifier and then press <F10>.
Once the line modifier has been entered, the screen designer
can be reactivated by pressing <Tab> on the screen name,
since the editor knows that this line refers to a screen and
not a rule.
If the menu screen type has been selected from the screen
type menu, a dialog box will be displayed prompting for the
menu variable (which can be any proper RExL LValue)
associated with that screen. As explained above, when the
menu screen terminates, the screen's menu variable will be
set to the field number of the field which was current when
<Enter> was pressed. When the menu variable has been
entered, the screen designer will start.
When the screen designer is entered for the first time, the
screen will be filled with the half-tone character (ASCII
177) colored in light gray on a black background (unless the
`Print' screen type was selected, in which case the screen
will be blank). The the cursor will be in the top left hand
corner of the screen and screen designer is now ready for
input. If there is a default screen defined (through the
Edit|Default screen menu option) then the contents of the
screen will be loaded automatically.
If the screen designer is started with a previously defined
screen, the screen designer will remove fields which would
be invalid in the newly chosen screen type. For example, if
a screen which was previously of type `Menu', and it were
then opened as a `Dialog' screen, then the menu variable and
the menu fields would be stripped from the screen. This
feature should be borne in mind when saving screens. In
general, cross-type screen
translation should be avoided for this reason.
6.2 Basic Design
The cursor is moved in the screen designer using the
standard arrow keys <Up>, <Down>, <Left> and <Right>. In
addition to these keys are the following:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 71 -
Table 6.1: Screen Designer Cursor Keys
Key Moves cursor
<Home> to start of line
<End> to end of line
<PgUp> to top of screen
<PgDn> to bottom of screen
<Ctrl-Left> left one word
<Ctrl-Right> right one word
<Ctrl-Home> to top of screen
<Ctrl-End> to bottom of screen
<Ctrl-PgUp> to top left hand corner of screen
<Ctrl-PgDn> to bottom right hand corner of screen
<Tab> right ten characters
<Shift-Tab> left ten characters
<Enter> to beginning of line
The action of the <Enter> key is slightly more complex than
simply moving to the start of the next line: If there is a
box character on the next line underneath and to the left of
the cursor, then the cursor will be placed on the right hand
side of the box character. This behaviour makes it easier
to enter text in boxes on the screen.
6.3 Fields in the Screen Designer
The screen designer supports the use of six different types
of fields as explained in the previous chapter. In general,
a field definition can be initiated by pressing <Ctrl> and
the initial letter of the field type which you wish to
define (for example output fields are attached to <Ctrl-O>).
A field definition menu is attached to <Ctrl-F>, from where
you can select the field type to define, if you can't
remember the different field types.
When defining a field, the area marked out on the screen is
painted in `reverse' colors to hilite it against the
background. The location on screen where the field
definition was initiated acts as an `anchor' point which
remains fixed while the field is defined. Initially, the
cursor is placed on the anchor point and can be moved about
the screen using the arrow keys plus the four other cursor
keys <Home>, <End>, <PgUp> and <PgDn>. <Enter> is used to
terminate the field definition.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 72 -
The menu field is the only field type which can be of
arbitrary size so in all other field type definitions, the
movements of the cursor are limited to avoid creating
improper fields. The following table lists the valid sizes
of fields:
Table 6.2: Valid Field Sizes
Vertical Movement Horizontal Movement
Output Fixed height of one Yes
Input Fixed height of one Yes
Toggle Yes Fixed width of 3
Check Fixed height of one Fixed width of 3
Radio Yes Fixed width of 3
Menu Yes Yes
When the field has been defined, a dialog box will appear
(not applicable to menu fields) into which the expression
associated with that field is entered. While in this dialog
box, you are free to use the scrap buffer as normal, even
though it is not displayed. The function and variable
dictionaries are also available.
Every field on the screen has a field number associated with
it. This number codes for the order in which the fields are
to be evaluated when the screen is run by the runtime
module. The fields are numbered sequentially from zero,
increasing moving to the right and then down the screen.
This behaviour is compatible with the IBM- and MicroSoft-
defined CUA standard for user interfaces. Whenever a field
is created, moved or deleted, the screen sequencing numbers
are recalculated, this may cause delays of the order of a
half a second or so on XT-class machines. In the current
release, there is no way to alter the sequencing order of
fields in the screen.
In any one screen there may be up to 128 fields. Beyond
this limit, the amount of time required for processing the
fields becomes noticeable. It should also be noted that any
screen which uses more than 128 fields will be cluttered and
should be redesigned to use less fields.
The methods for entering the various fields are presented in
the next six sections.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 73 -
6.3.0.1 Output
<Ctrl-O> is used to define an output field. Output fields
can be up to eighty characters wide, the width of the
screen, and are one character in height. Only horizontal
movement is permitted while defining an output field.
When the field has been marked out, a dialog box will appear
prompting for an output expression. This can be any valid
RExL expression and it will be syntax checked before it
being accepted by the designer. When a valid expression has
been entered, the marked area will be replaced with hash
symbols, #, to denote an output field.
6.3.0.2 Input
<Ctrl-I> is used to define an input field. Input fields can
be up to eighty characters wide and are one character in
height. The input expression must be a properly formed
LValue. As with output expressions, the designer will not
accept an improper expression. Input fields are denoted by
question marks, ?.
6.3.0.3 Toggle
<Ctrl-T> is used to define a toggle field. These fields can
be between seventy seven characters and six characters
(inclusive) in width and are one character in height. The
toggle expression must be a proper LValue.
You can have up to one hundred choices occupying up to four
thousand characters of storage in an individual toggle
choice field. When the field has been defined, two dialog
boxes will appear, the upper one for the toggle list LValue
and the lower for the list of choices. A field LValue, which
can be either string or numeric, must be entered before the
individual choices can be. As before, you are not permitted
to enter an invalid LValue. When a valid one has been
entered, the cursor will move to the second box, labelled
Choices.
The second box will be of the same width as the toggle list
field, so that strings which would not fit in the field are
not allowed. The strings are entered in the order in which
they are to appear in the field when it is activated. An
individual toggle list item can be deleted by pressing
<Alt-D> or <Ctrl-Y>. The list entry is terminated by
pressing <Enter> on an empty list item and it is for this
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 74 -
reason that empty toggle list items are not allowed. The
cursor can be toggled between the two windows by using <Tab>
and <Shift-Tab>.
When the field has been defined, the marked area will be
replaced by a series of piping symbols, |.
6.3.0.4 Check
}<Ctrl-C> is used to define a check box field. Since this
field can have only one size of three characters wide by one
high, the LValue dialog box will appear immediately
prompting for an LValue which may be either string or
numeric in type.
When the LValue has been entered, the marked are on the
screen will be displayed as a set of square brackets
separated by a tick, [√].
6.3.0.5 Radio
<Ctrl-R> is used to define an radio button field. Radio
button fields have fixed widths of three characters but may
be as high as twenty-five characters, the height of the
screen.
The radio button LValue must be a numeric expression and not
a string expression. When the field has been defined, the
marked area will be replaced by a vertical block of sets of
parentheses separated by the center dot character.
6.3.0.6 Menu
<Ctrl-M> is used to define a menu field and can only be used
in menu screens. Menu fields can be of arbitrary size and
may be nested within one another, unlike all other field
types.
Since, in menu screens, the menu expression is entered when
the screen itself is entered and is therefore constant for
all fields, there is no menu expression dialog box
associated with menu fields. So, when the menu area block
mark has been terminated by pressing <Enter>, the vertical
edges of the block will be marked with piping symbols, |,
and control will return to the main screen designer
directly.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 75 -
6.4 Block Operations
Blocks are rectangular areas of the screen which can be
defined and then used for various operations. A block is
marked by pressing <Alt-M> and then moving the cursor in the
same manner as that used during field definition. For those
more familiar with Sidekick and the Borland-type editors,
the keys <F7> and <F8> may be used to start and end block
definition. When a block has been defined, the block menu,
which contains nine items, will appear in the top left hand
corner of the screen (unless it has been moved).
There are nine separate operations selectable from the block
menu which may be carried out on marked blocks, and these
are covered in the next nine sections. Note that if the
block contains a portion of a field, then certain operations
are not allowed since they would have no meaning when
applied in those circumstances (for example, moving and
copying portions of a field). If these are attempted, then
the screen designer will display an error to the effect that
the area crosses fields.
Once a block has been defined and some block operation
carried out upon it, it may be re-marked for further
operations by pressing <Alt-R>. Typically, this is useful
when a box has been drawn which then needs to be painted.
6.4.1 Block Painting
This option is used for setting the foreground (ink) and
background (paper) colors of the defined block. When this
option is selected, the following paint box appears:
[Figure missing in disk manual]
The color of the foreground is altered using the <Up> and
<Down> keys and is tracked in the left pane of the paint box
window by a gray square. The background color tracked in
the right hand pane with two center dot characters and is
changed with the <PgUp> and <PgDn> keys.
The row of `x' characters at the bottom of the paint box
display the combined foreground and background colors. On
the EGA, VGA and most CGA systems, the screen designer can
make use of the flash-intensity bit. This allows the use of
sixteen background colors instead of eight, at the expense
of flashing. This bit can be toggled on and off by pressing
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 76 -
<Alt-T>. If the system which the editor is running on
supports this feature, then the lower eight colors in the
right hand pane will be `brightened'. These can then be
selected in the same manner as ordinary background colors.
Note, however, that some early CGA adapters do not support
this, with the result that what should have been displayed
in intense background will in fact be displayed as flashing.
The <Alt-T> keystroke can be used anywhere within the screen
designer and is not limited to the paint box.
If the block area being painted covers a field or part of a
field, then the attributes of the field will be updated to
the new colors. As with all windows in RExL, the paint box
can be moved by pressing the <Scroll-Lock> key, if it
obscuring something.
When the desired combination of foreground and background
colors has been reached, <Enter> will terminate the paint
and make the colors permanent.
6.4.2 Align
When the align option is selected, the marked area will be
moved from its old location and placed at the horizontal and
vertical center of the screen from where it can be moved
using the normal arrow keys. Pressing <Enter> will make the
alteration permanent.
In all cases where blocks are moved from one location to
another in the screen designer, the attributes of the screen
underneath the original block are left untouched and are
copied, along with the character information inside the
block, to the new location for the block.
It is not possible to align blocks which contain portions of
a field.
6.4.3 Box
The box option is used to draw boxes around the marked area
on screen. On selection, the following box menu appears:
[Figure not included in disk manual]
The first option in the menu selects whether the box is to
overwrite the contents of the box (but leave the fields
inside intact) or whether the box is to overlaid around the
edge of the area leaving the interior untouched. The option
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 77 -
can be toggled by pressing <Enter> on it. If the overlay
option is selected, then, if possible, the box will link up
with any boxes which impinge upon the marked area.
To draw a box of a particular type, hilite a suitable border
type and press <Enter>. The box will then be drawn on
screen. If the screen is destined for use with a printer
(such as a print screen), then, unless all printers which
may be used with the system support them, the first five box
edge types should not be selected, since few printers
support the line draw characters in their native mode.
When defining a block for use with this option, it is
permissible to include portions of a field within the block,
although those parts of the box which would cut the fields
are removed.
Alternatively, boxes can be drawn directly by using the
<Alt-B> keystroke. When this keystroke is pressed, the
screen designer again enters its block-define mode and the
extent of the box is drawn on the screen. When the desired
box has been drawn, it is selected using <Enter> and the box
type selection menu appears as before.
6.4.4 Delete
The delete option is used to delete a marked block. As with
the align and move options, the attributes of the originally
marked area remain unaltered after the operation.
Any fields which are fully within the block are also deleted
and the remaining fields are re-sequenced to take account of
the new field layout.
While the block is being marked, the <Alt-D>, <Del> and
<Ctrl-Y> keystrokes may be used to delete the block
immediately, without having to go through the block menu.
6.4.5 Move
The move option is used to move a marked block. The marked
area cannot cross any fields since attempting to move a
portion of a fields has no meaning. When the option has been
selected, the cursor will disappear and the screen designer
enters its block move mode.
The block may be moved using the <Up>, <Down>, <Left> and
<Right> keys. Pressing <Enter> will terminate the move.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 78 -
If the area where the block is to be placed contains any
fields, then the fields will be deleted and the field
sequence will be regenerated. If the area crosses any
fields, then the move will be terminated with an error.
When the block has been placed successfully, the character
information is removed from the old location of the block
while the attributes are left as they are.
6.4.6 Copy
The copy option is substantially the same as the move
operation above, with the single difference that when the
destination is selected, the contents of the original block
are left unchanged and new fields are created in the
destination.
If there are a large number of fields on the screen, then
care should be taken that the limit of 128 fields is not
reached while copying blocks. If it is reached, then an
error to this effect will be displayed and the copy
terminated with the fields remaining to be copied being left
uncopied.
6.4.7 Fill
The fill option in the block menu is used to fill a defined
area with a particular character. When the option is
selected, the character fill selection box appears on the
screen, again, in the top left hand corner of the screen
unless it has been specifically moved.
[Figure not included in disk manual]
The character to fill the block is hilited in the fill
selection box in yellow foreground on a magenta background.
The normal arrow keys are used to move the selection bar
around the list while <PgUp> and <PgDn> are used to move
from one group of 64 characters to the previous and next
pages respectively.
<Enter> is used to select the character to fill the defined
block with. If the block contains any fields, then these
will be redrawn when the fill operation is finished. The
foreground and background colors are left unchanged by
filling the block.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 79 -
6.4.8 Save
This option is used to save a block to the screen file.
This feature is mainly used for creating pop-up menu type
displays.
When this option is selected, a dialog box will appear,
prompting for a name under which to store the block in the
screen file. When a name has been entered, the screen
designer checks to see if that name already exists in the
screen file. If the name is unique, then the block is saved
immediately, otherwise, a yes/no menu will appear, asking
whether the previous version of the screen should be
overwritten with the new one. Selecting the `yes' option
from this menu will cause the marked block to be written to
the screen file in place of the old one.
Once the screen has been saved, it can be read and modified
like any other full sized screen.
Detailed information on the use of small screen blocks can
be found in the section on sub-screens further on in this
chapter.
6.4.9 Under shadow
The final option in the block menu is used for drawing
`shadows' which appear `underneath' marked blocks on the
screen. This option is most commonly used for hiliting some
important information in a box on the screen by making the
box stand out against the background.
The undershadow effect is achieved by painting the area to
the right of and below the marked block in a light gray
foreground color on a black background. The undershadow
effect works best when applied on a bright background.
Overuse of this effect should be avoided since it loses its
emphasis easily.
6.5 Sub-screens
Sub-screens are created using the save block procedure as
described in the previous section. They are mainly used for
creating pop-up menus and other types of pop-up queries.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 80 -
The easiest method to create a pop-up sub-screen is as
follows: Enter the screen designer at the screen where the
pop-up will appear and create the pop-up, mark the area and
then save it as a block. Exit from the screen designer, but
do not save the parent screen permanently when requested to.
Return to the location in the listing where this pop-up will
be used and then call it as a normal screen.
When the runtime module runs the saved block of screen, it
will only load that portion, leaving the rest of the screen
as it was before the screen was called, thus creating the
effect of a pop-up screen.
The screen designer treats sub-screens in almost exactly the
same manner as normal full-sized screens, the only
differences being as follows. Firstly, upon entering the
screen designer with a sub-screen, the sub-screen will be
loaded at the same co-ordinates on the screen as it was
saved from, while the rest of the screen will be painted
with the normal background half-tone character.
Secondly, when exiting from the screen designer, instead of
the normal `Do you want to save the screen ?' prompt, the
prompt `Screen was originally smaller. Save as:' will
appear. This menu has three options in it: Original area,
Full screen, and Return to editor. The first option will
save the original screen block to disk, the second saves the
entire screen to disk in place of the original sub-screen,
while the final option quits the screen designer entirely
and return control to the editor without saving the screen.
A minor point to note is that attempting to print sub-
screens will not produce the expected results, since the
rest of the screen currently on display will be included
with the output.
6.6 Field control menu
<Ctrl-F> has two uses in the screen designer, which one is
used depends on whether the cursor is over a field or not.
When the cursor is placed on a field, <Ctrl-F> will bring up
the field modification menu, described in this section.
When the cursor is not over a field, then <Ctrl-F> will pop
up the field type definition menu, described in the next
section, listing the six field types from which one can be
chosen.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 81 -
The field control menu, popped up by a keystroke of <Ctrl-F>
while the cursor is hiliting a field, controls the
properties attached to that field. The field control menu
is slightly different for each field type on account of the
differing requirements for each. In total, there are nine
properties which may be attached to each of the six
different field types as indicated as follows:
Table 6.3: Valid Field Attributes
Input Output Toggle Check Radio Menu
Active color Yes Yes Yes Yes Yes Yes
Inactive color Yes Yes Yes Yes Yes
Delete Yes Yes Yes Yes Yes Yes
Expression Yes Yes Yes Yes Yes
Recalc Yes Yes Yes Yes Yes
Justify Yes Yes Yes
Width Yes Yes Yes Yes
Necessary Yes
Precision Yes Yes
Validate Yes
The field control menu for a particular field type consists
of the options ticked in the table above underneath the
fields. The next nine subsections give the meanings of the
items in the field control menu:
6.6.0.1 Active color
The active color of a field is the attribute which is used
to color the contents of a field when that field is active.
All fields, except output fields, have active colors.
When this option is chosen from the menu, the standard paint
box appears and the field attribute can be selected from
this.
6.6.0.2 Inactive color
The inactive color of a field is the attribute which is used
to color the contents of a field when that field is
inactive. All fields, including output fields, have active
colors.
When this option is chosen from the menu, the standard paint
box appears and the field attribute can be selected from
this.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 82 -
6.6.0.3 Delete
This option will delete the hilited field from the screen
and perform a screen field resequencing. Pressing <Alt-D>
while hiliting a field in the screen designer has the same
effect as choosing this option.
6.6.0.4 Expression
The expression attached to a field can be edited when this
option is selected. The edited field expression will be
checked for correct syntax before it can be accepted by
RExL. When the cursor is hiliting a field, <F10> can be
used as a shortcut keystroke for this function, while <Alt-
F> will simply display the field expression on the bottom of
the screen.
For toggle fields, the choices may also be altered.
6.6.0.5 Recalc
Under normal circumstances, the runtime module will
automatically recalculate all fields in a screen whenever
the contents of one field are modified. If there are large
number of fields in the screen, then this may slow down the
operation of the screen designer. Toggling this option on
and off will enable and disable the automatic recalculation
of the hilited field.
6.6.0.6 Justify
Normally, the contents of fields are left justified, that
is, placed flush against the left hand end of the field.
This option can be used as a toggle to toggle the placement
between the left and right ends of fields.
Note that during numeric input in input fields, the number
is always justified right. When input is finished in the
field, the result will be justified as specified by this
flag.
6.6.0.7 Width
The width of a field can be altered using this option. When
it is selected, a block will appear of the same size and
shape of the field. This can then be changed in the same
manner as ordinary block definition.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 83 -
When a suitable size has been chosen and <Enter> has been
pressed, the screen designer will check to ensure that the
new field does not cross any earlier fields.
6.6.0.8 Necessary
String and numeric input fields my be defined as being
`necessary' for the proper completion of the screen. If
this flag has been set, then a zero value, for numeric
fields, and an empty string value, for string fields, will
not be allowed as valid input. The runtime module will
hilite the unfinished field in red, fill it with X's and
post an error message on the bottom of the screen and return
the end-user to the field.
6.6.0.9 Precision
Numeric input and output fields can have an optional decimal
precision supplied. This will be the number of decimal
places to be displayed or input when the runtime module
processes the field.
6.6.0.10 Validation
Numeric and string input fields may be validated as date and
time strings by toggling the validation type between `None',
`Date' and `Time'. If the user enters a string, then it
will be checked for validity by the runtime module. If the
string is found to be invalid, then execution will not
proceed until a valid string is entered. The format checked
will be the format current on your machine, or that set up
by a call to the DTformat() command.
Note that the null date string, "00/00/0000" is considered
to be a valid date. If you want to filter out this date,
then you should set the `necessary' flag.
6.7 Miscellaneous Functions
6.7.0.1 Changing Field Types
The <Ctrl-> key combinations noted above for defining fields
also have another use in changing a field from one type to
another. For example, pressing <Ctrl-O> when the cursor is
hiliting an input field will change that input field to an
output field. The exact procedure is as follows: When the
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 84 -
<Ctrl-> key combination is pressed, the screen designer
looks to see if the cursor is placed over a field, if it is,
then the field type is changed to that specified by the
keystroke and the field definition routine is called. The
width of the field can then be changed. Pressing <Enter>
will terminate the width definition and bring up the field
expression dialog box (or both of them if the new field is a
toggle field).
The field changing facility is most useful when changing a
screenful of input fields to output fields.
6.7.0.2 Field Utility Keys
<F10> is used to edit a field expression, when the cursor is
on a field. This function is placed on a special key of its
own, since it is used regularly. If the cursor is not over
a field, then this key has no effect. The <Alt-F> keystroke
can be used to display the expression associated with the
cursor field. When this keystroke is used, the expression
is only displayed and cannot be modified.
<Alt-D> is used to delete the field underneath the cursor.
As with <F10>, this keystroke has no effect if there is no
field underneath the cursor.
The <Ctrl-S> keystroke is used to display the screen status
on the bottom line of the screen. The status display
contains four items of information: Displayed from left to
right, these are the current cursor position in (x,y) format
with (0,0) at the top left hand corner. The next two sets
of coordinates give the size of the currently defined block
(if no block has been defined, then the full screen is
used). The `Fields' display gives the number of fields
defined in the screen (the second digit) while the first
digit gives the sequence number of the field underneath the
cursor, or 0 if there is no field there. The type of the
hilited field is displayed beside the sequence number. The
final display gives the amount of free memory left to the
screen designer. For proper operation, this figure should be
above 10k.
6.7.0.3 Line Drawing
The line drawing feature of the screen designer is used to
draw lines on the screen using the IBM ASCII characters
between 179 and 218 inclusive. When <Alt-L> is pressed, the
designer enters line draw mode and the cursor is backed by a
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 85 -
`reverse' attribute block to emphasise the fact that the
screen designer has changed mode.
When <Alt-L> is pressed, the line draw menu appears in the
top left hand corner of the screen:
[Figure not included in disk manual]
The first option in the menu toggles between overlay and
overwrite modes (explained below) while the other options
specify the type of line to be drawn.
The normal arrow keys and <Space>, to move right, are used
to move the head of the line about the screen. When drawing
a line, the character underneath the cursor is not updated
until the cursor is moved. This needs to be done because
the exact character required depends on the next direction
of travel of the cursor.
The line draw mode can operate in one of three modes:
o Overwrite mode, where the line being drawn does not
link up with any previous line on the screen.
o Overlay mode, where the line does link up with lines
already existing on the screen. Note that not all
combinations of line draw characters can be displayed
using the ASCII character set, in these cases, the
current line draw type will take precedence over
older lines.
o Delete mode, where the character underneath the
cursor is deleted. This option is most useful for
deleting old lines from the screen.
The <Ins> key is used to toggle between overlay and
overwrite modes, with the cursor being an underline in
overlay mode and a half-box in overwrite mode. The <Del> key
is used to toggle delete mode on and off. In delete mode,
the cursor is placed in the upper half of the character box.
While the line is being drawn, the shape of the line being
draw may be changed using the <Alt> key in combination with
the digits 1 to 4.
The following table summarizes the keystrokes valid in line
draw mode:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 86 -
Table 6.4: Keys in Line Draw Mode
<Up> Move up
<Down> Move down
<Left> Move left
<Right>, <Space> Move right
<Enter>, <Esc> Terminate line draw mode
<Ins> Toggle overlay and overwrite mode
<Del> Toggle delete mode
<Alt-1> Set horizontal line emphasis to one line
<Alt-2> Set horizontal line emphasis to two lines
<Alt-3> Set vertical line emphasis to one line
<Alt-4> Set vertical line emphasis to two lines
6.7.0.4 Other Editing Keys
<Ctrl-Y>, used to delete lines, has two functions. When it
is first pressed, it deletes all characters and fields to
the left and right of the cursor up to, but not including,
the nearest box characters. If it is pressed again
immediately, then the entire screen line will be deleted
from the left edge to the right edge and the lines
underneath will be pulled up by one character. Note that
<Ctrl-Y> must be pressed twice in succession with no
intervening keystrokes for the entire line to be deleted.
<Del> is used to delete the character underneath the cursor.
All characters up to but not including the next box
character to the right of the cursor will be move one
character to the left. If <Del> is pressed over a box
character then the box character itself will be deleted.
<Backspace> deletes the character to the left of the cursor
and moves the cursor one character to the left, moving all
characters to its right, up to but not including the nearest
box character, one character left.
6.7.0.5 Lists in the Screen Designer
The editor's three most commonly used lists are also
available in the screen designer. These are the variable
list on <Alt-V> and <Shift-F6>, the rule list on <Alt-Z> and
<Shift-F2> and the screen list on <Alt-S> and <Shift-F3>.
The hotkey reference lists which are available in the main
editor are not available when these lists are requested in
the screen designer.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 87 -
6.7.0.6 Miscellaneous Keys
The <F2> keystroke will save the screen to the screen file.
If the screen was originally a sub-screen and not a full
sized screen, then the prompt `Screen was originally
smaller. Save as:' will appear with a three option menu,
instead of the normal `Do you want to save the screen ?'
prompt. This feature is explained in the section on sub-
screens.
<Alt-X> and <Esc> are used to exit from the screen designer
and to return to the main editor. As before, if the screen
has been altered, then you'll be prompted to save it before
continuing.
All keystrokes greater or equal to the space character and
less than or equal to an ASCII code of 255 are placed
directly onto the screen. If insert mode is active, then
all characters to the right of the cursor will be moved one
character to the right, with the rightmost character being
lost. If insert mode is not active, then the character
underneath the cursor will be deleted.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 88 -
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 89 -
Chapter 7
The Runtime-Debugger
7.1 Introduction
This chapter covers the functions and capabilities of the
debugger module in depth (when we refer to the debugger in
this chapter, we mean the runtime-debugger module as a
whole). The interface used in the debugger is much the same
as that in the editor, so you shouldn't have much trouble
using it. The debugger-specific keystrokes are largely the
same as those used by the Borland integrated debuggers, so
if you have used those, then a quick read through this
chapter should be sufficient.
7.2 Debugger Basics
The debugger is started by typing `rexlrd' at the DOS
prompt. Contrary to the requirements of the editor, you
must supply a file name on the command line. If you omit the
file name, then a few lines of command line help will
appear. In the current release, there are three command line
parameters which can be supplied to the debugger, these will
be covered at the end of the chapter. Unlike the editor,
the debugger does not read or generate a configuration file.
The debugger can run in either of two modes: The first is
run mode, in which the application is executed without
stopping between rule calls, statements and screens. The
second mode is debug mode, in which the full screen debugger
controls the execution of the system. Debug mode is used if
you select the option Debug application from the Run menu in
the editor, or if you press <Alt-D> while the application is
executing in run mode.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 90 -
There are a few terms which you need to understand before
you continue with the rest of this chapter. These are
explained here:
o Step and Trace: An application is stepped or traced
when the runtime portion of the module gains control
of the application and executes some portion of it.
o Watch: A watch is an expression, visible in the watch
window at the bottom of the screen, which is
evaluated every time the debugger module is given
control of application execution.
When you enter debug mode, you will be presented with the
main debugger screen (note that you can't have all the menus
pulled down at once, as they are here! The dots and arrows
indicate where the menu is normally displayed):
[Figure not included in disk manual]
The bar at the top of the screen has four pull down menus.
In the same manner as the editor, these can be activated by
pressing the left and right arrow keys to move from one to
the next, and pressing the enter key to select the hilited
menu. Press <Esc> to return to the code window from the
menus.
To the right of the four menu titles, is the name of the
RExL file which is currently being debugged. The third last
line on the screen is the debugger status line, which has
the same function and features as the editor status line in
the editor.
Underneath the debugger status line is the watch window
(blank above) where watches are kept. On start-up, the
watch window is one character high, but this will grow and
contract as watches are added and removed. The bottom line
of the display lists some of the short-cut keystrokes which
can be used in the debugger.
The Code Window is above the status line and displays the
rule currently being executed. Cursor movement in the code
window uses the same keys as in the editor.
The four menus on the main horizontal menu bar have contents
as follows:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 91 -
7.2.1 File menu
┌────────────────────────┐
│ Return to editor │
│ OS shell │
│ Quit │
└────────────────────────┘
The file menu has the following seven options:
o Return to editor: This option will return control to
the editor, loading the application currently being
debugged.
o OS Shell: If you want to run a DOS command, but do
not wish to exit from the debugger permanently,
choose this option to go into a DOS shell. While you
are in the shell, you should not, under any
circumstances, run any T&SR programs (such as
Sidekick, ScrGrab and so forth), since these programs
change critical area of the computer's memory which
may cause it to crash unpredictably when you return
to RExL. When you are finished in the shell, type
`exit' at the DOS prompt to return to RExL.
o Quit: This choice will quit from the debugger and
return you directly to DOS, irrespective of whether
you started the debugger from within the editor or
not.
7.2.2 Debug menu
┌───────────────────┐
│ Watch │
│ Evaluate │
│ Run │
│ Step │
│ Trace │
│ Halt here │
│ Breakpoint │
│ Animate │
└───────────────────┘
All of the options in this menu are also available through
hot-key short-cuts. When you become familiar with the
debugger's keystroke map, you'll probably not need to use
this menu. There are eight options in this menu:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 92 -
o Watch: This option, which is also available via the
hot-key
o <Ctrl-F7> or <Ctrl-W>, controls the entry of new
expression watches into the watch window at the
bottom of the screen. The procedure for entering
watches is covered in detail in the next section.
o Evaluate: Selecting this option, also available
through <Ctrl-F4> or <Ctrl-E>, causes an expression
evaluation box to appear. This is also covered in
the next section.
o Run: This choice will return the debugger to run mode
and will not return control to the debugger, unless
it meets a breakpoint or you press <Alt-D>. Pressing
<F9> is equivalent to selecting this choice.
o Step: This menu choice is identical to pressing <F8>.
o Trace: This choice is identical to pressing <F7>.
o Halt here: This option, also available by pressing
<F4>, will set a temporary breakpoint at the line
currently hilited in the code window. When execution
reaches the line, the debugger will regain control
and the breakpoint will be cleared.
o Breakpoint: This option (also on <Ctrl-F8>)sets a
breakpoint at the line hilited in the code window.
Whenever execution reaches this line, the debugger
will regain control.
o Animate: This choice (also on <Alt-F4>) will cause
the debugger to emit a trace instruction at variable
intervals, so that the debugger appears to control
itself. Pressing any key while animating will return
control to the user.
7.2.3 Lists menu
┌────────────────────┐
│ Rule list │
│ Screen list │
│ Unused rule list │
│ Unused screen list │
│ Variable list │
│ Function list │
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 93 -
│ Call stack │
└────────────────────┘
This menu gives you access to all the lists of entities
which are defined the current application. Most of the lists
have special `hot-links' to other, more specific, lists.
These are mentioned briefly at the end of this subsection
and covered in more detail further on. All of these lists
are also available via hot-keys from within the main editor
window. Consult the section on editor keys for more
information on this.
The lists run menu has the following six options:
o Rule list: This list contains the names of all of the
rules which are currently defined in your
application.
o Screen list: This list contains the names of all
screens defined in the currently active screen file.
o Unused rule list: This list shows all rules which,
although defined in the normal way, are not actually
referenced by the application. Pressing <Alt-D>
within this list will delete the unused rule from the
application.
o Unused screen list: This list gives all screens which
are not referenced in the current application. As
with the unused rule list above, press <Alt-D> to
delete the unused screen from the list and free up
the space it occupies within the screen file.
o Variable list: This list contains all variables. The
status line at the bottom of the screen displays the
type of the variable, whether numeric or string, and
whether it's an array or a simple variable.
o Function list: This list contains all the functions
available in RExL. Press <Ctrl-F1> for help on the
hilited function.
o Call stack: The call stack is the list of rules which
are currently executing. The most recent call is at
the bottom of the list. The `Main Program' rule is
always at the top of the list.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 94 -
All the list windows are movable by pressing <Scroll-Lock>,
using the arrow keys to position and pressing <Enter>,
<Scroll-Lock> or <Esc> to terminate the window move. Note
that all lists in RExL feature helix searching. You can
also output the contents of any list to a file (or the
printer) by pressing <Ctrl-P>, as in DOS.
If you terminate any of the lists by pressing <Enter>, then
the choice which you selected from that menu will be placed
into the scrap buffer, ready for pasting using the <Shift-
Insert> keystroke.
7.2.4 Options menu
┌───────────────────────┐
│ Load macros │
│ Save macros │
│ Beep off │
│ Function lower case │
│ Exploding windows off │
│ Screen swap: smart │
│ Repaint screen │
└───────────────────────┘
The options menu controls various system parameters and
features not directly connected to the editor per se.
o Load macros: Any macro definitions you define in the
editor may be saved to disk for later retrieval using
this menu option. The macro file format is constant
across the RExL product range, so that macros defined
in the editor may be used in the debugger or in the
database manager and so on. Macros are explained in
more detail at the beginning of this chapter.
o Save macros: This option allows you to save macros
which can then be reloaded at some future time using
the load option above.
o Beep off: By default, RExL beeps whenever it
encounters an error. This beeping can be toggled on
and off by selecting this option.
o Function lower case: By default, all functions in
RExL are displayed in their natural case. This is
that functions which are members of families are
displayed with the first two or three letters
capitalised, while the miscellaneous functions are
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 95 -
entirely capitalised. This option is used to toggle
between upper (or partially upper) case function name
display and lower case.
o Exploding windows off: In its normal state, all
windows in RExL open instantaneously upon activation.
This option can be used to make windows `grow' to
full size on the screen. This is only a visual
effect and has no effect upon the application.
o Screen swap on: Whenever the debugger is stepped or
traced, the debugger will swap its own screen with
that of the application running underneath it. If
your application does not access the screen, then you
can toggle this option to `None' to disable the
screen swap.
o Alternatively, you can set the mode to `Smart', when
RExL will check the line about to execute to
determine if the line contains an expression which
could change the screen. If this is so, then
the screen will be swapped, but not otherwise. Smart
screen swapping is the default screen swap mode.
If, when screen swap is off, your application
accesses the screen, the change will be lost when the
debugger regains control of execution, possibly with
a garbled screen.
o Repaint screen: This option is used to restore the
debugger screen after it has become
corrupted. Corruption of the debugger screen happens
when screen swap has been disabled during a screen
access by the application.
7.3 Using the Debugger
The familiar keystrokes of <Up>, <Down>, <Tab>, <Shift-Tab>
and so on, are all supported in the debugger as they are in
the editor. While designing the debugger, we have tried to
strike a balance between its functionality and size. It is
for this reason that, although the <Alt-Z> keystroke
generates the rules list as in the editor, there are no
hot-links to the other features, such as rule reference and
so forth.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 96 -
The following is a typical debugger screen:
[Figure not included in disk manual]
As with the editor, the status line (this time on the third
last line) shows the amount of memory remaining free for the
runtime module to use. To the right of this is the level
display, showing the depth which the debugger has reached.
There are two differences to the layout of rules in the code
window. The first difference is the current line pointer
character, ASCII 16. This points to the line which will be
executed as soon as the runtime module regains control of
execution. The line pointer character is placed between the
line's modifier and the actual text of the line. In the
example above, the line pointer points to the final line in
the code window. In practice, this character will be
colored yellow to make it visible above the background.
The second difference is the character on the far left of
the line. This character indicates the current logical
status of the line, X, for False, √ for True and ? for
unknown. On start-up, all lines are assigned a value of
unknown, but as the application executes, the lines' logical
values are filled in. When a line is about to be executed,
its status is set to unknown.
Other than the differences from the editor noted above, the
only features to be understood in the debugger are
application step, trace and the function of watches and
breakpoints. These are covered in the next four subsections.
7.3.1 Step
When the application is stepped, the runtime module is given
control of execution and it will run the line which was last
hilited in the debugger's code window. RExL uses the <F8>
keystroke to step.
If the line was a statement, then it will be evaluated and
the value returned will be assigned to the line's logical
status as indicated by the character at the far left of the
line.
If the line was a rule, then the rule in its entirety will
be executed and control returned when the rule has returned
True or False to the caller.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 97 -
If the line was a screen, then the screen will execute and
return True.
7.3.2 Trace
Trace works in the same manner as step does above, with one
important difference: When you trace a rule, the debugger
will expand the definition and place the debugger's hilite
bar on the first non-blank line of the rule.
<F7> or <Space> is used to trace a line.
7.3.3 Watch
As explained above, a watch is an expression which is
`watched' by both you and the debugger. The expression can
be either string or numeric in type and is displayed in the
watch window, underneath the code window.
Watches are entered by pressing the <Ctrl-F7> key (or
<Ctrl-W>). A dialog box appears, prompting for an
expression to watch. The syntax will be checked and if
valid, will be entered into the watch list. The format of
the watch is simple: It consists of the expression entered,
followed by a colon and a space, followed by the value of
the expression you entered.
If the cursor is placed over some alphanumeric symbol in
your source, then that symbol will be entered in the dialog
box.
You can move the hilite bar to the watch window by pressing
<F6>, although this will not be allowed if you do not have
any watches in the watch window. When in the watch window,
you can add new ones by pressing <Ctrl-F7> or <Ctrl-W> as
before. Watches can be deleted by pressing <Del> or <Ctrl-
Y> or <Alt-D>.
Watches are more powerful (and dangerous) than they may at
first seem: Since you are allowed to enter any expression
as a watch, this may clearly include expressions like
DBnext(), CLS() (and so on), functions which alter the
status of RExL. Entering expressions such as these can have
various unwanted side-effects in debugging sessions. The
final point to note is that only those expressions which are
visible in the watch window are actually evaluated at every
cycle. You can have at most ten watches visible in the
watch window at any one time.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 98 -
7.3.4 Expression Evaluate
Expression evaluation is a `shortened' version of watching.
It allows you to enter an expression and RExL will return
the value of that expression either string or numeric.
Evaluation, however, has one major difference from watching
in that it allows you to enter a new value for an
expression, if that expression is a valid LValue.
[Figure not available in disk manual]
When the expression evaluation box initially appears, the
cursor will be in the Evaluate pane. If the cursor was
placed on a word within the window, then that word will be
pasted into the box. The expression which you want to be
evaluated is then entered.
The expression will then be syntax checked. If the syntax
is not correct, then the you will be returned to the
evaluate pane, otherwise the expression will be evaluated
and the result displayed in the Result pane. If RExL has
determined that the expression is a modifiable LValue, then
the result of the expression will also be displayed in the
New Value pane (whose border will change color), otherwise
that pane will remain empty and the border color of the new
value pane will remain unchanged.
If the expression is an LValue, then you can press <Tab> to
bring the cursor to the new value pane where you can enter a
new value for the expression. This new value can be any
valid expression which returns a result of the same type as
the initial expression. Again, this expression is syntax
checked and evaluated and the result is assigned to the
expression in the evaluate pane.
7.3.5 Animation
You can `animate' the execution of your application by
pressing <Alt-F4>. During animation, the debugger simulates
the pressing of the trace key at a definable interval.
When you press <Alt-F4>, a numeric dialog box appears,
prompting for an animate delay, measured in tenths of a
second. This value can range from 0, where there will be no
delay, to 600, where there will be a delay of one minute
between successive steps.
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 99 -
Press any key to stop the debugger animating the execution
of the application.
7.3.6 To Here
The debugger can execute an application to the current
cursor line, `to here', when you press <F4>. This feature
is sometimes known as temporary break-pointing, since the
effect is to place a breakpoint at the line and run the
application until either execution reaches a breakpoint, the
application terminates or you press <Alt-D>: In any case,
the breakpoint will be cleared.
7.4 Miscellaneous keystrokes
<Ctrl-Home> moves the hilite bar to the top of the screen,
while <Ctrl-End> moves it to the bottom of the screen or the
last line in the rule, whichever is nearer. <Ctrl-PgUp>
moves the hilite bar to the first line in the rule.
<Alt-X> will attempt to terminate the debugger and return
you to the editor, if the debugger was called from there.
<F4> sets up a temporary breakpoint on the currently hilited
line.
<Ctrl-F4> and <Ctrl-E> bring up the expression evaluation
box.
<Alt-F5> displays the start-up screen of the editor.
<Ctrl-F8> toggles a breakpoint at the current line. The
breakpoint will be signalled by a breakpoint character, ≡.
<Alt-F4> animates the debugger. You will be prompted for an
animation delay.
<Ctrl-F7> and <Ctrl-W> enter a new watch expression.
Entity lists are (as in the editor) as follows:
- RExL Version 2.10 Copyright 1992, The Software Loft -
- Main Manual. Page: 100 -
Rule list: on <Alt-Z> and <Shift-F2>
Screen list: on <Alt-S> and <Shift-F3>
Unused rule list: on <Alt-U> and <Shift-F4>
Unused screen list: on <Shift-F5>
Variable list: on <Alt-V> and <Shift-F6>
Function list: on <Ctrl-F> and <Shift-F7>
7.5 Command Line Parameters
The debugger accepts the use of a number of command line
parameters. These are letters (preceded by minus signs, -,
or forward slashes /) which alter some internal default of
the debugger. The current command line parameters are as
follows:
o -d: The `d' parameter will cause the debugger to
start up in debug mode, as if the user had pressed
<Alt-D> during loading of the application. This
switch is passed invisibly by the editor to the
debugger whenever the debugger is called via the
Debug application option in the Run menu in the
editor.
o -e: The `e' option will return control to the editor
when the debugger terminates. Whenever the editor
calls the debugger, this option is silently passed to
the debugger, so that the debugger will return to the
editor when it terminates.
o -k: This `k' option is used to tell the runtime
module not to watch out for the two keystrokes of
<Alt-D> and <Esc>, which are normally monitored.
(<Alt-D> will interrupt the run module and relinquish
control to the debugger while pressing <Esc> twice
will terminate the application.)
- RExL Version 2.10 Copyright 1992, The Software Loft -
