void bddDump(bdd_manager *bddm)
{
int i;
printf("\nBDD DUMP:\n");
for (i = 0; i < bdd_roots_length(bddm); i++)
bddDumpNode(bddm, BDD_ROOT(bddm, i));
printf("END\n\n");
for (i = 0; i < bdd_roots_length(bddm); i++)
bddReverseMarks(bddm, BDD_ROOT(bddm, i));
}
void dumpBM(BehaviourMatrix *bbb, bdd_manager *bddm)
{
int i, j;
printf("\nBEHAVIOUR:");
for (i = 0; i < bbb->lf; i++) {
for (j = 0; j < bbb->rf; j++)
printf("%u ", BDD_ROOT(bddm, bbb->m[i*bbb->rs+j]));
printf("\n");
}
bddDump(bddm);
}
void gtaReplaceIndices(GTA *P, unsigned map[])
{
unsigned i,p1,p2;
for (i = 0; i < guide.numSs; i++) {
unsigned rs = P->ss[guide.muRight[i]].size;
unsigned ls = P->ss[guide.muLeft[i]].size;
bdd_prepare_apply1(P->ss[i].bddm);
for (p1 = 0; p1 < ls; p1++)
for (p2 = 0; p2 < rs; p2++)
bdd_replace_indices(
P->ss[i].bddm,
BDD_ROOT(P->ss[i].bddm, BEH(P->ss[i], p1, p2)),
map);
}
}
static void printTypeExample(Tree *example, unsigned num, char *names[],
char orders[], unsigned indices[],
int *univs[], int trees[])
{
trace_descr bools;
int i;
bools = find_one_path(example->bddm,
BDD_ROOT(example->bddm,
example->behavior_handle),
example->state);
for (i = 0; i < num; i++) {
printf(" %s = ", names[i]);
switch (orders[i]) {
case 0: /* Boolean variable */
{
trace_descr t = bools;
while (t && (t->index != indices[i]))
t = t->next;
if (t && t->value)
printf("true\n");
else
printf("false\n");
break;
}
case 1: /* first-order variable */
{
int j, first = 1, any = 0;
for (j = 0; univs[i][j] != -1; j++) {
int u = univs[i][j];
Tree *t = findNode(example, guide.univPos[u], 0);
if (t) {
char *univname = guide.univName[u];
char *path = (char *) mem_alloc(strlen(univname)+2);
sprintf(path, "%s:", univname);
printTypePositions(t, indices[i], &first, 1, 0, path,
guide.ssType[t->d]);
if (!first)
any = 1;
mem_free(path);
}
}
if (!any)
printf("?");
printf("\n");
break;
}
case 2: /* second-order variable */
{
if (trees[i]) { /* print as typed tree */
int j, any = 0;
for (j = 0; univs[i][j] != -1 && !any; j++) {
int u = univs[i][j];
Tree *t = findNode(example, guide.univPos[u], 0);
if (t) {
char *univname = guide.univName[u];
char *path = (char *) mem_alloc(strlen(univname)+2);
sprintf(path, "%s:", univname);
t = printTreeRoot(t, indices[i], guide.ssType[t->d], path);
mem_free(path);
if (t) {
printTypedTree(guide.ssType[t->d], t, indices[i]);
any = 1;
}
}
}
if (!any)
printf("?");
printf("\n");
}
else { /* print as set of positions */
int j, first = 1;
printf("{");
for (j = 0; univs[i][j] != -1; j++) {
int u = univs[i][j];
Tree *t = findNode(example, guide.univPos[u], 0);
if (t) {
char *univname = guide.univName[u];
char *path = (char *) mem_alloc(strlen(univname)+2);
sprintf(path, "%s:", univname);
printTypePositions(t, indices[i], &first, 1, 1, path,
guide.ssType[t->d]);
mem_free(path);
}
}
printf("}\n");
}
break;
}
}
}
kill_trace(bools);
}
int main () {
GTA* G;
char **free_vars;
int *orders;
unsigned numvars;
SSSet *statespaces;
/*read the automaton from a file, the TRUE argument means that the
guide is being defined by the automaton description in the file */
G = gtaImport("html.gta", &free_vars, &orders, &statespaces, TRUE);
if(!G) {
printf("error: file 'html.gta' not found (run 'mona -n html.mona')\n");
exit(1);
}
printf("Guide: number of state spaces is %d\n", guide.numSs);
/* illustrate use of state space names */
{
SsId d;
for (d = 0; d < guide.numSs; d++)
printf("State space %s is numbered %d\n", guide.ssName[d], d);
}
/* illustrate use of inherited acceptance information */
{
SsId d;
State p;
int s;
boolean ***inheritedAcceptance = gtaCalcInheritedAcceptance(G);
for (d = 0; d < guide.numSs; d++) {
printf("State space %d\n", d);
for (p = 0; p < G->ss[d].size; p++)
for (s = 1; s >= -1; s--)
printf(" State %d can%s lead to %s\n",
p, inheritedAcceptance[d][p][s]? "": " not",
(s==1)? "accept":(s==0)? "don't care": "reject");
}
gtaFreeInheritedAcceptance(inheritedAcceptance);
}
/* illustrate how to find indices of free variables and how to find
out about their order (Boolean, first-order, or second-order) */
{
unsigned i;
numvars = 0;
while (free_vars[numvars] != 0)
numvars++;
printf("Number of free variables: %d\n", numvars);
if (numvars != 6) {
printf("Oops\n");
exit(1);
}
/* get table index of variable G1 */
for (i = 0; i < numvars; i++)
if (strcmp(free_vars[i], "G1")==0)
break;
if (i == numvars)
printf("G1 not found\n");
else {
printf("G1 has index %d and is %d. order\n", i, orders[i]);
}
}
/* illustrate how to analyze the BDD associated with an entry in the
transition table */
{ /* lookup, say, transition corresponding to state space 1,
state pair (left, right) = (4,3) */
unsigned i;
bdd_ptr my_bdd_ptr = BDD_ROOT(G->ss[1].bddm, BEH(G->ss[1], 4, 3));
char var_is_used[MAXVARS]; /* var_is_used[i] is true iff variable i
is the index of some BDD node in
the DAG rooted in my_bdd_ptr */
printf("State space 0 goes to (%d, %d)\n",
guide.muLeft[0], guide.muRight[0]);
printf("State space 1 goes to (%d, %d)\n",
guide.muLeft[1], guide.muRight[1]);
printf("Number of BDD nodes in state space 1: %d\n", bdd_size(G->ss[1].bddm));
for (i = 0; i < numvars; i++)
var_is_used[i] = 0;
bdd_prepare_apply1(G->ss[1].bddm);
my_global_variable = var_is_used;
global_bddm = (G->ss[1].bddm);
bdd_operate_on_nodes(G->ss[1].bddm, my_bdd_ptr, &check_off_index);
for (i = 0; i < numvars; i++)
if (var_is_used[i])
printf("Variable %s in use for transitions from (4,3) in state space 1\n",
free_vars[i]);
}
/* illustrate how to perform a lookup in the transition table */
{
char bit_vector[6] = {0, 1, 1, 0, 1, 0};
bdd_manager *bddm = G->ss[1].bddm;
bdd_ptr my_bdd_ptr = BDD_ROOT(bddm, BEH(G->ss[1], 0, 2));
while (!bdd_is_leaf(bddm, my_bdd_ptr)) {
my_bdd_ptr = (bit_vector[bdd_ifindex(bddm, my_bdd_ptr)])?
bdd_then(bddm, my_bdd_ptr):
bdd_else(bddm, my_bdd_ptr);
}
printf("State reached from (0,2) on {0, 1, 1, 0, 1, 0} is %d\n",
bdd_leaf_value(bddm, my_bdd_ptr));
}
return 0;
}
int main() {
bdd_manager *bddm, *bddm1;
bdd_ptr zero, one;
bdd_handle var2, var7;
bdd_ptr and_2_7, nand_2_7;
/*bdd_handle handle;*/
bdd_init(); /* needed since we're using statistics */
bddm = bdd_new_manager(100,50);
/* get a BDD pointer to a node that is the leaf with value 0 */
zero = bdd_find_leaf_hashed_add_root(bddm, 0);
/* and a leaf with value 1 */
one = bdd_find_leaf_hashed_add_root(bddm, 1);
/* note already at this point "zero" could have been invalidated if
the table doubled, but we know that there is room for a 100
nodes---anyway, this is really very bad style, so we go on in
a more appropriate manner */
/* "then" part is one, "else" part is zero */
var2 = bdd_handle_find_node_hashed_add_root(bddm, zero, one, 2);
var7 = bdd_handle_find_node_hashed_add_root(bddm, zero, one, 7);
/* check node pointers and handles */
assert(zero == BDD_ROOT(bddm, 0)); /* since table was not doubled */
assert(one == BDD_ROOT(bddm, 1));
assert(var2 == 2);
assert(var7 == 3);
bddm1 = bdd_new_manager(100,50); /* make room for at least 100 nodes,
overflow increment is 50 */
bdd_make_cache(bddm1, 100, 50); /* apply2 needs a result cache, here the size
is a hundred with increment 50 */
/* apply operation on var2 and var7 in bddm; the result is
a completely fresh bdd in bddm1 and a BDD pointer, named "and_2_7" */
and_2_7 = bdd_apply2_hashed(bddm, BDD_ROOT(bddm, var2), /* BDD #1 */
bddm, BDD_ROOT(bddm, var7), /* BDD #2 */
bddm1, /* result BDD */
&and); /* leaf operation */
bdd_update_statistics(bddm, 0); /* update statics group "0" with data from bddm
before killing the manager */
printf("Size of bddm: %d\n\n", bdd_size(bddm)); /* let's see the number of nodes created */
bdd_kill_manager(bddm);
printf("Size of bddm1: %d\n\n", bdd_size(bddm1));
/*handle = BDD_LAST_HANDLE(bddm1);*/
/*
assert(handle == 0);
assert(BDD_ROOT(bddm1, handle) == and_2_7);
*/
/* reset all mark fields in bddm1 before an apply1 operation */
bdd_prepare_apply1(bddm1);
/* a new bdd (which as an unlabelled graph is isomorphic to old one)
in bddm1 is the result of the following apply operation */
/* it's safe here to use and_2_7 since no operations were performed
after it was calculated that could have entailed doubling of table */
nand_2_7 = bdd_apply1(bddm1, and_2_7, bddm1, ¬);
bdd_update_statistics(bddm1, 1);
printf("Size of bddm1: %d\n\n", bdd_size(bddm1));
print_bdd(bddm1, and_2_7);
printf("\n\n");
print_bdd(bddm1, nand_2_7);
printf("\n\n");
bdd_kill_manager(bddm1);
bdd_print_statistics(0, "bddm"); /* print group 0 statistics with heading "bddm" */
bdd_print_statistics(1, "bddm1"); /* print group 1 statistics with heading "bddm1" */
return 0;
}
