struct list *direct_one(module_ptr agent,struct term *term,
			var_array *vars,
                        garbage_lists *g);
struct list *direct_cl(module_ptr agent,
                       struct term *term,
                       struct clause *cl,
		       var_array *vars,
                       garbage_lists *g);
term_pointer de_ref(term_pointer t,
                    var_array *var);
int unify(term_pointer t1, term_pointer t2, var_array *var);

struct list *direct_process(module_ptr agent,
                         struct term **dir, int count,
			 int entry,
                         struct list *vars_list,
                         garbage_lists *g)
{
  struct list *so_far=NULL;
  while(entry<count&&
        sym_table[dir[entry]->functor]->type!='D'&&
        sym_table[dir[entry]->functor]->type!='S')
     entry++;
  if (entry==count) return vars_list;
  for(;vars_list;vars_list=vars_list->next)
    {
      so_far=append(direct_one(agent,dir[entry],
                               vars_list->object,g),so_far);
    }
  return direct_process(agent,dir,count,entry+1,so_far,g);
}

/* solves a conjunction of direct predicates,
   returning the bindings as result */

struct list *direct_conj(module_ptr agent,
                         struct term **dir, int count,
			 int entry,
                         struct list *vars_list,
                         garbage_lists *g)
{
  struct list *so_far=NULL;
  if (entry==count) return vars_list;
  for(;vars_list;vars_list=vars_list->next)
    {
/*      printf("direct_conj :");
      print_term(dereference(dir[entry],
                             vars_list->object),
		 sym_table);
      printf("\n");*/
      so_far=append(direct_one(agent,dir[entry],
                               vars_list->object,g),so_far);
    }
  return direct_conj(agent,dir,count,entry+1,so_far,g);
}

/* returns the list of solutions to one term */
struct list *direct_one(module_ptr agent,
                        struct term *term, 
			var_array *vars,
                        garbage_lists *g)
{

  struct list *result=NULL;
  if (sym_table[term->functor]->type=='S')
     switch (term->functor)
     {
     case NOT:{
        struct list *temp;
        var_array *local_vars=create_vars(vars->length);
        copy_vars(vars,local_vars);
        temp=direct_one(agent,term->argument_array[0],local_vars,g);
        if (temp==NULL)
           result=g_cons(vars,NULL,g);
        else result==NULL;
        free(local_vars->array);
        free(local_vars);
        }
        break;
     default:{
        SystemCallDescriptor *des=GetSysDescriptor(term->functor);
        /* des is NULL if term's functor is not a system predicate */
        if(des)
           result=system_call(des,term,vars,g);
        }
        break;
     }
  else
  {
     struct list *cl_list=
        agent->clause_direct_table[term->functor];
     for(;cl_list;cl_list=cl_list->next)
     {
        result=append(direct_cl(agent,term,cl_list->object,
                                vars,
                                g),
                      result);
     }
  }
  return result;
}

struct list *direct_cl(module_ptr agent,
                       struct term *term,
                       struct clause *cl,
		       var_array *vars,
                       garbage_lists *g)
{
  int unification_status;
  var_array *local_vars=create_vars(vars->length+cl->var_counter);
  struct clause *local_cl=offset_copy_clause(cl,vars->length);
  g->garbage_vars=cons(local_vars,g->garbage_vars);
  g->garbage_clauses=cons(local_cl,g->garbage_clauses);
  copy_vars(vars,local_vars);
  unification_status=unify(term,
                           local_cl->head,
                           local_vars);
  
  if (unification_status==SUCCESS) 
    {

       return direct_conj(agent,local_cl->body,
                         local_cl->body_size,0,
		       g_cons(local_vars,NULL,g),g);
    }
  else 
    {
      return NULL;
    }
}
extern int shallow_identical(struct term *t1, struct term *t2);

int unify(term_pointer t1, term_pointer t2, var_array *vars)
{
  term_pointer dt1=de_ref(t1,vars);
  term_pointer dt2=de_ref(t2,vars);
  if (dt1->term_type==VARIABLE)
  {
    vars->array[dt1->functor]=dt2;
    return SUCCESS;
  }
  else if (dt2->term_type==VARIABLE)
    {
      vars->array[dt2->functor]=dt1;
      return SUCCESS;
    }
  else
    {
      if (shallow_identical(dt1,dt2)==FAILURE)
	return FAILURE;
      else
	{
	  int i;
	  int sofar=SUCCESS;
	  for (i=0;(sofar && i<dt1->arity);i++)
	    {
	      sofar=unify(dt1->argument_array[i],
                          dt2->argument_array[i],vars);
	    }
	  return sofar;
	}
    }
}