Copyright (c) 1998, Stuart King. All rights reserved.

		  ------------------------------------
		  Irie Pascal for OS/2 Beta 2B Release
		  ------------------------------------

This is the Irie Pascal for OS/2 Users Guide.
In this guide "Software", "Compiler", and "Interpreter" 
mean the following:
"Software" means "Irie Pascal for OS/2",
"Compiler" means "Irie Pascal Compiler for OS/2", and
"Interpreter" means "Irie Virtual Machine Interpreter for OS/2".

-----------------
Table Of Contents
-----------------
Preface
Purpose
1.0 Introduction
1.1    The Software
1.2    Disclaimer - Agreement
1.3    Compliance statement
1.4    Product support
1.5    Contacting the author
2.0 Installation
2.1    Minimum system requirements
2.2    Installing the Software
2.3    Uninstalling the Software
3.0 Compiling programs
3.1    Compiler messages
3.2    Compiler options
3.2.1     Compiler options list
3.3    Compiler directives
3.3.1     Compiler directives list
4.0 Executing programs
5.0 Extensions to Pascal as specified by ISO/IEC 7185
5.1    Relaxed declarations
5.2    Constant ranges
5.3    Otherwise
5.4    Relaxed parameter list congruity
5.5    Non-numeric statement labels
5.6    Underscores in identifiers
5.7    Binary integer constants
5.8    Hexadecimal integer constants
5.9    Input and Output automatically declared
5.10   Double-quoted literals
5.11   and_then operator
5.12   or_else operator
5.13   shl operator
5.14   shr operator
5.15   Extended constants
5.15.1    maxchar
5.16   Extended types
5.16.1    filename
5.16.2    list
5.16.3    string
5.17   Extended variables
5.17.1    exitcode
5.18   Extended functions
5.18.1    concat
5.18.2    copy
5.18.3    cosh
5.18.4    FilePos
5.18.5    FileSize
5.18.6    frac
5.18.7    GetEnv
5.18.8    hex
5.18.9    int
5.18.10    IOResult
5.18.11    length
5.18.12    log
5.18.13    locase
5.18.14    lowercase
5.18.15    paramcount
5.18.16    paramstr
5.18.17    pi
5.18.18    pos
5.18.19    random
5.18.20    reverse
5.18.21    sinh
5.18.22    swap
5.18.23    system
5.18.24    trim
5.18.25    upcase
5.18.26    uppercase
5.19   Extended procedures
5.19.1    append
5.19.2    assign
5.19.3    close
5.19.4    dec
5.19.5    delete
5.19.6    dispose
5.19.7    erase
5.19.8    exec
5.19.9    exit
5.19.10    flush
5.19.11    GetDate
5.19.12    GetTime
5.19.13    halt
5.19.14    inc
5.19.15    insert
5.19.16    new
5.19.17    randomize
5.19.18    RawRead
5.19.19    RawWrite
5.19.20    rename
5.19.21    seek
5.19.22    str
5.19.23    val
6.0 Miscellaneous features
6.1    Program parameters
6.2    Compatible types
6.3    Assignment compatibility
6.3.1      Assignment compatibility with array indexing
6.3.2      Assignment compatibility with value parameters
6.3.3      Assignment compatibility with 'read'
6.3.4      Assignment compatibility with assignment statements
6.3.5      Assignment compatibility with 'for'
6.3.6      Transfer procedures

Appendix A. Deviations from ISO/IEC 7185
A.1         end-of-line characters
A.2         Termination of all lines in text files
A.3         new(p, c1..CN)
A.4         dispose(q, k1..kM)
A.5         Carriage return

Appendix B. Implementation limits
B.1         Length of source lines
B.2         Number and nesting of statement sequences
B.3         Nesting of functions/procedures
B.4         Range of variant selectors type & Number of variants
B.5         Range of case-index's type & Number of case-list-elements
B.6         Size of integer constants
B.7         Size of real constants
B.8         Size of code and data
B.9         Number of set elements
B.10        Nesting of statements
B.11        Stack size

Appendix C. Implementation-defined features
C.1         String-elements
C.2         Provision of tokens and delimiting characters
C.3         Size and precision of real values
C.4         Character set
C.5         Ordinal values of characters
C.6         Characters prohibited from text files
C.7         When I/O is performed
C.8         Value of maxint
C.9         Accuracy of real operations and functions
C.10        Default value of TotalWidth for integer-type
C.11        Default value of TotalWidth for real-type
C.12        Default value of TotalWidth for Boolean-type
C.13        Number of digits written in exponents
C.14        Use of 'e' of 'E' as exponent character on output
C.15        Case of characters used on output of Boolean values
C.16        Effect of built-in procedure 'page'
C.17        Binding of file-type program-parameters
C.18        Effect of 'reset' and 'rewrite' on 'input' and 'output'

Appendix D. Implementation-dependent features
D.1         Effect of writing 'prohibited' characters
D.2         Order of evaluation of index-expressions
D.3         Order of evaluation of expressions of a member-designator
D.4         Order of evaluation of member-designators
D.5         Order of evaluation of operands of dyadic operators
D.6         Order of evaluation of actual-parameters for function calls
D.7         Order of evaluating components of assignment statements
D.8         Order of evaluation of actual-parameters for procedure calls
D.9         Effect of reading a text file to which 'page' has been applied
D.10        Binding of non-file program-parameters

Appendix E. Errors
E.1         Array index out of bounds
E.2         Accessing inactive variant
E.3         Dereferencing nil pointers
E.4         Dereferencing undefined pointers
E.5         Dangling pointers
E.6         Altering file-variables
E.7         Using out-of-range value parameters
E.8         Using out-of-range set value parameters
E.9         Output to file not open for writing
E.10        Output to undefined file
E.11        Writing to middle of file
E.12        Putting undefined buffer-variables
E.13        Resetting undefined files
E.14        Input from file not open for reading
E.15        Input from undefined file
E.16        Reading past end-of-file
E.17        Reading out of range values
E.18        Writing out of range values
E.19        new(p, c1..cN) constraints violated
E.20        Incompatible use of dispose(p)
E.21        Incompatible use of dispose(p, k1..kM)
E.22        dispose(p, k1..kM) constraint violations
E.23        disposing nil pointer
E.24        disposing undefined pointer
E.25        new(p, c1..cN) constraints violated
E.26        Invalid use of pack
E.27        Invalid use of pack
E.28        Invalid use of pack
E.29        Invalid use of unpack
E.30        Invalid use of unpack
E.31        Invalid use of unpack
E.32        Square root of negative number
E.33        ln(x) and x <= 0
E.34        Square root of negative number
E.35        Problems with trunc
E.36        Problems with round
E.37        Problems with chr
E.38        Problems with succ
E.39        Problems with pred
E.40        Using eof on undefined files
E.41        Using eoln on undefined files
E.42        Using eoln at end-of-file
E.43        Using undefined variables
E.44        Division by zero
E.45        Division by zero
E.46        Modulus of zero or negative
E.47        Integer overflow/underflow
E.48        Returning undefined value from function
E.49        Assigning out of range ordinal values
E.50        Assigning out of range set values
E.51        Non-matching case index
E.52        For loops initial value out of range
E.53        For loops final value out of range
E.54        Reading invalid integer values
E.55        Reading out of range integer values
E.56        Reading invalid numeric values
E.57        Reading when file is not open
E.58        Writing with TotalWidth or FracDigits less than one
E.59        Problems with program-parameters
E.60        Problems with conformant arrays

Appendix F. I/O error codes

-------
Preface
-------
The Software supports Standard (i.e. ISO/IEC 7185) Pascal
(see the Compliance statement) below. This guide covers mainly how
to install and use the Software, and the extensions to Standard Pascal
supported by the Software. This guide is NOT a Standard Pascal reference,
so for example the functions and procedures defined by Standard Pascal are
not described in this guide, even though they are supported by the Software.

You will probably need, in addition to this guide, reference and/or
tutorial information about Standard Pascal. However when choosing a Pascal
book, to supplement this guide, avoid books with "TURBO" or "BORLAND"
in their titles since these books are likely to cover Borland's
implementation of Pascal and not Standard Pascal.

-------
Purpose
-------
The main purpose of Irie Pascal is to provide an excellent multi-platform
tool for people who either want to learn Pascal or who want to write small
to medium sized scripts and utility programs. As a result the following
are emphasized:
   1) Simplicity and ease of use
   2) Good diagnostics (both compile time and run-time)
   3) Generating correct code
   4) Very strong support for Standard Pascal
   5) Support for many extensions to Standard Pascal, particularly in the
	  areas of file and string processing
   6) Support for multi-platform programming (i.e. you should be able to
	  compile your programs once and run them on any supported platform)
   7) Moderate price

----------------
1.0 Introduction
----------------

-------------------
1.1    The Software
-------------------
The Software consists of two programs, the Compiler and the Interpreter.
The Compiler is not a native code compiler (i.e. it does not generate
instructions for a real computer), instead it generates instructions
(also called byte codes) for an imaginary computer (called the
"Irie Virtual Machine"). These byte codes can not be directly executed
by any existing computer, but instead must be executed by the Interpreter.

The main advantage of generating byte codes instead of native code is that
the resulting programs are very portable. The programs generated by the
Compiler can be run (without being recompiled) on any computer platform
on which the Interpreter exists. Currently the Interpreter exists on four
computer platforms:
	1) Win95/NT
	2) OS/2.
	3) MS-DOS
	4) Linux
A ports to FreeBSD is planned for the very near future.

Another advantage to generating byte codes is that the resulting programs
tend to be much smaller than their native-code equivalents. I have found
that programs generated by the Compiler tend to be roughly 20 times smaller
than equivalent programs generated by native code compilers.

The main disadvantage of generating byte codes instead of native code is
speed or rather the lack of it. This is because the byte codes are not
directly executed, but are executed by the Interpreter. I have found that
programs generated by the Compiler tend to run roughly 50 times slower than
equivalent programs generated by native code compilers. There are many
kinds of programs where this speed is perfectly acceptable, but there
are other kinds where this speed is just too slow. I expect the Software
to be used mainly to generate utility programs, and programs for learning
purposes (if you are learning Pascal you don't need your test programs to
be the fastest possible, you probably need good diagnostics
(both compile-time and run-time) more.

This is a beta release of Irie Pascal (i.e. this release has been thoroughly
tested by me but has not been tested by anyone else). While I am confident
that Irie Pascal is stable enough to be a useful tool, I can not guarantee
that it is bug free. You should be also be aware that although I claim
Irie Pascal complies with ISO/IEC 7185 Level 0 (since it does according to
my tests) it has not been formally certified by an external body.

This beta release of Irie Pascal is available free of charge. Feel free to
share this release with your friends, but do not give it away altered or as
part of another system.

NOTE: The final version of Irie Pascal will be released as shareware.
There will be two versions. One version is called the evaluation version
which will be freely available at no charge. You are encouraged to share
this version with others (hence the name 'shareware'). The other version
is called the registered version which you will be able to obtain after
paying the registration fee. You will not authorized to share the
registered version (i.e. you should treat it like any other type of
commercial software). The amount of the registration fee will be specified
when the final version is released.

This is actually the evaluation version of Irie Pascal, but because
this is a beta release I am not accepting registration fees, and therefore
the registered version is not yet available. The only reason I mention this
is that programs compiled by the evaluation version expire after seven days,
while programs compiled with the registered version never expire. This is
intended to gently encourage you to pay the registration fee and obtain the
registered version. I say "gently encourage" because you can re-compile
expired programs as many times as you like to keep them running indefinitely.

-----------------------------
1.2    Disclaimer - Agreement
-----------------------------
Users of the Software must accept this disclaimer of warranty:
"The Software is supplied as is.  The author disclaims all warranties,
expressed or implied, including, without limitation, the warranties of
merchantability and of fitness for any purpose. The author assumes no
liability for damages, direct or consequential, which may result from the
use of the Software."

---------------------------
1.3    Compliance statement
---------------------------
The following compliance statement is required by the International
Standard for the Pascal language ISO/IEC 7185.

"Irie Pascal for OS/2 complies with the requirements of level 0 of
ISO/IEC 7185, with the following exceptions: (see Appendix A)".

----------------------
1.4    Product support
----------------------
I am very interested in all your comments about the Software, but
most especially in your comments about the usefullness of the Software,
any problems you encounter installing or using the Software, and any
changes you would like to see in this guide or in the Software.

The latest information and updates of the Software are available at
the Irie Tools web site at    http://www.irietools.com

You can also contact me directly with your technical support
questions (see "Contacting the author" below).

----------------------------
1.5    Contacting the author
----------------------------
For the quickest response contact me by e-mail at support@irietools.com

If you prefer you can contact me by regular mail (but this takes longer) at:
   Stuart King
   MB #247
   221 S. State Road 7
   Ft. Lauderdale, Fl 33317
   U.S.A.

----------------
2.0 Installation
----------------

----------------------------------
2.1    Minimum system requirements
----------------------------------
- 1 MB hard disk space

--------------------------------
2.2    Installation the Software
--------------------------------
For information on installing Irie Pascal see "install.txt"

--------------------------------
2.3    Uninstalling the Software
--------------------------------
For information on uninstalling Irie Pascal see "install.txt"

----------------------
3.0 Compiling programs
----------------------
You compile programs using the Irie Pascal Compiler (referred to as
"the Compiler"). The Compiler should be run from a command-line prompt.

Once you are at a command-line prompt use the following syntax
Syntax: ipc [options] filename
	or  ipc ?
	or  ipc
 where  [options]    modify the behaviour of the Compiler.
	[filename]   specifies the file to compile.
NOTE: [x] indicates that x is optional.

If you enter
   "ipc"
then the Compiler displays a brief help screen showing the proper syntax.
If you enter
   "ipc ?"
then the Compiler displays a more detailed help screen listing all the
options that you can use.
If you enter
   "ipc [options] filename"
then the Compiler attempts to compile the file specified by 'filename'
taking into account the options specified if any.

If we ignore the compiler options for the time being then to
compile a program you enter "ipc filename".

For example to compile the sample "hello.pas" program
enter "ipc hello" or "ipc hello.pas" (assuming of course that
"hello.pas" is in the current directory).
The Compiler will generate a file called "hello.ivm" which contains an
Irie Virtual Machine Executable. You can run it by entering
"ivm hello" or "ivm hello.ivm".

------------------------
3.1    Compiler messages
------------------------
The compiler can display four different classes of messages
1) Fatal error messages
2) Error messages
3) Warning messages
4) Informatory messages

Fatal error messages are displayed when the compiler detects a problem
that is so serious it can not continue. After displaying a fatal error
message the compiler deletes the Irie Virtual Machine Executable if one
is being created and then stops immediately.

Error messages are displayed when the compiler detects a problem
that prevents it from generating a reliable executable. After displaying
an error message the compile deletes the Irie Virtual Machine Executable
and continues compiling in order to detect other problems.

Warning messages are generated when the compiler detects something
which may indicate a problem with your program. For example if you
declare a variable and never use it the compile displays a warning
message.

Informatory messages display information which may be interesting
but not really necessary. For example there are messages which show
the speed of compilation.

Here is an example of what I mean.
If you compile the following program which is one of the sample programs
"bad.pas"

   program bad(output);
   begin
	  writelm('Hello') (* writelm used instead of writeln *)
   end.

then the Compiler produces the following output

   Irie Pascal for OS/2 (Beta 2B) Copyright (c) 1998, Stuart King.
   Error #76: "bad.pas" (line 3, col 4): Procedure identifier expected.
	  writelm('Hello') (* writelm used instead of writeln *)
	  ^
   Warning #44: "bad.pas" (line 1, col 13): Variable is never used.
   program bad(output);
		   ^
   1 error(s) and 1 warning(s) were issued.
   5 lines compiled in  0.110 seconds.
   Compilation speed   45 lines/sec,  2700 lines/min.

The first line is the copyright notice.
The second line is an error message
   The word "Error" indicates that this is an error or fatal error message.
   The #76 is the message number.
   Then comes the name of the file with the error.
   Then comes the location where the error was detected
	  (line 3, column 4).
   Finally the text of the message.
The third line shows the line where the error was detected.
The fourth line has a ^ pointing to the location in the third line where
   the error was detected.
The fifth line is blank.
The sixth, seventh and eighth lines display a warning message with
essentially the same layout as the error message.
The final three lines are informatory messages.
NOTE: The speed of compilation will vary.

Tip: Sometimes a single problem can confuse the Compiler and make it
report problems later on that don't really exist. So pay special
attention to the problem reported by the first message and try to fix
this one first.

-----------------------
3.2    Compiler options
-----------------------
Compiler options are instructions to the Compiler to somehow modify it's
behaviour (usually they are instruction to enable or disable a particular
compiler feature). Compiler options are entered on the command-line when
you invoke the Compiler (see "Compiling programs" above).
NOTE: Compile options are case sensitive so for example 'i' and 'I' are
different options.

There are two kinds of compiler options
1) Flag options
2) Value options

Flag options are used to enable or disable a compiler feature.
To enable the feature use
   -option    or -option+
where
   option is the particular compiler option.
To disable the feature use
   -option-

For example the 'nc' option is used to enable/disable the processing of
nested comments. So -nc or -nc+ is used to enable the processing of nested
comments and -nc- is used to disable the processing of nested comments.

Value options are used to specify the value of some quantity.
To specify a value option use
   -optionVALUE
where
   option is the particular compiler option
and
   VALUE is the value being specified.

For example the 'mw' option is used to specify the maximum number of
warnings that the Compiler should process.
So -mw2 is used to set the maximum number of warnings to 2.

More than one option can be specified so suppose you want to compile
the program "bad.pas" using brief messages and nested comments then
you can enter    "ipc -b -nc bad.pas".

Options can be combined so you can also enter   "ipc -bnc bad".

To turn off nested comment processing and brief message then
you can enter "ipc -nc- -b- bad" or "ipc -ncb- bad".

-------------------------------
3.2.1     Compiler options list
-------------------------------
Option:  'a'
Purpose: Specifies the maximum alignment used by the Compiler.
Syntax:  -aN     Set maximum alignment to N.
Default: Maximum alignment 4.
Notes:
N must be between 0 and 8 (N=0 is treated like N=1).

Some CPUs (including those in the 80x86 family) access data faster if it
is aligned on an address which is a multiple of the size of the data.
Suppose the CPU is accessing a real which is 8 bytes long then for
fastest access the real should be on an address which is a multiple
of 8 (for example 0, 8, 16, 24, 32, 40, 48, ...).

The Compiler stores variables in memory at the lowest available address
which is a multiple of either the variables size or the maximum alignment,
whichever is smaller.

For example suppose you compile the following program and the maximum
alignment is 4.

	program x(output);
	var
	   c : char;
	   i : integer;
	   b : boolean;
	   r : real;
	begin
	end.

The compiler needs to decide where to store the variables
'c', 'i', 'b' and 'r'.

The first variable 'c' gets stored at address 0, and since 'c' is
a char variable (which are 1 byte long) the available addresses are
from 1 upwards.

The second variable 'i' is an integer variable (which are 4 bytes long).
The lowest available address which is a multiple of the variable size
is 4 and the lowest available address which is a multiple of the maximum
alignment is also 4. So the Compiler stores 'i' at address 4, and the
available address are from 8 upwards (since 'i' is 4 bytes long).

The third variable 'b' is a boolean variable (which are 4 bytes long).
The lowest available address which is a multiple of the variable size
is 8 and the lowest available address which is a multiple of the maximum
alignment is also 8. So the Compiler stores 'b' at address 8, and the
available address are from 12 upwards (since 'b' is 4 bytes long).

The fourth variable 'r' is a real variable (which are 8 bytes long).
The lowest available address which is a multiple of the variable size
is 16 but the lowest available address which is a multiple of the maximum
alignment is 12. So the Compiler stores 'r' at address 12 (since 12 is
less than 16).

In general if you set maximum alignment to 1 then you waste no memory
but you get fastest access only for chars. If you set the maximum alignment
to 4 you may waste memory when storing all variables except char, but
you get the fastest access to all variables except real. If you set the
maximum alignment to 8 you may waste memory when storing all variables
except char, but you get the fastest access to variables of all types.

If you are not sure about the setting of this option just leave the default.

		 ------------------------------

Option:  'ao'
Purpose: Enables/disables assignment overflow checking.
Syntax:  -ao[+|-]
Default: Enabled
Notes:
When assignment overflow checking is enabled the Compiler generates code
to check that variables are large enough to contain the values
assigned to them. The generated code will display a run-time diagnostic
message and stop your program if an assignment overflow error is detected.
Assignment overflow errors are only possible when assigning to string
variables or set variables using the array representation
(See "B.9 Number of set elements" for more information).

I strongly recommend you leave this option enabled.

		 ------------------------------

Option:  'b'
Purpose: Enables/disables the use of the brief format for messages.
Syntax:  -b[+|-]
Default: Disabled
Notes:
The verbose format for Fatal error and Error messages (which is used by
default) is
	 Error #nn: "name" (Line l, Col c): text
where
	 nn is a number identifying the message
	 name is the file where the problem as detected
	 l is the line where the problem was detected
	 c is the column where the problem was detected
	 text is the text of the message
The verbose format for warning messages are similiar except that "Warning"
is used instead of "Error".

The brief format for Fatal error and Error messages is
	Enn: "name" l:text
where
	 nn is a number identifying the message
	 name is the file where the problem as detected
	 l is the line number of the line where the problem was detected
	 text is the text of the message
The brief format for warning messages are similiar except that "W" is
used instead of "E".

		 ------------------------------


Option:  'C'
Purpose: Enables/disables case-sensitive compilation.
Syntax:  -C[+|-]
Default: Disabled
Notes:
When case-sensitive compilation is disabled then the case of identifiers
is not considered significant. So for example 'x', and 'X' would be
considered to be the same identifier. When case-sensitive compilation
is enabled then the case of identifiers is considered to be significant.
So for example 'x', and 'X' are considered to be different identifiers.
Case-sensitive compilation is disabled by default since Standard Pascal is
not case-sensitive.

This option is disabled by default since Standard Pascal is not
case-sensitive. If you enable this option then remember to use all
lowercase for keywords and built-in identifiers
(i.e. constants, types, functions, procedures, and variables).

		 ------------------------------

Option:  'eat'
Purpose: Enables/disables the and_then operator.
Syntax:  -eat[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the and_then operator.

		 ------------------------------

Option:  'eb'
Purpose: Enables/disables binary constants.
Syntax:  -eb[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of binary constants.

		 ------------------------------

Option:  'ec'
Purpose: Enables/disables extended constants.
Syntax:  -ec[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of extended constants.

		 ------------------------------
Option:  'ecr'
Purpose: Enables/disables constant ranges.
Syntax:  -ecr[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of constant ranges.

		 ------------------------------

Option:  'edq'
Purpose: Enables/disables double quoted string and character literals.
Syntax:  -edq[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of double quoted literals.

		 ------------------------------

Option:  'ef'
Purpose: Enables/disables extended functions.
Syntax:  -ef[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the extended functions.

		 ------------------------------

Option:  'efn'
Purpose: Enables/disables the built-in type 'filename'.
Syntax:  -efn[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of 'filename'.

		 ------------------------------
Option:  'eh'
Purpose: Enables/disables hexadecimal constants.
Syntax:  -eh[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of hexadecimal constants.

		 ------------------------------

Option:  'eio'
Purpose: Enables/disables automatic declaration of 'input' and 'output'.
Syntax:  -eio[+|-]
Default: Enabled
Notes:
Standard Pascal specifies that whenever the required identifiers 'input'
and 'output' are referenced in a program
  (either directly like   write(output, 'Hello')   or read(input, x)
  or indirectly like      write('Hello')           or read(x))
then they must appear as program parameters.
However because some Pascal compilers do not enforce this requirement
many programmers don't bother.
If this option is enabled then the compiler automatically declares
'input' and 'output' as if they were specified as program parameters.

		 ------------------------------

Option:  'el'
Purpose: Enables/disables the built-in type 'list'.
Syntax:  -el[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the list type.

		 ------------------------------

Option:  'emc'
Purpose: Enables/disables the built-in constant 'maxchar'.
Syntax:  -emc[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of 'maxchar'.

		 ------------------------------
Option:  'enn'
Purpose: Enables/disables non-numeric statement labels.
Syntax:  -enn[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of non-numeric statement labels.

		 ------------------------------

Option:  'eoe'
Purpose: Enables/disables the or_else operator.
Syntax:  -eoe[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the or_else operator.

		 ------------------------------

Option:  'eoth'
Purpose: Enables/disables 'otherwise' in case statements and variant records.
Syntax:  -eoth[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the 'otherwise' keyword.

		 ------------------------------

Option:  'ep'
Purpose: Enables/disables extended procedures.
Syntax:  -ep[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the extended procedures.

		 ------------------------------

Option:  'erd'
Purpose: Enables/disables relaxed declarations.
Syntax:  -erd[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of relaxed declarations.

		 ------------------------------

Option:  'es'
Purpose: Enables/disables the built-in type 'string'.
Syntax:  -es[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the string type.

		 ------------------------------

Option:  'esh'
Purpose: Enables/disables the bit shift operators 'shr' and 'shl'.
Syntax:  -esh[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of the bit shift operators

		 ------------------------------

Option:  'et'
Purpose: Enables/disables extended types.
Syntax:  -et[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of extended types

		 ------------------------------
Option:  'eus'
Purpose: Enables/disables underscores in identifiers.
Syntax:  -eus[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of underscores in identifiers.

		 ------------------------------

Option:  'ev'
Purpose: Enables/disables extended variables.
Syntax:  -ev[+|-]
Default: Enabled
Notes:
See "Extensions to Pascal as specified by ISO/IEC 7185" for a description
of extended variables

		 ------------------------------
Option:  'E'
Purpose: Enables/disables groups of extensions.
Syntax:  -E[0|1|2]
Default: -E2
Notes:
Use -E0 to disable all extensions.
Use E1 to disable extensions which require a new keyword
   and at the same time enable all other extensions.
   Using E1 is the same as using
	 -eat- -eio+ -el- -eoe- -eoth- esh- eb+ -ed+ -eq+ -ef+ -ep+ -eh+ -es+
Use E2 to enable all extensions.

		 ------------------------------

Option:  'i'
Purpose: Enables/disables I/O checking.
Syntax:  -i[+|-]
Default: Enabled
Notes:
When I/O checking is enabled the Compiler generates code which checks each
I/O operation and issues a run-time diagnostic if an I/O error is detected.

		 ------------------------------

Option:  'I'
Purpose: Enables/disables informatory messages.
Syntax:  -I[nn][+|-]
Default: All informatory message enabled.
Notes:
Use -I or -I+ to enable all informatory messages.
Use -I- to disable all informatory messages.
Use -Inn or -Inn+ to enable the informatory message with message number nn.
Use -Inn- to disable the informatory message with message number nn.

		 ------------------------------

Option:  'ln'
Purpose: Enables/disables line number information.
Syntax:  -ln[+|-]
Default: Enabled
Notes:
When line number information is enabled, the Compiler stores the address
of the byte-codes generated for each line of source code, inside the
Irie Virtual Machine Executable. Enabling line number information
makes the executable bigger, but allows for more meaningful run-time
diagnostic messages since the line number of the source line that caused
the error is displayed in the message.

When line number information is not enabled, the executable is smaller
but run-time diagnostics messages display only the address of the code
that caused the error, which is unlikely to be very useful to you.

I recommend leaving this option enabled unless you really need to make the
executable as small as possible.

		 ------------------------------

Option:  'mc'
Purpose: Enables/disables message context information
Syntax:  -mc[+|-]
Default: Enabled
Notes:
When message context information is enabled the Compiler displays
context information for most error and warning messages. This context
information points to the specific place or item in the file that the
message is referring to.

		 ------------------------------

Option:  'me'
Purpose: Specifies that the Compiler stop after N error messages.
Syntax:  -meN
Default: N = 25
Notes:
Suppose you want the compiler to stop after 5 error messages then
use -me5

		 ------------------------------

Option:  'ml'
Purpose: Enables/disables the the display of the message list.
Syntax:  -ml[+|-]
Default: Disabled
Notes:
When the display of the message list is enabled the Compiler displays a
list of all of it's messages and then stops (it does not attempt to compile
anything). This option is useful to me when debugging the compiler so
that I can turn individual tracer messages on and off (I need to know
the message number).

		 ------------------------------

Option:  'mw'
Purpose: Specifies that the Compiler stop after N warning messages.
Syntax:  -mwN
Default: N = 100
Notes:
Suppose you want the compiler to stop after 5 warning messages then
use -mw5

		 ------------------------------

Option:  'nc'
Purpose: Enables/disables nested comments.
Syntax:  -nc[+|-]
Default: Disabled
Notes:
Nested comments are comments inside other comments.
For example
   (* outer (* inner comment *) comment *)
When nested comments is disabled the example comment above will
terminate at the first *) so only
   (* outer (* inner comment *)
will be treated as a comment.
When nested comments is enabled Compiler recognizes the end of comments
only when the number of close comment markers matches the number of open
comment markers. So the example comment above will terminate only after the
second *).

Both open comment markers (* and { are considered to be equivelent.
Both close comment markers *) and } are considered to be equivelent.
So attempting to trick the Compiler into accepting nested comments with
something like
   (* outer { inner comment } comment *)
will not work.

Nested comments are disabled by default since in Standard Pascal comments
do not nest.

		 ------------------------------
Option:  'p'
Purpose: Enables/disables mandatory parentheses mode.
Syntax:  -p[+|-]
Default: Disabled
Notes:
The one thing I dislike about Pascal is that parentheses are not used
when calling or declaring functions or procedures with no parameters.
So for example in the following statement
		 a := b;
it is not clear whether 'b' is a function that takes no parameters or
whether 'b' is a variable.

When mandatory parentheses mode is enabled then parentheses are required
when declaring or calling all functions and procedures even those with
no parameters. Parentheses are also required after the program name even
if there are no program parameters.

So for example to declare a procedure that takes no parameters you would
use the following

	procedure name();
	...
	begin
	...
	end;

And when calling it you would use

	name();

The problem with using this option is that your programs are not strictly
speaking Pascal programs any longer and they probably could not be compiled
by another compiler without being modified.

		 ------------------------------

Option:  'r'
Purpose: Enables/disables range checking.
Syntax:  -r[+|-]
Default: Enabled
Notes:
When range checking is enabled the Compiler generates code to check
for range errors. The generated code will display a run-time diagnostic
message and stop your program if a range error is detected.
The possible causes of range errors are:
A) Attempts to assign or read in values which are not assignment
   compatible with a particular type to a variable of that type.
   e.g. given   var bit : 0..1;
	using   bit := 2 is a range error.
B) Attempts to access element outside of array bounds.
   e.g. given   var x : array[-4..10] of integer;
	using   x[-5] is a range error
C) Attempts to use width or fraction specifiers in write/writeln
   which are less than 1.
   e.g.
	  writeln(1234.56677:x, y);
   is a range error if x or y is less than 1.

		 ------------------------------

Option:  's'
Purpose: Enables/disabled strict checking of var string parameters.
Syntax:  -s[+|-]
Default: Enabled
Notes:
When strict checking is enabled it is an error to pass a string variable
by reference if the length of the variable's string type is not equal to
the length of the formal parameter's string type.

When strict checking is disabled you can pass a string variable by reference
even if the length of the string variable is not equal to the length of the
formal parameter.

For example if you compile the following program and strict checking is
enabled

   program p(output);
   type
	  string8 = string[8];
   var
	  x : string16;

	  procedure print(var s : string8);
	  begin
	  writeln(s)
	  end;

   begin
	  x := 'Hello';
	  print(x)          (* Error only if strict checking is enabled *)
   end.

then the Compiler will report an error with the call print(x) since the
length of x's string type is 16 and the length of the formal parameter's
sting type is 8 (i.e.. they are not equal). If strict checking is disabled
then no errors are reported.

		 ------------------------------

Option:  'sc'
Purpose: Enables/disables short-circuit evaluation for 'and' and 'or'
Syntax:  -sc[+|-]
Default: Enabled
Notes:
The Boolean operators 'and' and 'or' are both binary operators which
take two Boolean operands one on the left and one on the right.
Like 
	 left 'and' right         and left 'or' right
where left and right are Boolean expressions.

Remember that the result of the 'and' operator is true only if both the
left operand and the right operand are true. Short-circuit evaluation
takes advantage of the fact that if the left operand of 'and' is
evaluated and found to be false then there is no need to evaluate the
right operand since the final result must be false.

Similiarly the result of the 'or' operator is false only if both the
left operand and the right operand are false. Short-circuit evaluation
takes advantage of the fact that if the left operand of 'or' is evaluated
and found to be true then there is no need to evaluate the right operand
since the final result must be true.

You might want to disable short-circuit evaluation if you need the
"side-effects" of evaluating the right operand. For example suppose the
right operand is a call to a function which modifies some global variables
(a "side-effect") in addition to returning a Boolean value. Then
short-circuit evaluation might cause the function not to be called and
therefore the global variables will not get modified. If you want to make
sure that the right operand is always evaluated then disable short-circuit
evaluation.

On the other hand short-circuit evaluation is sometimes useful. For example
suppose you have a pointer to an integer and you want to perform some
calculations if the integer is greater than 100, but you don't know whether
the pointer is equal to Nil, then with short-circuit evaluation you can
write:

	 if (p <> Nil) and (p^ > 100) then ... perform calculations ...

If p is Nil then (p <> Nil) is false and the right operand (p^ > 100) is
not evaluated which is good since evaluating the (p^ > 100) will cause
an run-time error when p (which is equal to Nil) is dereferenced.
Without short-circuit evaluation you would have to write something like:

	 if p <> Nil then
	if p^ > 100 then ... perform calculations ...

One solution is to disable short-circuit evaluation for 'and' and 'or' using
this compiler option and use 'and_then' instead of 'and' and 'or_else'
instead of 'or' when you want short-circuit evaluation.

See "Extensions to Pascal as specified by ISO/IEC 7185" for a
description of the 'and_then' and 'or_else' operators.

		 ------------------------------

Option:  'so'
Purpose: Enables/disables detailed stack overflow checking
Syntax:  -so[+|-]
Default: Disabled
Notes:
The Interpreter automatically checks for stack overflow at the beginning
and end of each procedure/function call and when large values are placed
on the stack. These checks should suffice for most purposes, however you
can enable this option if you want the compiler to generates code which
forces the Interpreter to check for stack overflow before every statement
is executed.

		 ------------------------------

Option:  'S'
Purpose: Specifies the number of kilobytes to allocate for your program's
	 stack.
Syntax:  -Snn
Default: nn = 64
Notes:
The default stack size (64K) should be more than enough for the vast
majority of programs. However if your program is heavily recursive or has
functions that need a large amount of space for local variables or
parameters then you can increase this value up to a maximum of 1024K (1MB).
On the other hand you can alse use this options to reduce the size of your
program's stack.

		 ------------------------------

Option:  't'
Purpose: Enables/disables monitoring of stack temporaries.
Syntax:  -t[+|-]
Default: Disabled
Notes:
This option is useful to me when debugging the Compiler to check that
the generated code is using the stack correctly.

If you suspect that the Compiler is generating faulty code then one way
to check is to compile your program with this option enabled and run it as
usual. If you get one of the following run-time diagnostic messages
   Error: Stack log overflow
   Error: Stack log is empty
   Error: Value of BP does not agree with stack log entry
   Error: Value of SP does not agree with stack log entry
then you have probably found a bug in the Compiler.

		 ------------------------------

Option:  'u'
Purpose: Enables/disables checking for undefined values.
Syntax:  -u[+|-]
Default: Enabled
Notes:
When this option is enabled the Compiler generates code which checks
each time your program gets a value from a variable to make sure that
the value is not undefined. If your program does get an undefined value
from a variable then the code generated by the Compiler will issue a
diagnostic message and terminate your program.
So for example if you compile and run the following program
   program bad(output);
   var
	  r : real;
   begin
	  writeln(r) (* The value of 'r' is undefined *)
   end.
The program will terminate with a diagnostic message because of the
attempt to print the value of 'r' which is undefined.

Unfortunately not all variable accesses can be checked, checks are only
made for accesses to variables of the following types:
   enumerated types (including boolean)
   subranges of enumerated types
   subranges of integer that do not include -1
   file
   list
   pointer
   real
   set (array representation) (See "B.9 Number of set elements"
				   for more information).

Accesses to variables of types 'char', 'integer', 'record' and 'set'
(Bit set representation) are not checked.

Checking for undefined values is performed as follows:
A) All memory is initialized by setting all bits to 1.
B) When accessing a variable a check is performed to see if all bits
are set and if they are this variable is undefined.

This doesn't work for 'char', 'integer' or 'set' (bit set representation)
variables since a value with all bits set is valid for these variables.
Record are not checked because they may contain fields which can not be
checked.

		 ------------------------------

Option:  'v'
Purpose: Enables/disables variant checking.
Syntax:  -v[+|-]
Default: Enabled
Notes:
When variant checking is enabled the Compiler generates code to check each
reference to a variant to make sure the variant is active.

		 ------------------------------

Option:  'W'
Purpose: Enables/disables warning messages.
Syntax:  -W[nn][+|-]
Default: All warning messages enabled.
Notes:
Use -W or -W+ to enable all warning messages.
Use -W- to disable all warning messages.
Use -Wnn or -Wnn+ to enable warning message number nn.
Use -Wnn- to disable warning message number nn.

		 ------------------------------

--------------------------
3.3    Compiler directives
--------------------------
Compiler directives are special comments that can be placed in a program
to enable or disable certain compiler features.
The Compiler will treat
any comment that begins with a '$' as a compiler directive.

To enable the feature use
   {$D+} or (*$D+*)
where
   D specifies the particular compiler directive.
To disable the feature use
   {$D-} or (*$D-*)

For example the '$I' directive is used to enable/disable I/O checking.
So use {$I+} or (*$I+*) to enable I/O checking and
use {$I-} or (*$I-*) to disable I/O checking.

----------------------------------
3.3.1     Compiler directives list
----------------------------------
Directive: '$B'
Purpose:   Enables/disables short-circuit evaluation of 'and' and 'or'.
Syntax:    {$B+} or (*$B+*) or {$B-} or (*$B-*)
Notes:
see option 'sc' in the Compiler options list for more information on
short-circuit evaluation.

		 ------------------------------

Directive: '$I'
Purpose:   Enables/disables I/O checking.
Syntax:    {$I+} or (*$I+*) or {$I-} or (*$I-*)
Notes:
When I/O checking is enabled the Compiler generates code to check each
I/O operation. The generated code will display a run-time diagnostic message
and stop your program if an I/O error is detected.

		 ------------------------------

Directive: '$P'
Purpose:   Enables/disables mandatory parentheses mode.
Syntax:    {$P+} or (*$P+*) or {$P-} or (*$P-*)
Notes:
see the 'p' option in the Compiler options list for more information.

		 ------------------------------

Directive: '$R'
Purpose:   Enables/disables range checking.
Syntax:    {$R+} or (*$R+*) or {$R-} or (*$R-*)
Notes:
see the 'r' option in the Compiler options list for more information.

		 ------------------------------

Directive: '$S'
Purpose:   Enables/disabled strict checking of var string parameters.
Syntax:    {$S+} or (*$S+*) or {$S-} or (*$S-*)
Notes:
see the 's' option in the Compiler options list for more information.

		 ------------------------------

Directive: '$U'
Purpose:   Enables/disables checking for undefined values.
Syntax:    {$U+} or (*$U+*) or {$U-} or (*$U-*)
Notes:
see the 'u' option in the Compiler options list for more information.

		 ------------------------------

Directive: '$V'
Purpose:   Enables/disables variant checking.
Syntax:    {$V+} or (*$V+*) or {$V-} or (*$V-*)
Notes:
see the 'v' option in the Compiler options list for more information.

		 ------------------------------

Directive: '$W'
Purpose:   Enables/disables warning messages.
Syntax:    {$W[nn]+} or (*$W[nn]+*) or {$W[nn]-} or (*$W[nn]-*)
Notes:
Use $W+ to enable all warning messages.
Use $W- to disable all warning messages.
Use $WnnWnn+ to enable warning message number nn.
Use $Wnn- to disable warning message number nn.

		 ------------------------------

--------------------
4.0 Running programs
--------------------
You run programs using the Irie Pascal Interpreter (referred to as
"the Interpreter"). The Interpreter should be run from a command-line
prompt.

To go to a command-line prompt you do one of the following:
   If you are running Windows NT 3.51 then double click on the
	 MS-DOS prompt icon in the main program group.
   If you are running Windows 95 or Windows NT 4.0 then
	  a) Click on start
	  b) Select "programs"
	  c) Select "Command prompt"

Once you are at a command-line prompt use the following syntax
Syntax: ivm [filename] [arguments]
 where
   filename      specifies the Irie Virtual Machine Executable to run.
 and
   [arguments]   are program arguments passed to the executable.
NOTE: [x] indicates that x is optional.

For example if you compile the sample "hello.pas" program, the Compiler
will generate a file called "hello.ivm" which contains an
Irie Virtual Machine Executable. You can run it by entering
"ivm hello" or "ivm hello.ivm".

-----------------------------------------------------
5.0 Extensions to Pascal as specified by ISO/IEC 7185
-----------------------------------------------------
Irie Pascal supports a number of extensions to Standard Pascal.
Some of these extensions were added for compatibility with Turbo Pascal and
Extended Pascal, while others were added because I thought they might be
useful.

Most extensions can be enabled/disabled using compiler options.

---------------------------
5.1    Relaxed declarations
---------------------------
Standard Pascal requires that all declarations/definitions of the same
kind must be made together in a single group and that the groups must
appear in a specific order. The order required by Standard Pascal is:
   Label declaration group
   Constant definition group
   Type definition group
   Variable declaration group
   Function/Procedure declaration group

When "relaxed declarations" is enabled there can be more than one of each
kind of group and groups can appear in any order except that the
Function/Procedure group must be last.

So if "relaxed declarations" is enabled then the following program is legal,

   program summing(output);
   const
	  first = 1;
	  last = 100;
   type
	  num = first..last;
   var
	  i : num;
   type
	  atype = array[first..last] of integer;
   var
	  a : atype;
	  sum : integer;
   begin
	  sum := 0;
	  for i := first to last do
	 begin
		sum := sum + i;
		a[i] := sum
	 end;
	  for i := last downto first do
	 writeln(i, a[i]);
   end.

even though it has two type definition groups
  "type num = first..last;"
and
  "type atype = array[first..last] of integer;"
and two variable declaration groups
  "var i : num;"
and
  "var a : atype; sum : integer;"

In Standard Pascal or with "relaxed declarations" disabled you would have to
combine these groups so you would have the following

   program summing(output);
   const
	  first = 1;
	  last = 100;
   type
	  num = first..last;
	  atype = array[first..last] of integer;
   var
	  i : num;
	  a : atype;
	  sum : integer;
   begin
	  sum := 0;
	  for i := first to last do
	 begin
		sum := sum + i;
		a[i] := sum
	 end;
	  for i := last downto first do
	 writeln(i, a[i]);
   end.

"Relaxed declarations" can be enabled/disabled using the 'erd' compiler
option.

----------------------
5.2    Constant ranges
----------------------
You can use constant ranges to specify a number of consecutive case
constants.
To use a constant range you specify the first constant, and the last
constant, separated by '..' as follows:
   first..last

You could use the constant range
   1..5
to specify the following constants
   1, 2, 3, 4, 5

For example suppose 'c' is a char variable and you want to use a
case statement to write the word 'Letter' if 'c' contains a letter, and  the
word 'Digit' if 'c' contains a digit, then you could specify each constant
individually as follows:

   case c of
	  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
	  'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
	  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
	  'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
	 : write('Letter');
	  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
	 : write('Digit');
   end;

Or you could use constant ranges like the following:

   case c of
	  'a'..'z', 'A'..'Z'
	 : write('Letter');
	  '0'..'9'
	 : write('Digit');
   end;

Constant ranges can be used in case statements, like the example above, 
and in variant records.
  
Support for constant ranges can be enabled/disabled using the 'ecr'
compiler option.

----------------
5.3    Otherwise
----------------
You can use the keyword 'otherwise' in case statements and variant records
to specify "all values that haven't been specified yet".

For example in the following variant record

   type
	  character = record
	 case c : char of
	 'a'..'z', 'A'..'Z'
		: (vowel : Boolean);
	 '0'..'9'
		: (value : integer);
	 otherwise
		: ();
	  end;

when 'otherwise' is used, the following values have already been specified
   'a'..'z', 'A'..'Z', and '0'..'9'
so otherwise specifies all character values except
   'a'..'z', 'A'..'Z', and '0'..'9'

Support for otherwise can be enabled/disabled using the 'eoth'
compiler option.

---------------------------------------
5.4    Relaxed parameter list congruity
---------------------------------------
Standard Pascal says the following parameter lists
   (VAR a, b : integer)
and
   (VAR c : integer; VAR d : integer)
are not congruous even though the individual parameters are congruous
because Standard Pascal compares formal parameter sections.
So in the example above the parameter lists are not congruous for two
reasons:
1) The first parameter list has one formal parameter section
	  'VAR a, b : integer'
   while the second parameter list has two formal parameter section
	  'VAR c : integer' and 'VAR d : integer'
2) The individual parameter sections are not congruous
  (i.e.. 'VAR a, b : integer' is not congruous with 'VAR c : integer')

Irie Pascal checks for parameter list congruity by comparing the
individual parameters without regard to the formal-parameter-sections.
So the example above would be considered congruous since
   'a' and 'c' are both integer variable parameters
and
   'b' and 'd' are both integer variable parameters

Parameter list congruity becomes important when passing functions/procedures
since the parameter list of the actual function/procedure parameter must be
congrous with the parameter list of the corresponding formal
function/procedure parameter.

Relaxed parameter list congruity can not be disabled.

-----------------------------------
5.5    Non-numeric statement labels
-----------------------------------
Irie Pascal supports non-numeric statement labels.

For example in the following program 'loop' is used as a statement label.

   program name(output);
   label loop;
   var
   i : integer;
   begin
	  i := 1;
	  loop:
	  writeln(i);
	  i := i + 1;
	  if i <= 20 then goto loop;
   end.

Support for non-numeric statement labels can be enabled/disabled using the
'enn' compiler option.

---------------------------------
5.6    Underscores in identifiers
---------------------------------
Irie Pascal supports identifiers which contain and/or start with
underscores ('_').

Support for underscores in identifiers can be enabled/disabled using the
'eus' compiler option.

-------------------------------
5.7    Binary integer constants
-------------------------------
Binary integer constants begin with '%', and are followed by one or
more binary digits.

The following are examples of valid binary constants
   %0   %1      %01110101010101010111101

The following are not valid binary constants
   %2    %      %151       %g

Support for binary integer constants can be enabled/disabled using the
'eb' compiler option.

------------------------------------
5.8    Hexadecimal integer constants
------------------------------------
Hexadecimal integer constants begin with '$', and are followed by one or
more hexadecimal digits.

The following are examples of valid hexadecimal integer constants
   $9   $A123      $ffff

The following is not a valid hexadecimal integer constant
   $abgd
since 'g' is not a hexadecimal integer constants.

Support for hexadecimal integer constants can be enabled/disabled using the
'eh' compiler option.

-----------------------------------------------
5.9    Input and Output automatically declared.
-----------------------------------------------
Standard (ISO/IEC 7185) Pascal specifies that whenever the required
identifiers 'Input' and 'Output' are referenced in a program that they
must by declared (i.e. appear as program parameters). However because
some Pascal compilers do not enforce this requirement many Pascal programs
do not meet this specification. In order to allow Irie Pascal to compile
these programs without requiring the user to insert Input and Output
in the program parameter list, I decided that by default Irie Pascal
should automatically declare Input and Output.

Support for automatic declaration of Input and Output can be
enabled/disabled using the 'eio' compiler option.

-----------------------------
5.10   Double-quoted literals
-----------------------------
You can use double quotation marks to form character and string literals.

For example you could use
   "Hello world"
instead of
   'Hello world'

Double-quoted literals can be useful if you want to create literals with
single quotes in them since you don't have to use two single quotes to
represent one single quote.

For example you could use
   "Don't go away"
which is equivalent to
   'Don''t do away'

Support for double-quoted literals can be enabled/disabled using the
'edq' compiler option.

------------------------
5.11   and_then operator
------------------------
The 'and_then' operator is similiar to the 'and' operator except that
short-circuit evaluation is always used for 'and_then' regardless of
the setting of the 'sc' compiler option.

See the 'sc' compiler option for more information on short-circuit
evaluation.

Support for the 'and_then' operator can be enabled/disabled using the 'eat'
compiler option.

-----------------------
5.12   or_else operator
-----------------------
The 'or_else' operator is similiar to the 'or' operator except that
short-circuit evaluation is always used for 'or_else' regardless of
the setting of the 'sc' compiler option.

See the 'sc' compiler option for more information on short-circuit
evaluation.

Support for the 'or_else' operator can be enabled/disabled using the 'eoe'
compiler option.

-------------------
5.13   shl operator
-------------------
The 'shl' operator performs a left bit-shift, and returns the result of
this bit-shift. The left operand is the integer to be shifted, and the
right operand, which is also an integer, specifies the number of bits
to shift.

For example
	4 shl 2
is equal to 16, since 4 shifted left by 2 bits is 16.

Support for the 'shl' and the 'shr' operators can be enabled/disabled using
the 'esh' compiler option.

-------------------
5.14   shr operator
-------------------
The 'shr' operator performs a right bit-shift, and returns the result of
this bit-shift. The left operand is the integer to be shifted, and the
right operand, which is also an integer, specifies the number of bits
to shift.

For example
	4 shr 2
is equal to 1, since 4 shifted right by 2 bits is 1.

Support for the 'shl' and the 'shr' operators can be enabled/disabled using
the 'esh' compiler option.

-------------------------
5.15   Extended constants
-------------------------
Irie Pascal defines one of extended constant
(i.e. a built-in constant that is not a part of Standard Pascal).

-----------------
5.15.1    maxchar
-----------------
Irie Pascal defines 'maxchar' which is a built-in character constant,
whoose value is the maximum character value allowed.

Syntax: maxchar

'maxchar' can be enabled/disabled using the 'emc' compiler option.

---------------------
5.16   Extended types
---------------------
Irie Pascal defines a number of extended types
(i.e. built-in types that are not a part of Standard Pascal).

------------------
5.16.1    filename
------------------
Irie Pascal defines a type identifier called 'filename' which is the
string type most suitable for variables used to store filenames.

Syntax: filename

For example to declare a variable to store filenames use
var
   name : filename;

NOTE: You can also use string types such as
var
   name : packed array[1..N] of char;
or
   name : string;

But I recommend you use 'filename' since this type is will always be
the most suitable type for storing filenames.

'filename' can be enabled/disabled using the 'efn' compiler option.

--------------
5.16.2    list
--------------
Irie Pascal defines a new keyword 'list' in order to provide support
for lists. To create a list type use the syntax below.

Syntax: [packed] list of Type
where
   'Type' is the type of the components in the list.

If you use 'packed' then the list is likely to be more efficient in
terms of memory but less efficient in terms of speed.

You must use 'new' to initialize a list variable before you use it.
The syntax is:
	new(list-variable)

You can use 'dispose' to release the memory used by a list variable
after you have finished with it. The syntax is:
	dispose(list-variable)

You can use 'insert' to add components to a list variable.
The syntax is:
	insert(component, list-variable [, p])
where
	'component' is an expression which is assignment compatible with the
	  type of the list components.
	'list-variable' is the list variable to which the component is to be
	  added.
	'p' is an integer expression specifying the position in the list
	  at which to add the component. The valid values of 'p' are 1..N+1
	  where N is the number of components in the list variable.
	  If 'p' is not specified then the position used for the insertion
	  is N+1 (i.e. 'component' is appended at the end of the list).

If 'p' is between 1 and N then the component already at position 'p' is
not overwritten, instead the components at positions 'p' thru N are moved
down one position to make room for the new component.
If 'p' is equal to N+1 then 'component' is appended at the end of the list. 
If 'p' > N+1 or 'p' < 1 then a run-time diagnostic message is displayed
and your program is stopped.


You can use 'delete' to remove components from a list variable.
The syntax is:
	delete(lv, p [, count])
where
	'lv' is the list variable from which the components are to be removed.
	'p' is an integer expression specifying the position in the
	  list variable 'lv', from which to remove the components. The valid
	  values of 'p' are 1..N where N is the number of components in the
	  list variable 'lv'.
	'count' is an integer expression specifying the number of components to
	  remove. If 'count' is not specified, or count is greater than the number
	  of components in the list from position 'p' to the end, then all the
	  components from position 'p' to the end are removed.

You can use the 'length' function to determine the number of components in a
list variable. The syntax is
	 length(list-variable)

Length is a function that takes as its only argument a list variable and
returns an integer value equal to the number of components in the list
variable.

You can access the components of a list variable just like an array
variable. The syntax is
	 lv '[' p ']'
where
	 'lv' is the list variable being accessed
	 'p' is the position of the component being accessed
For example if 'i' is an integer and 'lv' is a list variable the
statement below will write each component of 'lv'.
	 for i := 1 to length(lv) do
	writeln(lv[i])

List types can be enabled/disabled using the 'el' compiler option.

----------------
5.16.3    string
----------------
Standard Pascal considers packed arrays of char with a lower bound of 1 to
be strings. However these are fixed length strings (i.e.. the only text that
can be assigned to these strings is text of exactly the same length as the
length of the array).

Irie Pascal supports variable length strings using a new type 'string'.
To create variable length string types use the syntax below.

Syntax: string
	or  string[max]
	or  string(max)
where
   max is an integer constant, between 1 and 255, which specifies the maximum
	   length of the string.
   If max is not specified the maximum length used is 255.

For example to create a variable length string type called 'name' with
a maximum length of 80 use
   name = string[80];
or
   name = string(80);
To create a variable length string type called 'address' with a maximum length
of 255 use
   address = string;
or
   address = string[255];
or
   address = string(255);

The advantage of variable length strings is that any string can be assigned
to them, whether fixed or variable length, as long as the length of the
string being assigned does not exceed the string's maximum length.
Even characters can be assigned to variable length strings.

You can use the '+' operator to perform string concatenation.
For example here is a hello world program using string concatenation.

   program good(output);
   begin
	  writeln('hello' + ' ' + 'world' + '!')
   end.

See "Extended functions" and "Extended procedures" for information the
functions and procedures that can be used with the 'string' type.

The string type can be enabled/disabled using the 'es' compiler option.

-------------------------
5.17   Extended variables
-------------------------
Irie Pascal defines one extended variable
(i.e. a built-in variable that is not a part of Standard Pascal).

------------------
5.17.1    exitcode
------------------
Irie Pascal defines 'exitcode' which is a built-in integer variable,
whoose value is returned to the calling program when your program exits.

Syntax: exitcode

For example suppose you want to return a value of 1 from your program
(perhaps to indicate that your program detected an error) then you can
use the following code

   exitcode := 1;
   halt;

NOTE: You can treat 'exitcode' like any other integer variable
(i.e. you can assign to it, use it in an expression, pass it as an
argument to a function, etc).

'exitcode' can be enabled/disabled using the 'ev' compiler option.

-------------------------
5.18   Extended functions
-------------------------
Irie Pascal defines a number of extended functions
(i.e. built-in functions that are not a part of Standard Pascal).

Extended functions can be enabled/disabled using the 'ef' compiler option.

----------------
5.18.1    concat
----------------
Syntax: concat(s1, ..., sN)
	where N is the number of string/character parameters.
Purpose: Creates a string by concatenating its parameters.
Returns: The concatenated string.
Notes:
For example you could do something like
   message := concat('Hello', ' ', 'world', '!');
to make message equal to 'Hello world!'

---------------
5.18.2    copy
---------------
Syntax: copy(strg, start [, N])
   where 'strg' is a string/char value
   and 'start' is an integer value
   and 'N' is an integer value.
Purpose: Creates a string by copying 'N' characters in 'strg' starting from
	 position 'start'. If 'N' is omitted, or is greater than the number
	 of characters in 'strg' from 'start' to the end, then all the
	 characters in 'strg' starting from 'start' to the end are copied.
Returns: The created string.
Notes:
For example
	copy('Testing...', 5, 2)    is equal to 'in'
and
	copy('Testing...', 7)       is equal to 'g...'
and
	copy('Testing...', 1, 1000) is equal to 'Testing...'

---------------
5.18.3    cosh
---------------
Syntax: cosh(x)
   where 'x' is an integer or real value.
Purpose: Returns the hyperbolic cosine of 'x'
Notes:
This function always returns a real value even if 'x' is an integer.

-----------------
5.18.4    FilePos
-----------------
Syntax: FilePos(f)
   where 'f' is a file variable.
Purpose: Returns the value of the file position indicator of 'f'.
Notes:
This function returns an integer value.
The file variable 'f' must be open.
For a text file variable the value of the file position indicator may
not be equal to the number of characters read/written so far.
For a binary file the value of the file position indicator is equal to
the number of characters read/written so far.

------------------
5.18.5    FileSize
------------------
Syntax: FileSize(f)
   where 'f' is a file variable.
Purpose: Returns the size of the 'f'.
Notes:
This function returns an integer value.
The file variable 'f' must be open.
This function is currently implemented by saving the current file position
indicator, then seeking to the end of the file, then calling 'filepos' and
saving the result of this call, and finally seeking back to the saved
file position. One problem with this implementation is that it may not
be accurate for text files. However this implementation was chosen because
it is portable.

--------------
5.18.6    frac
--------------
Syntax: frac(x)
   where 'x' is a real value.
Purpose: Returns the fractional part of 'x'.
Notes:
For example frac(7.234) is equal to .234 .
This function returns a real value.

----------------
5.18.7    GetEnv
----------------
Syntax: GetEnv(s)
   where 's' is a string/char value.
Purpose: Searches the program's environment list for a string that matches
	 's'.
Notes:
If a string matching 's' can not be found in the environment list then an
empty string is returned.

-------------
5.18.8    hex
-------------
Syntax: hex(i)
	where 'i' is an integer value.
Purpose: Returns a string equal to the hexadecimal representation of 'i'.
Notes:
For example hex(16) is equal to '10'.

-------------
5.18.9    int
-------------
Syntax: int(x)
   where 'x' is a real value.
Purpose: Returns the integer part of 'x'.
Notes:
For example int(7.234) is equal to 7 .
This function returns a real value.

-------------------
5.18.10    IOResult
-------------------
Syntax: IOResult
Purpose: Returns the error code of the last input/output operation.
Notes:
By default (when I/O checking is enabled) your program automatically
checks for errors after each I/O operation and terminates with an error
message if any errors are detected. If you do not want this default
behaviour you can disable I/O checking (either globally using the 'i'
compiler option or locally using the 'i' compiler directive) and call
this function to determine if any I/O errors occurred.
The error codes returned by this function are given in Appendix F
(0 means no error occurred).
This function resets the error code to zero after it is called, so if you
call this function twice after an I/O operation then the second call
will always return 0. If you need to refer to the error code more than once
you can save the error code into a variable.
For example:
   errcode := IOResult;
   if errcode <> 0 then
	   case errcode of
	1: writeln('Error erasing file');
	2: writeln('Error renaming file');
	3: writeln('File is undefined')
	   end

See also the 'i' compiler option and the '$I' compiler directive.

-----------------
5.18.11    length
-----------------
Syntax: length(l) | length(s)
   where 'l' is a list variable
   and   's' is a string/char variable
Purpose: Returns the length of the list 'l' or the string 's'.
Notes:

--------------
5.18.12    log
--------------
Syntax: log(x)
   where 'x' is an integer or real value.
Purpose: Returns the base-ten logarithm of 'x'.
Notes:

-----------------
5.18.13    locase
-----------------
Syntax: locase(c)
   where 'c' is a character value.
Purpose: Returns the lowercase letter corresponding to 'c'.
	 If there is no lowercase letter corresponding to 'c' then
	 'c' is returned.
Notes:

--------------------
5.18.14    lowercase
--------------------
Syntax: lowercase(s)
   where 's' is a string value.
Purpose: Returns a string equal to 's' with all of it's uppercase letters
	 converted to lowercase letters.
Notes:

---------------------
5.18.15    paramcount
---------------------
Syntax: paramcount
Purpose: Returns the number of arguments passed to the program.
Notes:
For example the following is the sample program 'args.pas'.

   program args(output);
   begin
	  writeln('Number of program arguments =', paramcount)
   end.

If you compile it and run it as follows
	ipc args
	ivm args this is a test
then the output would be
	Number of program arguments = 4

-------------------
5.18.16    paramstr
-------------------
Syntax: paramstr(i)
   where 'i' is an integer value.
Purpose: Returns the ith program argument as a string.
Notes:
If there is no ith program argument an empty string is returned.

-------------
5.18.17    pi
-------------
Syntax: pi
Purpose: Returns the approximate value of the mathematical constant 'pi'
Notes:

--------------
5.18.18    pos
--------------
Syntax: pos(needle, haystack [, start])
   where 'needle' is a string/char value
   and   'haystack' is a string/char value
   and   'start' in an integer value
Purpose: Search for 'needle' in 'haystack' starting at position 'start'
	 and returns 0 if 'needle' is not found or returns the position
	 of 'needle' in 'haystack'. If 'start' is omitted then the search
	 begins at position 1. If 'start' is greater than the length of
	 'haystack' then 0 is returned.
Notes:
   pos('o', 'Hello world')    is equal to 5
   pos('o', 'Hello world', 1) is equal to 5
   pos('o', 'Hello world', 6) is equal to 8
   pos('o', 'Hello world', 256) is equal to 0

-----------------
5.18.19    random
-----------------
Syntax: random [ (i) ]
	where 'i' is an integer value.
Purpose: Returns a psuedo-random number.
Notes:
If 'i' is not specified then random returns a psuedo-random real value
between 0 and 1.
If 'i' is specified then random returns a psuedo-random integer value
between 1 and 'i'-1.
See also the randomize procedure.

------------------
5.18.20    reverse
------------------
Syntax: reverse(s)
   where 's' is a string/char value.
Purpose: Returns a string created by reversing the characters in 's'.
Notes:
For example
	reverse('Hello')    is equal to 'olleH'

---------------
5.18.21    sinh
---------------
Syntax: sin(x)
   where 'x' is an integer or real value.
Purpose: Returns the hyperbolic sine of 'x'
Notes:
This function always returns a real value even if 'x' is an integer.

---------------
5.18.22    swap
---------------
Syntax: swap(i)
   where 'i' is an integer value.
Purpose: Returns an integer value calculated by reversing the byte ordering
	 in 'i'.
Notes:
For example assuming 32 bit little endian integers then 256 is stored in
four bytes as follows:

   0 0 1 0

So swap(256) results in the following integer:

   0 1 0 0

which is equal to 65536

-----------------
5.18.23    system
-----------------
Syntax: system(s)
	where 's' is a string value.
Purpose: Passes 's' to the command processor, which will attempt to process
	 's' as a command.
Notes:
If there is an error then 'system' returns a non-zero value indicating
the kind of error.
If there is no error then 'system' returns zero.

See also the 'exec' procedure.

For example the sample program 'batch.pas' below is a very primitive
batch processor. It sends each line in the input file to the command
processor to be executed.

   program batch(f, output);
   var
	  f : text;
	  s : string;
	  err : integer;
   begin
	  reset(f);    (* open input file or standard input file *)
	  while not eof(f) do
	 begin
		readln(f, s);
		writeln('Executing ', s);
		err := system(s);      (* Pass 's' to the command processor *)
		writeln('Error code is ', err)
	 end
   end.

---------------
5.18.24    trim
---------------
Syntax: trim(s)
   where 's' is a string value.
Purpose: Returns a string equal to 's' with no leading or trailing spaces.
Notes:
For example
	trim(' hello ') is equal to 'hello'

-----------------
5.18.25    upcase
-----------------
Syntax: upcase(c)
   where 'c' is a character value.
Purpose: Returns the uppercase letter corresponding to 'c'.
	 If there is no uppercase letter corresponding to 'c' then
	 'c' is returned.
Notes:

--------------------
5.18.26    uppercase
--------------------
Syntax: uppercase(s)
   where 's' is a string value.
Purpose: Returns a string equal to 's' with all of it's lowercase letters
	 converted to uppercase letters.
Notes:


--------------------------
5.19   Extended procedures
--------------------------
Irie Pascal defines a number of extended procedures
(i.e. built-in procedures that are not a part of Standard Pascal).

Extended procedures can be enabled/disabled using the 'ep' compiler option.

----------------
5.19.1    append
----------------
Syntax: append(f)
   where 'f' is a file variable.
Purpose: Opens the file variable 'f' for writing at the end of file.
Notes:
All writes will occur at the end of the file regardless of calls to 'seek'.

----------------
5.19.2    assign
----------------
Syntax: assign(f, name)
	where 'f' is a file variable.
	and   'name' is a string value
Purpose: Associates 'name' with the file variable 'f'.
Notes:
The file variable 'f' must be closed.

For example to open a file named 'README.TXT' for reading use
	assign(f, 'README.TXT');
	reset(f);
where 'f' is a file variable.

You can't use this function to rename a file, use the 'rename' procedure
if you want to do that.

---------------
5.19.3    close
---------------
Syntax: close(f)
   where 'f' is a file variable.
Purpose: Flushes and then closes the file variable 'f'.
Notes:

-------------
5.19.4    dec
-------------
Syntax: dec(o [, amount])
   where 'o' is an ordinal variable
   and amount is an integer value.
Purpose: Decrements 'o' by 'amount' or by one if 'amount' is omitted.
Notes:
Using this function is slightly more efficient than using
	o := o - amount;

----------------
5.19.5    delete
----------------
Syntax: delete(s, start [, count]) | delete(l, start [, count])
   where 's' is a string variable
   and   'l' is a list variable
   and   'start' is an integer value
   and   'count' is an integer value
Purpose: Deletes 'count' components from a list or string.
	 'start' specifies the position at which to perform the deletion.
	 'count' specifies the number of components to delete.
	 If 'count' is omitted all the components from 'start' to the
	 end are deleted.
Notes:

-----------------
5.19.6    dispose
-----------------
Syntax: dispose(l)
   where 'l' is a list variable.
Purpose: Releases the memory allocated for 'l' and makes 'l' undefined.
Notes:
The use of 'dispose' with pointer variables is part of Standard Pascal
and while supported by Irie Pascal is not covered in this guide.

---------------
5.19.7    erase
---------------
Syntax: erase(f)
   where 'f' is a file variable.
Purpose: Erases the file associated with 'f'.
Notes:
'f' must be closed and must have a name associated with it (either using
the 'assign' procedure or by being one of the program arguments.

--------------
5.19.8    exec
--------------
Syntax: exec(p, a)
   where 'p' and 'a' are string values.
Purpose: Executes the program specified by 'p' and passes 'a' as it's program
	 argument(s). The return code from 'p' is stored in the built-in
	 integer variable 'ExitCode'.
Notes:
For example here is the sample program 'dirpas.pas'.
	program dirpas(output);
	begin
	   exec('dir', '*.pas');
	   if exitcode <> 0 then
	  writeln('Error listing directory', exitcode)
	end.

--------------
5.19.9    exit
--------------
Syntax: exit [ (x) ]
   where 'x' is a value.
Purpose: Terminates the function/procedure/program in which it is used,
	 and returns 'x' if 'x' is specified.
	 If used in a function then 'exit' terminates the function.
	 If used in a function named 'f' then 'exit(x)' is equivalent to
		  f := x;
		  exit
	 If used in a procedure then 'exit' terminates the procedure.
	 If used in a procedure then 'exit(x)' is an error since you can
		not return a value from a procedure.
	 If used not in a function or procedure but in the main program
		then 'exit' terminates the program.
	 If used not in a function or procedure but in the main program
		then 'exit(x)' is equivalent to:
		  ExitCode := x;
		  exit
		 (i.e. the program is terminated with 'x' as the exit code).
Notes:
See also 'halt'

----------------
5.19.10    flush
----------------
Syntax: flush(f)
   where 'f' is a file variable.
Purpose: Flushes the file associated with 'f' (i.e.. all data waiting to
	 be written to the file is written).
Notes:
The file associated with 'f' must be open.

------------------
5.19.11    GetDate
------------------
Syntax: GetDate(year, month, day, day_of_week)
   where 'year', 'month', 'day', 'day_of_week' are integer variables.
Purpose: Retrieves the current system date into the four integer variables.
	 'month' = 1 to 12
	 day = 1 to 31
	 day_of_week = 0 to 6 counting from Sunday
Notes:
Suppose the current system date is Saturday September 6, 1997 then after
	GetDate(year, month, day, day_of_week)
	year = 1997
	month = 9
	day = 6
	day_of_week = 6

------------------
5.19.12    GetTime
------------------
Syntax: GetTime(hour, minute, second)
   where 'hour' is an integer variable
   and   'minute' is an integer variable
   and   'second' is an integer variable.
Purpose: Retrieves the current system time into the three integer variables.
	 'hour' = 0 thru 23
	 'minute' = 0 thru 59
	 'second' = 0 thru 61
Notes:

---------------
5.19.13    halt
---------------
Syntax: halt [ (i) ]
   where 'i' is an integer value.
Purpose: Terminates the program and if 'i' is specified returns 'i' as
	 the program's exit code.
Notes:

--------------
5.19.14    inc
--------------
Syntax: inc(o [, amount])
   where 'o' is an ordinal variable
   and amount is an integer value.
Purpose: Increments 'o' by 'amount' or by one if 'amount' is omitted.
Notes:
Using this function is slightly more efficient than using
	o := o + amount;

-----------------
5.19.15    insert
-----------------
Syntax: insert(x, s, position) or insert(v, l, position)
   where 'x' is a string or char value
   and   's' is a string variable
   and   'position' is an integer value
   and   'v' is a value
   and   'l' is a list variable.
Purpose: Inserts 'x' into 's' at 'position' or
	 inserts 'v' into 'l' at 'position'.
Notes:
'v' must be assignment compatible with the component type of the list 'l'.

--------------
5.19.16    new
--------------
Syntax: new(l)
   where 'l' is a list variable.
Purpose: Initializes the list 'l'.
Notes:
The use of 'new' with pointer variables is part of Standard Pascal
and while supported by Irie Pascal is not covered in this guide.

--------------------
5.19.17    randomize
--------------------
Syntax: randomize[ (i) ]
   where 'i' is an integer value.
Purpose: Seeds the random number generator with 'i'. If 'i' is omitted
	 the random number generator is seeded with a value derived from
	 the current system time and date.
Note:
Specifying 'i' is useful if you want a repeatable sequence of random
numbers.

------------------
5.19.18    RawRead
------------------
Syntax: RawRead(f, buffer, count, actual)
   where 'f' is a file variable
   and   'buffer' is a packed array of char variable
   and   'count' is an integer value
   and   'actual' is an integer variable.
Purpose: Reads up to 'count' characters from the file associated with
	 'f' into 'buffer' and returns the actual number of characters
	 read in 'actual'.
Notes:
After calling RawRead 'actual' may be less than 'count' if there was
an I/O error (you can check for this by disabling I/O checking and using
the IOResult function) or if end of file was reached.

-------------------
5.19.19    RawWrite
-------------------
Syntax: RawWrite(f, buffer, count, actual)
   where 'f' is a file variable
   and   'buffer' is a packed array of char variable
   and   'count' is an integer value
   and   'actual' is an integer variable.
Purpose: Writes up to 'count' characters from 'buffer' to the file
	 associated with 'f' into 'buffer' and returns the actual number of
	 characters written in 'actual'.
Notes:
After calling RawWrite 'actual' may be less than 'count' if there was
an I/O error (you can check for this by disabling I/O checking and using
the IOResult function).

-----------------
5.19.20    rename
-----------------
Syntax: rename(f, name)
	where 'f' is a file variable
	and  'name' is a string/char expression.
Purpose: Renames the file associated with 'f' to 'name'
Notes:
The file associated with 'f' must be closed.

---------------
5.19.21    seek
---------------
Syntax: seek(f, offset)
   where 'f' is a file variable
   and  'offset' is an integer value.
Purpose: Sets the position indicator for the file associated with 'f'.
Notes:
The file associated with 'f' must be open.

--------------
5.19.22    str
--------------
Syntax:
   str(i [:width], s)
or
   str(r [:width[:frac]], s)

   where 'i', 'width', and 'frac' are integer expresions
   and   'r' is a real expression
   and   's' is a string variable
Purpose: Converts 'i' or 'r' into a string value and assigns this value to s.
	 'width' specifies the minimum width of the string value.
	 If 'width' is ommited then eight is assumed for integer conversion
	   and nine is assumed for real conversions.
	 The string value is padded on the left if necessary.
	 'frac' specifies the number of digits after the decimal point.
	 if 'frac' is ommited then the real exression is converted into a
	   string in exponential form.
	 if 'frac' is present then the real expression is converted into
	   a string in fixed form.
	 For example
		 str(1034:6, s) will store '  1034' in 's'
		 str(3.1:8, s) will store '3.1E+001' in 's'
		 str(-3.14:6:2, s) will store ' -3.14' in 's'

		 ------------------------------

--------------
5.19.23    val
--------------
Syntax: val(s, v, offset)
   where 's' is a string/char value
   and   'v' is a numeric (i.e.. integer, real or a subrange) variable
   and  'offset' is an integer variable.
Purpose: Converts 's' into a numeric value of the same type as 'v'
	 and returns in 'offset' the position in 's' of the first
	 character which could not be converted.
	 If all of 's' could be converted then val sets 'offset' to zero.
Notes:
For example given integer variables 'i' and 'x' the following statement
	val('123EB', i, x)
will store 123 in 'i' and 4 in 'x'.

		 ------------------------------

--------------------------
6.0 Miscellaneous features
--------------------------

-------------------------
6.1    Program parameters
-------------------------
Program parameters are are identifiers which appear after the program name
(placed between parentheses). In addition to appearing after the program
name, most program parameters must also appear in a global variable
declaration. Two special program parameters 'input' and 'output' are
the exceptions to this rule. The appearance of the two special program
parameters, after the program name, automatically declares them as two
special file variables which reference the standard-input and
standard-output streams.

You can use program parameters to access command-line arguments passed to
your program (see also extended procedures 'paramcount' and 'paramstr'). For
example suppose you want to write a program to append two files together,
writing the appended files to a third file, then you might write a program
similiar to the sample program below.

   (**********************************************************************
   ** This program appends two files together, writing the appended files
   ** out to a third file.
   *)
   program append(in1, in2, out, output);
   type
	  char_file = file of char;
   var
	  in1 : char_file;     (* first input file *)
	  in2 : char_file;     (* second input file *)
	  out : char_file;     (* output file *)

	  (***************************************************************
	  ** PURPOSE: Writes copies the contents of one file into another.
	  ** ARGUMENTS:
	  **    'f' - the input file
	  **    'g' - the output file
	  ** NOTES: It is up to the caller to open and close the files.
	  *)
	  procedure WriteFile(var f, g: char_file);
	  var
	 c : char;
	  begin
	 while not eof(f) do
		begin
		   read(f, c);
		   write(g, c)
		end
	  end;

	  (**********************************************
	  ** PURPOSE: Writes a help screen and then halts
	  *)
	  procedure syntax;
	  begin
	 writeln('Appends two files together and writes the output to a third file');
	 writeln('Syntax');
	 writeln('   ivm append in1 in2 out');
	 writeln('where "in1" is the first input file');
	 writeln('and   "in2" is the second input file');
	 writeln('and   "out" is the output file');
	 halt
	  end;

   begin
	  if paramcount <> 3 then
	 syntax;
	  rewrite(out);
	  reset(in1);
	  WriteFile(in1, out);
	  close(in1);
	  reset(in2);
	  WriteFile(in2, out);
	  close(in2)
	  close(out);
   end.

The first thing to notice about this program is the line below:

   program append(in1, in2, out, output);

Here four program parameters are being used 'in1', 'in2', 'out', and 'output'.
The first program parameter 'in1' accesses the first command-line argument
The second program parameter 'in2' accesses the second command-line argument.
The third program parameter 'out' accesses the third command-line argument.
The fourth program parameter 'output' declares the special file variable
which references the standard-output stream, and has nothing to do with
command-line arguments. 'output' does not have to be the last program
parameter, it can be used in the first, or second or any position. Since
'output' does not access any command-line arguments it can appear in any
position (not just the fourth and last position) without disturbing the
command-line arguments accessed by the other program parameters. In other
words all of the following are equivalent

   program append(output, in1, in2, out);
or
   program append(in1, output, in2, out);
or
   program append(in1, in2, output, out);
or
   program append(in1, in2, out, output);

And in each of the four cases 'in1' accesses the first command-line argument
and 'in2' accesses the second command-line argument
and 'out' accesses the third command-line argument.

The second thing to notice about the program are the following lines.

   var
	  in1 : char_file;     (* first input file *)
	  in2 : char_file;     (* second input file *)
	  out : char_file;     (* output file *)

Here the program parameters (except for 'output') appear in global variable
declarations as required. They are declared to be variables of type
'char_file' which has been declared to be 'file of char'. Now since they are
declared to be file variables it means that the command-line arguments
accessed specify the names of the external files associated with the file
variables. What this means is that if the file variables are opened (using
'reset', 'rewrite', or 'append') then the external file which is opened is
the one specified by the command-line argument accessed.
For example if the program is run with the line

   ivm append x.txt y.txt a:\z.txt

then when 'in1' is opened the file 'x.txt' is opened
and when 'in2' is opened the file 'y.txt' is opened
and when 'out' is opened the file 'a:\z.txt' is opened.

The final thing to notice about the program are the following lines.

	  if paramcount <> 3 then
	 syntax;

These lines cause the procedure 'syntax' to be called if the number of
command-line arguments is not 3. These lines are intended to prevent
problems if the user does not enter 3 command-line arguments.

Suppose for example the this program was run with no command-line arguments.
The first program argument 'in1' will access the first command-line argument
which does not exist so the empty string will specify the external file
associated with this file variable. Similarly the empty string will specify
the external files associated with the file variables 'in2' and 'out'.

You might ask what happens if you open a file variable associated with an
external file specified by an empty string? Well if you open such a
file variable for reading (with 'reset') then the external file opened
is the standard input stream. If you open such a file for writing
(with 'rewrite') then the external file opened is the standard output
stream.

I didn't want this effect when I wrote the sample program above so I
inserted the lines

	  if paramcount <> 3 then
	 syntax;

to avoid this.

So far I have described how file-type program parameters are handled.
You can also use string-type program parameters. They also access the
command-line arguments, but in a different way. The command-line
argument accessed is simply assigned to the string-type program parameter.

If you use program parameters other than file-type or string-type then
the command-line argument is ignored. The compiler will issue a warning,
that the command-line argument has an invalid type, but otherwise do
nothing.

For example look at this rather strange program.

   program strange(f, s1, dummy, s2);
   var
	  f : text;
	  s1, s2 : string;
	  dummy : real;
   begin
	  rewrite(f);
	  writeln(f, s1);
	  writeln(f, s2)
   end.

If you compile it you will get some warnings but ignore them.
If you run the program with

   ivm strange out.txt first skip second

then the first program parameter 'f' will access 'out.txt', and since
'f' is a file-type program argument when 'rewrite' is used on 'f' the
file 'out.txt' will be created.
The second program parameter 's1' will access 'first', and since this
is a string-type program argument then 'first' will be assigned to 's1'.
The third program parameter 'dummy' is not a file-type or string-type
program parameter so the third command-line argument 'skip' will be
ignored.
The fourth program parameter 's2' will access 'second', and since this
is a string-type program argument then 'second' will be assigned to 's2'.

So the effect of the following three lines

	  rewrite(f);
	  writeln(f, s1);
	  writeln(f, s2)

is that a text file 'out.txt' is created and two lines are written to it.
The first line will be 'first' and the second will be 'second'.

-----------------------
6.2    Compatible types
-----------------------
Irie Pascal implements the type compatibility rules defined by Standard
Pascal (ISO/IEC 7185), and adds one more to support the new string type.
The first four rules below are taken from ISO/IEC 7185 and the last one
is the one added to support the new string type. In this section the term
'standard-string-type' refers to the string type defined by Standard Pascal
(i.e.. packed arrays of char with lower bounds of one). The term
'string-type' refers to the new string type implemented by Irie Pascal.

Types T1 and T2 shall be designated compatible if any of the following
statements is true:

1. T1 and T2 are the same type.

2. T1 is a subrange of T2, or T2 is a subrange of T1, or both T1 and T2 are
   subranges of the same host type.

3. T1 and T2 are set-types of compatible base-types, and either both T1 and
   T2 are designated packed or neither T1 nor T2 is designated packed.

4. T1 and T2 are standard-string-types with the same number of components.

5. Either T1 is a string-type and T2 is a string-type,
   or T1 is a string-type and T2 is a standard-string-type, and the number
	  of components in T2 is less than or equal to the maximum length of T1,
   or T1 is a string-type and T2 is the char-type
   or T2 is a string-type and T1 is a standard-string-type, and the number
	  of components in T1 is less than or equal to the maximum length of T2,
   or T2 is a string-type and T1 is the char-type.

-------------------------------
6.3    Assignment compatibility
-------------------------------
Irie Pascal implements the assignment compatibility rules defined by
Standard Pascal (ISO/IEC 7185), and adds one more to support the new
string type. The first five rules below are taken from ISO/IEC 7185 and
the last one is the one added to support the new string type. In this
section the term 'standard-string-type' refers to the string type defined
by Standard Pascal (i.e.. packed arrays of char with lower bounds of one).
The term 'string-type' refers to the new string type implemented by
Irie Pascal.

A value 'V' of type T2 is assignment compatible with a type T1 if any of
the following is true:

1. T1 and T2 are the same type, and that type is not a file type or a type
   which contains a file type.

2. T1 is the real-type and T2 is the integer-type.

3. T1 and T2 are compatible ordinal-types, and V is in the closed interval
   specified by T1.

4. T1 and T2 are compatible set-types, and all the members of V are in the
   closed interval specified by the base-type of T1.

5. T1 and T2 are standard-string-types with the same length.

6. T1 is a string-type and either
	  T2 is a string-type
   or T2 is a standard-string-type, and the length of
   or T2 is a char-type.
   In addition the length of V must not be greater then the maximum
   length of T1.

-------------------------------------------------------
6.3.1      Assignment compatibility with array indexing
-------------------------------------------------------
The value of an index-expression shall be assignment compatible with the
index-type of the array variable.

For example given:

   var x : array[1..10] of integer;

and

   x[i] := 20;

then 'i' (the value of the index-expression) shall be assignment compatible
with '1..10' (the index-type of the array variable).

---------------------------------------------------------
6.3.2      Assignment compatibility with value parameters
---------------------------------------------------------
When passing a parameter by value the actual-parameter shall be
assignment compatible with the type of the formal-parameter.

For example given:

   function IsDigit(c : char) : Boolean;
   begin
	  if c in ['0'..'9'] then
	 IsDigit := true
	  else
	 IsDigit := false
   end;

and

   while not IsDigit(key) do
	   read(key)

then 'key' (the actual-parameter in IsDigit(key) shall be
assignment compatible with 'char' (the type of the formal-parameter).

-----------------------------------------------
6.3.3      Assignment compatibility with 'read'
-----------------------------------------------
When using the built-in procedure 'read' to store an input value into
a variable the input value shall be assignment compatible with the type of
the variable to which it is stored.

For example given:

   var s : string[40];

and

   read(s);

then the value read in by 'read(s)' must be assignment compatible with
'string[40]'.

--------------------------------------------------------------
6.3.4      Assignment compatibility with assignment statements
--------------------------------------------------------------
The value of the expression on the right-hand side of an assignment statement
shall be assignment compatible with the type of the left-hand side (i.e..
either the variable or the function-identifier on the left-hand side).

For example given:

   var age : 0..100;

and

   age := v;

then 'v' (the right-hand side of the assignment statement) shall be
assignment compatible the '0..100' (the type of the left-hand side of the
assignment statement).

----------------------------------------------
6.3.5      Assignment compatibility with 'for'
----------------------------------------------
The initial value and the final value in a for-statement shall be
assignment compatible with the type of the control variable if the
statement of the for-statement is executed.

For example given:

   for i := low to high do writeln(i);

then 'low' (the initial value) and 'high' (the final value) shall be
assignment compatible with the type of 'i' (the control variable) if
'writeln(i)' is executed. NOTE: 'writeln(i)' will get executed unless
'low' is greater than 'high'.

------------------------------
6.3.6      Transfer procedures
------------------------------
In the statement pack(a,i,z) and unpack(z,a,i) the value of 'i' shall be
assignment compatible with the index-type of a.

For example given:

   var a : array[1..100] of real;
	   z : packed array[1..100] of real;
	   i : integer;

and

   pack(a,i,z) or unpack(z,a,i)

then 'i' shall be assignment compatible with '1..100'
(the index-type of 'a').

----------------------------------------
Appendix A. Deviations from ISO/IEC 7185
----------------------------------------

----------------------------------
A.1         end-of-line characters
----------------------------------
ISO/IEC 7185 requires that end-of-line characters read from text files
be converted to spaces. For example given

   read(f, c)
   where 'f' is a file at end-of-line
   and   'c' is a character variable

then according to ISO/IEC 7185, after the read above 'c' should contain
a space character rather than an end-of-line character.
Irie Pascal does not convert end-of-line characters read from text file,
so in the example above 'c' will contain an end-of-line character
(i.e.. a linefeed character, chr(10)).

-------------------------------------------------
A.2         Termination of all lines in text files
-------------------------------------------------
ISO/IEC 7185 requires that all lines in text files (except possibly the line
that is currently being written) should be terminated by an end-of-line.
Irie Pascal does not automatically terminate the last line in a text file.

--------------------------
A.3         new(p, c1..cN)
--------------------------
ISO/IEC 7185 requires support for a form of the required procedure 'new'
as follows:

   new(p, c1..cN)
   where 'p' is a pointer to a variant record and 'c1' thru 'cN' are
	 case constants which correspond to the variants in p^.

Irie Pascal does not currently support this form of 'new'.

------------------------------
A.4         dispose(q, k1..kM)
------------------------------
ISO/IEC 7185 requires support for a form of the required procedure 'dispose'
as follows:

   dispose(q, k1..kM)
   where 'q' is a pointer to a variant record and 'k1' thru 'kM' are
	 case constants which correspond to the variants in q^.

Irie Pascal does not currently support this form of 'dispose'.

---------------------------
A.5         Carriage return
---------------------------
ISO/IEC requires that all characters written to a file should appear when
the file is read (the exception to this is that implementations are allowed
to designate a set of characters 'prohibited from text files' and treat these
characters specially).

Irie Pascal does not currently comply fully with this requirement, since
currently carriage return characters do not appear when individual
characters are read from text files (i.e. carriage return/line feed pairs
are converted into a single line feed).

---------------------------------
Appendix B. Implementation limits
---------------------------------
Irie Pascal imposes various limits on the size and complexity of programs
that it will process. These limits have been set fairly high so as not to
inconvenience the user.

----------------------------------
B.1         Length of source lines
----------------------------------
The maximum length of a source line is 400 characters.

If you exceed this limit the compiler will issue an error message.

-----------------------------------------------------
B.2         Number and nesting of statement sequences
-----------------------------------------------------
Statement sequences are the statements that occur between 'begin' and 'end'
and between 'repeat' and 'until'. Irie Pascal limits both the total number
of statement sequences in a function/procedure and the maximum nesting of
statement sequences. Statement sequences are nested when one statement
sequence is contained in another.

The maximum number of statement sequences in a function/procedure is
2,147,486,647.
The maximum nesting of statement sequences is 256.

If you exceed one of these limits the compiler issues a fatal error message
(see 3.1 Compiler messages).

-------------------------------------------
B.3         Nesting of functions/procedures
-------------------------------------------
The maximum nesting of functions/procedures is 256.
NOTE: This does NOT mean that the total number of functions and
procedures in a program is 256. This limits only the depth of nesting
of functions and procedures. Pascal allows functions and procedures to
contain other functions and procedures, and these in turn can contain
other functions and procedures, this is called nesting.

If you exceed this limit the compiler issues a fatal error message
(see 3.1 Compiler messages).

-----------------------------------------------------------------
B.4         Range of variant selector's type & Number of variants
-----------------------------------------------------------------
A variant record is a record which contains a variant part.
The syntax for variant parts given below is taken from ISO/IEC 7185.

   variant-part = 'case' variant-selector 'of' variant { ';' variant }
   variant-selector = [ tag-field ':' ] tag-type
   tag-field = identifier
   tag-type = ordinal-type-identifier
   variant = case-constant-list ':' '(' field-list ')'
   case-constant-list = case-constant { ',' case-constant }
   case-constant = constant
   field-list = [ (fixed-part [ ';' variant-part] | variant-part) [';'] ]
   fixed-part = record-section { ';' record-section }
   record-section = identifier-list ':' type-denoter
   identifier-list = identifier { ',' identifier }
   
Now the important part of the syntax above in plain English is :
A variant part consists of the word 'case' followed by a variant-selector
(which is either an identifier followed by a colon and the tag-type or just
the tag-type), followed by the word 'of', and followed by one or more
variants.

Irie Pascal limits the maximum range of the tag-type of a variant selector
to 1024.
Irie Pascal limits the number of variants in a variant-part to 1024.

If you exceed any of these limits the compiler issues a warning message and
the following checks are not performed on the variant record which exceeded
the limit(s).
1. No case-constant should appears more than once.
2. Each value specified by the tag-type should appear as a case-constant.
3. Only active variants in variant records are accessed.

---------------------------------------------------------------------
B.5         Range of case-index's type & Number of case-list-elements
---------------------------------------------------------------------
A case-index is the expression that follows the word 'case' in a
case statement.
case-list-elements are the choices in the case statement.
The syntax for case statements given below is taken from ISO/IEC 7185.

   case-statement = 'case' case-index 'of' case-list-element
			   { ';' case-list-element } [';' 'end' ]
   case-index = expression
   case-list-element = case-constant-list ':' statement
   case-constant-list = case-constant { ',' case-constant }
   case-constant = constant

Irie Pascal limits the maximum range of the case index's type to 1024.
Irie Pascal limits the number of case-list-elements to 1024.

If you exceed any of these limits the compiler issues a warning message and
the following checks are not performed on the case statement which exceeded
the limit(s).
1. No case-constant should appears more than once.
2. Each value specified by the type of the case-index should appear as a
   case-constant.

-------------------------------------
B.6         Size of integer constants
-------------------------------------
The maximum size of an integer constant is 2,147,486,647

If you exceed this limit the compiler will issue an error message.

----------------------------------
B.7         Size of real constants
-----------------------------------
The maximum size of an real constant is approximately 1e308

If you exceed this limit the compiler will issue an error message.

---------------------------------
B.8         Size of code and data
---------------------------------
The maximum size of the code in a program is 4GB
The maximum size of the data in a program is 4GB

If you exceed this limit the compiler will issue an error message.

----------------------------------
B.9         Number of set elements
----------------------------------
Irie Pascal uses two different representations for sets depending on
the range of the sets base type, or if the base type is a subrange type
depending on the range of the subranges host type.
For example suppose you have a set type
   "set of T"
and T is not a subrange type then if T's range is less than or equal to 256
then the set is represented as a bit set, if T's range is greater than 256
then the set is represented using an array representation of fixed size.
If you have a set type
   "set of S"
and S is  a subrange of T then if T's range is less than or equal to 256
then the set is represented as a bit set, if T's range is greater than 256
then the set is represented using an array representation of fixed size.

Why am I telling you all this?
Well because the fixed size of the array represention means that there is
a limit (255) on the number of set elements that can fit in set variables
that use the array representation. If you assign a set value with more
elements than the limit then the set value will overflow and overwrite
the memory that follows the variable. If assignment overflow checking is
enabled (see the -ao compiler option) then the overflow will be detected.

---------------------------------
B.10        Nesting of statements
---------------------------------
Irie Pascal limits the maximum depth of nesting of statements to 256.
NOTE: This does NOT mean that the total number of statements in a program
is 256. This limits the depth of nesting (i.e.. the depth to which statements
can contain other statements which can contain other statements etc.).

If you exceed one of these limits the compiler issues a fatal error message
(see 3.1 Compiler messages).

----------------------
B.11        Stack size
----------------------
The default stack size is 64K but you can adjust this to any value from
1K to 1024K (1MB) using the -S compiler option.

If you exceed this limit the compiler will issue an error message.

-------------------------------------------
Appendix C. Implementation-defined features
-------------------------------------------
The Pascal Standard (ISO/IEC 7185) specifies that some features of the
Pascal language are implementation-defined. ISO/IEC 7185 further specifies
that each implementation (called a processor by ISO/IEC 7185) must provide
a definition of all implementation-defined features. The effect of this is
that the exact behaviour of the implementation-defined features, may differ
between processors, but must be consistent for any particular processor.

Below is the definition of how this implementation/processor handles all
implementation-defined features.
Each definition has the following format:
First the official description of the feature is taken from ISO/IEC 7185
and placed in quotation marks.
This is followed by my interpretation of the official description if I
feel the official description is unclear or requires the reader to have
a copy of ISO/IEC 7185.
A statement describing how this implementation/processor handles the
feature is at the end.

---------------------------
C.1         String-elements
---------------------------
"6.1.7 There shall be an implementation-defined one-to-one correspondence
between the set of alternatives from which string-elements are drawn and
a subset of the values of the required char-type".

In other words an implementation-defined subset of the character values
can be used to create character literals.

Irie Pascal allows character literals to be formed from any of the
"printable" characters from the IBM extended character set.

---------------------------------------------------------
C.2         Provision of tokens and delimiting characters
---------------------------------------------------------
"6.1.9 Provision of the reference tokens ^, [, and ], of the alternative
token @, and of the delimiting characters { and }, is
implementation-defined".

Irie Pascal provides the reference tokens, the alternative token, and the
delimiting characters.

---------------------------------------------
C.3         Size and precision of real values
---------------------------------------------
"6.4.2.2 b) The values of the real-type shall be an implementation-defined
subset of the real numbers denoted by signed-real".

The real numbers denoted by signed-real have infinite size and infinite
precision. Implementations are allowed to limit the maximum size and
precision of real values.

Irie Pascal uses 64 bit reals stored as specified by the following standard:
"IEEE standard for binary floating-point arithmetic (ANSI/IEC std 754-1985)".

-------------------------
C.4         Character set
-------------------------
"6.4.2.2 d) The values of char-type shall be the enumeration of a set of
implementation-defined characters, some possibly without graphic
representation".

Irie Pascal uses the enumeration of the IBM extended character set for
values of char-type.

----------------------------------------
C.5         Ordinal values of characters
----------------------------------------
"6.4.2.2 d) The ordinal numbers of each value of char-type are
implementation-defined".

Irie Pascal uses the position of each value of char-type, in the IBM
extended character set, as it's ordinal number.
So for example since the space character is at position 32 then
 ord(' ') = 32.

------------------------------------------------
C.6         Characters prohibited from text files
------------------------------------------------
"6.4.3.5 There shall be an implementation-defined subset of the set of 
char-type values, designated 'characters prohibited from text files'".

Irie Pascal designates one character as 'characters prohibited from
text files'. This character has ordinal value 26 and is the EOF character.

---------------------------------
C.7         When I/O is performed
---------------------------------
"6.6.5.2 The point at which the file operations 'rewrite', 'put', 'reset',
and 'get' are actually performed is implementation-defined".

Irie Pascal implements "lazy I/O" (i.e.. input operations are performed at
the latest opportunity and output operations are performed at the earliest
opportunity), which facilitates interactive terminal input and output.
So the four file operations are performed as specified below:
'rewrite' - the file is opened but the file buffer is empty.
'put' - the contents of the file buffer are appended to the file.
'reset' - the file is opened, but the file buffer is not filled until
	  it is accessed.
'get' - If the file buffer is full then the file buffer is emptied to
	  make room for the next file value (NOTE: In this case no I/O
	  is actually performed).
	If the file buffer is empty then the next data value is skipped
	  (i.e.. read and ignored). The file buffer remains empty.

---------------------------
C.8         Value of maxint
---------------------------
"6.7.2.2 The required constant-identifier maxint shall denote an
implementation-defined value of integer-type".

Irie Pascal uses 2,147,483,647 as the value of 'maxint'.

-----------------------------------------------------
C.9         Accuracy of real operations and functions
-----------------------------------------------------
"6.7.2.2 The accuracy of the approximation of the result of the real
operations and functions to the mathematical result is
implementation-defined".

Irie Pascal performs real operations as specified in
"IEEE standard for binary floating-point arithmetic (ANSI/IEC std 754-1985)"
the final results are stored in 64 bit reals.

--------------------------------------------------------
C.10        Default value of TotalWidth for integer-type
--------------------------------------------------------
"6.9.3.1 The default value of TotalWidth for integer-type is
implementation-defined".

Irie Pascal uses 8 as the default value of TotalWidth for integer-type.

-----------------------------------------------------
C.11        Default value of TotalWidth for real-type
-----------------------------------------------------
"6.9.3.1 The default value of TotalWidth for real-type is
implementation-defined".

Irie Pascal uses 9 as the default value of TotalWidth for real-type.

--------------------------------------------------------
C.12        Default value of TotalWidth for Boolean-type
--------------------------------------------------------
"6.9.3.1 The default value of TotalWidth for Boolean-type is
implementation-defined".

Irie Pascal uses 8 as the default value of TotalWidth for Boolean-type.

-------------------------------------------------
C.13        Number of digits written in exponents
-------------------------------------------------
"6.9.3.4.1 ExpDigits is an implementation-defined value representing the
number of digit-characters written in an exponent".

Irie Pascal uses 3 as the value of ExpDigits.

------------------------------------------------------------
C.14        Use of 'e' of 'E' as exponent character on output
------------------------------------------------------------
"6.9.3.4.1 The value of the exponent character ('e' or 'E') used on output
of values of real-type is implementation-defined".

Irie Pascal uses 'E' on output of values of real-types.

---------------------------------------------------------------
C.15        Case of characters used on output of Boolean values
---------------------------------------------------------------
"6.9.3.5 The case of each character of 'True' and 'False' used on output of
values of Boolean-type is implementation-defined".

Irie Pascal uses 'true' and 'false' on output of values of Boolean-type.

-----------------------------------------------
C.16        Effect of built-in procedure 'page'
-----------------------------------------------
"6.9.5 The effect of the procedure 'page' when applied to a text file which
is in generation mode is implementation-defined".

The procedure 'page' causes a form feed character (i.e.. chr(12)) to be
written to text files to which it is applied.

---------------------------------------------------
C.17        Binding of file-type program-parameters
---------------------------------------------------
"6.10 The binding of a file-type program-parameter is
implementation-defined".

See '6.1 Program parameters' for a description of how file-type program
parameters are handled.

-------------------------------------------------------------------
C.18        Effect of 'reset' and 'rewrite' on 'input' and 'output'
-------------------------------------------------------------------
"6.10 The effect of 'reset' and 'rewrite' on the standard files 'input' and
'output' is implementation-defined".

'reset' and 'rewrite' have no effect on the standard files 'input' and
'output'.

---------------------------------------------
Appendix D. Implementation-dependent features
---------------------------------------------
The Pascal Standard (ISO/IEC 7185) does not completely define all features
of the language. Some features are implementation-dependent (i.e.. possibly
differing between implementations and not necessarily defined for any
particular implementation).

Below is the definition of how this implementation/processor treats all
implementation-dependent features.
Each definition has the following format:
First the official description of the feature is taken from ISO/IEC 7185
and placed in quotation marks.
This is followed by my interpretation of the official description if I
feel the official description is unclear or requires the reader to have
a copy of the ISO/IEC 7185.
A statement describing how this implementation/processor handles the
feature is at the end.

-----------------------------------------------------
D.1         Effect of writing 'prohibited' characters
-----------------------------------------------------
"6.4.3.5 For any text file t, the effect of attributing to a component of
either t.L or t.R a member of the characters prohibited from text files
is implementation-dependent".

In other words the effect of writing any of the characters, that
implementations are allowed to prohibit from text files, to a text file is
implementation-dependent.

Irie Pascal 'prohibits' one character from text files, the character is
chr(26) the end-of-file character. Writing the end-of-file character to a
text file causes the file to be terminated (i.e.. any characters written
after the EOF character will not appear when the file is read).

----------------------------------------------------
D.2         Order of evaluation of index-expressions
----------------------------------------------------
"6.5.3.2 The order of evaluation of the index-expressions of an
indexed-variable is implementation-dependent".

Irie Pascal evaluates index-expressions of indexed-variables from left to
right.

For example given

	 var   x[1..10, 1..20] of integer;

and later on

	 x[i, j] := 20;

'i' will get evaluated before 'j'.

---------------------------------------------------------------------
D.3         Order of evaluation of expressions of a member-designator
---------------------------------------------------------------------
"6.7.1 The order of evaluation of expressions of a member-designator
is implementation-dependent".

Irie Pascal evaluates expressions of member-designators from left to right.

For example given
	const low = 'a'; high = 'z';
	var letter : set of char;
and later on
	letter := [low..high]'

'low' will be evaluated before 'high'.

-----------------------------------------------------
D.4         Order of evaluation of member-designators
-----------------------------------------------------
"6.7.1 The order of evaluation of the member-designators of a set-constructor
is implementation-dependent".

Irie Pascal evaluates member-designators of set-constructors from left to
right.

For example given
	var yes : set of char;
and later on
	yes := ['y', 'Y']'

'y' will be evaluated before 'Y'.

---------------------------------------------------------------
D.5         Order of evaluation of operands of dyadic operators
---------------------------------------------------------------
"6.7.2.1 The order of evaluation of the operands of a dyadic operator is
implementation-dependent".

In other words the order of evaluation of the operands of any of the
following operators is implementation-dependent:
   * / div mod and + - or = <> < > <= >= in and_then or_else shr shl
(i.e.. the operands can be evaluation left-to-right, right-to-left,
in parallel, or they may not both be evaluated).

Irie Pascal always evaluates the operands of the following operators from
left-to-right:
   * / div mod + - = <> < > <= >= in shr shl

Irie Pascal always evaluates the operands of the following operators using
short-circuit evaluation:
   and_then or_else
See the 'sc' compiler option for more information on short-circuit
evaluation.

Irie Pascal evaluates the operands of the following operators, using
short-circuit evaluation if short-circuit evaluation is enabled,
or left-to-right if short-circuit evaluation is disabled:
   and   or
See the 'sc' compiler option and the $B compiler directive for information
on enabling and disabling short-circuit evaluation.

-----------------------------------------------------------------------
D.6         Order of evaluation of actual-parameters for function calls
-----------------------------------------------------------------------
"6.7.3 The order of evaluation, accessing, and binding of the
actual-parameters  of a function-designator is implementation-dependent".

In other words the order in which the actual-parameters are evaluated
and passed to the formal-parameters during a functions call is
implementation-dependent.

Irie Pascal evaluates and passes actual-parameters from left to right.

-------------------------------------------------------------------
D.7         Order of evaluating components of assignment statements
-------------------------------------------------------------------
"6.8.2.2 The order of accessing the variable and evaluating the expression
of an assignment-statement is implementation-dependent".

I am not sure what is meant by "accessing the variable" so all I
can say is that the address of the variable is calculated before the
expression is evaluated.

------------------------------------------------------------------------
D.8         Order of evaluation of actual-parameters for procedure calls
------------------------------------------------------------------------
"6.7.3 The order of evaluation, accessing, and binding of the
actual-parameters  of a procedure-statement is implementation-dependent".

In other words the order in which the actual-parameters are evaluated
and passed to the formal-parameters during a procedure call is
implementation-dependent.

Irie Pascal evaluates and passes actual-parameters from left to right.

-------------------------------------------------------------------------
D.9         Effect of reading a text file to which 'page' has been applied
-------------------------------------------------------------------------
"6.9.5 The effect of inspecting a text file to which the page procedure was
applied during generation is implementation-dependent".

Applying 'page' to a text file during generation causes a form feed character
chr(12) to be written to the file. During inspection (i.e.. when the text
file is read) the handling of the form feed character depends on the type of
data being read in at the time the form feed is read. If the data being
read is of type integer or real then the form feed character is treated like
a space character and is therefore skipped. If the data being read is of
type character or string then the form feed character is read in like
any other character.

---------------------------------------------------
D.10        Binding of non-file program-parameters
---------------------------------------------------
"6.10 The binding of the non-file variables denoted by the program-parameters
to entities external to the program is implementation-dependent".

The binding of program-parameters to entities external to the program are
described in "6.1 Program parameters".

------------------
Appendix E. Errors
------------------
ISO/IEC 7185 defines an error as follows:

"A violation by a program of the requirements of this International Standard
that a processor is permitted to leave undetected".

ISO/IEC 7185 then goes on to add the following two notes:

"1. If it is possible to construct a program in which the violation or
non-violation of this International Standard requires knowledge of the
data read by the program or the implementation definition of
implementation-defined features, then violation of that requirement is
classified as an error. Processors may report on such violations of the
requirement without such knowledge, but there always remain some cases
that require execution, simulated execution, or proof procedures with the
required knowledge. Requirements that can be verified without such
knowledge are not classified as errors.

2. Processors should attempt the detection of as many errors as possible,
and to as complete a degree as possible. Permission to omit detection is
provided for implementations in which the detection would be an excessive
burden."

Below is the documentation of how this implementation/processor handles
all errors. Most of the time the documentation consists only of a statement
about whether or not the error is reported. The description of each error is
taken from ISO/IEC 7185.

-------------------------------------
E.1         Array index out of bounds
-------------------------------------
"6.5.3.2 For an indexed-variabe closest-containing a single index-expression,
it is an error if the value of the index-expression is not
assignment-compatible with the index-type of the array-type."

In other words it is error to access an array component that does not exist.
For example given:

   var a : array[1..20] of char;

then

   a[0]

is an error since 0 is not assignment-compatible with 1..10.
NOTE: There is no 0th component of 'a'.

This error is reported if range checking is enabled.
See also the 'r' compiler option and the '$R' compiler directive.

--------------------------------------
E.2         Accessing inactive variant
--------------------------------------
"6.5.3.3 It is an error unless a variant is active for the entirety of each
reference and access to each component of the variant."

This error is reported if the following two conditions are met:
1. Range checking is enabled
2. The range of the variant selector's type is less than or equal to the
   implementation limit (i.e.. 4096).

See also the 'v' compiler option and the '$V' compiler directive.

--------------------------------------
E.3         Dereferencing nil pointers
--------------------------------------
"6.5.4 It is an error if the pointer-variable of an identified-variable
denotes a nil-value."

In other words it is an error to dereference a pointer variable which is
equal to nil (i.e.. p^ is an error if 'p' = nil).

This error is reported.

--------------------------------------------
E.4         Dereferencing undefined pointers
--------------------------------------------
"6.5.4 Is an error if the pointer-variable of an identified-variable is
undefined."

In other words it is an error to dereference a pointer-variable which is
undefined (i.e.. p^ is an error if 'p' is undefined).

This error is reported.

-----------------------------
E.5         Dangling pointers
-----------------------------
"6.5.4 It is an error to remove from its pointer-type the identifying-value
of an identified-variable when a reference to the identified-variable
exists."

In other words it is an error to use 'dispose' to free the memory allocated
for a pointer if other pointers to the same memory exists.

This error is not reported.

-----------------------------------
E.6         Altering file-variables
-----------------------------------
"6.5.5 It is an error to alter the value of a file-variable f when a
reference to the buffer-variable f^ exists."

According to ISO/IEC 7185 there are four ways of establishing a reference
to a variable.
1. Passing the variable by reference establishes a reference to the variable
   for the life of the function/procedure call.
2. Using an assignment-statement to assign a value to the variable
   establishes a reference to the variable starting either before or after
   the expression on the right-hand side of the assignment statement is
   evaluated, and lasting until the value has been assigned to the variable.
3. Using the variable on a with-statement establishes a reference to the
   variable that exists during the execution of the statement in the
   with-statement.
4. Establishing a reference to a component of the variable.

So for example it would be an error if you pass a file-buffer by reference
to a procedure, and that procedure performs I/O on the file associated
with the file-buffer.

This error is not reported.

-----------------------------------------------
E.7         Using out-of-range value parameters
-----------------------------------------------
"6.6.3.2 It is an error if the value of each corresponding actual value
parameter is not assignment-compatible with the type possessed by the
formal-parameter."

If you think about it this makes sense since passing a value to a function
or procedure is very much like assignment the value to the corresponding
formal parameter.

This error is reported if range checking is enabled.
See also the 'r' compiler option and the '$R' compiler directive.

--------------------------------------------------
E.8         Using out-of-range set value parameters
--------------------------------------------------
"6.6.5.2 For a value parameter, it is an error if the actual-parameter
is an expression of a set-type whose value is not assignment-compatible
with the type possessed by the formal-parameter."

This is very similiar to the previous error (E.7).

This error is reported if range checking is enabled.
See also the 'r' compiler option and the '$R' compiler directive.

-----------------------------------------------
E.9         Output to file not open for writing
-----------------------------------------------
"6.6.5.2 It is an error if the file mode is not Generation immediately prior
to any use of put, write, writeln or page."

In other words it is an error to perform output on a file which is not
open for writing (i.e.. either not open or open for reading).

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

------------------------------------
E.10        Output to undefined file
------------------------------------
"6.6.5.2 It is an error if the file is undefined immediately prior to any
use of put, write, writeln or page."

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

-------------------------------------
E.11        Writing to middle of file
-------------------------------------
"6.6.5.2 It is an error if end-of-file is not true immediately prior to
any use of put, write, writeln or page."

In other words all output must take place at the end of files.

Irie Pascal supports output in the middle of a file using the 'seek'
procedure, so this implementation does not consider this an error and
therefore does not report it.

----------------------------------------------
E.12        Putting undefined buffer-variables
----------------------------------------------
"6.6.5.2 It is an error if the buffer-variable is undefined immediately
prior to any use of put."

This error is not reported.

------------------------------------
E.13        Resetting undefined files
------------------------------------
"6.6.5.2 It is an error if the file is undefined immediately prior to
any use of reset."

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

------------------------------------------------
E.14        Input from file not open for reading
------------------------------------------------
"6.6.5.2 It is an error if the file mode is not inspection immediately
prior to any use of get or read."

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

-------------------------------------
E.15        Input from undefined file
-------------------------------------
"6.6.5.2 It is an error if the file is undefined immediately prior to
any use if get or read."

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

------------------------------------
E.16        Reading past end-of-file
------------------------------------
"6.6.5.2 It is an error if end-of-file is true immediately prior to any
use of get or read."

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

---------------------------------------
E.17        Reading out of range values
---------------------------------------
"6.6.5.2 For read, it is an error if the value possessed by the
buffer-variable is not assignment-compatible with the variable-access."

In other words it is an error to read out of range values into variables.

This error is reported if range checking is enabled.
See also the 'r' compiler option and the '$R' compiler directive.

---------------------------------------
E.18        Writing out of range values
---------------------------------------
"6.6.5.2 For write, it is an error if the value possessed by the expression
is not assignment-compatible with the buffer-variable."

In other words it is an error to write out of range values to files.

This error is reported if range checking is enabled.
See also the 'r' compiler option and the '$R' compiler directive.

-----------------------------------------------
E.19        new(p, c1..cN) constraints violated
-----------------------------------------------
"6.6.5.3 For new(p, c1..cN), it is an error if a variant of a variant-part
within the new variable becomes active and a different variant of the
variant-part is one of the specified variants."

In other words if you use this form of 'new' and specify case-constants
c1 thru cN then it is an error if a variant other than those specified
by c1 thru cN become active.

Irie Pascal does not support this form of 'new' so the error can not occur.

------------------------------------------
E.20        Incompatible use of dispose(p)
------------------------------------------
"6.6.5.3 For dispose(p), it is an error if the identifying-value had been
created using the form new(p, c1..cN)."

Irie Pascal does not support this form of 'new' so the error can not occur.

--------------------------------------------------
E.21        Incompatible use of dispose(p, k1..kM)
--------------------------------------------------
"6.6.5.3 For dispose(p, k1..kM), it is an error unless the variable had
been created using the form new(p, c1..cN) and m is equal to n."

Irie Pascal does not support this form of 'dispose' so the error can not
occur.

----------------------------------------------------
E.22        dispose(p, k1..kM) constraint violations
----------------------------------------------------
"6.6.5.3 for dispose(p, k1..kM), it is an error if the variants identified
by the pointer value of p are different from those specified by the
case-constants k1..kM."

Irie Pascal does not support this form of 'dispose' so the error can not
occur.

---------------------------------
E.23        disposing nil pointer
---------------------------------
"6.6.5.3 For dispose, it is an error if the pointer variable has a
nil-value."

This error is reported.

---------------------------------------
E.24        disposing undefined pointer
---------------------------------------
"6.6.5.3 For dispose, it is an error if the pointer variable has an
undefined value."

This error is reported.

-----------------------------------------------
E.25        new(p, c1..cN) constraints violated
-----------------------------------------------
"6.6.5.3 It is an error if a variable created using the second form of new
is accessed by the identified-variable of the variable-access of a factor,
of an assignment-statement, or of an actual parameter."

Irie Pascal does not support this form of 'new' so the error can not occur.

-------------------------------
E.26        Invalid use of pack
-------------------------------
"6.6.5.4 For pack, it is an error if the parameter of ordinal-type is not
assignment-compatible with the index-type of the unpacked array parameter."

This error is reported.

-------------------------------
E.27        Invalid use of pack
-------------------------------
"6.6.5.4 For pack, it is an error if any of the components of the unpacked
array are both undefined and accessed."

This error is not reported.

-------------------------------
E.28        Invalid use of pack
-------------------------------
"6.6.5.4 For pack, it is an error if the index-type of the unpacked array
is exceeded."

This error is reported.

---------------------------------
E.29        Invalid use of unpack
---------------------------------
"6.6.5.4 For unpack, it is an error if the parameter of ordinal-type is not
assignment-compatible with the index-type of the unpacked array parameter."

This error is reported.

---------------------------------
E.30        Invalid use of unpack
---------------------------------
"6.6.5.4 For unpack, it is an error if any of the components of the packed
array are undefined."

This error is not reported.

---------------------------------
E.31        Invalid use of unpack
---------------------------------
"6.6.5.4 For unpack, it is an error if the index-type of the unpacked array
is exceeded."

This error is reported.

-----------------------------------
E.32        Square of large numbers
-----------------------------------
"6.6.6.2 Sqr(x) computes the square of x. It is an error if such a value
does not exist."

In other words it is an error if sqr(x) is too large to be represented
by real.

This error is reported.

----------------------------
E.33        ln(x) and x <= 0
----------------------------
"6.6.6.2 For ln(x), it is an error if x is not greater than zero."

This error is reported.

------------------------------------------
E.34        Square root of negative number
------------------------------------------
"6.6.6.2 For sqrt(x), it is an error if x is negative."

This error is reported.

-------------------------------
E.35        Problems with trunc
-------------------------------
"6.6.6.3 For trunc(x), the value of trunc(x) is such that if x is positive
or zero then 0<=x-trunct(x)<1; otherwise 1<x-trunc(x)<=0. It is an error
if such a value does not exist."

This error is not reported.

-------------------------------
E.36        Problems with round
-------------------------------
"6.6.6.3 For round(x), if x is positive or zero then round(x) is equivalent
to trunc(x+0.5), otherwise round(x) is equivalent to trunc(x-0.5). It is an
error if such a value does not exist."

This error is not reported.

-----------------------------
E.37        Problems with chr
-----------------------------
"6.6.6.3 For chr(x), the function returns a result of char-type that is
the value whose ordinal number is equal to the value of the expression x
if such a character value exists. It is an error if such a character value
does not exist."

This error is reported.

------------------------------
E.38        Problems with succ
------------------------------
"6.6.6.4 For succ(x), the function yields a value whose ordinal number is
one greater than that of x, if such a value exists. It is an error if such
a value does not exist."

This error is reported if range checking is enabled.
See also the 'r' compiler option and the '$R' compiler directive.

------------------------------
E.39        Problems with pred
------------------------------
"6.6.6.4 For pred(x), the function yields a value whose ordinal number
is one less than that of x, if such a value exists. It is an error if such
a value does not exist."

This error is reported if range checking is enabled.
See also the 'r' compiler option and the '$R' compiler directive.

----------------------------------------
E.40        Using eof on undefined files
----------------------------------------
"6.6.6.5 When eof(f) is activated, it is an error if f is undefined."

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

-----------------------------------------
E.41        Using eoln on undefined files
-----------------------------------------
"6.6.6.5 When eoln(f) is activated, it is an error if f is undefined."

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

-------------------------------------
E.42        Using eoln at end-of-file
-------------------------------------
"6.6.6.5 When eoln(f) is activated, it is an error if eof(f) is true."

This error is not reported.

-------------------------------------
E.43        Using undefined variables
-------------------------------------
"6.7.1 An expression denotes a value unless a variable denoted by a
variable-access contained by the expression is undefined at the time of
its use, in which case that use is an error."

In other words it is an error to use an undefined variable in an expression
(i.e.. use the value of an undefined variable).

This error is reported only if checking for undefined values is enabled
and the variable's type is one of the supported types
(See the 'u' compiler option and the '$U' compiler directive).

----------------------------
E.44        Division by zero
----------------------------
"6.7.2.2 A term of the form x/y is an error if y is zero."

In other words for real division, it is an error if the denominator is zero.

This error is reported.

----------------------------
E.45        Division by zero
----------------------------
"6.7.2.2 A term of the form i div j is an error if j is zero."

In other words for integer division, it is an error if the denominator is
zero.

This error is reported.

---------------------------------------
E.46        Modulus of zero or negative
---------------------------------------
"6.7.2.2 A term of the form i mod j is an error if j is zero or negative."

In other words for the modulus operation, it is an error if the right
operand is zero or negative."

This error is reported if the right operand is zero.
This error is not reported if the right operand is negative.

--------------------------------------
E.47        Integer overflow/underflow
--------------------------------------
"6.7.2.2 It is an error if an integer operation or function is not performed
according to the mathematical rules for integer arithmetic."

I think this means that it is an error if integer operations or functions
overflow or underflow. So for example

   maxint+maxint

should be an error since

   maxint = 2,147,486,647

but due to integer overflow

   maxint+maxint = -2


This error is not reported.

---------------------------------------------------
E.48        Returning undefined value from function
---------------------------------------------------
"6.7.3 It is an error if the result of an activation of a function is
undefined upon completion of the algorithm of the activation."

In other words it is an error if result of a function call is undefined.

This error is reported if checking for undefined values is enabled and
the type of the functions result is one of the supported types
(See the 'u' compiler option and the '$U' compiler directive).

-------------------------------------------------
E.49        Assigning out of range ordinal values
-------------------------------------------------
"6.8.2.2 For an assignment-statement, it is an error if the expression is of
an ordinal-type whose value is not assignment-compatible with the type
possessed by the variable or function-identifier."

In other words it is an error to assign an out of range ordinal value
to a variable or a function result.

This error is reported if range checking is enabled.
See the 'r' compiler option and the '$R' compiler directive.

---------------------------------------------
E.50        Assigning out of range set values
---------------------------------------------
"6.8.2.2 For an assignment-statement, it is an error if the expression is of
a set-type whose value is not assignment-compatible with the type
possessed by the variable."

In other words it is an error to assign an out of range set value
to a variable.
NOTE: The previous error said "... the variable or function-identifier"
but this one just says  "... the variable". Which seems to imply that it
is not an error to assign an out of range set value to a function result.
I don't see the point of allowing such assignments so this implementation
treats them as errors also and reports both types of assignments.

This error is reported if range checking is enabled.
See the 'r' compiler option and the '$R' compiler directive.

-----------------------------------
E.51        Non-matching case index
-----------------------------------
"6.8.3.5 For a case-statement, it is an error if none of the case-constants
is equal to the value of the case-index upon entry to the case-statement."

NOTE: Irie Pascal supports the 'otherwise' keyword which matches the
case-index if none of the case-constants match the case-index. So
technically in that situation this error is not reported.
See the 'eoth' compiler option.

This error is reported if the range of the case-index's type is less
than a certain implementation limit
(See "B.5 Range of case-index's type & Number of case-list-elements").

------------------------------------------------
E.52        For loops initial value out of range
------------------------------------------------
"6.8.3.9 For a for-statement, it is an error if the value of the
initial-value is not assignment-compatible with the type possessed by
the control-variable, if the statement of the for-statement is executed."

In other words it is an error if the initial value specified on a for
statement is not in the range specified by the type of the control variable
and the loop is started.
For example given:

   type num = 1..100;
   var n : num;

then the following are errors:

   for n := 0 to 10 do writeln(n);
or
   for n := 101 to 102 do writeln(n);
or
   for n := 11 downto 1 do writeln(n);
or
   for n := 101 downto 100 do writeln(n);

But the following are not errors since the for loops are never started
(and therefore no assignments are made to 'n').

   for n := 0 to -1 do writeln(n);
or
   for n := 101 to 100 do writeln(n);
or
   for n := 11 downto 12 do writeln(n);
or
   for n := 101 downto 102 do writeln(n);

This error is reported if range checking is enabled.
See the 'r' compiler option and the '$R' compiler directive.

----------------------------------------------
E.53        For loops final value out of range
----------------------------------------------
"6.8.3.9 For a for-statement, it is an error if the value of the
final-value is not assignment-compatible with the type possessed by
the control-variable, if the statement of the for-statement is executed."

In other words it is an error if the final value specified on a for
statement is not in the range specified by the type of the control variable
and the loop is started.
For example given:

   type num = 1..10;
   var n : num;

then the following are errors:

   for n := 1 to 11 do writeln(n);
or
   for n := 101 to 102 do writeln(n);
or
   for n := 11 downto 1 do writeln(n);
or
   for n := 101 downto 100 do writeln(n);

But the following are not errors since the for loops are never started
(and therefore no assignments are made to 'n').

   for n := 0 to -1 do writeln(n);
or
   for n := 101 to 100 do writeln(n);
or
   for n := 11 downto 12 do writeln(n);
or
   for n := 101 downto 102 do writeln(n);

This error is reported if range checking is enabled.
See the 'r' compiler option and the '$R' compiler directive.

------------------------------------------
E.54        Reading invalid integer values
------------------------------------------
"6.9.1 On reading an integer from a text file, after skipping preceding spaces
and end-of-lines, it is an error if the rest of the sequence does not form
a signed-integer."

In other words it is an error if the program attempts to read an integer
from a text file but the next characters to be read from the text file can
not form an integer.
For example if a text file contains the following "z" and you try
to read in an integer value from this file it is an error.

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

-----------------------------------------------
E.55        Reading out of range integer values
-----------------------------------------------
"6.9.1 On reading an integer from a text file, it is an error if the value
of the signed-integer read is not assignment-compatible with the type
possessed by the variable-access."

This error is reported if range checking is enabled.
See the 'r' compiler option and the '$R' compiler directive.

------------------------------------------
E.56        Reading invalid numeric values
------------------------------------------
"6.9.1 On reading a number from a text file, after skipping preceding spaces
and end-of-lines, it is an error if the rest of the sequence does not form
a signed-number."

In other words it is an error if the program attempts to read an integer
or a real from a text file but the next characters to be read from the
text file can not form an integer or real.
For example if a text file contains the following "z" and you try
to read in an integer or real value from this file it is an error.

This error is reported if I/O checking is enabled.
See the 'i' compiler option and the '$I' compiler directive.

-----------------------------------------
E.57        Reading when file is not open
-----------------------------------------
"6.9.1 It is an error if the buffer-variable is undefined immediately prior
to any use of read."

The only way I can see this happening is if the file is not open or has
been opened for writing. In both cases reading from such a file will
cause an error to be reported if I/O checking is enabled.

See the 'i' compiler option and the '$I' compiler directive.

---------------------------------------------------------------
E.58        Writing with TotalWidth or FracDigits less than one
---------------------------------------------------------------
"6.9.3.1 On writing to a textfile, the values of TotalWidth and FracDigits
are greater than equal to one; it is an error if either value is less
than one."

In other words if you have

   write(100:w)
or
   write(100.23:w:f)

it is an error if 'w' of 'f' is less than one.

This error is reported if range checking is enabled.
See the 'r' compiler option and the '$R' compiler directive.

--------------------------------------------
E.59        Problems with program-parameters
--------------------------------------------
"6.10 The execution of any action, operation, defined to operate on a
variable, is an error if the variable is a program-parameter and, as a
result of the binding of the program-parameter, the execution cannot be
completed as defined."

The bindings of program-parameters used by Irie Pascal are so simple that
this error can not occur.

-------------------------------------------
E.60        Problems with conformant arrays
-------------------------------------------
"6.6.3.8 For a conformant array, it is an error if the smallest or largest
value specified by the index-type of the actual-parameter lies outside
the closed interval specified by the index-type-specification of the
conformant-array-schema."

Irie Pascal does not support conformant arrays so this error can not occur.

---------------------------
Appendix F. I/O error codes
---------------------------
The following I/O error codes may be returned from various I/O operations.
If I/O checking is enabled (the default situation) then the compiler
generates code to automatically check I/O operation for errors and
report any errors detected.

If you want more control on how errors are handled you can disable
I/O checking either globally using the 'i' compiler option or
locally using the '$I' compiler directive and then use the function
IOResult to check the result of I/O operations.

Value   Error Code             Cause
  0      NoErrors              I/O operation completed successfully
  1      FileEraseFailure      Attempt to erase a file failed
  2      FileRenameFailure     Attempt to rename a file failed
  3      FileIsUndefined       Attempt to operate on an undefined file
  4      FileIsOpen            Using assign, erase, or rename on an open file
  5      FileIsNotOpen         Attempt to perform I/O on a closed file
  6      FileModeUndefined     THIS SHOULD NEVER OCCUR
  7      FileNameTooLong       Attempt to give a file a name too long
  8      FileNameNotDefined    Attempt to erase or rename a file with no name
  9      FilePosFailure        Attempt to use pos on a file failed
 10      FileSeekFailure       Attempt to use seek on a file failed
 11      NotOutputFile         Attempt to write to a file not open for writing
 12      UnexpectedEOF         Attempt to read past end-of-file
 13      WriteFailure          Attempt to write to file failed
 14      WidthTooLarge         Attempt to write a field too wide
 15      NotInputFile          Attempt to read from a file not open for reading
 16      ReadFailure           Attempt to read from file failed
 17      ClosingFailure        Attempt to close a file failed
 18      OpeningFailure        Attempt to open a file failed
 19      FileBufferIsEmpty     Attempt to use put and the file-buffer is empty

END

