ATrans *boolean(tl_Node *p) /* computes the transitions to boolean nodes -> next & init */
{
    ATrans *t1, *t2, *lft, *rgt, *result = (ATrans *)0;
    int id;
    switch (p->ntyp)
    {
    case TRUE:
        result = emalloc_atrans();
        clear_set(result->to,  0);
        clear_set(result->pos, 1);
        clear_set(result->neg, 1);
    case FALSE:
        break;
    case AND:
        lft = boolean(p->lft);
        rgt = boolean(p->rgt);
        for (t1 = lft; t1; t1 = t1->nxt)
        {
            for (t2 = rgt; t2; t2 = t2->nxt)
            {
                ATrans *tmp = merge_trans(t1, t2);
                if (tmp)
                {
                    tmp->nxt = result;
                    result = tmp;
                }
            }
        }
        free_atrans(lft, 1);
        free_atrans(rgt, 1);
        break;
    case OR:
        lft = boolean(p->lft);
        for (t1 = lft; t1; t1 = t1->nxt)
        {
            ATrans *tmp = dup_trans(t1);
            tmp->nxt = result;
            result = tmp;
        }
        free_atrans(lft, 1);
        rgt = boolean(p->rgt);
        for (t1 = rgt; t1; t1 = t1->nxt)
        {
            ATrans *tmp = dup_trans(t1);
            tmp->nxt = result;
            result = tmp;
        }
        free_atrans(rgt, 1);
        break;
    default:
        build_alternating(p);
        result = emalloc_atrans();
        clear_set(result->to,  0);
        clear_set(result->pos, 1);
        clear_set(result->neg, 1);
        add_set(result->to, already_done(p));
    }
    return result;
}
Пример #2
0
void simplify_atrans(ATrans **trans) /* simplifies the transitions */
{
  ATrans *t, *father = (ATrans *)0;
  for(t = *trans; t;) {
    ATrans *t1;
    for(t1 = *trans; t1; t1 = t1->nxt) {
      if((t1 != t) && 
	 included_set(t1->to,  t->to,  0) &&
	 included_set(t1->pos, t->pos, 1) &&
	 included_set(t1->neg, t->neg, 1))
	break;
    }
    if(t1) {
      if (father)
	father->nxt = t->nxt;
      else
	*trans = t->nxt;
      free_atrans(t, 0);
      if (father)
	t = father->nxt;
      else
	t = *trans;
      continue;
    }
    atrans_count++;
    father = t;
    t = t->nxt;
  }
}
void simplify_astates() /* simplifies the alternating automaton */
{
    ATrans *t;
    int i, *acc = make_set(-1, 0); /* no state is accessible initially */

    for (t = transition[0]; t; t = t->nxt, i = 0)
    {
        merge_sets(acc, t->to, 0);    /* all initial states are accessible */
    }

    for (i = node_id - 1; i > 0; i--)
    {
        if (!in_set(acc, i))   /* frees unaccessible states */
        {
            label[i] = ZN;
            free_atrans(transition[i], 1);
            transition[i] = (ATrans *)0;
            continue;
        }
        astate_count++;
        simplify_atrans(&transition[i]);
        for (t = transition[i]; t; t = t->nxt)
        {
            merge_sets(acc, t->to, 0);
        }
    }

    tfree(acc);
}
Пример #4
0
void do_merge_trans(ATrans **result, ATrans *trans1, ATrans *trans2) 
{ /* merges two transitions */
  if(!trans1 || !trans2) {
    free_atrans(*result, 0);
    *result = (ATrans *)0;
    return;
  }
  if(!*result)
    *result = emalloc_atrans();
  do_merge_sets((*result)->to, trans1->to,  trans2->to,  0);
  do_merge_sets((*result)->pos, trans1->pos, trans2->pos, 1);
  do_merge_sets((*result)->neg, trans1->neg, trans2->neg, 1);
  if(!empty_intersect_sets((*result)->pos, (*result)->neg, 1)) {
    free_atrans(*result, 0);
    *result = (ATrans *)0;
  }
}