in grolp/gen/ff_planner/inst_final.c [98:357]
void perform_reachability_analysis( void )
{
int size, i, j, k, adr, num, pargtype;
Bool fixpoint;
Facts *f;
NormOperator *no;
EasyTemplate *t1, *t2;
NormEffect *ne;
Action *tmp, *a;
Bool *had_hard_template;
PseudoAction *pa;
PseudoActionEffect *pae;
gactions = NULL;
gnum_actions = 0;
for ( i = 0; i < gnum_predicates; i++ ) {
size = 1;
for ( j = 0; j < garity[i]; j++ ) {
pargtype = gpredicates_args_type[i][j];
size *= gtype_size[pargtype];
}
lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) );
luse[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) );
for ( j = 0; j < size; j++ ) {
lpos[i][j] = 0;
lneg[i][j] = 1;/* all facts but initials are poss. negative */
luse[i][j] = 0;
lindex[i][j] = -1;
}
}
had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) );
for ( i = 0; i < gnum_hard_templates; i++ ) {
had_hard_template[i] = FALSE;
}
/* mark initial facts as possibly positive, not poss. negative
*/
for ( i = 0; i < gnum_predicates; i++ ) {
lp = i;
for ( j = 0; j < gnum_initial_predicate[i]; j++ ) {
for ( k = 0; k < garity[i]; k++ ) {
largs[k] = ginitial_predicate[i][j].args[k];
}
adr = fact_adress();
lpos[lp][adr] = 1;
lneg[lp][adr] = 0;
}
}
/* compute fixpoint
*/
fixpoint = FALSE;
while ( !fixpoint ) {
fixpoint = TRUE;
/* assign next layer of easy templates to possibly positive fixpoint
*/
t1 = geasy_templates;
while ( t1 ) {
no = t1->op;
for ( i = 0; i < no->num_preconds; i++ ) {
lp = no->preconds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ( no->preconds[i].args[j] >= 0 ) ?
no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )];
}
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( i < no->num_preconds ) {
t1 = t1->next;
continue;
}
num = 0;
for ( ne = no->effects; ne; ne = ne->next ) {
num++;
/* currently, simply ignore effect conditions and assume
* they will all be made true eventually.
*/
for ( i = 0; i < ne->num_adds; i++ ) {
lp = ne->adds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ( ne->adds[i].args[j] >= 0 ) ?
ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )];
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n",
MAX_RELEVANT_FACTS);
exit( 1 );
}
grelevant_facts[gnum_relevant_facts].predicate = lp;
for ( j = 0; j < garity[lp]; j++ ) {
grelevant_facts[gnum_relevant_facts].args[j] = largs[j];
}
lindex[lp][adr] = gnum_relevant_facts;
gnum_relevant_facts++;
fixpoint = FALSE;
}
}
}
tmp = new_Action();
tmp->norm_operator = no;
tmp->axiom = no->operator->axiom;
for ( i = 0; i < no->num_vars; i++ ) {
tmp->inst_table[i] = t1->inst_table[i];
}
tmp->name = no->operator->name;
tmp->num_name_vars = no->operator->number_of_real_params;
make_name_inst_table_from_NormOperator( tmp, no, t1 );
tmp->next = gactions;
tmp->num_effects = num;
gactions = tmp;
gnum_actions++;
t2 = t1->next;
if ( t1->next ) {
t1->next->prev = t1->prev;
}
if ( t1->prev ) {
t1->prev->next = t1->next;
} else {
geasy_templates = t1->next;
}
free_single_EasyTemplate( t1 );
t1 = t2;
}
/* now assign all hard templates that have not been transformed
* to actions yet.
*/
for ( i = 0; i < gnum_hard_templates; i++ ) {
if ( had_hard_template[i] ) {
continue;
}
pa = ghard_templates[i];
for ( j = 0; j < pa->num_preconds; j++ ) {
lp = pa->preconds[j].predicate;
for ( k = 0; k < garity[lp]; k++ ) {
largs[k] = pa->preconds[j].args[k];
}
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( j < pa->num_preconds ) {
continue;
}
for ( pae = pa->effects; pae; pae = pae->next ) {
/* currently, simply ignore effect conditions and assume
* they will all be made true eventually.
*/
for ( j = 0; j < pae->num_adds; j++ ) {
lp = pae->adds[j].predicate;
for ( k = 0; k < garity[lp]; k++ ) {
largs[k] = pae->adds[j].args[k];
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n",
MAX_RELEVANT_FACTS);
exit( 1 );
}
grelevant_facts[gnum_relevant_facts].predicate = lp;
for ( k = 0; k < garity[lp]; k++ ) {
grelevant_facts[gnum_relevant_facts].args[k] = largs[k];
}
lindex[lp][adr] = gnum_relevant_facts;
gnum_relevant_facts++;
fixpoint = FALSE;
}
}
}
tmp = new_Action();
tmp->pseudo_action = pa;
tmp->axiom = pa->operator->axiom;
for ( j = 0; j < pa->operator->num_vars; j++ ) {
tmp->inst_table[j] = pa->inst_table[j];
}
tmp->name = pa->operator->name;
tmp->num_name_vars = pa->operator->number_of_real_params;
make_name_inst_table_from_PseudoAction( tmp, pa );
tmp->next = gactions;
tmp->num_effects = pa->num_effects;
gactions = tmp;
gnum_actions++;
had_hard_template[i] = TRUE;
}
}
free( had_hard_template );
gnum_pp_facts = gnum_initial + gnum_relevant_facts;
if ( gcmd_line.display_info == 118 ) {
printf("\nreachability analysys came up with:");
printf("\n\npossibly positive facts:");
for ( f = ginitial; f; f = f->next ) {
printf("\n");
print_Fact( f->fact );
}
for ( i = 0; i < gnum_relevant_facts; i++ ) {
printf("\n");
print_Fact( &(grelevant_facts[i]) );
}
printf("\n\nthis yields these %d action templates:", gnum_actions);
for ( i = 0; i < gnum_operators; i++ ) {
printf("\n\noperator %s:", goperators[i]->name);
for ( a = gactions; a; a = a->next ) {
if ( ( a->norm_operator &&
a->norm_operator->operator != goperators[i] ) ||
( a->pseudo_action &&
a->pseudo_action->operator != goperators[i] ) ) {
continue;
}
printf("\ntemplate: ");
if ( a->axiom ) printf("(axiom) ");
for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) {
printf("%s", gconstants[a->name_inst_table[j]]);
if ( j < goperators[i]->num_vars-1 ) {
printf(" ");
}
}
}
}
printf("\n\n");
}
}