[an error occurred while processing this directive]
<h1>Implementing ADM - Mike Slade's Version</h1>
<h2>Program Execution</h2>
<p>
Once the entity descriptions are entered, the desired instantiations
are made by commands of the form
</p>
<pre>
name (parameter_list)
</pre>
<p>
More than one instantiation of the same entity can occure, but each
must be disambiguated by the use of distinct parameters.  The program
can be executed by typing <code>start</code>.  Execution consists of
repeated execution cycles.  Each execution cycle involves evaluating all
guards, performing the procedural actions associated with true guards
and putting the associated command lists into the run set, and then
executing the lists of commands on the run set.  Evaluation is
optimised, so "<code>true || x</code>" always evaluates to true. 
Evaluation of guards and printing of messages is performed prior to any
redefinition in an execution cycle.
</p>
<p>
The program executes until a <code>stop</code> command is executed, no
guards are true, the specified number of iterations have been performed,
or an error occurs.  Errors are classified into notifiable, avoidance
and fatal, with explanatory diagnostics.  A notifiable error occurs when
a variable which is referred to is not in the definition store D, or a
dynamic action refers to an entity which is not in the program store P. 
An avoidance error occurs when a guard cannot be evaluated.  A fatal
error occurs when there is interference between the commands in the run
set.  See a <a href="exec.html">summary
of the execution model</a>.
</p>
<h4>Control variables in <code>am</code></h4>
<p>
There are four control variables used by <code>am</code> (default
values in brackets):
</p>
<dl><dt><code>nflag</code> (true)</dt>
<dd>if true then print notifiable errors</dd>
<dt><code>aflag</code> (true)</dt>
<dd>if true then print avoidance errors</dd>
<dt><code>silent</code> (false)</dt>
<dd>if false then print information during simulation</dd>
<dt><code>iterations</code> (0)</dt>
<dd>the number of execution cycles which are to be performed in each
simulation</dd></dl>
<p>
Their values can be examined by the keyword <code>status</code>, and
can be changed either by using the command line flags <code>-n</code>, <code>-a</code>,
<code>-s</code> and <code>-i<em>number</em></code> respectively, or as a
command from within am using the keyword set, e.g. "<code>set iterations
= 12</code>" or "<code>set aflag = false</code>".
</p>
<h4>Commands to <code>am</code></h4>
<p>
Generally a program will be executed for a specified number of
execution cycles (according to the value of iterations), and then the
user will be allowed to intervene.  The contents of the various stores
can be examined:
</p>
<dl><dt><code>l en</code></dt>
<dd>list the contents of the program store P</dd>
<dt><code>l ds</code></dt>
<dd>list the contents of the definition store D</dd>
<dt><code>l as</code></dt>
<dd>list the contents of the action store A</dd>
<dt><code>l in</code></dt>
<dd>list the currently instantiated entities</dd></dl>
<p>
The run set can be loaded and examined:
</p>
<dl><dt><code>load runset</code></dt>
<dd>load the run set</dd>
<dt><code>l runset</code></dt>
<dd>list the run set</dd></dl>
<p>
Entities can be instantiated, in the same way as the initial
instantiations were made.  Variables can be redefined directly:
</p>

<pre>
define variable = expression ;
</pre>

<p>
The definition and value of a variable can be printed:
</p>

<pre>
?(<em>variable</em>)
</pre>

<p>
Notice that these facilities are intrinsic to the execution of an
ADM program, and are not merely debugging aids.  In particular, it is
intended that the user will intervene to effect changes of state by
means of redefinitions and instantiations.  Such changes will be guided
by the curent state, which is discerned by examination of the various
stores.  Execution can then be continued by using the keyword <code>cont</code>.
</p>
<p>
The implementation described here uses boolean and arithmetic data
types and operators.  Other underlying algebras could have been used,
which would be more suitable for specialised applications.  More
sophisticated variants of the ADM can be simulated by using the print
command to generate input to an interpreter for a special purpose
definitive notation, such as DoNaLD and SCOUT.
</p>

[an error occurred while processing this directive]