A Guide to Using ACT Data Structures

Getting Started


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:

Act::Init (&argc, &argv);

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:

Act *a;
a = new Act (argv[1]);

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):

Process *p = a->findProcess (argv[2]);
if (!p->isExpanded()) {
   p = p->Expand (ActNamespace::Global(), p->CurScope(), 0, NULL);

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:

act_languages *lang;
lang = p->getlang();

This provides access to all the sub-languages specified within the process.1)

Referencing a particular language body

A language body can be accessed from the languages pointer. For example, for the chp body:

act_chp *chp;
chp = lang->getchp();

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:

act_chp_lang_t *chp_lang;
chp_lang = chp->c;

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:

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
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.