Bool make_conjunction_of_atoms( PlNode **n ) { PlNode *tmp, *i, *p, *m; if ( !(*n) ) { return TRUE; } if ( (*n)->connective != AND ) { switch ( (*n)->connective ) { case ATOM: tmp = new_PlNode( ATOM ); tmp->atom = (*n)->atom; (*n)->atom = NULL; (*n)->connective = AND; (*n)->sons = tmp; return TRUE; case NOT: free_PlNode( *n ); (*n) = NULL; return TRUE; default: return FALSE; } } p = NULL; i = (*n)->sons; while ( i ) { switch ( i->connective ) { case ATOM: p = i; i = i->next; break; case NOT: if ( p ) { p->next = i->next; } else { (*n)->sons = i->next; } m = i->next; i->next = NULL; free_PlNode( i ); i = m; break; default: return FALSE; } } return TRUE; }
void free_PlNode( PlNode *node ) { if ( node ) { free_PlNode( node->sons ); free_PlNode( node->next ); free_TokenList( node->atom ); free( node ); } }
void free_PlOperator( PlOperator *o ) { if ( o ) { free_PlOperator( o->next ); if ( o->name ) { free( o->name ); } free_FactList( o->params ); free_PlNode( o->preconds ); free_PlNode( o->effects ); free( o ); } }
void create_integer_representation( void ) { PlNode *n; PlOperator *o; Operator *tmp; FactList *ff; int type_num, i; if ( gorig_initial_facts ) { for ( n = gorig_initial_facts->sons; n; n = n->next ) { if ( gnum_full_initial == MAX_INITIAL ) { printf("\ntoo many initial facts! increase MAX_INITIAL (currently %d)\n\n", MAX_INITIAL); exit( 1 ); } make_Fact( &(gfull_initial[gnum_full_initial]), n, NULL ); if ( gfull_initial[gnum_full_initial].predicate == -1 ) { printf("\nequality in initial state! check input files.\n\n"); exit( 1 ); } gnum_full_initial++; } free_PlNode( gorig_initial_facts ); } if ( gorig_goal_facts ) { for ( n = gorig_goal_facts->sons; n; n = n->next ) { if ( gnum_goal == MAX_STATE ) { printf("\ntoo many goal facts! increase MAX_STATE (currently %d)\n\n", MAX_STATE); exit( 1 ); } make_Fact( &(ggoal[gnum_goal]), n, NULL ); if ( ggoal[gnum_goal].predicate == -1 ) { printf("\nequality in goal state! check input files.\n\n"); exit( 1 ); } gnum_goal++; } free_PlNode( gorig_goal_facts ); } for ( i = 0; i < MAX_TYPES; i++ ) { gpredicate_to_type[i] = -1; gnum_intersected_types[i] = -1; } for ( o = gloaded_ops; o; o = o->next ) { tmp = new_Operator( o->name, o->number_of_real_params ); for ( ff = o->params; ff; ff = ff->next ) { if ( (type_num = position_in_types_table( ff->item->next->item )) == -1 ) { printf("\nwarning: parameter %s of op %s has unknown or empty type. skipping op", ff->item->item, ff->item->next->item); break; } if ( tmp->num_vars == MAX_VARS ) { printf("\ntoo many parameters! increase MAX_VARS (currently %d)\n\n", MAX_VARS); exit( 1 ); } tmp->var_names[tmp->num_vars] = ff->item->item; tmp->var_types[tmp->num_vars++] = type_num; } if ( ff ) { free_Operator( tmp ); continue; } if ( o->preconds ) { for ( n = o->preconds->sons; n; n = n->next ) { if ( tmp->num_preconds == MAX_OP_P ) { printf("\ntoo many preconds! increase MAX_OP_P (currently %d)\n\n", MAX_OP_P); exit( 1 ); } make_Fact( &((tmp->preconds)[tmp->num_preconds]), n, tmp ); tmp->num_preconds++; } } if ( o->effects ) { for ( n = o->effects->sons; n; n = n->next ) { if ( n->connective == ATOM ) { if ( tmp->num_adds == MAX_OP_A ) { printf("\ntoo many added facts! increase MAX_OP_A (currently %d)\n\n", MAX_OP_A); exit( 1 ); } make_Fact( &((tmp->adds)[tmp->num_adds]), n, tmp ); if ( (tmp->adds)[tmp->num_adds].predicate == -1 ) { printf("\nequality in effect of op %s! check input files.\n\n", o->name); exit( 1 ); } tmp->num_adds++; } else {/* n->connective == NOT */ if ( tmp->num_dels == MAX_OP_D ) { printf("\ntoo many deleted facts! increase MAX_OP_D (currently %d)\n\n", MAX_OP_D); exit( 1 ); } make_Fact( &((tmp->dels)[tmp->num_dels]), n->sons, tmp ); if ( (tmp->dels)[tmp->num_dels].predicate == -1 ) { printf("\nequality in effect of op %s! check input files.\n\n", o->name); exit( 1 ); } tmp->num_dels++; } } } if ( gnum_operators == MAX_OPERATORS ) { printf("\ntoo many operators! increase MAX_OPERATORS (currently %d)\n\n", MAX_OPERATORS); exit( 1 ); } goperators[gnum_operators++] = tmp; } free_PlOperator( gloaded_ops ); }