!TITLE Variables, constants, expressions
!KEY
!<Types
!KEY
Each data item (i.e. each constant or variable) used by an IMP80 program
has a type associated with it which determines what sort of item it is
or can have as a value.

There are five categories of type:

!<Arithmetic types
!KEY

  These comprise integer and real types, as follows:

        %byte %integer
        %short %integer
        %half %integer
        %integer
        %long %integer
        %real
        %long %real
        %long %long %real


  Some implementations of IMP80 might not provide all of these types;
  see Appendix B for details.
!PAGE
  The modifiers %byte, %short, etc. relate to the size or precision of
  items of the appropriate type.  For byte-addressed machines, the
  ranges and (where appropriate) precisions associated with arithmetic
  types are as follows:

 ______________________________________________________________________
|                                                                      |
| type              normal         range of values                     |
|                   storage        (inclusive)                         |
|                   allocation                                         |
|______________________________________________________________________|
|%byte %integer      8 bits         0 to 255                           |
|(or just %byte)                                                       |
|%short %integer    16 bits        -32767 to 32767                     |
|(or just %short)                                                      |
|______________________________________________________________________|
!PAGE
 ______________________________________________________________________
| type              normal         range of values            precision|
|                   storage        (inclusive)                (decimal |
|                   allocation                                 digits) |
|______________________________________________________________________|
|%half %integer     16 bits         0 to 65535                         |
|(or just %half)                                                       |
|%integer           16 bits or     -32767 to 32767 or                  |
|                   32 bits        -2147483647 to 2147483647           |
|%long %integer     64 bits        -9223372036854775807 to             |
|                                   9223372036854775807                |
|    Integer arithmetic involving values outside the range             |
|    which a variable of type %integer can hold may be invalid.        |
|______________________________________________________________________|
|%real              32 bits   \                                  7     |
|                              |   -7.2x10@75 to -1.2x10@(-77),        |
|%long %real        64 bits    |-   0,                           16    |
|                              |    1.2x10@(-77) to 7.2x10@75          |
|%long %long %real 128 bits   /                                  36    |
|______________________________________________________________________| 
!>
!<String type
!KEY

  The type %string relates to sequences of characters.  An item of this
  type has a length associated with it, the actual or maximum number of
  characters which the item comprises or can have as a value.
!>
!<Record types
!KEY

  An item of type %record is a composite of several sub-items, each of
  which has an associated type.  When a variable of type %record is
  declared, its precise composition must be specified.
!>
!<Array types
!KEY

  An item of array type is a composite of (in general) several
  sub-items, each with the same associated type, which must be one of
  those listed above.  The name of the array type is obtained by
  appending the keyword %array to the name of the type in question.

  For example:

           type                 corresponding array type

           %byte %integer       %byte %integer %array
           %record (<format>)   %record (<format>) %array
           %string(<n>)         %string(<n>)%array
!>
!<Reference types
!KEY

  An item of this type is, or has as its value, a reference to a
  variable of a specified type.  For each of the foregoing types there
  is a corresponding reference type, the name of which is obtained by
  appending the keyword %name to the name of the type in question.

  For example:

           type                 corresponding reference type

           %byte %integer       %byte %integer %name
           %record (<format>)   %record (<format>) %name
           %string(<n>)         %string(<n>)%name
           %real %array         %real %array %name

  Variables of this type are known as reference variables or pointer
  variables.
!>
!>
!<Variables
!KEY
Variables are named store locations used to hold numeric or textual
information.  Each variable must be defined in a declaration statement
which specifies its type and an identifier to name it.  The amount of
storage allocated to a variable depends on its type.  All variables must
be declared at the head of the block in which they are to be used, or in
an outer block.

The initial value of a variable, i.e. the value assigned to it when it
is created, is implementation-dependent; in most cases it is undefined
(see Appendix B for details).  Any attempt to use a variable whose value
is undefined will cause an event to be signalled.

{IMP77: all variables can be assigned initial values.  The syntax is as
for %own variable initialisation, described below.  Stack variables are
re-initialised whenever they are re-created.}

Variables can be divided into four categories:
!PAGE
           Arithmetic
           String
           Record
           Reference

The following standard integer function is provided (a 'standard'
procedure is one which is predefined; see Section 7):

  %integer %function SIZE OF(%name A)

     The number of storage units occupied by the given variable is
     returned.  The unit is implementation-dependent but commonly is a
     byte.

!<Arithmetic variables
!KEY

  Arithmetic variables may be of two types: %integer and %real.  The
  first holds whole numbers and the second holds numbers with fractional
  parts.  For more efficient use of store, %short, %half, %byte and
  %long integer types may be provided, whilst greater precision will be
  obtained when %long %real and %long %long %real are available.
  However, the provision of different lengths is necessarily hardware
  dependent, though type %integer will always be available; it
  corresponds to the word length of the machine.  Furthermore, it is
  possible that on some restricted implementations for small machines,
  type %real will not be supported.  Where implementation is on a
  byte-addressed machine (e.g. IBM 370, ICL 2900 ranges) %short %integer
  and %half %integer would be 16 bits in length, %integer 16 or 32 bits,
  %long %integer 64 bits, and %real types would be 32 bits, 64 bits and
  128 bits in length.  On such machines, %real variables can only hold
  values to a precision of 7.2 significant decimal digits whereas %long
  %real variables are precise to 16.8 decimal digits and %long %long
  %real variables (if available) to 36 decimal digits.  Further details
  of the representation of variables can be found in the relevant
  hardware manuals.
!PAGE
  The following example illustrates the declaration of various
  arithmetic variables.

  Example:
           %begin
              %integer I, J
              %real P, Q

              %begin
                 %byte %integer Z
                  :
                  :
                 P = I+J+Q
                 Z = 0
                  :
                  :
              %end
               :
               :
           %end %of %program
!PAGE
  Arithmetic variables can be grouped into arrays.  The array bounds
  separated by the symbol ':' are given in brackets after the array
  identifier when the array is declared.

  Example:
           %integer %array IN(1:10), OUT(1:20)


  Multi-dimensional arrays can be used.  The maximum number of
  dimensions is implementation dependent.

  Example:
           %integer %array BITLIST(-4:4, 1:2, 10:100, 1:2)


  When an individual array element is accessed, the array identifier is
  followed by an ordered list of integer expressions (one for each
  dimension) enclosed in brackets.  These integer expressions are called
  subscripts.
!PAGE
  Examples:
           BITLIST(3, 1, 54, J)

           BITLIST(I+K, I, 10, 1)

  Each of these integer expressions must evaluate to an integer which
  lies within the range described by the bounds for the relevant
  dimension.  A run time fault may occur if the array bounds are
  exceeded.

  An array can be declared with integer variables instead of constants
  for the array bounds.  Obviously, the variables used in such a
  declaration must be declared and given a value before the array
  declaration occurs.
!PAGE
  Examples:
           %begin
              %integer TOP

              READ(TOP); ! TOP is given a value from the input data.

              %begin
                 %integer %array TABLE(1:TOP)
                  :
                  :
              %end

               :
           %end
!>
!<String variables
!KEY
  A string variable is one which holds textual information.  The maximum
  length of a string is implementation dependent but is not normally
  less than 255 characters.  When the string variable is declared, the
  maximum number of characters which the string may hold is specified,
  in parentheses, after the keyword %string.

  Example:
           %string(24) S
            :
           S = "Results of last test"


  As the string of characters may vary in length within the given
  location while the program executes, an indication of the current
  length is stored along with the current contents.
!PAGE
  In all implementations on byte-oriented machines to date, the current
  length is held in an extra byte at the front of the string location.
  Thus the string S declared in the above example would be allocated 25
  bytes of storage.

  As can be seen from the above example, the character " (double quote)
  is used to delimit textual information to be stored in a string
  location.  Where one double quote character is part of the text, two
  consecutive double quote characters should occur in the text, to
  distinguish it from the terminating delimiter.

  Example:
           MESSAGE = "Peter says ""No"" "

  Multi-dimensional string arrays can be used.  Note that the maximum
  number of dimensions is implementation dependent.  Each element of a
  string array must have the same maximum length, which is specified
  when the array is declared.
!PAGE
  Example:
           %string(63)%array FIELDS (1:5)

     FIELDS consists of five strings, each of maximum length 63
  characters.

  The occurrence in an IMP program of a semi-colon or newline character
  normally terminates a statement.  However, both are permitted in
  string constants.

  Example:
           S = "A; B; C"
           SNL = "
           "

  A string may be regarded as having a value based on the ISO code
  values of the characters of the string.  Thus the relational operators
  >, <, =, #, <=, >= may be used to compare strings.  In particular,
  strings composed entirely of alphabetic characters can be regarded as
  having a dictionary ordering for the purposes of comparison.

  Example:
           "AB" < "C"        is TRUE
           "AB" < "ABC"      is TRUE
           "IMP" < "FORTRAN" is FALSE
!>
!<Record variables
!KEY

  A record is a variable comprising a collection of entities which may
  be of different types.  It has an identifier which refers to the whole
  collection and each entity has an identifier; an entity (or
  "sub-field") can be referenced by using the record identifier together
  with the required sub-field identifier.

  The collection of sub-fields which makes up the record is described in
  a record format statement, which specifies the identifier and type of
  each sub-field.

  Arrays with constant bounds may be used as sub-fields.

  Example:
           %constant %integer FROM=3, TO=5
           %record %format F(%byte %integer A, %string(8) S,
                      %integer %array M, F(FROM:TO, 1:400), %real Y)
           %record (F) R
            :
!PAGE
  Record format statements are placed with other declarations at the
  head of a block or procedure.  They do not cause allocation of
  storage.

  Note that the sub-field identifiers need not be distinct from other
  identifiers in use in the program, as they are always associated with
  a specific record identifier.

  A record format may include alternatives.

  Example:
           %record %format AS(%byte %integer %array CHAR(0:12) %or %c
                              %string(12) TEXT)

     The space allocated to a record of this format can be regarded as
     holding a byte integer array of 13 elements or a string of maximum
     length 12 characters.
!PAGE
  Alternatives provide a means of imposing different interpretations on
  all or part of a record.  Where only part of a record is to have an
  alternative format, brackets must be used within the record format
  statement to enclose the alternatives.

  Example:
           %record %format AT(%real X, 
                              (%byte %integer A, B, C  %or  %real R %c
                               %or  %integer E),
                              %string(10) F)

  Every sub-field in the record format must be distinct.  Each
  alternative will start at the same address within the record and will
  be padded out to the size of the largest.  (In the example above
  padding will be added, as the three alternatives are not all of the
  same size).  The amount of padding required depends on the amount of
  store allocated to each sub-field, which is implementation-dependent
  (as is the relation between elements in different alternatives).
!PAGE
  A record format may contain several sets of alternatives, and
  alternatives may be nested to any depth.  Note, however, that
  redundant brackets within a record format statement are not allowed.

  Records are declared at the head of a block or procedure.  Space is
  allocated according to the associated record format statement whose
  identifier occurs in parentheses in the record declaration.  The
  amount of space occupied by a record of given format is the total
  number of bytes occupied by all the sub-fields plus the minimum number
  of 'padding' bytes required to achieve alignment of sub-fields
  appropriate to their types.  This alignment is
  implementation-dependent.

  Example:
           %record %format F(%integer A, %string(8) S)
           %record (F) R
           %record (F) PP, QQ, RR
!PAGE
  Note that, as in the example above, more than one record may be
  declared having the same record format.

  {EMAS IMP80: in a record declaration it is permissible to give the
  actual record format instead of giving the name of a record format.

  Example:
           %record (%integer I, J, %string(7) S) A, B, C

  It is also permissible to give the name of a record already declared
  in place of a record format name.  The format of the specified record
  is then taken as the required format for the record being declared.

  Example:
           %record (A) D
           ! A is the record declared in the previous example.
!PAGE
  Each sub-field of a record can be referenced as a location of the
  appropriate variable type by subscripting the record identifier with
  the sub-field identifier, the two being separated by the underline
  character '_'.

  Examples:
           %record %format F(%integer A, %string(8) S)
           %record (F) R
            :
           %if R_S="INC" %then R_A = R_A+1
            :


           %record %format PE(%integer I, %real %array X(0:10))
           %record (PE) P
           %integer J
            :
           P_X(J+1) = P_X(J)*2
            :
            :
!PAGE
  Arrays of records are analogous to the arithmetic and string types of
  arrays already described.  Each element of a record array is a record
  of format specified in the record array declaration.

  Example:
           %record %format F(%integer A, %real %array X(1:5))
           %record (F) %array RA(1:100)

     The fifth element of sub-field X in the 76th record array element
     may be referenced as follows:

           RA(76)_X(5)

  As with other types of array, several record arrays having the same
  bounds and format may be defined in a single declaration.

  Example:
           %record (F) %array RR1, RR2(1:100)
!PAGE
  A sub-field may be of type %record.  In this case its format must have
  been already declared.  In particular, its format may not be the
  record format being described (c.f. record name sub-fields).

  Example:
           %record %format P(%integer %array X(0:4), %integer I)
           %record %format F1(%integer A, B, %record (P) D)
           %record %format F2(%record (P) J, K)

           %record (F1) ENT
           %record (F2) JAK

  An arbitrary depth of subscription can thus obtain.  Using the above
  declarations, the following are valid references to record elements:

           ENT_D_X(1)
           JAK_J_I
!PAGE
  A sub-field of type %record is word-aligned in most implementations,
  irrespective of the format of the sub-field.

  Whilst sub-fields of records may be used exactly like IMP80 entities
  of corresponding type, it is also possible to assign a whole record
  from one location to another.  Two assignment operators are permitted:
  '=' and '<-'.  Both operators require that operands on each side of
  the assignment refer to %record locations, except in the case where
  zero occurs on the right-hand side of the '=' operator: this results
  in the space allocated to the record referenced by the left-hand
  operand being set to binary zeros.

  When the '=' operator is used, the record formats associated with the
  left-hand and right-hand operands must be the same.

  {EMAS IMP80: the formats need not be the same, but they must have the
  same length.}

  The '<-' assignment operator transfers as many bytes from the record
  referenced by the right-hand operand as will fit into the record
  referenced by the left-hand operand.  The '<-' operator takes no
  account of record formats.

  Example:
           %record %format F(%integer X, Y, Z, A)
           %record %format Q(%byte %integer %array B(0:15))
           %record (F) J
           %record (Q) %array K(0:100)

            :
            :
           J = K(1)
           K(1) = 0; ! K(1)_B(0), K(1)_B(1), ..., K(1)_B(15)
                     ! all set to binary zeros.

  {IMP77: A %record %format %spec statement is provided to enable a
  record format to be referred to before it has been declared.  A
  statement of the form

           %record %format %spec <name>
!PAGE
  specifies a record format identifier.  Until the format is declared
  fully in a %record %format statement the identifier may only be used
  in the declaration of record reference variables (described below).

  Example:
           %record %format %spec Y
           %record %format X(%record (Y) %name P, %real VALUE)
           %record %format Y(%record (X) %name Q, %integer VALUE)

     Record formats of this sort are useful in list processing when the
     items in the list are records of alternating format X, then Y, then
     X, etc.}
!>
!<Reference variables
!KEY
  A reference variable (or "pointer variable") is one which has as its
  value, not a constant, but a reference to a variable of a specified
  type.  Reference variables are declared in the same way as the
  variables to which they can refer, but with the suffix %name added.

  Example:
           %integer A
           %integer %name AREF

  When a reference variable is declared, space is allocated for a
  reference to a variable of the corresponding type and precision.  The
  operator "==" is used to establish the reference.  Once a reference is
  established, all references to the reference variable will be
  redirected to the variable which it references.  Note that the
  reference can be established before the referenced variable has been
  assigned a value.  Reference variables are often used in conjunction
  with store mapping facilities (see Section 6).
!PAGE
  Example:
           %integer %name N
           %integer B

           N == B; ! Reference established
            :
            :
           N = 10; ! Assigns 10 to B
            :

  In exactly the same way, a reference to an array can be set up in an
  %array %name variable of the appropriate type.
!PAGE
  Example:
           %real %array %name P
           %real %array Q(0:27)
           %real %name Z

            P == Q; ! Reference established.
             :
             :
            P(25) = 10.3; ! This puts 10.3 into Q(25).
            Z == P(27)
             :
             :
            Z = 0; ! This sets the 27th element of Q to zero.
             :

  The examples above have been of reference variables of arithmetic
  types.  However, string and record reference variables may also be
  used.
!PAGE
  Example:
           %string(20)%name SREF
           %string(20) S
            :
           SREF == S
            :

  A maximum size must be specified for a string reference variable, as
  for a string variable.  A string reference variable can only refer to
  a string variable whose maximum size is equal to that of its own.
  However, where a string reference variable is required to refer to
  several strings of different maximum sizes, the form

           %string(*)%name <var>

  may be used.

  {EMAS IMP80: the string variable maximum size may be omitted.  Whether
  it is or not, the EMAS IMP80 compiler treats the size specification as
  '(*)'.}
!PAGE
  In the case of record reference variables, the format of the record to
  be referenced must be specified in the reference variable declaration.

  Example:
           %record %format RECFORMR(.....)
           %record (RECFORMR) REPORT
           %record (RECFORMR) %name REP2

  A reference variable of type %record %name is assigned to by using the
  '==' operator (as before), where the right-hand operand is a reference
  to a record location with the same format as that specified for the
  reference variable.
!PAGE
  Example:
           %record %format F(.....)
           %record (F) %name F1
           %record (F) Q, R
           %record (F) %array A(1:10)
           %record (F) %array %name Z, W
           F1 == Q;     ! Makes F1 a synonym for record Q
           F1 == A(10); ! Makes F1 a synonym for 10th element of A
           Z == A;      ! Makes Z a synonym for A

  {EMAS IMP80: the record location referenced by the right-hand operand
  does not have to have the same format as the record reference
  variable.}

  {IMP77: when a record reference variable is declared, the format can
  be specified as (*), meaning that the variable can refer to a record
  of any format.  The reference variable can have no associated
  sub-fields; it is only of use when it is passed as a parameter to a
  procedure, to be pointed at subsequently within the procedure by a
  reference variable with a specific format.}
!PAGE
  Note that records may contain sub-fields of type %record %name.  In
  this case the format of the record name sub-field may be the record
  format being described (c.f. sub-fields of type %record).

  The following example illustrates how the recursive nature of the
  format and sub-field format definitions facilitates the creation of a
  list structure:

  Example:
           %record %format F(%integer DATA, %record (F) %name LINK)
           %record (F) %array P(1:1000)

     The structure may be initialised as follows so that the 'link'
     field of each element of the record array P 'points' to the
     subsequent element:

           %record %format F(%integer DATA, %record (F) %name LINK)
           %record (F) %array P(1:1000)
           %record (F) END
           %integer J
!PAGE
           P(J)_LINK == P(J+1) %for J=1,1,999
           P(1000)_LINK == END
            :
            :
           %if P(J)_LINK == END %then ....

     Note how the link field of the last record in the chain is set to
     point to the record END.
!>
!<%own, %constant and %external
!KEY
  Additional properties can be given to variables by means of the
  prefixes %own, %constant (which can be abbreviated to %const) or
  %external added to the type in their declarations.

  An %own variable is allocated storage in such a way that it preserves
  its value between successive entries to the block or procedure in
  which it is declared.  It can be initialised in its declaration
  statement.  An %own variable can be used in any circumstances in which
  a normal variable of the corresponding type can be used.

  A %constant variable is declared in a similar manner to an %own
  variable, but it cannot be changed from its initial value.  Constant
  variables are also known as "named constants", which better describes
  them, in that they have all the attributes of constants.  Note that
  they do not have addresses (see ADDR, described in Section 6).

  Wherever a constant is permitted in an IMP80 program, a "constant
  expression" can be used instead.  A constant expression is one which
  can be evaluated at compile-time, i.e. its operands are constants or
  named constants.
!PAGE
  Example:
           %string (73) DELIVERY

     can be replaced by

           %constant %integer MAXNAME=20, MAXADDRESS=52
           %string (MAXNAME+1{for the newline}+MAXADDRESS) DELIVERY

  The constant integer NL is predefined: it contains the code value for
  the newline character.

  The constant long real PI is predefined.  It is the value of pi to the
  long real precision of the implementation; where 64 bits are used to
  hold a long real, this is 3.141592653589793.

  An %external variable is a special form of %own variable which is used
  to provide communication between sections of program compiled
  separately (see "External linkage", 3.3).  An %external variable can
  be used in any circumstances in which a normal variable of the
  corresponding type can be used.
!PAGE
  %own, %constant and %external arrays are normally one-dimensional, but
  need not be.

  Examples:
           %constant %byte %integer NUL=0, CR=13, DEL=127, FF=12

           %own %long %real  RMIN = -3.5@-4,
                             RMAX = 17.23614@10

  The initial values to be assigned to %own, %constant and %external
  variables are specified when the variables are declared.  A variable
  can be followed by =<cexpr> , where <cexpr> is a constant or constant
  expression of the appropriate type.  (A constant expression is one
  which can be evaluated at compile-time, i.e. made up of constants or
  variables of type %constant.)  The variable is initialised to the
  value of <cexpr>.

  If no initial value is specified, the value assigned by default is
  implementation-dependent.
!PAGE
  {EMAS IMP80: %own, %constant and %external variables which are not
  assigned initial values are set to binary zeros.}

  {IMP77: %own, %constant and %external variables which are not assigned
  initial values are undefined, and any attempt to use them before they
  are assigned will cause an event ("unassigned variable") to be
  signalled.}

  {IMP77: the '<-' assignment operator can be used in %own, %constant
  and %external variable initialisation.}

  Any identifier being declared as %external may be given an "alias".
  The details of this facility are described in Section 3.3.

  An %own, %constant or %external array is initialised by appending a
  list of values to its declaration.  Only one array may be declared per
  statement.  Each element of the array must have a corresponding value
  with which it is to be initialised.  In order to simplify this, each
  value may be followed by a repetition count in parentheses, and an
  asterisk, (*), may be used to represent the number of remaining
  elements of the array.  If the array is multi-dimensional, the order
  in which the array elements are assigned the initial values is
  implementation-dependent.

  {EMAS IMP80 and IMP77: in a two-dimensional array whose first element
  was (1,1), the order would be (1,1), (2,1), (3,1), i.e. first
  subscript changing fastest.}

  Examples:
           %external %integer %array VALUES(-3:7) = %c
                          17,  4, 23, -2,  3(4),  7,  1(2)

           %constant %integer RED=1, ORANGE=2, YELLOW=4, GREEN=8,
                            BLUE=16, INDIGO=32, VIOLET=64, WHITE=127

           %own %byte %integer %array COLOUR(1:22) = %c
                       RED, VIOLET(3), BLUE+GREEN, VIOLET,
                       INDIGO+ORANGE+BLUE, YELLOW(2), WHITE(*)
!PAGE
  The {...} form of comment is useful for commenting array
  initialisation.

  Example:
           %own %integer %array OPCODE(0:20) =  %c      {opcode values}
                    16_5800,    16_4800,    16_5000,    16_4000,
           {           L           LH          ST          STH
                    16_5A00,    16_5B00,    16_5C00,    16_5D00,
           {           A           S           M           D
                    16_1A00,    16_1B00,    16_1C00,    16_1D00,
           {           AR          SR          MR          DR
                    -1(*)                               {all the rest}

  %own, %constant and %external strings can be likewise initialised,
  with string constants or constant expressions at the time of their
  declaration.

  Example:
           %own %string(19) FILENAME = "ERCC00.TEST"
           %constant %string(6)%array F(0:4) = "Peter", "Mac", ""(3)
!PAGE
  Records may also be declared as %own, %constant or %external, but
  these may not be initialised at the time of declaration.

  {EMAS IMP80: the space allocated to such records is filled with binary
  zeros.}

  {IMP77: the values of the sub-fields of such records are undefined.}

  Variables of type %constant %record cannot be assigned at all, unless
  some implementation-dependent method is provided; see Appendix B.

  Reference variables may also be declared as %own, %external or
  %constant.  If initialisation is permitted in the implementation, then
  the initialisation establishes the initial reference in an
  implementation-dependent manner.  This facility is only useful for
  unusual system programming features.
!PAGE
  {Example:

     EMAS IMP80: the following declaration is valid:

           %constant %integer %name K INST PER SECOND = X'80C000C0'

     IMP77: the following declaration is valid:

           %constant %integer %name K INST PER SECOND == X'80C000C0'

     The value to which the integer name variable is being initialised
     specifies a particular storage location, and is therefore system
     dependent.}

  The initialisation of constant array name variables, if available, is
  described in Appendix B.
!>
!>
!<Constants
!KEY
Constant values can be assigned to variables.  In general, the type of
the constant must be the same as the type of the variable, although an
automatic type conversion is carried out on a constant of integer type
before assignment to a variable of real type.
!<Decimal constants
!KEY

  Decimal Constants are written in a straightforward notation:

        2.538    1     .25

  The exponent, where present, consists of the symbol @ followed by an
  optional sign and decimal digits:

        -17.28@-1   1@7

  The type of a decimal constant depends on its value.  It is of integer
  type if it has no fractional part, i.e. no decimal point in its
  specification and the exponent (if present) is non-negative; otherwise
  it is of real type.  The particular real or integer type depends upon
  the magnitude or precision of the constant.
!>
!<Base constants
!KEY
  A base constant may be constructed by using the prefix
  <decimal constant>_  to specify the base (up to a maximum of 36) of
  the subsequent constant.  The letters A, B, ..., Y, Z are used to
  represent the digits 10, 11, ..., 34, 35.

  Example:
           2_1010      ten in Binary
           8_12        ten in Octal
           9_11        ten in base nine
           16_A        ten in Hexadecimal

  An alternative form is provided for constants to bases 2, 8 and 16.
  The constant is written with the digits enclosed in single quotes and
  preceded by a code letter for the base, the codes being B for base 2
  (Binary), K for base 8 (Octal) and X for base 16 (Hexadecimal).

  Example:
           B'1010'     ten in Binary
           K'12'       ten in Octal
           X'A'        ten in Hexadecimal

  Either upper or lower case letters may be used in this form of
  constant, but spaces may not occur.

  When a program is to be used on other machines, care should be taken
  in the use of constants as the values of the constants may vary,
  particularly in a transfer from a machine using ones-complement
  arithmetic to one using twos-complement arithmetic, and vice-versa.

  Base constants are of type %integer.

  {IMP77: the base can have any positive integer value.  However, if it
  is greater than 36 then not all the digits will be representable by
  0...9 and A...Z.

  Example:
           I = 256_1234

  where I is a four-byte integer, assigns the values 1, 2, 3 and 4
  respectively to the four bytes of I.}
!PAGE
  {IMP77: a base constant can include a decimal part, in which case it
  is of type %real.

  Examples:
           3_0.1 {= 1/3}

           16_3.102A9 }
!>
!<Character constants
!KEY
  The ASCII code value of any character may be obtained as an integer
  value by enclosing the character in single quotes.  When the required
  character is a single quote, it must be represented by two consecutive
  single quotes.

  Examples:
           'A', 'a', '+', 'o', '"', '''', ' ', '
           '

  Note the last three examples which represent the code values for
  single quote, space and newline, respectively.  The predefined named
  constant NL may be used in place of the rather cumbersome form of a
  newline character enclosed in quotes.

  The code values for several characters may be packed together to form
  a single integer constant by enclosing the characters in single quotes
  and giving the prefix M.

  Examples:
           M'over', M'MAX', M'1+2', M'*@@#'
!PAGE
  The value of the constant is calculated by evaluating the expression:

           (..(c1<<b + c2)<<b + c3)<<b + ...

  where c1, c2... are the characters in the order specified, and b is an
  implementation-defined constant (commonly 8).  The number of
  characters which can be packed into an integer in this way is
  (no. of bits in an %integer)//b .

  Character constants are of type %integer.
!>
!<String constants
!KEY
  A %string constant is a sequence of characters enclosed in double
  quote characters, a double quote being represented inside a string
  constant by two consecutive double quotes.  The maximum number of
  characters allowed in the string is implementation dependent, but is
  not usually less than 255.

  Examples:
           "starting time"
           "x-y*4+2"
           "red"
           "HOOD"

  The null string, a string of no characters, is permitted and is
  represented by two consecutive double quote characters ("").

  A string constant of <n> characters is of type %string(<n>).
!>
!<Named constants
!KEY
  These are treated in this manual as variables of type %constant (see
  Section 2.2.5).
!>
!>
!<Arithmetic operators & expressions
!KEY
!<Arithmetic operators
!KEY
  There are two assignment operators for use with arithmetic
  expressions:
              =  equals
              <- jam transfer

  Where the = operator is used, the expression on the right-hand side is
  evaluated and the value obtained is assigned to the destination
  indicated by the left-hand side, provided that the lengths and types
  are compatible.  A fault occurs if an attempt is made to assign too
  large a value to a variable using this operator.

  Where the <- is used, only as many bits as will fit the location
  designated by the left hand side are assigned, starting with the least
  significant bits.

  In general the arithmetic assignment instruction assigns the result of
  evaluating an arithmetic expression to a variable.  Only the result of
  an integer expression may be assigned to an integer variable, but the
  result of an integer or real expression may be assigned to a real
  variable.
!PAGE
  The following operators may be applied to real and integer variables
  in arithmetic expressions:


        _______________________________________
       |                                       |
       |      +        addition                |
       |      -        subtraction             |
       |      *        multiplication          |
       |      /        real division           |
       |     //        integer division        |
       |      \        real exponentiation     |
       |               (e.g. Y\3 = Y cubed)    |
       |     \\        integer exponentiation  |
       |_______________________________________|
!PAGE

  The established order of precedence for the arithmetic operators is
  given in the following table, starting with the highest.  Operators on
  the same horizontal line of the table have equal precedence.

           _________________________ 
          |                         |
          |   \       \\            |
          |   *        /       //   |
          |   *        -            |
          |_________________________|


  Parentheses may be used to override the natural order of evaluation of
  an expression or to remove ambiguity.  Where operators are of equal
  precedence, left-hand precedence pertains as in normal mathematical
  usage.
!PAGE
  Examples:
           A-B+C    is equivalent to  (A-B)+C
           A-(B+C)                    (A)-(B+C)
           A/B*C                      (A/B)*C
           A/(B*C)                    (A)/(B*C)
           A**B*C                     (A**B)*C
           A**(B*C)                   (A)**(B*C)

  The one exception to the left-hand precedence rule is that consecutive
  exponentiations are evaluated from right to left; thus A**B**C is
  evaluated as A**(B**C), not as (A**B)**C.
!>
!<Arithmetic expressions
!KEY
  An arithmetic expression is a sequence of operators and integer or
  real operands obeying the elementary rules of algebra.  Expressions
  may be real or integer according to context.  Apart from the rules for
  operator precedence given above, no assumptions may be made about the
  order of evaluation of expressions.

!<Integer expressions
!KEY

     An expression is evaluated as integer if it is being assigned to an
     integer variable, or passed as an integer value parameter, or
     occurs in a position where an integer expression is mandatory.

     All the operands and operators in an integer expression must yield
     integer values.  The operators available for use in integer
     expressions are:

        +  addition

        -  subtraction

        *  multiplication

       //  integer division.  This operator always yields an integer
           result.  The result consists of a quotient whose sign is
           determined algebraically and a remainder which is ignored.
           Note that dividend and divisor must both be integer
           expressions.
!PAGE
       \\  integer exponentiation.  This operator only operates on
           integer variables and always yields an integer result which
           is obtained by repeated multiplication.  The exponent must be
           an integer expression with a value in the range 0 < exp < 63.

     The precision used in evaluating integer expressions depends on the
     operands.  Variables of type %byte %integer, %short %integer and
     %half %integer are expanded to normal integer precision before the
     operation is carried out.  An operation between an integer variable
     and a long integer variable will be carried out by long integer
     arithmetic.  However, **** is anomalous in that long integer ****
     integer is carried out by repeated long integer multiplication but
     integer **** long integer is carried out by repeated integer
     multiplication.

     The following standard integer functions are provided (a 'standard'
     procedure is one which is predefined; see Section 7):
!PAGE
        %integer %function IMOD(%integer I)

           This function returns the modulus (absolute value) of the
           parameter.

           {IMP77: the modulus of an integer expression can also be
           obtained by enclosing the expression between vertical bars;
           e.g. |I-J| .}


        %integer %function INT PT(%long %real L)

           This function returns the integer part of L, any truncation
           being towards zero.  Hence INT PT(-1.5)=-1.

           An event is signalled if the result cannot be held in an
           integer variable.
!PAGE
        %integer %function INT(%long %real L)

           This function returns the nearest integer to the parameter,
           truncation being towards zero.  It is thus equivalent to:

                 %integer %function INT(%long %real L)
                    %result = INT PT(L+0.5)
                 %end
!>
!<Real expressions
!KEY
     All the operands and operators in a real expression must yield real
     or integer values, and assignment can only be made to a real
     variable.  Integer values will automatically be converted into
     their real equivalents before being used.

     The operators available for use in real expressions are:

        +  addition

        -  subtraction

        *  multiplication

        /  division

       **  real exponentiation.  This always yields a real result.
           Where the exponent is an integer expression, the operation is
           carried out by repeated multiplication.  A negative exponent,
           e.g. X**(-4), is evaluated as 1/X**4.
!PAGE
           {EMAS IMP80: where the exponent is a real expression, the
           result is obtained by using the standard functions LOG and
           EXP, and events relating to these functions may be
           signalled.}


     A real expression is evaluated to single precision until a long
     real variable is encountered.  Thereafter the expression is
     evaluated to double precision.  Double precision work is time and
     space consuming and should only be used when strictly necessary to
     preserve accuracy.  However, it is often required with
     floating-point arithmetic where loss of accuracy may occur in
     addition and subtraction due to cancellation of significant
     figures.

     The following standard real functions are provided (a 'standard'
     procedure is one which is predefined; see Section 7):
!PAGE
        %long %real %function FRAC PT(%long %real L)

           The fractional part of the parameter L is returned as the
           result.  Note that the fractional part is always treated as
           being greater than or equal to zero; e.g. FRAC PT(-4.6) is
           0.4 .

        %long %real %function MOD(%long %real I)

           This function returns the modulus (absolute value) of the
           parameter.

           {IMP77: the modulus of an real expression can also be
           obtained by enclosing the expression between vertical bars;
           e.g. |X-Y| .}

        %long %real %function FLOAT(%integer N)

           The floating-point equivalent of the integer parameter is
           calculated and returned as the result.
!>
!>
!>
!<Logical ops and expressions
!KEY
  Logical operations are performed on bit patterns stored in integer
  variables, which may be of any of the permitted lengths.  Before the
  operation is carried out, byte, short, and half integer variables are
  made up to full integer length in one of two ways, according to the
  length of the initial variable: a) byte and half integers are made up
  by filling the left hand bits with zeros; b) short integers are made
  up by sign extension, i.e. the leftmost bit of the variable - the sign
  bit - is propagated leftwards until the necessary number of bits have
  been obtained.  Where necessary, integers are made up to long integer
  precision by sign extension.

  There are two assignment operators available for logical expressions.

     =  equals treats the result of the logical operation as a signed
        integer and attempts to perform an arithmetic assignment to the
        designated variable.  Hence it is not always possible to put the
        result back into a variable of the same precision as that in
        which an operand of the logical expression was originally held.
!PAGE
    <-  jam transfer copies the bit pattern of the expression indicated
        by the right hand side into the variable indicated by the left
        hand side, starting with the least significant bits and stopping
        when the variable has been filled.

  The choice of assignment operator depends on the context of the
  program.

  The following is a list of the logical operators available, excluding
  the assignment operators discussed above.
!PAGE
           _________________________ 
          |                         |
          |   <<       left shift   |
          |                         |
          |   >>       right shift  |
          |                         |
          |   &        and          |
          |                         |
          |   !        or           |
          |                         |
          |   !!       exclusive or |
          |                         |
          |   \ (or ~) not          |
          |_________________________|


  The shift operators allow the programmer to move the bit pattern of an
  integer of any length to the left or right by a number of places less
  than the number of bits in the specified integer.
!PAGE
  Example:
           J = I>>N

     This causes integer I to be shifted to the right the number of
     places specified by N and the result stored in integer J.  If I or
     N are of less than integer precision they will be made up to
     integer precision, as described above, before the operation takes
     place.

  In a left shift, bit positions vacated at the right hand end are
  filled with zeros and bits shifted off the left hand end are lost.  In
  a right shift, bit positions vacated at the left hand end are filled
  with zeros and bits shifted off the right hand end are lost.  Note
  that a shift of more than N-1 characters will result in an integer
  whose value is implementation- dependent, not necessarily zero-filled.

  The operators &, !, !! are carried out on a bit-by-bit basis between
  the patterns stored in two integer variables.  Where one operand is a
  long integer, the other will be made up to long integer by sign
  extension.
!PAGE
  'and' (&)            produces a pattern containing a 1-bit where the
                       two source patterns both have 1-bits and
                       containing 0-bits elsewhere.

  'inclusive or' (!)   produces a pattern containing a 0-bit where the
                       two source patterns both have 0-bits and
                       containing 1-bits elsewhere.

  'exclusive or' (!!)  produces a pattern containing a 1-bit where the
                       bits in the source patterns are different and
                       contains 0-bits elsewhere.

  These rules are summarised in the following table:
!PAGE
              ______________________________
             |            |                 |
             |  Operands  |  &     !    !!  |
             |____________|_________________|
             |            |                 |
             |   0  0     |  0     0     0  |
             |            |                 |
             |   0  1     |  0     1     1  |
             |            |                 |
             |   1  0     |  0     1     1  |
             |            |                 |
             |   1  1     |  1     1     0  |
             |____________|_________________|


  The \ operator operates on a single operand to invert the value of
  each bit; that is, 0-bits become 1-bits and vice versa.
!PAGE
  Example:

     If X contains the bit pattern    01....0100110011

     then \X is                       10....1011001100

     thus \X + X is                   11....1111111111
!PAGE
  Arithmetic and logical operators may occur in the same arithmetic
  expression.  The established order of precedence, starting with the
  highest, is:

               ________________________
              |                        |
              |  \                     |
              |                        |
              |  **    >>    <<        |
              |                        |
              |  *     /     //    &   |
              |                        |
              |  +     -     !     !!  |
              |________________________|


  Operators given on the same line in the above table have equal
  precedence.
!PAGE
  Example:
           %integer I, J
           ! Variables of type %integer are assumed to have 32 bits
           ! in this example.
           %byte %integer %array B(0:3)

            :
           I = ....
            :
           B(J//8) = I>>(24-J) & X'FF' %for J = 0,8,24
            :

     In this example, a 32-bit integer I is copied, in groups of 8 bits,
     into the byte integer array B.

  Note that X'FF' represents a bit pattern of eight 1s in the least
  significant end of the specified location and zeros elsewhere.
!>
!<String ops and expressions
!KEY
  There are three assignment operators available for use with strings:
  "=", "<-" and "->".

  Where "=" is used, the string expression on the right-hand side is
  evaluated and assigned to the string location specified on the
  left-hand side.  The string expression must evaluate to a string
  constant which is no larger than the maximum which the left-hand
  string location can hold.  A run-time error will occur if the
  left-hand string location overflows.

  "<-" is known as the "jam transfer" operator.  It will assign to the
  location specified on the left-hand side only as many characters of
  the right-hand string as will fit.  Any remaining characters from the
  right-hand end of the string being assigned will simply be omitted and
  no error will occur.

  "->" is known as the "string resolution" operator.  It is used
  exclusively for the manipulation of strings.  Its effect is described
  below.
!PAGE
  Another operation exclusive to strings is "concatenation".  This
  allows them to be joined in a prescribed order.  The strings to be
  concatenated are listed in the required order and separated by the
  symbol '.' .

  Example:
           %begin
              %string(65) S
              %string(15) NAME1, NAME2, NAME3
              %string(20) ADDRESS

              NAME1 = "Peter "
              NAME2 = "John "
              NAME3 = "Smith
           "
              ADDRESS = "12 Bothwell Drive"
              S = NAME1.NAME2.NAME3.ADDRESS
              PRINTSTRING(S)
              NEWLINE
           %end %of %program
!PAGE
     String S is assigned the concatenated characters of the four
     strings NAME1, NAME2, NAME3 and ADDRESS.  Thus the printed output
     would read

              Peter John Smith
              12 Bothwell Drive

     Note that the string NAME3 has a newline character in the text
     after the name Smith.

  The only type of string expression in IMP80 is that produced by
  concatenation, for which bracketed expressions are neither required
  nor permitted.

  String resolution allows a string to be searched for a specified
  substring of characters.  If this substring does not occur in the
  string being resolved, an error condition occurs.  If, however, the
  substring is found on searching the string from left to right, then
  all characters to the left and right of the substring will be stored
  respectively in two strings specified to the left and right of the
  substring in the resolution instruction.  The substring, which may be
  a string expression (a constant, a variable or a concatenation), is
  enclosed in parentheses with a string identifier on either side, each
  of these three elements being separated by '.' .

  Example:
           S = "ERCC00.FLAG"
           S -> A.(".").B
           ! A now contains "ERCC00" and B contains "FLAG".

     Thus string S has been split into two smaller strings neither of
     which include '.' .  The same exercise would be accomplished by the
     following:

           S = "ERCC00.FLAG"
           X = "."
           S -> A.(X).B
!PAGE
  The substring may be a concatenation:

  Example:
           FIRST NAME = "John"
           SURNAME = "Smith"
           NAME AND ADDRESS = "Peter John Smith, 12 Bothwell Drive"
           NAME AND ADDRESS -> A.(FIRST NAME." ".SURNAME).B

  {EMAS IMP80: multiple resolution is permitted; it is treated as a
  series of simple resolutions.

  Example:
           S = "WINSTON SPENCER CHURCHILL"
           S -> A.(" ").B.(" ").C

     The above resolution will be treated as

           S -> A.(" ").PRIV %and PRIV -> B.(" ").C}
!PAGE
  The strings used to store the characters which occur before and after
  the specified substring may be omitted, in which case the characters
  are discarded.

  Examples:
           S = "ERCC00.FLAG"
           S -> (".").B
           ! B now contains "FLAG".

           S = "ERCC00.FLAG"
           S -> A.(".")
           ! A now contains "ERCC00".

           S = "ERCC00.FLAG"
           S -> (".")
           ! Resolution would fail if "." did not occur in S.
           ! There are no other products of this resolution.
!PAGE
  Since a resolution must either succeed or fail, it may be used as a
  simple condition.

  Examples:
           S = A.B %while S -> A.(" ").B
           ! This statement removes all spaces from string S.

           %if S -> A.("/").B %then T = A." or ".B

  Note that, although the string resolution is used here as a condition,
  it is nonetheless carried out if it can be (i.e. if the condition is
  true).
!PAGE
  There are four procedures provided for the manipulation of strings.

  %byte %integer %map CHAR NO(%string(*)%name S, %integer N)

     This map returns a reference to the Nth character of string S.  An
     event is signalled if N is negative or greater than the current
     length of S.

  %byte %integer %map LENGTH(%string(*)%name S)

     The result is a reference to a variable containing the current
     length of the string S.

  %string(*)%function SUBSTRING(%string(*)%name S, %integer I, J)

     The result is the substring of S comprising the Ith to Jth
     (inclusive) characters of S.  An event is signalled unless
     1 <= I <= LENGTH(S) and I-1 <= J <= LENGTH(S).  If J=I-1 then a
     null string is returned.
!PAGE
  %string(1)%function TO STRING(%integer I)

     The result is a string of length 1 comprising the character defined
     by the least significant byte of integer I.

     Example:
              %string(80) S
              %integer %name L
               :
               :
              L == LENGTH(S) 
              L = L-1 %while L>0 %and CHARNO(S,L) = ' '
              ! This example shows how to delete trailing spaces
              ! from a string.
!>
!<Record operators
!KEY
  The only record operators taking complete records, rather than record
  sub-fields, as their operands are the assignment operators '=', '<-'
  and '=='.  These are described above, in 2.2.3/9 .