void free_NormOperator( NormOperator *o )
{
int i;
if ( o ) {
if ( o->preconds ) {
free( o->preconds );
}
if ( o->numeric_preconds_comp ) {
free( o->numeric_preconds_comp );
}
for ( i = 0; i < o->num_numeric_preconds; i++ ) {
free_ExpNode( o->numeric_preconds_lh[i] );
free_ExpNode( o->numeric_preconds_rh[i] );
}
if ( o->numeric_preconds_lh ) {
free( o->numeric_preconds_lh );
}
if ( o->numeric_preconds_rh ) {
free( o->numeric_preconds_rh );
}
free_NormEffect( o->effects );
free( o );
}
}
void free_ExpNode( ExpNode *n )
{
if ( n ) {
if ( n->fluent ) free( n->fluent );
free_ExpNode( n->son );
free_ExpNode( n->leftson );
free_ExpNode( n->rightson );
free( n );
}
}
void free_NormEffect( NormEffect *e )
{
int i;
if ( e ) {
free_NormEffect( e->next );
if ( e->conditions ) {
free( e->conditions );
}
if ( e->adds ) {
free( e->adds );
}
if ( e->dels ) {
free( e->dels );
}
if ( e->numeric_conditions_comp ) {
free( e->numeric_conditions_comp );
}
for ( i = 0; i < e->num_numeric_conditions; i++ ) {
free_ExpNode( e->numeric_conditions_lh[i] );
free_ExpNode( e->numeric_conditions_rh[i] );
}
if ( e->numeric_conditions_lh ) {
free( e->numeric_conditions_lh );
}
if ( e->numeric_conditions_rh ) {
free( e->numeric_conditions_rh );
}
if ( e->numeric_effects_neft ) {
free( e->numeric_effects_neft );
}
if ( e->numeric_effects_fluent ) {
free( e->numeric_effects_fluent );
}
for ( i = 0; i < e->num_numeric_effects; i++ ) {
free_ExpNode( e->numeric_effects_rh[i] );
}
if ( e->numeric_effects_rh ) {
free( e->numeric_effects_rh );
}
free( e );
}
}
void free_WffNode( WffNode *w )
{
if ( w ) {
free_WffNode( w->son );
free_WffNode( w->sons );
free_WffNode( w->next );
if ( w->var_name ) {
free( w->var_name );
}
if ( w->fact ) free( w->fact );
free_ExpNode( w->lh );
free_ExpNode( w->rh );
free( w );
}
}
void multiply_easy_non_constrained_effect_parameters( int curr_parameter )
{
int t, n, i, j, k, p, par;
NormEffect *tmp;
Bool rem;
if ( curr_parameter == lnum_multiply_parameters ) {
/* create new effect, adjusting conds to inst, and
* partially instantiating effects;
*
* add result to lres
*/
tmp = new_NormEffect2( le );
/* instantiate param occurences
*/
for ( i = 0; i < le->num_vars; i++ ) {
par = lo->num_vars + i;
/* numerical part
*/
for ( j = 0; j < tmp->num_numeric_conditions; j++ ) {
replace_var_with_const_in_exp( &(tmp->numeric_conditions_lh[j]),
par, le->inst_table[i] );
}
for ( j = 0; j < tmp->num_numeric_conditions; j++ ) {
replace_var_with_const_in_exp( &(tmp->numeric_conditions_rh[j]),
par, le->inst_table[i] );
}
/* was that already enough to get numbers? if yes,
* see whether comparison holds or not.
*/
j = 0;
while ( j < tmp->num_numeric_conditions ) {
if ( tmp->numeric_conditions_lh[j]->connective == NUMBER &&
tmp->numeric_conditions_rh[j]->connective == NUMBER ) {
if ( number_comparison_holds( tmp->numeric_conditions_comp[j],
tmp->numeric_conditions_lh[j]->value,
tmp->numeric_conditions_rh[j]->value ) ) {
free_ExpNode( tmp->numeric_conditions_lh[j] );
free_ExpNode( tmp->numeric_conditions_rh[j] );
for ( k = j; k < tmp->num_numeric_conditions-1; k++ ) {
tmp->numeric_conditions_comp[k] = tmp->numeric_conditions_comp[k+1];
tmp->numeric_conditions_lh[k] = tmp->numeric_conditions_lh[k+1];
tmp->numeric_conditions_rh[k] = tmp->numeric_conditions_rh[k+1];
}
tmp->num_numeric_conditions--;
} else {
free_NormEffect( tmp );
return;
}
} else {
j++;
}
}
for ( j = 0; j < tmp->num_numeric_effects; j++ ) {
for ( k = 0; k < gf_arity[tmp->numeric_effects_fluent[j].function]; k++ ) {
if ( tmp->numeric_effects_fluent[j].args[k] == ENCODE_VAR( par ) ) {
tmp->numeric_effects_fluent[j].args[k] = le->inst_table[i];
}
}
}
for ( j = 0; j < tmp->num_numeric_effects; j++ ) {
replace_var_with_const_in_exp( &(tmp->numeric_effects_rh[j]),
par, le->inst_table[i] );
}
/* logical part
*/
for ( j = 0; j < tmp->num_conditions; j++ ) {
for ( k = 0; k < garity[tmp->conditions[j].predicate]; k++ ) {
if ( tmp->conditions[j].args[k] == ENCODE_VAR( par ) ) {
tmp->conditions[j].args[k] = le->inst_table[i];
}
}
}
for ( j = 0; j < tmp->num_adds; j++ ) {
for ( k = 0; k < garity[tmp->adds[j].predicate]; k++ ) {
if ( tmp->adds[j].args[k] == ENCODE_VAR( par ) ) {
tmp->adds[j].args[k] = le->inst_table[i];
}
}
}
for ( j = 0; j < tmp->num_dels; j++ ) {
for ( k = 0; k < garity[tmp->dels[j].predicate]; k++ ) {
if ( tmp->dels[j].args[k] == ENCODE_VAR( par ) ) {
tmp->dels[j].args[k] = le->inst_table[i];
}
}
}
}
/* adjust conditions
*/
i = 0;
while ( i < tmp->num_conditions ) {
rem = FALSE;
p = tmp->conditions[i].predicate;
if ( !gis_added[p] &&
!gis_deleted[p] ) {
for ( j = 0; j < garity[p]; j++ ) {
if ( tmp->conditions[i].args[j] < 0 &&
DECODE_VAR( tmp->conditions[i].args[j] < lo->num_vars ) ) {
break;
}
}
if ( j == garity[p] ) {
/* inertia that constrain only effect params have been unified,
* are therefore TRUE
*/
rem = TRUE;
}
}
if ( rem ) {
for ( j = i; j < tmp->num_conditions - 1; j++ ) {
tmp->conditions[j].predicate = tmp->conditions[j+1].predicate;
for ( k = 0; k < garity[tmp->conditions[j+1].predicate]; k++ ) {
tmp->conditions[j].args[k] = tmp->conditions[j+1].args[k];
}
}
tmp->num_conditions--;
} else {
i++;
}
}
/* add result to lres
*/
if ( lres ) {
lres->prev = tmp;
}
tmp->next = lres;
lres = tmp;
return;
}
t = le->var_types[lmultiply_parameters[curr_parameter]];
n = gtype_size[t];
for ( i = 0; i < n; i++ ) {
le->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i];
multiply_easy_non_constrained_effect_parameters( curr_parameter + 1 );
}
le->inst_table[lmultiply_parameters[curr_parameter]] = -1;
}
void instantiate_exp( ExpNode **n )
{
int j, f, k, h;
Bool ok;
switch ( (*n)->connective ) {
case AD:
instantiate_exp( &((*n)->leftson) );
instantiate_exp( &((*n)->rightson) );
if ( (*n)->leftson->connective != NUMBER ||
(*n)->rightson->connective != NUMBER ) {
break;
}
(*n)->connective = NUMBER;
(*n)->value = (*n)->leftson->value + (*n)->rightson->value;
free_ExpNode( (*n)->leftson );
(*n)->leftson = NULL;
free_ExpNode( (*n)->rightson );
(*n)->rightson = NULL;
break;
case SU:
instantiate_exp( &((*n)->leftson) );
instantiate_exp( &((*n)->rightson) );
if ( (*n)->leftson->connective != NUMBER ||
(*n)->rightson->connective != NUMBER ) {
break;
}
(*n)->connective = NUMBER;
(*n)->value = (*n)->leftson->value - (*n)->rightson->value;
free_ExpNode( (*n)->leftson );
(*n)->leftson = NULL;
free_ExpNode( (*n)->rightson );
(*n)->rightson = NULL;
break;
case MU:
instantiate_exp( &((*n)->leftson) );
instantiate_exp( &((*n)->rightson) );
if ( (*n)->leftson->connective != NUMBER ||
(*n)->rightson->connective != NUMBER ) {
break;
}
(*n)->connective = NUMBER;
(*n)->value = (*n)->leftson->value * (*n)->rightson->value;
free_ExpNode( (*n)->leftson );
(*n)->leftson = NULL;
free_ExpNode( (*n)->rightson );
(*n)->rightson = NULL;
break;
case DI:
instantiate_exp( &((*n)->leftson) );
instantiate_exp( &((*n)->rightson) );
if ( (*n)->leftson->connective != NUMBER ||
(*n)->rightson->connective != NUMBER ) {
break;
}
if ( (*n)->rightson->value == 0 ) {
/* kind of unclean: simply leave that in here;
* we will later determine the right thing
* to do with it.
*/
break;
}
(*n)->connective = NUMBER;
(*n)->value = (*n)->leftson->value / (*n)->rightson->value;
free_ExpNode( (*n)->leftson );
(*n)->leftson = NULL;
free_ExpNode( (*n)->rightson );
(*n)->rightson = NULL;
break;
case MINUS:
instantiate_exp( &((*n)->son) );
if ( (*n)->son->connective != NUMBER ) break;
(*n)->connective = NUMBER;
(*n)->value = ((float) (-1)) * (*n)->son->value;
free_ExpNode( (*n)->son );
(*n)->son = NULL;
break;
case NUMBER:
break;
case FHEAD:
f = (*n)->fluent->function;
ok = TRUE;
for ( j = 0; j < gf_arity[f]; j++ ) {
h = ( (*n)->fluent->args[j] < 0 ) ?
linst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j];
if ( h < 0 ) {
ok = FALSE;
} else {
(*n)->fluent->args[j] = h;
}
}
if ( !ok ) {
break;
}
/* we handle only the case where the fluent is fully instantiated,
* static, and in the initial state.
*/
if ( gis_changed[f] ) break;
for ( j = 0; j < gnum_initial_function[f]; j++ ) {
for ( k = 0; k < gf_arity[f]; k++ ) {
if ( ginitial_function[f][j].fluent.args[k] !=
(*n)->fluent->args[k] ) break;
}
if ( k < gf_arity[f] ) continue;
(*n)->connective = NUMBER;
(*n)->value = ginitial_function[f][j].value;
break;
}
break;
default:
printf("\n\ninst exp: wrong specifier %d",
(*n)->connective);
exit( 1 );
}
}
WffNode *instantiate_wff( WffNode *w )
{
WffNode *res = NULL, *tmp, *i;
int j, m, h;
Bool ok, ct;
switch ( w->connective ) {
case AND:
m = 0;
i = w->sons;
while ( i ) {
tmp = instantiate_wff( i );
if ( tmp->connective == FAL ) {
free_WffNode( res );
return tmp;
}
if ( tmp->connective == TRU ) {
free( tmp );
i = i->next;
continue;
}
tmp->next = res;
if ( res ) {
res->prev = tmp;
}
res = tmp;
i = i->next;
m++;
}
if ( m == 0 ) {
res = new_WffNode( TRU );
break;
}
if ( m == 1 ) {
break;
}
tmp = new_WffNode( AND );
tmp->sons = res;
res = tmp;
break;
case OR:
m = 0;
i = w->sons;
while ( i ) {
tmp = instantiate_wff( i );
if ( tmp->connective == TRU ) {
free_WffNode( res );
return tmp;
}
if ( tmp->connective == FAL ) {
free( tmp );
i = i->next;
continue;
}
tmp->next = res;
if ( res ) {
res->prev = tmp;
}
res = tmp;
i = i->next;
m++;
}
if ( m == 0 ) {
res = new_WffNode( FAL );
break;
}
if ( m == 1 ) {
break;
}
tmp = new_WffNode( OR );
tmp->sons = res;
res = tmp;
break;
case ATOM:
res = new_WffNode( ATOM );
res->fact = new_Fact();
res->fact->predicate = w->fact->predicate;
ok = TRUE;
for ( j = 0; j < garity[res->fact->predicate]; j++ ) {
h = ( w->fact->args[j] < 0 ) ?
linst_table[DECODE_VAR( w->fact->args[j] )] : w->fact->args[j];
if ( h < 0 ) {
ok = FALSE;
res->fact->args[j] = w->fact->args[j];
} else {
res->fact->args[j] = h;
}
}
if ( !ok ) {/* contains ef params */
break;
}
if ( !full_possibly_negative( res->fact ) ) {
free( res->fact );
res->fact = NULL;
res->connective = TRU;
break;
}
if ( !full_possibly_positive( res->fact ) ) {
free( res->fact );
res->fact = NULL;
res->connective = FAL;
break;
}
break;
case COMP:
res = new_WffNode( COMP );
res->comp = w->comp;
res->lh = copy_Exp( w->lh );
res->rh = copy_Exp( w->rh );
instantiate_exp( &(res->lh) );
instantiate_exp( &(res->rh) );
if ( res->lh->connective != NUMBER ||
res->rh->connective != NUMBER ) {
/* logical simplification only possible if both parts are numbers
*/
break;
}
ct = number_comparison_holds( res->comp, res->lh->value, res->rh->value );
if ( ct ) {
res->connective = TRU;
free_ExpNode( res->lh );
res->lh = NULL;
free_ExpNode( res->rh );
res->rh = NULL;
res->comp = -1;
} else {
res->connective = FAL;
free_ExpNode( res->lh );
res->lh = NULL;
free_ExpNode( res->rh );
res->rh = NULL;
res->comp = -1;
}
break;
case TRU:
case FAL:
res = new_WffNode( w->connective );
break;
default:
printf("\n\nillegal connective %d in instantiate formula\n\n",
w->connective);
exit( 1 );
}
return res;
}