A Guide to Using ACT Data Structures

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.

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.

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.

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

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

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 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 linked list list_t contains elements of type listitem_t. See list.h or list.c for details and available methods. 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;

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

}