====== A Guide to Using ACT Data Structures ======

===== Getting Started =====

==== Initialization ====

Act configuration files are read in and any ACT command-line options are parsed and removed from the argument list automatically when the library is initialized as:
<code>
Act::Init (&argc, &argv);
</code>
where ''argc'' and ''argv'' are the usual command-line options to ''main()''. This should be the first function call before any other ACT functions are used. 
When this call is executed, any configuration files provided on the command-line and the default configuration files are read in and processed to create internal act data structures.
Typically, the next step is to create an ''Act'' pointer to the data structure:
<code>
Act *a;
a = new Act (argv[1]);
</code>
where ''argv[1]'' is the top-level ACT file name. This parses the ACT input file, and creates data structures for all the instances, namespaces, processes, etc. specified in the ACT file.
==== Referencing a process ====

Once the ''Act'' pointer has been created, a process (provided in the command-line arguments) within the file can be accessed and expanded (if necessary):
<code>
Process *p = a->findProcess (argv[2]);
if (!p->isExpanded()) {
   p = p->Expand (ActNamespace::Global(), p->CurScope(), 0, NULL);
}
</code>
In this example, the assumption is that ''argv[2]'' holds a string that corresponds to the process name.
==== Referencing the languages body ====

The languages body can be accessed from the process pointer:
<code>
act_languages *lang;
lang = p->getlang();
</code>
This provides access to all the sub-languages specified within the process.((The refinement body is processed by the expansion phase, and hence the expanded process will contains the appropriate sub-language bodies after taking the specified number of refinement steps into account. This is why ''-ref=k'' is an ACT command-line option.))
==== Referencing a particular language body ====

A language body can be accessed from the languages pointer. For example, for the chp body:
<code c++>
act_chp *chp;
chp = lang->getchp();
</code>
Note that the ''chp'' pointer will be NULL if there is no CHP sub-language specified within the process definition.

Finally, to get a pointer to the actual object that stores the CHP data structure:
<code>
act_chp_lang_t *chp_lang;
chp_lang = chp->c;
</code>

===== The CHP data structure =====
The ''act_chp_lang_t'' object is an object of the ''act_chp_lang'' structure (definition in ''lang.h''). It contains an integer ''type'', which says what type of ''ACT_CHP'' token it is. Two other members ''label'' and ''space'' are typically ''NULL''. The final member ''u'' is an object that contains the actual CHP statement. For example, any given ''u'' can be a loop, doloop, assignment statement, communication action, etc. Each of these have their own structure and the object is a ''union'' of these. One of the possibilities: a comma or semicolon separated list of statements is stored as a ''list_t'' linked list ''semi_comma.cmd''.

==== The statement list data structure ====
The linked list ''list_t'' contains elements of type ''listitem_t''. See ''list.h'' or ''list.c'' for details and available methods. In a CHP data structure, this is used to store lists of statements. To get the actual statement stored in the list of statements, call ''list_value'' on the required ''listitem_t'' of the list:
<code c++>
act_chp_lang_t *c; // contains the overall chp body
act_chp_lang_t *stmt;
list_t *stmt_list;
listitem_t *li;

// if c->type is ACT_CHP_SEMI or ACT_CHP_COMMA 
stmt_list = c->u.semi_comma.cmd; // returns the linked list

for (li = list_first (stmt_list); li; li = list_next (li)) {

stmt = (act_chp_lang_t *)(list_value(li));
// do something here

}
</code>