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; }