/* calls itself recursively to get all objects that are of the types and
* subtypes of ttl
*/
FactList *build_object_list_from_ttl( type_tree_list ttl, FactList *types_done )
{
FactList *f;
FactList *td;
FactList *std;
TokenList *t;
TokenList *tl_dummy;
TokenList *st;
type_tree_list sttl;
if ( !ttl ) {
return types_done;
}
types_done = build_object_list_from_ttl( ttl->next, types_done );
if ((t = type_already_known( ttl->item->name, types_done))) {
return types_done;
}
td = new_FactList();
t = td->item = new_TokenList();
/* begin with the name of the type...
*/
t->item = copy_Token( ttl->item->name );
for ( f = gorig_constant_list; f; f = f->next ) {
/* ...followed by objects of that type.
*/
if ( strcmp( f->item->next->item, ttl->item->name ) == SAME ) {
t->next = new_TokenList();
t = t->next;
t->item = copy_Token( f->item->item );
}
}
/* now append the objects of the subtypes
*/
std = build_object_list_from_ttl( ttl->item->sub_types, types_done );
/* now we can be sure that for each subtype a list with all
* objects of that type is somewhere in std. We simply take these
* lists and copy all of them into a new one for the supertype
*/
for ( sttl = ttl->item->sub_types; sttl; sttl = sttl->next ) {
st = type_already_known( sttl->item->name, std );
if ( st ) {
t->next = copy_complete_TokenList( st, &tl_dummy );
t = tl_dummy;
}
}
td->next = std;
return td;
}
void build_orig_constant_list( void )
{
FactList *f, *nextf, *end = NULL;
TokenList *t;
Bool do_count;
int objects_count = 0;
gtypes = build_object_list_from_ttl( gglobal_type_tree_list, NULL );
free_FactList( gorig_constant_list );
gorig_constant_list = NULL;
for ( f = gtypes; f; f = nextf ) {
nextf = f->next;
if ( strcmp( f->item->item, STANDARD_TYPE ) == SAME ) {
do_count = TRUE;
} else {
do_count = FALSE;
}
for ( t = f->item->next; t; t = t->next ) {
if ( !gorig_constant_list ) {
end = new_FactList();
gorig_constant_list = end;
} else {
end->next = new_FactList();
end = end->next;
}
end->item = new_TokenList();
end->item->item = copy_Token( t->item );
end->item->next = new_TokenList();
end->item->next->item = copy_Token( f->item->item );
if ( do_count ) {
/* count objects for RIFO meta strategy
*/
objects_count++;
}
}
}
}
void collect_type_names_in_pl( PlNode *n )
{
PlNode *i;
TypedList *tyl;
TokenList *tl;
char *tmp = NULL;
int nn;
if ( !n ) {
return;
}
switch( n->connective ) {
case ALL:
case EX:
for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) {
if ( tyl->type->next ) {
tmp = new_Token( MAX_LENGTH );
strcpy( tmp, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp, CONNECTOR );
strcat( tmp, tl->item );
}
} else {
tmp = copy_Token( tyl->type->item );
}
if ( (nn = get_type( tmp )) == -1 ) {
tyl->n = lnum_types;
ltype_names[lnum_types++] = copy_Token( tmp );
} else {
tyl->n = nn;
}
free( tmp );
tmp = NULL;
}
collect_type_names_in_pl( n->sons );
break;
case AND:
case OR:
for ( i = n->sons; i; i = i->next ) {
collect_type_names_in_pl( i );
}
break;
case NOT:
collect_type_names_in_pl( n->sons );
break;
case ATOM:
case TRU:
case FAL:
break;
case WHEN:
collect_type_names_in_pl( n->sons );
collect_type_names_in_pl( n->sons->next );
break;
default:
break;
}
}
void normalize_tyl_in_pl( PlNode **n )
{
PlNode *i;
TypedList *tyl;
PlNode *tmp_pl = NULL, *sons, *p_pl;
TokenList *tmp_tl, *tl;
if ( !(*n) ) {
return;
}
switch( (*n)->connective ) {
case ALL:
case EX:
/* we need to make a sequence of quantifiers ( ->sons ...)
* out of the given sequence of TypedList elements,
* with connected type names, var - name in TokenList
* and KEEPING THE SAME ORDERING !!
*/
if ( !(*n)->parse_vars ) {
printf("\n\nquantifier without argument !! check input files.\n\n");
exit( 1 );
}
tmp_tl = new_TokenList();
tmp_tl->next = new_TokenList();
tmp_tl->item = copy_Token( (*n)->parse_vars->name );
if ( (*n)->parse_vars->type->next ) {
tmp_tl->next->item = new_Token( MAX_LENGTH );
strcpy( tmp_tl->next->item, EITHER_STR );
for ( tl = (*n)->parse_vars->type; tl; tl = tl->next ) {
strcat( tmp_tl->next->item, CONNECTOR );
strcat( tmp_tl->next->item, tl->item );
}
} else {
tmp_tl->next->item = copy_Token( (*n)->parse_vars->type->item );
}
(*n)->atom = tmp_tl;
/* now add list of sons
*/
sons = (*n)->sons;
p_pl = *n;
for ( tyl = (*n)->parse_vars->next; tyl; tyl = tyl->next ) {
tmp_tl = new_TokenList();
tmp_tl->next = new_TokenList();
tmp_tl->item = copy_Token( tyl->name );
if ( tyl->type->next ) {
tmp_tl->next->item = new_Token( MAX_LENGTH );
strcpy( tmp_tl->next->item, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp_tl->next->item, CONNECTOR );
strcat( tmp_tl->next->item, tl->item );
}
} else {
tmp_tl->next->item = copy_Token( tyl->type->item );
}
tmp_pl = new_PlNode( (*n)->connective );
tmp_pl->atom = tmp_tl;
p_pl->sons = tmp_pl;
p_pl = tmp_pl;
}
/* remove typed-list-of info
*/
free_TypedList( (*n)->parse_vars );
(*n)->parse_vars = NULL;
/* the last son in list takes over ->sons
*/
p_pl->sons = sons;
/* normalize this sons and get out
*/
normalize_tyl_in_pl( &(p_pl->sons) );
break;
case AND:
case OR:
for ( i = (*n)->sons; i; i = i->next ) {
normalize_tyl_in_pl( &i );
}
break;
case NOT:
normalize_tyl_in_pl( &((*n)->sons) );
break;
case ATOM:
case TRU:
case FAL:
break;
case WHEN:
normalize_tyl_in_pl( &((*n)->sons) );
normalize_tyl_in_pl( &((*n)->sons->next) );
break;
default:
break;
}
}
void build_orig_constant_list( void )
{
char *tmp = NULL;
TypedList *tyl;
TypedListList *tyll;
TokenList *tl, *p_tl, *tmp_tl;
PlOperator *po;
int i, j, k, n, std;
Bool m[MAX_TYPES][MAX_TYPES];
FactList *fl, *p_fl;
lnum_types = 0;
for ( tyl = gparse_types; tyl; tyl = tyl->next ) {
if ( get_type( tyl->name ) == -1 ) {
ltype_names[lnum_types++] = copy_Token( tyl->name );
}
if ( tyl->type->next ) {
tmp = new_Token( MAX_LENGTH );
strcpy( tmp, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp, CONNECTOR );
strcat( tmp, tl->item );
}
} else {
tmp = copy_Token( tyl->type->item );
}
if ( (n = get_type( tmp )) == -1 ) {
tyl->n = lnum_types;
ltype_names[lnum_types++] = copy_Token( tmp );
} else {
tyl->n = n;
}
free( tmp );
tmp = NULL;
}
for ( tyl = gparse_constants; tyl; tyl = tyl->next ) {
if ( tyl->type->next ) {
tmp = new_Token( MAX_LENGTH );
strcpy( tmp, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp, CONNECTOR );
strcat( tmp, tl->item );
}
} else {
tmp = copy_Token( tyl->type->item );
}
if ( (n = get_type( tmp )) == -1 ) {
tyl->n = lnum_types;
ltype_names[lnum_types++] = copy_Token( tmp );
} else {
tyl->n = n;
}
free( tmp );
tmp = NULL;
}
for ( tyl = gparse_objects; tyl; tyl = tyl->next ) {
if ( tyl->type->next ) {
tmp = new_Token( MAX_LENGTH );
strcpy( tmp, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp, CONNECTOR );
strcat( tmp, tl->item );
}
} else {
tmp = copy_Token( tyl->type->item );
}
if ( (n = get_type( tmp )) == -1 ) {
tyl->n = lnum_types;
ltype_names[lnum_types++] = copy_Token( tmp );
} else {
tyl->n = n;
}
free( tmp );
tmp = NULL;
}
for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) {
for ( tyl = tyll->args; tyl; tyl = tyl->next ) {
if ( tyl->type->next ) {
tmp = new_Token( MAX_LENGTH );
strcpy( tmp, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp, CONNECTOR );
strcat( tmp, tl->item );
}
} else {
tmp = copy_Token( tyl->type->item );
}
if ( (n = get_type( tmp )) == -1 ) {
tyl->n = lnum_types;
ltype_names[lnum_types++] = copy_Token( tmp );
} else {
tyl->n = n;
}
free( tmp );
tmp = NULL;
}
}
collect_type_names_in_pl( gorig_goal_facts );
for ( po = gloaded_ops; po; po = po->next ) {
collect_type_names_in_pl( po->preconds );
collect_type_names_in_pl( po->effects );
for ( tyl = po->parse_params; tyl; tyl = tyl->next ) {
if ( tyl->type->next ) {
tmp = new_Token( MAX_LENGTH );
strcpy( tmp, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp, CONNECTOR );
strcat( tmp, tl->item );
}
} else {
tmp = copy_Token( tyl->type->item );
}
if ( (n = get_type( tmp )) == -1 ) {
tyl->n = lnum_types;
ltype_names[lnum_types++] = copy_Token( tmp );
} else {
tyl->n = n;
}
free( tmp );
tmp = NULL;
}
}
/* now get the numbers of all composed either types
*/
for ( i = 0; i < lnum_types; i++ ) {
lnum_either_ty[i] = 0;
}
for ( tyl = gparse_types; tyl; tyl = tyl->next ) {
make_either_ty( tyl );
}
for ( tyl = gparse_constants; tyl; tyl = tyl->next ) {
make_either_ty( tyl );
}
for ( tyl = gparse_objects; tyl; tyl = tyl->next ) {
make_either_ty( tyl );
}
for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) {
for ( tyl = tyll->args; tyl; tyl = tyl->next ) {
make_either_ty( tyl );
}
}
make_either_ty_in_pl( gorig_goal_facts );
for ( po = gloaded_ops; po; po = po->next ) {
make_either_ty_in_pl( po->preconds );
make_either_ty_in_pl( po->effects );
for ( tyl = po->parse_params; tyl; tyl = tyl->next ) {
make_either_ty( tyl );
}
}
/* now, compute the transitive closure of all type inclusions.
* first initialize the matrix.
*/
for ( i = 0; i < lnum_types; i++ ) {
for ( j = 0; j < lnum_types; j++ ) {
m[i][j] = ( i == j ? TRUE : FALSE );
}
}
std = -1;
for ( i = 0; i < lnum_types; i++ ) {
if ( strcmp( ltype_names[i], STANDARD_TYPE ) == SAME ) {
std = i;
break;
}
}
for ( i = 0; i < lnum_types; i++ ) {
m[i][std] = TRUE;/* all types are subtypes of OBJECT */
}
for ( tyl = gparse_types; tyl; tyl = tyl->next ) {
/* all inclusions as are defined in domain file
*/
m[get_type( tyl->name )][tyl->n] = TRUE;
}
/* compute transitive closure on inclusions matrix
*/
for ( j = 0; j < lnum_types; j++ ) {
for ( i = 0; i < lnum_types; i++ ) {
if ( m[i][j] ) {
for ( k = 0; k < lnum_types; k++ ) {
if ( m[j][k] ) {
m[i][k] = TRUE;
}
}
}
}
}
/* union types are subsets of all those types that contain all
* their components, and
* all component types are subsets of the either type !
*/
for ( i = 0; i < lnum_types; i++ ) {
if ( lnum_either_ty[i] < 2 ) continue;
for ( j = 0; j < lnum_types; j++ ) {
if ( j == i ) continue;
/* get supertypes of all component types
*/
for ( k = 0; k < lnum_either_ty[i]; k++ ) {
if ( !m[leither_ty[i][k]][j] ) break;
}
if ( k < lnum_either_ty[i] ) continue;
m[i][j] = TRUE;
/* make components subtypes of either type
*/
for ( k = 0; k < lnum_either_ty[i]; k++ ) {
m[leither_ty[i][k]][i] = TRUE;
}
}
}
/* and again, compute transitive closure on inclusions matrix.
* I guess, this won't change anything (?), but it also won't need
* any remarkable computation time, so why should one think about it ?
*/
for ( j = 0; j < lnum_types; j++ ) {
for ( i = 0; i < lnum_types; i++ ) {
if ( m[i][j] ) {
for ( k = 0; k < lnum_types; k++ ) {
if ( m[j][k] ) {
m[i][k] = TRUE;
}
}
}
}
}
/* now build FactList of ALL constant -> type pairs.
* for each constant / object, let it appear separately
* for each type it is a member of; compute type
* membership based on propagating constants / objects
* through inclusions matrix.
*
* this might make the same pair appear doubly, if an object
* is declared in type T as well as in some supertype T'.
* such cases will be filtered out in string collection.
*/
for ( tyl = gparse_constants; tyl; tyl = tyl->next ) {
fl = new_FactList();
fl->item = new_TokenList();
fl->item->next = new_TokenList();
fl->item->item = copy_Token( tyl->name );
if ( tyl->type->next ) {
fl->item->next->item = new_Token( MAX_LENGTH );
strcpy( fl->item->next->item, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( fl->item->next->item, CONNECTOR );
strcat( fl->item->next->item, tl->item );
}
} else {
fl->item->next->item = copy_Token( tyl->type->item );
}
fl->next = gorig_constant_list;
gorig_constant_list = fl;
/* now add constant to all supertypes
*/
n = get_type( fl->item->next->item );
for ( i = 0; i < lnum_types; i++ ) {
if ( i == n ||
!m[n][i] ) continue;
fl = new_FactList();
fl->item = new_TokenList();
fl->item->next = new_TokenList();
fl->item->item = copy_Token( tyl->name );
fl->item->next->item = copy_Token( ltype_names[i] );
fl->next = gorig_constant_list;
gorig_constant_list = fl;
}
}
for ( tyl = gparse_objects; tyl; tyl = tyl->next ) {
fl = new_FactList();
fl->item = new_TokenList();
fl->item->next = new_TokenList();
fl->item->item = copy_Token( tyl->name );
if ( tyl->type->next ) {
fl->item->next->item = new_Token( MAX_LENGTH );
strcpy( fl->item->next->item, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( fl->item->next->item, CONNECTOR );
strcat( fl->item->next->item, tl->item );
}
} else {
fl->item->next->item = copy_Token( tyl->type->item );
}
fl->next = gorig_constant_list;
gorig_constant_list = fl;
/* now add constant to all supertypes
*/
n = get_type( fl->item->next->item );
for ( i = 0; i < lnum_types; i++ ) {
if ( i == n ||
!m[n][i] ) continue;
fl = new_FactList();
fl->item = new_TokenList();
fl->item->next = new_TokenList();
fl->item->item = copy_Token( tyl->name );
fl->item->next->item = copy_Token( ltype_names[i] );
fl->next = gorig_constant_list;
gorig_constant_list = fl;
}
}
/* now, normalize all typed-list-of s in domain and problem def,
* i.e., in all PlNode quantifiers and in op parameters
*
* at the same time, remove typed-listof structures in these defs
*/
normalize_tyl_in_pl( &gorig_goal_facts );
for ( po = gloaded_ops; po; po = po->next ) {
normalize_tyl_in_pl( &po->preconds );
normalize_tyl_in_pl( &po->effects );
/* be careful to maintain parameter ordering !
*/
if ( !po->parse_params ) {
continue;/* no params at all */
}
fl = new_FactList();
fl->item = new_TokenList();
fl->item->next = new_TokenList();
fl->item->item = copy_Token( po->parse_params->name );
if ( po->parse_params->type->next ) {
fl->item->next->item = new_Token( MAX_LENGTH );
strcpy( fl->item->next->item, EITHER_STR );
for ( tl = po->parse_params->type; tl; tl = tl->next ) {
strcat( fl->item->next->item, CONNECTOR );
strcat( fl->item->next->item, tl->item );
}
} else {
fl->item->next->item = copy_Token( po->parse_params->type->item );
}
po->params = fl;
p_fl = fl;
for ( tyl = po->parse_params->next; tyl; tyl = tyl->next ) {
fl = new_FactList();
fl->item = new_TokenList();
fl->item->next = new_TokenList();
fl->item->item = copy_Token( tyl->name );
if ( tyl->type->next ) {
fl->item->next->item = new_Token( MAX_LENGTH );
strcpy( fl->item->next->item, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( fl->item->next->item, CONNECTOR );
strcat( fl->item->next->item, tl->item );
}
} else {
fl->item->next->item = copy_Token( tyl->type->item );
}
p_fl->next = fl;
p_fl = fl;
}
free_TypedList( po->parse_params );
po->parse_params = NULL;
}
/* finally, build gpredicates_and_types by chaining predicate names
* together with the names of their args' types.
*/
for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) {
fl = new_FactList();
fl->item = new_TokenList();
fl->item->item = copy_Token( tyll->predicate );
fl->next = gpredicates_and_types;
gpredicates_and_types = fl;
if ( !tyll->args ) continue;
/* add arg types; MAINTAIN ORDERING !
*/
fl->item->next = new_TokenList();
if ( tyll->args->type->next ) {
fl->item->next->item = new_Token( MAX_LENGTH );
strcpy( fl->item->next->item, EITHER_STR );
for ( tl = tyll->args->type; tl; tl = tl->next ) {
strcat( fl->item->next->item, CONNECTOR );
strcat( fl->item->next->item, tl->item );
}
} else {
fl->item->next->item = copy_Token( tyll->args->type->item );
}
p_tl = fl->item->next;
for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) {
tmp_tl = new_TokenList();
if ( tyl->type->next ) {
tmp_tl->item = new_Token( MAX_LENGTH );
strcpy( tmp_tl->item, EITHER_STR );
for ( tl = tyl->type; tl; tl = tl->next ) {
strcat( tmp_tl->item, CONNECTOR );
strcat( tmp_tl->item, tl->item );
}
} else {
tmp_tl->item = copy_Token( tyl->type->item );
}
p_tl->next = tmp_tl;
p_tl = tmp_tl;
}
}
/* now get rid of remaining typed-list-of parsing structures
*/
free_TypedList( gparse_types );
gparse_types = NULL;
free_TypedList( gparse_constants );
gparse_constants = NULL;
free_TypedList( gparse_objects );
gparse_objects = NULL;
free_TypedListList( gparse_predicates );
gparse_predicates = NULL;
}