home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
ftp.barnyard.co.uk
/
2015.02.ftp.barnyard.co.uk.tar
/
ftp.barnyard.co.uk
/
cpm
/
walnut-creek-CDROM
/
CPM
/
PARASOL
/
PARASOL.ARK
/
PARASOL.DOC
< prev
next >
Wrap
Text File
|
1986-10-06
|
157KB
|
5,744 lines
@Ox1P
P A R A S O L
L A N G U A G E M A N U A L
Copyright (C) 1982 - 1986 by Para-Soft and Shay O. Walters
All rights Reserved
Placed in the Public Domain October, 1986 by Shay O. Walters
PARASOL is a language I developed myself for my own business
use. It has been tailored to provide the features I needed for
the applications I have developed over the last several years.
Due to the overwhelming popularity of the MS-DOS systems running
on the 8086, I feel that there is no longer any need to keep this
to myself. Therefore, I am placing this into the public domain
so that others may benefit from it.
There used to be a more complete manual, but a system crash
before it was backed up destroyed that effort. I have spent what
time I could to polish this older version of the documentation to
the point that it could be really useful. If you have specific
questions, I'll be glad to help if I can. I can be contacted on
Compuserve at [73247,1163] or on GENIE at [SHAY]. (You are more
likely to get a timely responce on GENIE...Compuserve is TOO
expensive). Also, I can be reached (as of 10/86) at 803-799-0180
by phone. I am uploading a library of source code to a video-
tape rental store management system which should give many
examples of business-type usage of the language. I may be
uploading other source at a later date.
All the usual disclaimers apply. I have used this for
several years, and for the last couple of years, I have found
only one or two bugs, and I use it quite a lot, and I compile
some VERY large programs (18,000 lines or so). BUT, I generally
stick with a known layout and follow that pattern in other
modules. Other programmers may possibly do things in a way which
doesn't work, so I can't guarantee that it will be bug-free for
you, but I would like to be informed of anything you feel IS a
bug.
Being public domain, this is absolutely free for anyone to
use for personal use. For any profit-making usage of this
compiler or its source-code, a $25.00 registration fee is
required. Make your check payable to:
Shay Walters / Para-Soft Phone: 803-799-0180
P.O. Box 6273 GE-MAIL: SHAY
Columbia, S.C. 29260 CompuServe: 73247,1163
Registered users will be informed of availability of other
software written in PARASOL and will generally get better
support for problems or questions.
The only additional restriction I will impose is that if
anyone uses this source code as a basis for writing a compiler
for another type of computer or operating system (say 8086 or
68000, for example) that I receive a copy of that source, too.
It will not be disclosed to others, if that is what you wish.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:1
The library of the source code for the compiler contains the
following files:
PASM.SUB A SUBMIT file to assemble the compiler
LBASE.ASM The global memory definitions.
LCOMMON.ASM The global subroutines.
LMISC.ASM Miscellaneous support functions.
LSTMT.ASM The statement-compilation routines.
LEOJ1.ASM The final forward-reference fixup.
LEOJ2.ASM The support library for the compiled code.
NOTE: I have used a modified version of LOAD which forces
all undeclared data areas to binary zeros. The standard CP/M
LOAD program will fill any undeclared data with garbage. I
suggest that you use DDT instead of LOAD to make the COM files
(fill memory with zeros before reading in the HEX file). It
"should" work with LOAD, but I can't guarantee it. I no longer
even have an unmodified copy of LOAD to try it with, it caused me
no end of problems, so I destroyed all copies of it many years
ago and use only the version I modified. Since that's part of
DRI's licensed programs, I can't release it with this package.
Also, the source, as supplied is not quite compatible with
DRI's ASM assembler. It will do better with MAC or RMAC. I have
a specially modified version of ASM, as well. If you want to try
using ASM, you will need to eliminate all multi-statement lines:
Anywhere an exclamation mark ("!") appears, (except inside string
literals), it should be replaced with CR/LF. DRI's ASM is doc-
umented as supporting the "!" as a multi-statement separator, but
it doesn't work following DB or DW pseudo-ops. Also, there are
several special characters such as underscore, AT-sign (@), and
period which may or may not be acceptable to the various DRI
assemblers as part of a variable name.
The source code is really being supplied for those of you who
are just curious about how the insides of a compiler (at least,
this compiler) work. If you have some special feature you would
like to have in the language, let me know about it, and maybe I
can install the feature for you.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:2
LANGUAGE DESCRIPTION LANGUAGE DESCRIPTION
PARASOL is not modeled after any one particular language,
but has features derived from COBOL, ALGOL, and PASCAL (and maybe
just a touch of BASIC). The individual statements are COBOL-like
while the structure of the language more closely follows ALGOL.
The language provides many high-level constructs, especially
in the area of file record I/O, yet it maintains the closeness to
the machine hardware which is so necessary in those difficult
situations.
PARASOL is a single-pass compiler. The object code (.COM
only, no REL capability) is produced as the source code is read,
and the source code is read only once. Forward references are
resolved in the object file at whatever points the compiler
detects there resolution in the source code. There is a final
fix-up pass folling the end of the source file which connects all
forward references to the built-in support routines.
PARASOL was designed to be a highly-efficient language for
the Z80 and 8080 microprocessors. Most PARASOL statements require
either several machine-level instructions, or a subroutine-call.
However, only the subroutines needed by a program are included
with the object-code for that program, there is not a large
subroutine library overhead as most high-level languages require.
A variety of compiler switches are supported which provide
features ranging from compiler-listing format and disposition to
run-time protection features.
The philosophy behind PARASOL is to provide the most
efficient object code possible, while retaining the readability
which makes program debugging and maintenance simpler. PARASOL
was designed to be straightforward, easy-to-read, and self-
documenting. It was not designed to provide the maximum
processing power with the least coding effort.
Although PARASOL is actually a "medium-to-high-level"
language (as opposed to a high-level language), it provides many
advanced constructs which are not found together in any other
single language. PARASOL is ideally suited for applications
ranging from process-control to business-accounting packages.
For process-control, and other "real-time" applications, PARASOL
offers the advantages of very fast execution time, and compact
object-code size which minimizes the amount of ROM which must be
included in a controller.
For business and accounting applications, PARASOL supports a
BCD numeric format which eliminates "round-off" or "truncation"
errors inherent in the binary floating-point formats used by many
other languages. Also, due to the compact object-code produced,
an application module may contain more application functions than
many other compilers will allow due to object-code size
limitations. This allows fewer overlays and/or program
"chain"'s; and even when one module must execute another module,
the program-loading time is reduced due to the smaller object-
code size.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:3
LANGUAGE DESCRIPTION LANGUAGE DESCRIPTION
PARASOL also provides the capability of compiling a program
which is larger than the available memory through the use of
overlays. See the SEGMENTED statement for further information
about this.
PARASOL is generally not suited to scientific or
mathematical applications, because there is no floating-point
capability, nor built-in provision for handling multi-dimensional
arrays.
The language syntax of PARASOL combines the readability of
COBOL with the structure of ALGOL, PASCAL, etc. All statements
start with what would be called a VERB in COBOL, but anywhere
that a single source-statement may appear, a list of statements
bounded by BEGIN and END may appear. Identifier-scope rules BEGIN END
parallel those of ALGOL, where an identifier is global throughout
the block in which it is declared, and undefined outside that
block.
Strictly speaking, there are no reserved-words in PARASOL,
only key-words. Key-words are 'reserved' in context only. Any
key-word may be used as a variable-name or statement-label if
desired, although this is discouraged, since, when a syntax-error
is encountered by the compiler, it begins compiling again with
the next key-word it finds following the error. For example:
ADD SUBTRACT TO MULTIPLY GIVING DIVIDE ___ ______ ADD TO GIVING ___ ______
will compile code which will add two values named "SUBTRACT" and
"MULTIPLY" and store the result in a variable named "DIVIDE". A
problem may arise, however, if the word GIVING is misspelled. GIVING
The compiler will print an error for the unrecognised word, then
will attempt to compile a DIVIDE statement. For further DIVIDE
information see the section on valid identifier-names which
follows.
There is also a compiler option (LIMIT WORD) which makes all
key-words into reserved-words. This prevents any accidental
usage of key-words as identifiers, and also speeds the
compilation process for very large programs.
ARRAYs are not currently implemented in PARASOL. This was a
design consideration, but since generalized array-processing
could not be made as efficient as user-programmed POINTER usage, POINTER
and since the inclusion of arrays in the language would have
complicated the construction of the compiler enormously, I
decided to go with POINTER capability only. I have found that POINTER
although there is a certain amount of discomfort getting
accustomed to working without arrays, that the usage of POINTERs POINTER
has all the capabilities of arrays and many fewer disadvantages
than one would expect. Also the usage of POINTERs is inherently POINTER
more flexible than arrays, since the memory past the end of a
program which would generally be wasted, can be used for storage
of data, also a subscript generally must be re-evaluated, and a
new index computed each time a subscript is used, but a POINTER POINTER
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:4
LANGUAGE DESCRIPTION LANGUAGE DESCRIPTION
can be set once and used many times with no additional overhead.
The usage of the INDEX statement greatly simplifies the
implementation of arrays.
There is no provision in the compiler for linking-in
relocatable assembler routines, but it is easy to perform this
function using DDT or a similar program. Also there is rarely
any need to resort to assembly-language coded routines, since all
assembler capabilities are provided in PARASOL, and since the
generated object code is nearly as efficient as assembly-language
coding.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:5
RUNNING PARASOL RUNNING PARASOL
PARASOL consists of two object modules:
1. PARASOL.COM
2. PARASOL2.OVL
Both of these files must be available on the disk for
correct operation. PARASOL2.OVL contains the code for the final
forward-reference cleanup after the source has been processed, as
well as the built-in procedure library. If PARASOL cannot locate
PARASOL2.OVL on the current drive/user, it will also attempt to
load it from drive A:, user 0.
Start PARASOL with the following command:
12B>PARASOL <source-name> [<option-list>] PARASOL [ ]
The source-name identifies the source file with a required
extension of .SRC. If source-name has an extension, it will be
used for the object file. The option-list is optional, but, if
present, must be enclosed in square brackets. For example:
12B>PARASOL BUILD.CPM [PRINT CON]
This will compile the source in BUILD.SRC and generate an
object file as BUILD.CPM. The compiler listing will be displayed
on the console.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:6
Compiler Switches Compiler Switches
There are several compile-time switches which may be used to
control various aspects of the compiler. These must appear in
one of two places; either on the CP/M command line following the
name of the program to compile, or as the first source line of
the program. There is one extension to this rule: the first
source line of the program may be a COPY statement which copies a COPY
one-line library containing the compiler switches.
Note that the compiler switches may appear BOTH on the CP/M
command line in addition to the first source line for the same
program. The switches on the command line are processed first,
and some switches may only appear on the command line, and are
invalid if specified in the source-code.
The format of the compiler switches is:
[ switch [ switch ] ... ] _ _ [ ] _ _
Note that the beginning and ending square brackets are
boldface and underlined, indicating that they are required. The
"switch" is any of the options from the table below.
ADDRESS This option tells the compiler to list the address ADDRESS
of the generated code on the compiler listing.
CSTACK SIZE n This option specifies the size of the compiler's CSTACK SIZE n
stack. The work SIZE is optional. "n" is the SIZE
number of bytes to use for the compiler's stack
space. The default value is 256 bytes. It is
possible that a very deeply nested program may
exceed the compiler stack/symbol-table space.
This option is provided to circumvent that
possibility.
EXECUTE This option specifies that the compiler should EXECUTE
execute this program immediately after compiling
it. The program will not be executed if there
were any compile errors.
INPUT x This option must appear on the CP/M command line. INPUT
This allows you to specify that the source file
resides on drive "x". When this option is not
used, the source file is assummed to reside on the
current default drive.
LIMIT STRING This option provides some small measure of LIMIT STRING
protection against STRING variables overrunning STRING
their allocated space. It causes all MOVEs of one MOVE
string to another to be a fixed number of bytes.
The number of bytes moved will be the smaller of
the declared lengths of the two strings.
LIMIT WORD This option causes all PARASOL key-words to be LIMIT WORD
treated as reserved-words. A by-product of this
is, since the compiler can skip the symbol-table
search for any key-words, the compile time is
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:7
Compiler Switches Compiler Switches
reduced somewhat.
LEVEL This option tells the compiler to print the LEVEL
syntactic-level counter beside each source line in
the compiler-listing file.
MAP This option specifies that the compiler should MAP
list a map of the addresses of the built-in
routines added to the end of the program. This
map will be included at the end of the compiler
listing file.
MATCH This option tells the compiler to match-up BEGIN- MATCH BEGIN
END pairs, as well as block markers of all other END
types ( RECORD ENDREC, etc. ). On the compiler RECORD ENDREC
listing, whenever the ending block marker is
found, the line-number of the corresponding
beginning marker is listed.
MPM This option specifies that the generated object- MPM
code MAY be run under MP/M, and that the PARASOL
MP/M-interface routine should be included in the
object-code. See the section about running under
MP/M later in this manual.
NOWARN This option inhibits compiler warning messages, NOWARN
inhibits SEGMENT summary messages, and shortens SEGMENT
the compiler summary at the end of the compile.
NSTAR This option specifies that the generated object- NSTAR
code will be run in multi-user mode under the
n/Star operating system of Molecular Computers.
This switch allows the compiler to handle
various run-time error conditions correctly. See
the section about running under n/Star later in
this manual.
If NSTAR is specified, MPM is assummed. NSTAR MPM
NUMBER This option tells the compiler to print line- NUMBER
numbers on the compiler listing.
PRINT [CON] [PRN] [DISK x .ext] [FULL] PRINT CON PRN DISK FULL
This option tells the compiler the disposition of
the compiler-listing. The word PRINT may be PRINT
followed by any of the above options in any order.
CON - print the listing to the console. CON
PRN - print the listing to the printer PRN
DISK x .ext - print the listing to a disk file on drive DISK
"x". The filename will be the same as the source
filename with an extension of ".PRN" unless ".ext"
is specified.
FULL - Print the full listing, even if PRINT OFF FULL PRINT OFF
appears within the source.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:8
Compiler Switches Compiler Switches
STACK NONE This option specifies that the object program STACK NONE
should NOT have a stack allocated. The program
will use the small stack provided by CP/M. It is
essential that this option be used only by
programs which have little or no stack usage,
since the stack space available by CP/M is quite
limited. The STACK SAVE option is generally STACK SAVE
preferred.
STACK SAVE This option must appear on the CP/M command-line. STACK SAVE
This option will allow a program to return to CP/M
without rebooting. The CP/M stack is saved, but
the PARASOL program has it's own stack. When the
program finishes running, the CP/M stack is
restored, and the program RETurns to CP/M. This
option must not be used in any program which uses
the HIMEM construct for data-storage, since that HIMEM
is likely to wipe-out the transient CP/M module
which is needed for this RETurn.
STACK num This option allocates a fixed stack of "num" STACK num
number of bytes immediately following the object
module.
*NOTE* Note that if neither STACK NONE or STACK num is *NOTE* STACK NONE STACK num
specified, that the object program's stack will
begin just below the BDOS, and grow downwards from
there. This provides the maximum allowable stack
space.
STANDALONE This option specifies that the generated object- STANDALONE
code will not be run under CP/M, or any "CP/M-
compatible" operating system. Any statements
which would cause a CP/M function call to be
generated will be flagged with an error message.
TAB n This option tells the compiler at what interval to TAB n
expand TAB characters. The default is every 4
spaces. Note that the CP/M default with ED, and
BDOS is every 8 spaces. "n" can be 2, 4, or 8
only.
TABLE This option specifies that all PARASOL generated TABLE
built-in routines should be accessed through a
table in the low memory of the program. If this
is NOT specified, all references to the built-in
subroutines will be direct. The disadvantage to
this is that the compiler must maintain a forward-
reference marker for each call to each built-in
subroutine, until it has been determined at which
address these routines will be loaded. This
greatly increases the symbol-table size, and
consequently slows down the compiler, since it's
symbol-table searches take longer. Also, a larger
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:9
Compiler Switches Compiler Switches
program may be compiled with TABLE specified than TABLE
without it, since a larger symbol-table may be
handled.
When TABLE is specified, the compiler inserts TABLE
a jump-table at a known address in low-memory, and
all references to built-in routines go through
this jump table. When the built-in routines are
actually loaded into the object code, this table
is the only thing which needs to be patched to
reflect those addresses.
Z80 This option specifies that the generated object- Z80
code will be run on a Z80 processor, and that the
compiler should take advantage of the special Z80
instruction set.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:10
EXPLANATION OF SYNTAX FORMAT USED IN THIS MANUAL EXPLANATION OF SYNTAX FORMAT USED IN THIS MANUAL
Key-words are printed BOLDFACE, and where they are required, BOLDFACE
they are also underlined. This means that a word which is __________ underlined __________
printed boldface but not underlined may be omitted from the
source statement with no effect on the operation of that
statement.
When a clause (group of words) is optional, and may be
omitted, the entire clause is enclosed in brackets.
For example:
ADD n1 TO n2 [ GIVING n3 ] ___ ______ ADD TO GIVING ___ ______
The word TO is optional and may be omitted with no effect on TO
the operation of the statement.
The GIVING clause is optional and may be omitted, but if ______ GIVING ______
used, the word GIVING is required. ______ GIVING ______
Generic items (items which describe the actual word to be
placed in the position shown) are printed lower-case.
When there is a choise of words, either key-words or generic
words, they are printed inside braces ('{}'), and any which are
not defaults are underlined. This means that if a choise is
shown, and one entry is NOT underlined, that it is assumed if it
is omitted. As a further explanation, refer to the following
example:
{ RIGHT } RIGHT
{ LEFT } ____ LEFT ____
In this example, there is a choise of LEFT or RIGHT. Since LEFT RIGHT
RIGHT is not underlined, it is optional, and will be assumed if RIGHT
neither is specified, but LEFT is required if it is the option LEFT
desired. Also LEFT and RIGHT can be seen to be key-words since LEFT RIGHT
they are printed boldface.
When a clause may be repeated, the clause is followed by an
elipsis ('...'). For example:
BYTE [id1] [VALUE value] ____ _____ BYTE VALUE ____ _____
[, [id2] [VALUE value] ]... _ _____ , VALUE _ _____
This indicates that the declaration of a second variable may
be done in the same statement by following the first declaration
with a comma and another declaration; likewise a third, fourth,
etc. may follow.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:11
IDENTIFIERS, NAMES, LABELS, AND KEY-WORDS IDENTIFIERS, NAMES, LABELS, AND KEY-WORDS
All identifers in PARASOL are composed of the following
character-set:
The upper-case alphabet A...Z
The lower-case alphabet a...z
The numbers 0...9
The special symbols: . (period)
_ (underscore)
` (grave accent)*
* note that the grave accent (`)
is NOT an apostrophe (')
All identifiers must begin with any character of the above
set EXCEPT for a number. Any character after the first may be a
number, if desired.
Case (whether a letter is capialized or not) is NOT
significant for key-words. The word MOVE may be placed in the
source as 'MOVE', 'move', or even as 'MoVe'.
NOTE that case IS significant for all labels and variable-
names, for example, the following items are all considered to be
separate identifiers by the compiler:
ABC abc Abc aBc a.bc ab.c ab_c A_BC
As an aid in choosing identifiers which do not conflict with any
key-words it is convenient to use the period, underscore, and/or
grave-accent in all identifiers. None of the key-words contain
any special characters or numbers, so any identifier containing
one of these characters is certain to be recognised as not being
a key-word by the compiler.
Identifiers may be any length up to 79 characters. 79
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:12
VARIABLE-TYPES SUPPORTED BY PARASOL VARIABLE-TYPES SUPPORTED BY PARASOL
PARASOL supports the following variable types:
BYTE BYTE
WORD WORD
STRING STRING
BCD BCD
FIELD FIELD
BIT BIT
RECORD RECORD
BYTE-POINTER BYTE-POINTER
WORD-POINTER WORD-POINTER
STRING-POINTER STRING-POINTER
BCD-POINTER BCD-POINTER
A BYTE variable is numeric and can have values from 0 to BYTE
255. Also, it may contain a single-character value.
A WORD variable is numeric and can have values from 0 to WORD
65535. Also, it may contain a single- or double-character value.
If it contains a single-character value, the hi-order byte is a
null character (hex code ^h00). If it contains a double-
character value, the second character is the high-order byte.
All of the POINTER variables are treated as WORD variables unless POINTER WORD
preceded by '@'. @
A STRING variable is alphanumeric, and may contain any STRING
character except for the null character, since this character is
used by the compiler to mark the end of the string. The length
of a string is limited only by the size allocated.
A BCD variable is numeric and may contain any decimal value BCD
from -99999999999999 to +99999999999999 (up to 14 digits). BCD BCD
variables are not compatible with binary variables (BYTE and BYTE
WORD), and the CONVERT statement must be used to convert one type WORD CONVERT
to another before they can be used together in an arithmetic
operation. Compilers which handle more than 14 digits are
available on request (up to 126 digits), but it should be noted
that ALL BCD variables are fixed-length, and each additional two BCD
digits require one additional byte of storage per variable.
A BIT variable is boolean (logical) and can have only the BIT
values TRUE (or 1) or FALSE (or 0). BIT's are allocated 8 bits TRUE FALSE BIT
per byte (if declared contiguously), and actually occupy only one
bit of storage.
A FIELD variable is a fixed-length string. It is NOT FIELD
interchangable with STRING variables in statements requiring STRING
STRING variables. It is primarily designed for use in disk STRING
records, and print-line formatting routines. It IS allowed to be
used in a MOVE statement to or from a STRING variable, and in MOVE STRING
conditional expressions with STRING variables. STRING
POINTER variables are all special cases of WORD variables. POINTER WORD
Any POINTER variable is treated exactly like a WORD variable when POINTER WORD
referenced alone, however, when the POINTER variable is preceded POINTER
by '@' ('AT' sign), the pointer is treated as what it points to. @
A BYTE POINTER is treated as a BYTE variable, a WORD POINTER is BYTE POINTER BYTE WORD POINTER
treated as a WORD variable, etc. In all cases, the values which WORD
are referenced by the POINTER are the values starting in memory POINTER
at the location whose address is in the POINTER variable. Note POINTER
that since a STRING POINTER does not have a length declared, it STRING POINTER
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:13
VARIABLE-TYPES SUPPORTED BY PARASOL VARIABLE-TYPES SUPPORTED BY PARASOL
is treated as a STRING with "indefinite" length unless there is STRING
some other limitation provided (as with the MOVE statement). MOVE
A RECORD variable is a collective reference to a structure RECORD
of variables, which may contain other RECORD variables. A RECORD RECORD RECORD
variable is referenced only in MOVE, ACCEPT, and FILE statements, MOVE ACCEPT FILE
and implicitly referenced in READ and WRITE statements. The READ WRITE
length of a RECORD is the sum of the lengths of all subordinate RECORD
fields.
Note that since FIELDs and RECORDs have a length associated FIELD RECORD
with them, there are no POINTERs for these types, since POINTERs POINTER POINTER
do not have an associated length.
PARASOL language manual Copyright (C) 1982, Para-Soft Pg:14
NUMERIC QUANTITIES IN PARASOL NUMERIC QUANTITIES IN PARASOL
The following varaible-types are considered to be binary-
numeric by the compiler:
BYTE, WORD, BYTE-POINTER, WORD-POINTER, BYTE, WORD, BYTE-POINTER, WORD-POINTER,
STRING-POINTER, BCD-POINTER, @BYTE-POINTER, STRING-POINTER, BCD-POINTER, @BYTE-POINTER,
@WORD-POINTER @WORD-POINTER
also the following are numeric, but are listed separately, since
they are incompatible with the binary-numeric types listed above:
BCD, @BCD-POINTER BCD, @BCD-POINTER
NUMERIC CONSTANTS NUMERIC CONSTANTS
Numeric constants may be expressed in a variety of ways:
(1): A character-string of length 1 or 2 (the first
character is the low-order byte).
(2): An identifier preceded by '#', example: #
#x is a constant whose value is the 16-bit word
which is the address of 'x'.
(3): An identifier preceded by '##', example ##
##x is a constant whose value is the 16-bit word which
is the length (in bytes) of the identifier 'x'.
'##' may precede any variable type, the resulting value
is determined according to the following table:
a statement-label 0
a BIT variable 0 BIT
a BYTE variable 1 BYTE
a WORD variable 2 WORD
a BCD variable 8 (assuming 14-digit BCD) BCD
a STRING variable the defined maximum length STRING
a FIELD variable the defined length FIELD
a RECORD variable the defined length RECORD
(4): An integer expression which is of the form:
[^<base>]<value>