instantiatei.c

intel ipp4.1性能库的一些例子。

/*********************************************************************
 * File: instantiateI.c
 * Description: code for instantiating operators, first part.
 *              - transforms PlNodes to CodeNodes
 *              - performs syntax check
 *              - builds gobal tuple tables
 *              - encodes unary inertia as types
 *
 * Author: Joerg Hoffmann 1999
 *
 *********************************************************************/ 
/*********************************************************************
 * (C) Copyright 1998 Albert Ludwigs University Freiburg
 *     Institute of Computer Science
 *
 * All rights reserved. Use of this software is permitted for 
 * non-commercial research purposes, and it may be copied only 
 * for that use.  All copies must include this copyright message.
 * This software is made available AS IS, and neither the authors
 * nor the  Albert Ludwigs University Freiburg make any warranty
 * about the software or its performance. 
 *********************************************************************/
/*********************************************************************
 *
 * one thing that I'd like to say about the instantiation code is this:
 *
 *      it might look terrible to have four big files of C code just
 *      to instantiate the operators, and in fact, it is.
 *
 *      on the other hand, this is only the result of the terrible
 *      things that the domain designer is allowed to define in 
 *      full scale PDDL.
 *
 *      though the code produces a very tight domain representation
 *      in all cases, see Technical Report 122 
 *      "Handling of Inertia in a Planning System" on the IPP homepage,
 *      there are quite some cases where it could be made far more
 *      efficient. At the very least, if one is facing a simple STRIPS
 *      domain, it's better to skip the whole thing and use a specialised
 *      algorithm which will be faster than this code by factors in the order
 *      of hundreds...
 *
 **********************************************************************/








#include "ipp.h"

#include "output.h"
#include "utilities.h"
#include "memory.h"

#include "instantiateI.h"



  




/*
 *  ----------------------------- SET UP GLOBAL STRING ARRAYS ----------------------------
 */









void collect_all_strings( void )

{

  FactList *f;
  TokenList *t;
  int p_num, type_num, c_num, i, j, ar;
  Integers *tmp, *g;

  for ( f = gorig_constant_list; f; f = f->next ) {
    if ( (type_num = position_in_types_table( f->item->next->item )) == -1 ) {
      if ( gtypes_table_size == MAX_TYPES_TABLE ) {
	printf("\ntoo many types! increase MAX_TYPES_TABLE (currently %d)\n\n",
	       MAX_TYPES_TABLE);
	exit( 1 );
      }
      gtypes_table[gtypes_table_size].name = copy_string( f->item->next->item );
      gtypes_table[gtypes_table_size].integers = NULL;
      type_num = gtypes_table_size++;
    }

    if ( (c_num = position_in_constants_table( f->item->item )) == -1 ) {
      if ( gconstants_table_size == MAX_CONSTANTS_TABLE ) {
	printf("\ntoo many constants! increase MAX_CONSTANTS_TABLE (currently %d)\n\n",
	       MAX_CONSTANTS_TABLE);
	exit( 1 );
      }
      gconstants_table[gconstants_table_size] = copy_string( f->item->item );
      c_num = gconstants_table_size++;
    }
    
    tmp = new_integers( c_num );
    for ( g = gtypes_table[type_num].integers; g; g = g->next ) {
      if ( g->index == c_num ) break;
    }
    if ( !g ) {
      tmp->next = gtypes_table[type_num].integers;
      gtypes_table[type_num].integers = tmp;
    }
  }

  for ( f = gpredicates_and_types; f; f = f->next ) {
    if ( (p_num = position_in_predicates_table( f->item->item )) != -1 ) {
      printf("\npredicate %s declared twice!\n\n", f->item->item);
      exit(BADDOMAIN_ERROR_CODE);
    }
    if ( gpredicates_table_size == MAX_PREDICATES_TABLE ) {
      printf("\ntoo many predicates! increase MAX_PREDICATES_TABLE (currently %d)\n\n",
	     MAX_PREDICATES_TABLE);
      exit( 1 );
    }
    gpredicates_table[gpredicates_table_size] = copy_string( f->item->item );
    ar = 0;
    for ( t = f->item->next; t; t = t->next ) {
      if ( (type_num = position_in_types_table( t->item )) == -1 ) {
	printf("\nwarning: predicate %s uses unknown or empty type %s\n\n", 
	       f->item->item, t->item);
      }
      gpredicates_args_type[gpredicates_table_size][ar++] = type_num;
    }
    garity[gpredicates_table_size++] = ar;
  }

  free_complete_fact_list( gorig_constant_list );
  free_complete_fact_list( gpredicates_and_types );

  if ( gcmd_line.display_info == 2 ||
       gcmd_line.display_info == 3 ) {
    printf("\nconstant table:");
    for ( i = 0; i < gconstants_table_size; i++ ) {
      printf("\n%d --> %s", i, gconstants_table[i]);
    }
    printf("\n\ntypes table:");
    for ( i = 0; i < gtypes_table_size; i++ ) {
      printf("\n%d --> %s: ", i, gtypes_table[i].name);
      for ( tmp=gtypes_table[i].integers; tmp; tmp=tmp->next ) {
	printf("%d ", tmp->index);
      }
    }
    printf("\n\npredicates table:");
    for ( i = 0; i < gpredicates_table_size; i++ ) {
      printf("\n%d --> %s: ", i, gpredicates_table[i]);
      for ( j = 0; j < garity[i]; j++ ) {
	printf("%s ", gtypes_table[gpredicates_args_type[i][j]].name);
      }
    }
    printf("\n\n");
  }

}



int position_in_types_table( char *str )

{

  int i;

  for ( i=0; i<gtypes_table_size; i++ ) {
    if ( str == gtypes_table[i].name || 
	 (strcmp( str, gtypes_table[i].name ) == SAME) ) {
      break;
    }
  }

  return ( i == gtypes_table_size ) ? -1 : i;

}



int position_in_constants_table( char *str )

{

  int i;

  for ( i=0; i<gconstants_table_size; i++ ) {
    if ( str == gconstants_table[i] || 
	 strcmp( str, gconstants_table[i] ) == SAME ) {
      break;
    }
  }

  return ( i == gconstants_table_size ) ? -1 : i;

}



int position_in_predicates_table( char *str )

{

  int i;

  for ( i=0; i<gpredicates_table_size; i++ ) {
    if ( str == gpredicates_table[i] || 
	 strcmp( str, gpredicates_table[i] ) == SAME ) {
      break;
    }
  }

  return ( i == gpredicates_table_size ) ? -1 : i;

}



  






/*
 *  ----------------------- TRANSLATE TO CODE NODES + SYNTAX CHECK ------------------------
 */









char *lvar_str[MAX_VARS];
int lvar_types[MAX_VARS];








void transform_PlNodes_to_CodeNodes( void )

{

  PlOperator *op;
  CodeOperator *tmp, *j;

  if ( !normalize_initial( &gorig_initial_facts ) ) {
    printf("\nillegal initial state!\n\n");
    exit(BADDOMAIN_ERROR_CODE);
  }
  if ( !is_legal_condition( gorig_goal_facts ) ) {
    printf("\nillegal goal state!\n\n");
    exit(BADDOMAIN_ERROR_CODE);
  }
  for ( op = gloaded_ops; op; op = op->next ) {
    if ( !is_legal_condition( op->preconds ) ) {
      printf("\nop %s has illegal precondition\n\n", op->name->item);
      exit(BADDOMAIN_ERROR_CODE);
    }
    if ( !normalize_effects( &op->effects ) ) {
      printf("\nop %s has illegal effects\n\n", op->name->item);
      exit(BADDOMAIN_ERROR_CODE);
    }
  }

  gcode_initial_state = transform_Pl_to_Code( gorig_initial_facts, 0 );
  gcode_goal_state = transform_Pl_to_Code( gorig_goal_facts, 0 );
  for ( op = gloaded_ops; op; op = op->next ) {
    tmp = transform_PlOp_to_CodeOp( op );
    if ( tmp != NULL ) {
      tmp->next = gcode_operators;
      gcode_operators = tmp;
    }
  }

  if ( gcmd_line.display_info == 3 ) {
    printf("\ntranslation to CodeNodes complete.");
    printf("\ncoded initial state is:\n");
    print_CodeNode( gcode_initial_state, 0 );
    printf("\ncoded goal state is:\n");
    print_CodeNode( gcode_goal_state, 0 );
    printf("\ncoded operators are:\n");
    for ( j = gcode_operators; j; j = j->next ) {
      print_CodeOperator( j );
    }
  }

}
  


Bool normalize_initial( PlNode **n )

{

  PlNode *i, *tmp;
  TokenList *t;

  if ( !(*n) ) {
    return TRUE;
  }

  if ( (*n)->connective != AND ) {
    tmp = copy_pl_node( *n );
    tmp->sons = (*n)->sons;
    tmp->next = (*n)->next;
    (*n)->connective = AND;
    (*n)->sons = tmp;
    (*n)->next = NULL;

    return normalize_initial( n );
  }

  for ( i = (*n)->sons; i; i=i->next ) {
    if ( i->connective != ATOM ) {
      printf("\nnon ATOM in initial state");
      return FALSE;
    }

    if ( i->sons != NULL ) {
      printf("\ninitial atom has sons");
      return FALSE;
    }

    if ( (strcmp( i->atom->item, "EQ" ) == SAME) ||
	 (strcmp( i->atom->item, "eq" ) == SAME) ) {
      printf("\neq predicate in initial state");
      return FALSE;
    }

    for ( t = i->atom->next; t; t = t->next ) {
      if ( t->item[0] == '?' ) {
	printf("\nvariable in initial state");
	return FALSE;
      }
    }
  }

  return TRUE;

}



Bool is_legal_condition( PlNode *n )

{

  PlNode *i;

  if ( !n ) {
    return TRUE;
  }

  switch ( n->connective ) {
  case ATOM:
    if ( n->sons != NULL ) {
      printf("\nATOM has son");
      return FALSE;
    }
    return TRUE;
  case ALL:
  case EX:
  case NOT:
    if ( !(n->sons) ) {
      printf("\n%s without sons",
	     gconnectives[n->connective]);
    }
    if ( !is_legal_condition( n->sons ) ) {
      return FALSE;
    }
    return TRUE;
  case AND:
  case OR:
    if ( !(n->sons) ) {
      printf("\n%s without sons",
	     gconnectives[n->connective]);
      return FALSE;
    }
    for ( i=n->sons; i; i = i->next ) {
      if ( !is_legal_condition( i ) ) {
	return FALSE;
      }
    }
    return TRUE;
  case TRU:
  case FAL:
    if ( n->sons ) {
      printf("\n%s with sons", 
	     gconnectives[n->connective]);
      return FALSE;
    }
    return TRUE;
  default:
    printf("\nillegal connective in condition: %s", 
	   gconnectives[n->connective]);
    return FALSE;
  }

  return TRUE;

}



Bool normalize_effects( PlNode **n )

{

  PlNode *i, *j, *tmp;

  if ( !(*n) ) {
    return TRUE;
  }

  if ( (*n)->connective != AND ) {
    tmp = copy_pl_node( *n );
    tmp->sons = (*n)->sons;
    tmp->next = (*n)->next;
    (*n)->connective = AND;
    (*n)->sons = tmp;
    (*n)->next = NULL;

    return normalize_effects( n );
  }

  for ( i = (*n)->sons; i; i = i->next ) {
    for ( j = i; j; j = j->sons ) {
      if ( j->connective == WHEN ) {
	break;
      }
      if ( j->connective != ALL ) {
	printf("\nnon ALL before WHEN");
	return FALSE;
      }
    }
    if ( !j ) {
      printf("\neffect without WHEN");
      return FALSE;
    }
    if ( !j->sons ) {
      printf("\neffect has neither condition nor postconds");
      return FALSE;
    }
    if ( !j->sons->next ) {
      printf("\neffect has empty postconds");
      return FALSE;
    }
    if ( !is_legal_condition( j->sons ) ) {
      printf("\neffect condition illegal");
      return FALSE;
    }
    if ( !normalize_effect( &(j->sons->next) ) ) {
      printf("\neffect illegal");
      return FALSE;
    }
  }

  return TRUE;

}



Bool normalize_effect( PlNode **n )

{

  PlNode *i, *tmp;

  if ( !(*n) ) {
    return FALSE;
  }

  if ( (*n)->connective != AND ) {
    tmp = copy_pl_node( *n );
    tmp->sons = (*n)->sons;
    tmp->next = (*n)->next;
    (*n)->connective = AND;
    (*n)->sons = tmp;
    (*n)->next = NULL;

    return normalize_effect( n );
  }

  for ( i = (*n)->sons; i; i = i->next ) {
    if ( i->connective != ATOM ) {
      if ( i->connective != NOT ) {
	printf("\nnon literal in effect");
	return FALSE;
      }
      if ( !i->sons ) {
	printf("NOT without son");
	return FALSE;
      }
      if ( i->sons->connective != ATOM ) {
	printf("\nnon literal in effect");
	return FALSE;
      }
      if ( i->sons->sons ||
	   i->sons->next ) {
	printf("\nnegated atom with sons/next");
	return FALSE;
      }
      if ( (strcmp( i->sons->atom->item, "EQ" ) == SAME) ||
	   (strcmp( i->sons->atom->item, "eq" ) == SAME) ) {
	printf("\neq predicate in effect");
	return FALSE;
      }
    } else {
      if ( (strcmp( i->atom->item, "EQ" ) == SAME) ||
	   (strcmp( i->atom->item, "eq" ) == SAME) ) {
	printf("\neq predicate in effect");
	return FALSE;
      }
      if ( i->sons ) {
	printf("\natom with sons");
	return FALSE;
      }
    }
  }
   
  return TRUE;

}