liboaa.c

Go to the documentation of this file.

/****************************************************************************
 *   File    : liboaa.c
 *   Author  : Adam Cheyer, David Martin
 *   Purpose : Contains C version of library for the Open Agent Architecture
 *   Updated : 5/21/97
 */
/*
 * Copyright (C) 2006  SRI International
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * SRI International: 333 Ravenswood Ave, Menlo Park, CA 94025
 */
 /*
 ****************************************************************************
 * Note: internal functions use the naming convention oaa_function_name(),
 *     while public predicates use oaa_PublicPredicate().
 *****************************************************************************/
#define EXPORT_BORLAND

#ifdef IS_DLL
#define EXPORT_MSCPP __declspec(dllexport)
#else
#define EXPORT_MSCPP
#endif


/****************************************************************************
 * RCS Header
 ****************************************************************************/
#ifndef lint
/*static char *rcsid= "$Header: /home/zuma1/OAA/CVSRepository/oaa2/src/oaalib/c/src/liboaa.c,v 1.77 2006/12/20 15:21:21 agno Exp $";*/
#endif


/****************************************************************************
 *Include files
 ****************************************************************************/

#include <string.h> /* string functions     */
#include <stdio.h>
#include <stdlib.h>

#ifndef _WINDOWS
#include <sys/param.h>  /* used by getlocalhostname     */
#include <sys/time.h>   /* used by oaa_Ping     */
#include <stdarg.h>   /* used by oaa_Ping   */
#else
#include <time.h>   /* used by oaa_Ping     */
#include <stdarg.h>   /* used by oaa_Ping   */
#include <windows.h>   /* used by oaa_Ping    */
#include <winsock.h> /* bzero, bcopy */
#endif

#include "libicl_private.h"
#include "libicl.h" /* ICL term parsing/generating library  */
#include "libdb.h"  /* Database library       */
#include "libcom_tcp.h" /* coms library       */
#include "liboaa.h" /* OAA library headers      */
#include "dictionary.h" /* utility collection data type */
#include "testers.h"

/* Some param.h versions don't have this defined? */
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 256
#endif

// forward declarations
int oaa_SeqNumLessThan(int a, int b);

/****************************************************************************
 * Global variables
 ****************************************************************************/

char const* oaa_library_version_str = "[2,3,2]";

/* DEBUG */
extern ICLDatabase *commdb;

static ICLTerm  *oaa_solvables = NULL;                /* list of agent capabilities */
static int      oaa_trace_on  = FALSE;      /* Tracing on         */
static int      oaa_com_trace_on  = FALSE;  /* COM Tracing on         */
static int      oaa_debug_on  = FALSE;      /* Debugging on       */
static double   oaa_timeout = 0.0;          /* Idle timeout value */

/* Queue of events    */
ICLTerm  *oaa_saved_events = NULL;

static ICLDatabase *local_db = NULL;                  /* C equivalent of prolog db */

/* This list contains the terms to be printed by oaa_TraceMsg */
/*static ICLTerm* trace_messages_list = NULL;*/

static char * oaa_built_in_solvables_str =
"[solvable(oaa_trigger(_TriggerId, _Type, _Condition, _Action, _Params), [type(data)], [write(true)])]";

static ICLTerm *oaa_built_in_solvables_term = NULL;

static ICLTerm* oaa_outSeqNum_matcher = NULL;

static ICLTerm* oaa_lastSeenSeqNum_matcher = NULL;

int oaa_argc = 0;
char** oaa_argv = NULL;

/* For unique goal and trigger IDs */
static int globalCounter = 1;

/*
************************  TABLES   *****************************
* these substitute for various lists of things that are
* stored in the generic database in the prolog version.
*/

/*
 * context_table is used to store current contexts in the absence of
 * asserta and retract predicates
 */
static DICTIONARY *context_table = (DICTIONARY *)NULL;
/*
 * oaa_delay is a table to record requests for delayed solutions to particular
 * goals
 */
static DICTIONARY *oaa_delay = (DICTIONARY *)NULL;
/*
 * oaa_delay_table records the detailed results of a delayed goal
 */
static DICTIONARY *oaa_delay_table = (DICTIONARY *)NULL;
/*
 * oaa_callback stores asserted callbacks.  takes the place of
 * oaa_callback/2 predicates
 */
static DICTIONARY *oaa_callback = (DICTIONARY *)NULL;
/*
 * oaa_cache stores cached solutions.  This is a alternative to asserting
 * oaa_cache(Goal,Solutions) terms in the general DB.
 */
static DICTIONARY *oaa_cache = (DICTIONARY *)NULL;
/*
 * oaa_waiting_for is used to associate event lists with unique ids
 */
static DICTIONARY *oaa_waiting_for = (DICTIONARY *)NULL;
/*
 * oaa_waiting_event stores the events themselves
 */
static DICTIONARY *oaa_waiting_event = (DICTIONARY *)NULL;

EXTERN int oaa_Init(int argc, char* argv[]) {
  oaa_argc = argc;
  oaa_argv = argv;
  return TRUE;
}

static ICLTerm* getEvSolvedGoal(ICLTerm* goal)
{
  static int useVar = -1;
  ICLTerm* resolved;
  if(useVar == -1) {
    if(oaa_ResolveVariable("return_goal_with_solutions", &resolved)) {
      if(resolved && icl_IsStr(resolved) && strcmp("true", icl_Str(resolved))) {
        useVar = 0;
      }
      else {
        useVar = 1;
      }
      icl_Free(resolved);
    }
    else {
      useVar = 1;
    }
  }

  if(useVar) {
    return icl_NewVar("_");
  }
  else {
    return icl_CopyTerm(goal);
  }
}

int oaa_compare_terms(void *t1, void *t2) {
  ICLTerm *term1 = (ICLTerm *)t1;
  ICLTerm *term2 = (ICLTerm *)t2;

  /* DEBUG */
  /*
    printDebug(1, "oaa_compare_terms : %s VS %s \n",
    icl_NewStringFromTerm(term1),
    icl_NewStringFromTerm(term2));
  */

  if(icl_Unify(term1, term2, NULL)) {
    return 1;
  }
  return 0;
}

int oaa_assert_current_contexts(ICLTerm *id, ICLTerm *contexts) {
  /*
   * if this is the first use of this function, create a dictionary
   * that uses unification to determine key equivalency
   */
  if(context_table == NULL)
    context_table = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  dict_put_nonunique(context_table, (void *)icl_CopyTerm(id), (void *)contexts);
  return TRUE;
}

int oaa_retrieve_current_contexts(ICLTerm *id, ICLTerm **contexts) {
  if(context_table != NULL) {
    *contexts = (ICLTerm *)dict_get(context_table, (void *)id);
    if(*contexts)
      return TRUE;
  }
  return FALSE;
}

int oaa_retrieve_nth_current_contexts(ICLTerm **id, ICLTerm **contexts,
                                      int n) {
  /*
   * if this is the first use of this function, create a dictionary
   * that uses unification to determine key equivalency
   */
  if(context_table != NULL) {
    if(dict_get_nth(context_table, (void **)id, (void **)contexts, n))
      return TRUE;
  }
  return FALSE;
}

int oaa_retractall_current_contexts(ICLTerm *id) {
  if(context_table != NULL) {
    void **values;
    int    num_found, i;

    values = dict_remove_all(context_table, id, &num_found);
    if (values != NULL) {
      for (i=0; i<num_found; i++) {
  free((values[i]));
      }
      free(values);
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_assert_delay(ICLTerm *id, ICLTerm *user_id) {
  if(oaa_delay == NULL) {
    oaa_delay = dict_new(oaa_compare_terms, NULL);
  }
  dict_put(oaa_delay, (void *)id, (void *)user_id);
  return TRUE;
}

int oaa_retract_delay(ICLTerm *id, ICLTerm **user_id) {
  if(oaa_delay != NULL) {
    *user_id = (ICLTerm *)dict_remove(oaa_delay, (void *)id);
    if(*user_id)
      return TRUE;
  }
  return FALSE;
}

int oaa_assert_delay_table(ICLTerm *goal_id, ICLTerm *user_id,
                           ICLTerm *full_goal, ICLTerm *solve_params,
                           ICLTerm *all_params) {
  ICLTerm *value_list = icl_NewList(NULL);
  /* first make sure the table exists */
  if(oaa_delay_table == NULL) {
    oaa_delay_table = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  }
  /*
   * Now make a list out of the value terms.  Lookups will be done based
   * on the user_id, so make that the key and put the rest of the terms
   * into a list
   */
  icl_AddToList(value_list, goal_id, TRUE);
  icl_AddToList(value_list, full_goal, TRUE);
  icl_AddToList(value_list, solve_params, TRUE);
  icl_AddToList(value_list, all_params, TRUE);
  /*
   * put nonunique since there may be more than one delayed solution
   * per user_id
   */
  dict_put_nonunique(oaa_delay_table, (void *)icl_CopyTerm(user_id), (void *)value_list);
  return TRUE;
}

int oaa_retract_delay_table(ICLTerm **goal_id, ICLTerm *user_id,
                            ICLTerm **full_goal, ICLTerm **solve_params,
                            ICLTerm **all_params) {
  /* first make sure the table exists */
  if(oaa_delay_table != NULL) {
    ICLTerm *value_list =
      dict_remove(oaa_delay_table, (void *)user_id);
    if(value_list) {
      *goal_id = icl_CopyTerm(icl_NthTerm(value_list, 1));
      *full_goal = icl_CopyTerm(icl_NthTerm(value_list, 2));
      *solve_params = icl_CopyTerm(icl_NthTerm(value_list, 3));
      *all_params = icl_CopyTerm(icl_NthTerm(value_list, 4));
      icl_Free(value_list);
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_assert_callback(ICLTerm *id, int (*user_callback)(ICLTerm*, ICLTerm*, ICLTerm*)) {
  {
    ICLTerm *key;
    if(oaa_callback == NULL) {
      oaa_callback = dict_new(oaa_compare_terms, NULL);
    }
    if(dict_index_for_key(oaa_callback, id) >= 0) {
      key = id;
    }
    else {
      key = icl_CopyTerm(id);
    }
    dict_put(oaa_callback, key, user_callback);
  }
  CHECK_LEAKS();
  return TRUE;
}

int oaa_retrieve_callback(ICLTerm *id,  int (**user_callback)(ICLTerm*, ICLTerm*, ICLTerm*)) {
  if(oaa_callback != NULL) {
    *user_callback = dict_get(oaa_callback, (void*)id);
    if(*user_callback) {
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_retract_callback(ICLTerm *id, int (*user_callback)(ICLTerm*, ICLTerm*, ICLTerm*)) {
  if(oaa_callback != NULL) {
    user_callback = dict_remove(oaa_callback, (void *)id);
    if(user_callback != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_retractall_callback(ICLTerm *id, ICLTerm **proc) {

  if(oaa_callback != NULL) {
    void **values;
    int    num_found, i;

    values = dict_remove_all(oaa_callback, id, &num_found);
    if (values != NULL) {
      *proc = (ICLTerm *)*values; /* ?? */
      for (i=0; i<num_found; i++) {
        free((values[i]));
      }
      free(values);
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_assert_cache(ICLTerm *goal, ICLTerm *solutions) {
  if(oaa_cache == NULL) {
    oaa_cache = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  }
  dict_put_nonunique(oaa_cache, (void *)icl_CopyTerm(goal), (void *)solutions);
  return TRUE;
}

int oaa_retrieve_cache(ICLTerm *goal, ICLTerm **solutions) {
  if(oaa_cache != NULL) {
    *solutions = (ICLTerm *)dict_get(oaa_cache, (void *)goal);
    if(*solutions != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_retractall_cache(ICLTerm *goal) {

  if(oaa_cache != NULL) {
    int    num_found = 0;
    int    i = 0;
    void **values = dict_remove_all(oaa_cache, goal, &num_found);

    if (values != NULL) {
      for (i=0; i<num_found; i++) {
        free((values[i]));
      }
      free(values);
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_retrieve_all_cache(ICLTerm *goal, ICLTerm **solutions) {
  int i = 0, n = 0, inited = FALSE, res = FALSE;
  if(oaa_cache != NULL) {
    /* loop through cache table */
    for(i=0, n=oaa_cache->size; i<n; i++) {
      ICLTerm *test_goal = oaa_cache->key[i];
      /* compare keys */
      if(!(oaa_cache->compar)((void *)goal, (void *)test_goal)) {
        ICLTerm *tmpsoln = oaa_cache->value[i];
        /* add tmpsoln to solutions list */
        if(inited)
          icl_AddToList(*solutions, tmpsoln, TRUE);
        else {
          *solutions = icl_NewList(icl_NewCons(tmpsoln, NULL));
          inited = TRUE;
        }
        res = TRUE;
      }
    }
  }
  return res;
}

int oaa_retract_cache(ICLTerm *goal, ICLTerm **solutions) {
  if(oaa_cache != NULL) {
    *solutions = (ICLTerm *)dict_remove(oaa_cache, (void *)goal);
    if(*solutions != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_assert_waiting_for(ICLTerm *id, ICLTerm *event_list) {
  if(oaa_waiting_for == NULL)
    oaa_waiting_for = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  dict_put(oaa_waiting_for, (void *)icl_CopyTerm(id), (void *)event_list);
  return TRUE;
}

int oaa_retrieve_waiting_for(ICLTerm *id, ICLTerm **event_list) {
  if(oaa_waiting_for != NULL) {
    *event_list = (ICLTerm *)dict_get(oaa_waiting_for, (void *)id);
    if(*event_list != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_retrieve_all_waiting_for(ICLTerm *id, ICLTerm **event_list) {
  int res = FALSE, inited = FALSE, i = 0, n = 0;
  if(oaa_waiting_for != NULL) {
    for(i=0, n=oaa_waiting_for->size; i<n; i++) {
      ICLTerm *test_id = oaa_waiting_for->key[i];
      /* compare keys */
      if((oaa_waiting_for->compar)((void *)id, (void *)test_id)) {
        ICLTerm *tmpel = oaa_waiting_for->value[i];
        /* add tmpel to events list */
        if(inited) {
          icl_AppendCopy(*event_list, tmpel);
        }
        else {
          *event_list = icl_CopyTerm(tmpel);
          inited = TRUE;
        }
        res = TRUE;
      }
    }
  }
  return res;
}


int oaa_retract_waiting_for(ICLTerm *id, ICLTerm **event_list) {
  if(oaa_waiting_for != NULL) {
    *event_list = (ICLTerm *)dict_remove(oaa_waiting_for, (void *)id);
    if(*event_list != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

int oaa_assert_waiting_event(ICLTerm *event){
  if(oaa_waiting_event == NULL) {
    oaa_waiting_event = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  }
  /* store term under both key and value */
  dict_put(oaa_waiting_event, (void *)icl_CopyTerm(event), (void *)icl_CopyTerm(event));
  return TRUE;
}

int oaa_retrieve_all_waiting_events(ICLTerm **event_list) {
  int i = 0, n = 0;
  *event_list = icl_NewList(NULL);
  if(oaa_waiting_event != NULL) {
    for(i=0, n=oaa_waiting_event->size; i<n; i++) {
      ICLTerm *event = oaa_waiting_event->value[i];
      /* add event to events list */
      icl_AddToList(*event_list, icl_CopyTerm(event), TRUE);
    }
  }
  return TRUE;
}


int oaa_retract_waiting_event(ICLTerm *event) {
  ICLTerm *retracted = NULL;
  if(oaa_waiting_event != NULL) {
    retracted = (ICLTerm *)dict_remove(oaa_waiting_event, (void *)event);
    if(retracted != NULL) {
      icl_Free(retracted);
      return TRUE;
    }
  }
  return FALSE;
}

ICLTerm * oaa_built_in_solvables()
{
  if (oaa_built_in_solvables_term == NULL) {
    oaa_built_in_solvables_term =
      icl_NewTermFromString(oaa_built_in_solvables_str);
  }

  return oaa_built_in_solvables_term;
}


/*****************************************************************************
 * Forward function declarations
 *****************************************************************************/

EXTERN void icl_param_standard_form(ICLTerm *param, ICLListType **SList);
EXTERN int icl_param_default(ICLTerm *param, ICLTerm **result);
EXTERN void icl_perm_standard_form(ICLTerm *perm, ICLTerm **Standard);
EXTERN int icl_perm_default(ICLTerm *perm, ICLTerm **result);
EXTERN int icl_address_to_id(ICLTerm* inFullAddress, ICLTerm** result);
EXTERN int icl_standardize_address(ICLTerm *Addr, ICLTerm **StandardAddr);
EXTERN int icl_standardize_solvables(ICLTerm *ShorthandSolvables, ICLTerm **StandardSolvables);
EXTERN int icl_readable_solvables(ICLTerm *StandardSolvables, ICLTerm **ShorthandSolvables);
EXTERN int icl_readable_solvable(ICLTerm *StandardSolvable, ICLTerm **ShorthandSolvable);
EXTERN int oaa_goal_in_solvables(ICLTerm *Goal, ICLTerm *Solvables, ICLTerm **MatchedSolvable);
EXTERN int oaa_call_callback(char* callback_id, ICLTerm *goal, ICLTerm *params, ICLTerm* solutions);
EXTERN int oaa_sort_and_get_event(ICLTerm *EventList, int LowestPriority, ICLTerm **Event, ICLTerm **Params);
EXTERN int oaa_extract_event(ICLTerm *raw_event, ICLTerm **content, ICLTerm **params);

EXTERN int oaa_class(char *class);
EXTERN char *oaa_name_string(void);
EXTERN int oaa_Id(ICLTerm **Id);
EXTERN ICLTerm *perm_default_list();
EXTERN ICLTerm *param_default_list();
EXTERN int oaa_priority_compare(ICLTerm *Elt1, ICLTerm *Elt2);
EXTERN int oaa_extract_event_param(ICLTerm *event, char *param,
                                   ICLTerm **result);
EXTERN int oaa_choose_event(int LowestPriority, ICLTerm *EventList,
                            ICLTerm **Event);
EXTERN int oaa_read_all_events(double TimeOut, ICLListType **Events,
                               int *FlushPriority);
EXTERN int oaa_select_event(double timeout, ICLTerm **event);
EXTERN int oaa_flush_events(ICLTerm **original_events, int flush_priority);
EXTERN int oaa_data_in_solvables(ICLTerm *Clause, ICLTerm *Solvables,
                                 ICLTerm *Perm, ICLTerm **MatchedSolvable);
EXTERN int oaa_distribute_perms(ICLTerm *solvables, ICLTerm *common_perms,
                                ICLTerm **new_solvables);
EXTERN int oaa_distribute_params(ICLTerm *solvables, ICLTerm *common_params,
                                 ICLTerm **new_solvables);

EXTERN int oaa_declare_aux(char *mode, ICLTerm *solvables, ICLTerm *params,
                           ICLTerm **declared_solvables);
EXTERN int icl_standardize_addressee(ICLTerm *Addr, ICLTerm **StandardAddr);
EXTERN int oaa_address_to_comm_id(ICLTerm *inAddress, char **commId);
EXTERN char* new_goal_id();
EXTERN char* new_trigger_id();
EXTERN int select_elements(ICLTerm *list, int (*test_function)(ICLTerm*),
                           ICLTerm** result);
EXTERN int oaa_handle_user_event(ICLTerm *event,  ICLTerm *params,
                                 ICLTerm **solutions);
EXTERN int oaa_exec_event(ICLTerm *goal, ICLTerm *params, ICLTerm **solutions);
EXTERN int oaa_cont_solve(ICLTerm* goal_id, ICLTerm *goal,
                          ICLTerm *global_params, ICLTerm **solutions,
                          ICLTerm **out_params);
EXTERN ICLTerm *remove_element(ICLTerm *elt, ICLTerm *list, ICLTerm **rest);
EXTERN int oaa_cont_poll_until_all_events(ICLTerm *event_list, ICLTerm *event,
                                          ICLTerm *params, int priority,
                                          ICLTerm **solutions);
EXTERN int oaa_handle_ev_update_data(ICLTerm *goal, ICLTerm *params);

EXTERN int oaa_ComTraceMsg(char *format_string, ...);
EXTERN int oaa_flush_notification(ICLTerm *raw_event);
EXTERN int oaa_event_param(ICLTerm *event, ICLTerm *param);
EXTERN int oaa_get_flush_notify(ICLTerm *event, ICLTerm **notify_event);
EXTERN int oaa_translate_incoming_event(ICLTerm *raw_event_in, ICLTerm **raw_event_out);
EXTERN int oaa_unwrap_event(ICLTerm *in_event, char **connection_id, ICLTerm **out_event);
EXTERN int oaa_from_param(ICLTerm *event);
EXTERN int oaa_content_fac_id(ICLTerm *content, ICLTerm **id);
EXTERN int oaa_is_parent_fac_id(char *connection_id, ICLTerm **id);
EXTERN int oaa_is_oaa_id(char *connection_id, ICLTerm **id);
EXTERN int oaa_remove_data_owned_by(ICLTerm *id);
EXTERN int oaa_handle_ev_update_trigger(ICLTerm *goal, ICLTerm *params);
EXTERN int oaa_handle_ev_solve(ICLTerm *goal, ICLTerm *params, ICLTerm **solutions);
EXTERN int oaa_handle_ev_solved(ICLTerm *goal, ICLTerm *params);
EXTERN int oaa_add_data_local(ICLTerm *clause1, ICLTerm *params);
EXTERN int oaa_remove_data_local(ICLTerm *clause1, ICLTerm *params);
EXTERN int oaa_replace_data_local(ICLTerm *clause1_in, ICLTerm *params);
EXTERN int oaa_Inform(ICLTerm *type_info, char *format_string, ICLTerm *args);
EXTERN int oaa_solve_local(ICLTerm *full_goal, ICLTerm *params, ICLTerm **solutions);
EXTERN int oaa_turn_on_debug();
EXTERN int oaa_turn_off_debug();
EXTERN int predicate_skeleton(ICLTerm *goal, ICLTerm **skeleton);
EXTERN int oaa_is_waiting_for(ICLTerm *event);
EXTERN int oaa_translate_outgoing_event(ICLTerm *event, ICLTerm *dest_id, char* commId,
                                        ICLTerm **new_event);
EXTERN int oaa_poll_until_event(ICLTerm *event, ICLTerm **solution);
EXTERN int oaa_declare_local(char *mode, ICLTerm *solvable0, ICLTerm *params,
                             ICLTerm **returned_solvables);
EXTERN int solvables_to_be_added(ICLTerm *solvables, ICLTerm *current,
                                 ICLTerm **ok_solvables);
EXTERN int solvables_to_be_removed(ICLTerm *solvables, ICLTerm *current,
                                   ICLTerm **ok_solvables);
EXTERN int oaa_remove_solvables_data(ICLTerm *solvables);
EXTERN int icl_subtract(ICLTerm *list1, ICLTerm *list2, ICLTerm **result);
EXTERN int replace_element(ICLTerm *elt, ICLTerm *old_list, ICLTerm *new,
                           ICLTerm **new_list);
EXTERN int oaa_update(char *mode, ICLTerm *clause, ICLTerm *initial_params,
                      ICLTerm **out_params);
EXTERN int oaa_retractall(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int retract_all(ICLTerm *clause);
EXTERN int oaa_data_owner(ICLTerm *params, ICLTerm **owner);
EXTERN int oaa_asserta(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int oaa_assertz(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int oaa_retract(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int oaa_replace_all(ICLTerm *clause1, ICLTerm *clause2, ICLTerm *owner,
                           ICLTerm *callback);
EXTERN int oaa_poll_until_event_priority(ICLTerm *event, int priority,
                                         ICLTerm **solutions);
EXTERN int oaa_poll_until_all_events(ICLTerm *event_list, int priority,
                                     ICLTerm **solutions);
EXTERN int oaa_grab_waiting_event(ICLTerm *event_list, ICLTerm **event);
EXTERN int replace_all(ICLTerm *clause1, ICLTerm *clause2);

// added for direct_connect
static int ensure_direct_connection(ICLTerm *AgentAddress, char **ConnectionId);
static int isClientConnection(char *ConnectionId);
static char* new_direct_connection_id(void);
static int oaa_cont_solve_direct(ICLTerm* goal_id,
                                 ICLTerm *goal,
                                 ICLTerm *SingleAgentAddress,
                                 ICLTerm *global_params,
                                 ICLTerm **solutions,
                                 ICLTerm **out_params);
static int oaa_cont_plan(ICLTerm* goal_id,
                         ICLTerm *templateGoal,
                         ICLTerm *actualGoal,
                         ICLTerm *global_params,
                         ICLTerm **solutions,
                         ICLTerm **out_params);
static int oaa_get_single_address_from_plan(ICLTerm *ev_planned_term,
                                            ICLTerm **SingleAgentAddress);
static int oaa_handshake(char *ConnectionId, char *InitialAgentName, ICLTerm *Params);

/*****************************************************************************
 * Initialization and connection functions
 *****************************************************************************/


char *getlocalhostname(void) {
  char buf[MAXHOSTNAMELEN + 1];
  if (gethostname(buf, MAXHOSTNAMELEN) == 0) { /* success! */
    return(strdup(buf));
  }
  else return(NULL);
}


EXPORT_MSCPP
int EXPORT_BORLAND
oaa_Register(char *ConnectionId, char *AgentName, ICLTerm *Solvables)
{
  ICLTerm *Params = NULL;
  ICLTerm *t1   = NULL;
  ICLTerm *t2   = NULL;
  ICLTerm *t3   = NULL;
  ICLTerm *declared_solvables = NULL;
  /* If the agent's name is read from the command line */
  char    *host = (char *)NULL;
  int      result = TRUE;
  int      isClient = TRUE;

  /* Determine whether connection is server or client type */
  isClient = isClientConnection(ConnectionId);
  if (!isClient) {
    printf("oaa_Register: server type\n");
    return FALSE;
  }

  /* Make sure there's a valid connection id */
  if (!ConnectionId || !*ConnectionId ||
      !com_GetInfo(ConnectionId,
                   (t1 = icl_NewStruct("status",
                                       1,
                                       icl_NewStr("connected"))), NULL)){

    printf("oaa_Register: No Connection\n");
    icl_Free(t1);
    return FALSE;
  }

  /* DEBUG */
  /*db_PrintDB(commdb);*/

  icl_Free(t1);

  // Check if handshaking has already occurred.
  // The internal logic of com_getInfo() does not
  // seem to work if the final parameter is NULL.
  t1 = icl_NewStruct("other_name", 1, icl_NewVar("_"));
  if (!com_GetInfo(ConnectionId, t1, &t2)) {
    oaa_handshake(ConnectionId, AgentName, Params);
  }
  icl_Free(t1);
  icl_Free(t2);

  /* Register local host */
  host = getlocalhostname();
  if (host != NULL) {
    ICLTerm *agent_host = NULL;
    ICLTerm *agent_listener = NULL;
    ICLTerm *myAddress = NULL;
    ICLTerm *myListenAddress = NULL;
    ICLTerm *named_address = NULL;
    ICLTerm* tempTerm = NULL;
    oaa_Address("parent", NULL, &myAddress);
    oaa_Address("client_listener", NULL, &myListenAddress);

    agent_host     = icl_NewStruct("agent_host", 3,
               icl_CopyTerm(icl_NthTerm(myAddress,1)),
               icl_NewStr(AgentName), icl_NewStr(host));
    if (isClient) {
      tempTerm = icl_NewTermFromData("[address(parent)]", 17);
      oaa_AddData(agent_host, tempTerm, NULL);

      // add agent_listener fact if I am a direct-connect client
      if (!STREQ(icl_Str(icl_NthTerm(myListenAddress,1)), "no_address")) {
        agent_listener = icl_NewStruct("agent_listener", 2,
                                       icl_CopyTerm(icl_NthTerm(myAddress,1)),
                                       icl_CopyTerm(icl_NthTerm(myListenAddress,1)));
        oaa_AddData(agent_listener, tempTerm, NULL);
        icl_Free(agent_listener);
        named_address = icl_NewStruct("name", 1, icl_NewStr(AgentName));

        agent_listener = icl_NewStruct("agent_listener", 2,
                                       icl_CopyTerm(named_address),
                                       icl_CopyTerm(icl_NthTerm(myListenAddress,1)));
        oaa_AddData(agent_listener, tempTerm, NULL);
        icl_Free(agent_listener);
      }
    }

    else{
      tempTerm = icl_NewTermFromData("[address(self)]", 15);
      oaa_AddData(agent_host, tempTerm, NULL);
    }
    icl_Free(tempTerm);
    icl_Free(agent_host);
    icl_Free(myAddress);
    icl_Free(myListenAddress);
    icl_Free(named_address);
  }

  t1 = icl_NewTermFromData("[if_exists(overwrite)]", 22);
  t2 = icl_NewList(NULL);
  t3 = icl_NewList(NULL);
  oaa_Declare(Solvables, t2, t2, t1, &declared_solvables);

  icl_Free(t1);
  icl_Free(t2);
  icl_Free(t3);
  icl_Free(declared_solvables);
  icl_stFree(host);

  return result;

} // end of oaa_Register



EXPORT_MSCPP
void EXPORT_BORLAND
oaa_Ready(int ShouldPrint)
{
  char *name = NULL;

  /* If client, send ready message to Facilitator */
  if (!oaa_class("root") && (name = oaa_name_string())) {
    ICLTerm* toBePosted = icl_NewStruct("ev_ready", 1, icl_NewStr(name));
    oaa_PostEvent(toBePosted, ICL_EMPTY);
    icl_Free(toBePosted);
  }
  if(name != NULL) {
    icl_stFree(name);
  }

  if (ShouldPrint)
    printf("Ready.\n");
}



/*****************************************************************************
 * Classifying and Manipulating ICL expressions
 *****************************************************************************/

EXPORT_MSCPP
int EXPORT_BORLAND
icl_BuiltIn(ICLTerm *goal)
{
  int isStruct = icl_IsStruct(goal);

  if (isStruct) {
    char *s = icl_Str(goal);
    int arity = icl_NumTerms(goal);
    return (
     ((arity == 2) && STREQ(s, "="))
     || ((arity == 2) && STREQ(s, "=="))
     || ((arity == 2) && STREQ(s, "\\=="))
     || ((arity == 2) && STREQ(s, "=<"))
     || ((arity == 2) && STREQ(s, ">="))
     || ((arity == 2) && STREQ(s, "<"))
     || ((arity == 2) && STREQ(s, ">"))
     || ((arity == 2) && STREQ(s, "member"))
     || ((arity == 2) && STREQ(s, "memberchk"))
     || ((arity == 3) && STREQ(s, "findall"))
     || ((arity == 3) && STREQ(s, "icl_ConsistentParams"))
     );
  }
  else return FALSE;
}


int
icl_compound_goal(ICLTerm *goal)
{
  char *s = NULL;

  s = icl_Str(goal);

  return ((s != NULL) &&
          (
           STREQ(s, ":") ||
           STREQ(s, "::") ||
           STREQ(s, "\\+") ||
           STREQ(s, "->") ||
           STREQ(s, ":") ||
           STREQ(s, ",") ||
           STREQ(s, ";")
           )
          );
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_BasicGoal(ICLTerm *goal)
{
  return (icl_IsStruct(goal) && !icl_compound_goal(goal));
}



EXPORT_MSCPP
int EXPORT_BORLAND
icl_GoalComponents(ICLTerm* fullgoal, ICLTerm** address,
       ICLTerm** goal, ICLTerm** param)
{
  int res = FALSE;
  if (icl_IsStruct(fullgoal)&&(STREQ(icl_Str(fullgoal),"::"))) {
    /* Full goal a::g:p */
    if (icl_IsStruct(icl_NthTerm(fullgoal, 1)) &&
  (STREQ(icl_Str(icl_NthTerm(fullgoal, 1)),"::"))) {
      *address =  icl_CopyTerm(icl_NthTerm(icl_NthTerm(fullgoal, 1),1));
      *goal =  icl_CopyTerm(icl_NthTerm(icl_NthTerm(fullgoal, 1),2));
      *param = icl_CopyTerm(icl_NthTerm(fullgoal, 2));
      res = TRUE;
    }else{
      /* Simple goal goal::param */
      *address = icl_NewStr("unknown");
      *goal =  icl_CopyTerm(icl_NthTerm(fullgoal, 1));
      *param = icl_CopyTerm(icl_NthTerm(fullgoal, 2));
      res = TRUE;
    }
  }else {
    if (icl_IsStruct(fullgoal)&&(STREQ(icl_Str(fullgoal),":"))) {
      *address = icl_CopyTerm(icl_NthTerm(fullgoal, 1));
      *goal = icl_CopyTerm(icl_NthTerm(fullgoal, 2));
      *param = icl_NewList(NULL);
      res = TRUE;
    } else {
      *address = icl_NewStr("unknown");
      *goal = icl_CopyTerm(fullgoal);
      *param = icl_NewList(NULL);
      res = TRUE;
    }
  }
  return res;
}

/****************************************************************************
 * Permissions and parameter lists
 *
 * These procedures are used in processing solvables permissions, and
 * parameter lists of all kinds (including those used with solvables,
 * those contained in events, and those used in calls to various
 * library procedures).
 *
 * All permissions and many parameters have default values.
 *
 * Permissions and parameters lists have a standard form, as defined by
 * the predicates below.  To save bandwidth and promote readability, a
 * "perm" or "param" list in standard form OMITS default values.  For
 * easier processing (e.g., comparing/merging param lists), boolean
 * params in standard form always include a single argument 'true' or
 * 'false'.
 *
 * In definitions of solvables and calls to documented library
 * procedures, it's OK to include default params in a Params list, if
 * desired.  For boolean params, when the intended value is 'true', it's
 * OK just to specify the functor, for example, instead of
 * cache(true), it's OK just to include 'cache'.
 *
 *
 ***************************************************************************/

int
icl_standardize_perms(ICLTerm *Perms, int KeepDefaults, ICLTerm **Standardized)
{

  if (icl_IsList(Perms)) {
    ICLListType *args = NULL;
    ICLListType *newArgs = NULL;
    ICLListType *endp = NULL;
    ICLTerm *standard = NULL;

    args = icl_List(Perms);
    while (args) {
      icl_perm_standard_form(args->elt, &standard);
      if (KeepDefaults || !icl_perm_default(standard, NULL)) {
        /* Keep: add to result list */
        if (!newArgs) {
          newArgs = icl_NewCons(standard, NULL);
          endp = newArgs;
        }
        else {
          endp->next = icl_NewCons(standard, NULL);
          endp = endp->next;
        }
      }
      else icl_Free(standard);

      args = args->next;
    }
    *Standardized = icl_NewList(newArgs);
    return TRUE;
  }
  else return FALSE;
}


/*
 * remarks: call --> call(true)
 */
void
icl_perm_standard_form(ICLTerm *perm, ICLTerm **Standard)
{
  if (icl_IsStr(perm))
    *Standard = icl_NewStruct(icl_Str(perm), 1, icl_NewStr("true"));
  else *Standard = icl_CopyTerm(perm);
}


ICLTerm * perm_default_list()
{
  static ICLTerm *perm_defaults = NULL;

  /* check to see if first time or somehow invalidated */
  if (!icl_IsValid(perm_defaults)) {
    perm_defaults =
      icl_NewTermFromString("[call(true),read(false),write(false)]");
    return perm_defaults;
  }
  else return perm_defaults;
}


int
icl_perm_default(ICLTerm *perm, ICLTerm **result)
{
  return (icl_IsStruct(perm) && (icl_NumTerms(perm) == 1) &&
          icl_ParamValue(icl_Str(perm), icl_NthTerm(perm, 1),
                         perm_default_list(), result));
}


int
icl_standardize_params(ICLTerm *Params,int KeepDefaults,ICLTerm **Standardized)
{
  if (icl_IsList(Params)) {
    ICLListType *args = NULL;
    ICLListType *newArgs = NULL;
    ICLListType *endp = NULL;
    ICLListType *slist = NULL;
    ICLListType *next = NULL;

    args = icl_List(Params);
    while (args) {

      icl_param_standard_form(args->elt, &slist);

      while (slist) {
        if (KeepDefaults || !icl_param_default(slist->elt,NULL)) {
          /* Keep: add to result list */
          if (!newArgs) {
            newArgs = icl_NewCons(slist->elt, NULL);
            endp = newArgs;
          }
          else {
            endp->next = icl_NewCons(slist->elt, NULL);
            endp = endp->next;
          }
        }
        /* Free list as we go, but don't free elements
   * Very ugly.  Be careful if you happen to be changing this.
   */
        next = slist->next;
        free(slist);
        slist = next;
      }
      args = args->next;
    }
    *Standardized = icl_NewList(newArgs);
    return TRUE;
  }
  else {
    *Standardized = NULL;
    return FALSE;
  }
}


ICLTerm * param_default_list()
{
  static ICLTerm *param_defaults = NULL;

  /* check to see if first time or somehow invalidated */
  if (!icl_IsValid(param_defaults)) {
    param_defaults =
      icl_NewTermFromString("[from(unknown),priority(5),utility(5),if_exists(append),type(procedure),callback(app_do_event),private(false),single_value(false),unique_values(false),rules_ok(false),bookkeeping(true),persistent(false),at_beginning(false),do_all(false),reflexive(true),parallel_ok(true),reply(true),block(true),cache(false),flush_events(false),recurrence(when)]");
    return param_defaults;
  }
  else return param_defaults;
}


void
icl_param_standard_form(ICLTerm *param, ICLListType **SList)
{
  int isStruct = icl_IsStruct(param);
  int arity = icl_NumTerms(param);
  if (isStruct && (arity == 1) && STREQ(icl_Str(param), "block")) {
    *SList = icl_NewCons(icl_NewStruct("blocking", 1, icl_CopyTerm(icl_NthTerm(param, 1))),NULL);
  }
  else if (isStruct && (arity == 1) && STREQ(icl_Str(param), "reply") &&
           STREQ(icl_Str(icl_NthTerm(param, 1)), "false")) {
    *SList = icl_NewCons(icl_NewStruct("reply", 1, icl_NewStr("none")),NULL);
  }
  else if (isStruct && (arity == 1) && STREQ(icl_Str(param), "broadcast") &&
           STREQ(icl_Str(icl_NthTerm(param, 1)), "false")) {
    *SList = icl_NewCons(icl_NewStruct("reply", 1, icl_NewStr("true")),NULL);
  }
  else if ((arity == 0) && STREQ(icl_Str(param), "broadcast")) {
    *SList = icl_NewCons(icl_NewStruct("reply", 1, icl_NewStr("none")),NULL);
  }
  else if (isStruct && (arity == 1) && STREQ(icl_Str(param), "address")) {
    ICLTerm *newAddr;
    icl_standardize_address(icl_NthTerm(param, 1), &newAddr);
    *SList = icl_NewCons(icl_NewStruct("address", 1, newAddr),NULL);
  }
  else if (isStruct && (arity == 1) && STREQ(icl_Str(param), "strategy") &&
           STREQ(icl_Str(icl_NthTerm(param, 1)), "query")) {
    *SList = icl_NewCons(icl_NewStruct("parallel_ok", 1, icl_NewStr("true")),
                         NULL);
  }
  else if (isStruct && (arity == 1) && STREQ(icl_Str(param), "strategy") &&
           STREQ(icl_Str(icl_NthTerm(param, 1)), "action")) {
    *SList = icl_NewCons(icl_NewStruct("parallel_ok", 1, icl_NewStr("false")),
                         icl_NewCons(icl_NewStruct("solution_limit", 1, icl_NewInt(1)),NULL));
  }
  else if (isStruct && (arity == 1) && STREQ(icl_Str(param), "strategy") &&
           STREQ(icl_Str(icl_NthTerm(param, 1)), "inform")) {
    *SList = icl_NewCons(icl_NewStruct("parallel_ok", 1, icl_NewStr("true")),
                         icl_NewCons(icl_NewStruct("reply", 1, icl_NewStr("none")),NULL));
  }
  else if (icl_IsStr(param)) {
    *SList = icl_NewCons(icl_NewStruct(icl_Str(param), 1, icl_NewStr("true")),
                         NULL);
  }
  else {
    *SList = icl_NewCons(icl_CopyTerm(param), NULL);
  }
}


int
icl_param_default(ICLTerm *param, ICLTerm **result)
{
  return (icl_IsStruct(param) && (icl_NumTerms(param) == 1) &&
    icl_ParamValue(icl_Str(param), icl_NthTerm(param, 1),
       param_default_list(), result));
}

int icl_param_arg(char *param, ICLTerm *value, ICLTerm *paramlist,
                  ICLTerm **result) {
  ICLTerm *bigresult;
  int res = FALSE;
  if(icl_ParamValue(param, value, paramlist, &bigresult)) {
    res = TRUE;
    if (bigresult) {
      *result = icl_CopyTerm(icl_NthTerm(bigresult, 1));
      icl_Free(bigresult);
    }
  }
  return res;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_GetParamValue(ICLTerm *Param, ICLTerm *ParamList, ICLTerm **Result)
{
  int res = FALSE;

  if (icl_IsStruct(Param) && (icl_NumTerms(Param) == 1) &&
      icl_IsList(ParamList)) {
    ICLTerm *p;

    if (icl_ParamValue(icl_Str(Param), NULL, ParamList, &p)) {
      res = icl_Unify(Param, p, Result);
      icl_Free(p);
    } else

      if (icl_ParamValue(icl_Str(Param), NULL, param_default_list(), &p)) {
        res = icl_Unify(Param, p, Result);
        icl_Free(p);
      }

    return res;
  }
  else {
    return FALSE;
  }
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_GetPermValue(ICLTerm *Perm, ICLTerm *PermList, ICLTerm **Result)
{
  int res = FALSE;
  if (icl_IsStruct(Perm) && (icl_NumTerms(Perm) == 1) &&
      icl_IsList(PermList)) {
    ICLTerm *p;

    if (icl_ParamValue(icl_Str(Perm), NULL, PermList, &p)) {
      res = icl_Unify(Perm, p, Result);
      icl_Free(p);
    } else

      if (icl_ParamValue(icl_Str(Perm), NULL, perm_default_list(), &p)) {
        res = icl_Unify(Perm, p, Result);
        icl_Free(p);
      }

    return res;
  }
  else return FALSE;
}


/* NOT IMPLEMENTED YET
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   % name:    icl_RestrictParam(+ParamList, +ParamName, +ParamValue)
   % purpose: Often used in solvable declarations to filter on a certain
   %          condition.
   % definition:
   %          Test a param list: if one or more values are given in a parameter
   %          list for parameter ParamName, then ParamValue must be defined as
   %          one of the values to succeed.  If ParamValue is NOT defined, then
   %          icl_RestrictParam succeeds.
   % example:
   %    A natural language parser agent can only handle English definitions:
   %
   %        convert(nl, icl,Input,Params,Output) :-
   %               icl_RestrictParams(Params, language, english).
   %
   %    if "language(english)" is defined in parameter list of a solve request,
   %       the nl agent will receive the request.
   %    if "language(spanish)" is defined in the parameter list, the nl agent
   %       WILL NOT receive the request.
   %    if no language parameter is specified, the request WILL be sent
   %    if "language(X)" is specified, the request WILL be sent to the nl agent
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   icl_RestrictParam(ParamList, Param, Value) :-
*/



/****************************************************************************
 * Agent identity and addressing
 *
 * Every agent (including facilitators) has a symbolic name, a full address,
 * and a local address (or "local ID").  A full address has the form:
 *     addr(tcp(Host,Port))              for a facilitator (if TCP is protocol)
 *     addr(tcp(Host,Port), LocalID)     for a client agent.
 *
 * Even though it doesn't appear in the full address, a facilitator also
 * has a local ID, for consistency and convenient reference. The
 * local ID of a client agent is assigned to it by its facilitator.
 * This, and the facilitator's local ID, are passed to the client at
 * connection time.
 *
 * Full addresses are globally unique, and local addresses are unique with
 * respect to a facilitator.  Symbolic names are NOT unique in any sense.
 *
 * The local ID happens to be an integer, but developers should not rely
 * on this.
 *
 * When specifying addresses, in address/1 params for calls to
 * oaa_AddData, oaa_Solve, etc., either names or addresses may be used.
 * In addition, for convenience, reserved terms 'self', 'parent', and
 * 'facilitator' may also be used.
 *
 * More precisely, the address parameter may contain any of the following:
 * a full address; a local ID (when the addressee is known to be either
 * the facilitator or a peer client); a name, enclosed in the name/1 functor;
 * 'self'; 'parent'; or 'facilitator'.  ('parent' and 'facilitator are
 * synonymous.)
 *
 * Address parameters are standardized as follows: A full address for the
 * local facilitator or a peer client is changed to the local ID; all
 * other full addresses are left as is.  Names are left as is.  'self',
 * 'parent', and 'facilitator' are changed to the appropriate local ID.
 *
 ***************************************************************************/

int icl_name(ICLTerm *term)
{
  if (icl_IsStr(term)) {
    char *s = icl_Str(term);

    return (!(STREQ(s,"self") ||
              STREQ(s,"parent") ||
              STREQ(s,"facilitator")));
  }
  else return FALSE;
}


int icl_true_id(ICLTerm *term, ICLTerm **Id)
{
  int res = TRUE;

  if (icl_IsInt(term))
    *Id = icl_CopyTerm(term);
  else

    if (icl_IsStr(term)) {

      if STREQ(icl_Str(term), "self") {
        res = oaa_PrimaryAddress(Id);
      }
      else
  if (STREQ(icl_Str(term), "parent") ||
      STREQ(icl_Str(term), "facilitator")) {
    ICLTerm *fid, *t1;

    res = com_GetInfo("parent",
          (t1 = icl_NewStruct("fac_id",
            1,
            icl_NewVar("FId"))),
          &fid);

    icl_Free(t1);
    if (res) {
      *Id = icl_CopyTerm(icl_NthTerm(fid, 1));
      icl_Free(fid);
    }
  }
  else res = FALSE;
    }
    else res = FALSE;

  return res;
}


int
icl_standardize_addressee(ICLTerm *Addr, ICLTerm **StandardAddr)
{
  ICLTerm *tempRequest = icl_NewTermFromData("other_address(A)",16);
  ICLTerm *result = NULL;
  ICLTerm *fid = NULL;
  ICLTerm *t1;
  int freeResult = FALSE;
  int    returnValue = 0;

  /* -- self */
  if (icl_IsStr(Addr) && (STREQ(icl_Str(Addr),"self"))) {
    oaa_PrimaryAddress(&result);
    // need to icl_Free() result below...
    freeResult = TRUE;
  }else
    /* -- parent */
    if (icl_IsStr(Addr) && (STREQ(icl_Str(Addr),"parent"))) {
      com_GetInfo("parent", tempRequest, &fid);
      if (fid != NULL) {
        result = icl_CopyTerm(icl_NthTerm(fid, 1));
        // need to icl_Free() result below...
        freeResult = TRUE;
        icl_Free(fid);
      }
    }else

      /* -- facilitator */
      if (icl_IsStr(Addr) && (STREQ(icl_Str(Addr),"facilitator"))) {
        com_GetInfo("parent", tempRequest, &fid);
        if (fid != NULL) {
          result = icl_CopyTerm(icl_NthTerm(fid, 1));
          // need to icl_Free() result below...
          freeResult = TRUE;
          icl_Free(fid);
        }
      }else

        /* -- tcp(A,B) */
        if (icl_IsStruct(Addr) &&  (STREQ(icl_Str(Addr),"tcp")) &&
            (icl_NumTerms(Addr)==2)) {
          result = Addr;
          // don't free result below...
          freeResult = FALSE;
        }else

          /* addr(FacAddr, Id) */
          if (icl_IsStruct(Addr) && STREQ(icl_Str(Addr),"addr")) {
            ICLTerm *res, *fid;
            int arity = icl_NumTerms(Addr);

            if (com_GetInfo("parent",
                            (t1 = icl_NewStruct("addr",
                                                1,
                                                icl_NewVar("Addr"))),
                            &res)) {

              icl_Free(t1);
              if ((arity == 1) && icl_Unify(Addr, res, NULL)) {
                if (com_GetInfo("parent",
                                (t1 = icl_NewStruct("fac_id",
                                                    1,
                                                    icl_NewVar("FId"))),
                                &fid)) {

                  result = icl_CopyTerm(icl_NthTerm(fid, 1));
                  // need to icl_Free() result below...
                  freeResult = TRUE;
                  icl_Free(fid);
                  icl_Free(t1);
                }
              } 
              else {
                icl_Free(t1);
              }

              if ((arity == 2) && icl_Unify(icl_NthTerm(Addr,1),
                                            icl_NthTerm(res,1), NULL)) {
                result = icl_NthTerm(Addr, 2);
                // don't free result below...
                freeResult = FALSE;
              }
              icl_Free(res);
            }
            icl_Free(t1);

            if ((!result) && (icl_NumTerms(Addr) == 2)) {
              result = Addr;
              // don't free result below...
              freeResult = FALSE;
            }
          } 
            /* Here the incoming address may be a name and has to be left as is.
               -- name(Name)
            */
          else if (icl_IsStruct(Addr) && STREQ(icl_Str(Addr),"name")) {
              if (icl_name(icl_NthTerm(Addr, 1)))
                result = Addr;
                // don't free result below...
                freeResult = FALSE;
          } 
          else if (icl_name(Addr)) {
                result = icl_NewStruct("name", 1, icl_CopyTerm(Addr));
                // need to icl_Free() result below...
                freeResult = TRUE;
                printf("WARNING (liboaa.c): addressee name, in address/1 param, should be "
                       "specified as:\n  name(%s)\n", icl_Str(Addr));
          } 
          else if (!icl_true_id(Addr, &result)) {
                  printf("WARNING (liboaa.c): Illegal addressee, in address/1 param, discarded:\n   ");
                  icl_WriteTerm(Addr);
                  printf("\n");
                  icl_Free(result);
                  // don't need to free result again below...
                  freeResult = FALSE;
          }

  if (result)
    *StandardAddr = icl_CopyTerm(result);

  returnValue = (result != NULL) ? 1 : 0;

  if (freeResult) {
    icl_Free(result);
  }

  icl_Free(tempRequest);

  return (returnValue);
} // end of icl_standardize_addressee



int
icl_standardize_address(ICLTerm *Addr, ICLTerm **StandardAddr)
{
  ICLListType *args = NULL, *newArgs = NULL, *endp = NULL;
  ICLTerm *elt = NULL, *standard = NULL;

  if (!icl_IsList(Addr))
    elt = Addr;
  else
    args = icl_List(Addr);

  while (args || elt) {

    if (!elt) elt = args->elt;

    if (icl_standardize_addressee(elt, &standard)) {
      /* Keep: add to result list */
      if (!newArgs) {
        newArgs = icl_NewCons(standard, NULL);
        endp = newArgs;
      }
      else {
        endp->next = icl_NewCons(standard, NULL);
        endp = endp->next;
      }
    }

    if (args)
      args = args->next;
    elt = NULL;
  }
  if (args)
    *StandardAddr = icl_NewList(newArgs);
  else {
    *StandardAddr = newArgs->elt;

    /* Must free (iclListType *)newArgs and any elements in that list */
    if (newArgs->next == (ICLListType *)NULL)
      free(newArgs);
    else {
      ICLListType *list = newArgs->next, *next;

      free(newArgs);
      while (list) {
        icl_Free(list->elt);
        next = list->next;
        free(list);
        list = next;
      }
    }
  }

  return TRUE;
}




/*     - (@@DLM) This might be the place to check the validity of solvables,
 *       such as using only built-ins in tests.  Also, check for dependencies
 *       between solvables; e.g., when persistent(false) is there,
 *       bookkeeping(true) must also be there.
 */
EXPORT_MSCPP
int EXPORT_BORLAND
icl_ConvertSolvables(int toStandard,
         ICLTerm *ShorthandSolvables, ICLTerm **StandardSolvables)
{
  if (toStandard) {
    return icl_standardize_solvables(ShorthandSolvables, StandardSolvables);
  }
  else {
    return icl_readable_solvables(ShorthandSolvables, StandardSolvables);
  }
}

int
icl_standardize_solvable(ICLTerm *Shorthand,
                         ICLTerm **Standard)
{
  int isStruct = icl_IsStruct(Shorthand);
  int arity = icl_NumTerms(Shorthand);
  int res = TRUE;
  ICLTerm *tmp;
  ICLTerm *perms, *params;

  *Standard = NULL;
  /* solvable(Goal), solvable(Goal,Params), solvable(Goal,Params,Perms) */
  /* Goal may be simple or (G :- Test) */
  if (isStruct && STREQ(icl_Str(Shorthand), "solvable")) {
    ICLTerm *goal = icl_NthTerm(Shorthand, 1);

    if (arity > 1) {
      icl_standardize_params(icl_NthTerm(Shorthand, 2), FALSE, &params);
    }
    else {
      params = icl_NewList(NULL);
    }

    if (arity == 3) {
      icl_standardize_perms(icl_NthTerm(Shorthand, 3), FALSE, &perms);
    }
    else {
      perms = icl_NewList(NULL);
    }

    /* Handles all cases where goal is (Goal :- Test) */
    if (icl_IsStruct(goal) && (icl_NumTerms(goal) == 2) &&
        STREQ(icl_Str(goal), ":-")) {

      ICLTerm *g = icl_CopyTerm(icl_NthTerm(goal, 1));
      icl_AddToList(params,
        icl_NewStruct("test", 1,
          icl_CopyTerm(icl_NthTerm(goal, 2))), FALSE);

      tmp = icl_NewStruct("solvable", 3, g, params, perms);
      res = icl_standardize_solvable(tmp, Standard);
      icl_Free(tmp);
    }
    else {  /* Normal "simple" goal */
      *Standard = icl_NewStruct("solvable", 3,
        icl_CopyTerm(icl_NthTerm(Shorthand, 1)), params, perms);
    }
  }
  else if (isStruct && (arity == 2) && STREQ(icl_Str(Shorthand), ":-")) {
    /* (Goal :- Test) */
    ICLTerm *goal = icl_NthTerm(Shorthand, 1);

    *Standard =
      icl_NewStruct("solvable", 3, icl_CopyTerm(icl_NthTerm(goal, 1)),
        icl_NewList(icl_NewCons(icl_CopyTerm(icl_NthTerm(goal, 2)), NULL)),
        icl_NewList(NULL));
  }
  else {  /* goal */
    *Standard = icl_NewStruct("solvable", 3, icl_CopyTerm(Shorthand),
            icl_NewList(NULL), icl_NewList(NULL));
  }
  return res;
}

int
icl_standardize_solvables(ICLTerm *ShorthandSolvables,
        ICLTerm **StandardSolvables)
{

  if (icl_IsList(ShorthandSolvables)) {
    ICLListType *args, *newArgs = NULL, *endp = NULL;
    ICLTerm *standard = NULL;

    args = icl_List(ShorthandSolvables);
    while (args) {
      if (icl_standardize_solvable(args->elt, &standard)) {
        /* Keep: add to result list */
        if (!newArgs) {
          newArgs = icl_NewCons(standard, NULL);
          endp = newArgs;
        }
  else {
    endp->next = icl_NewCons(standard, NULL);
    endp = endp->next;
  }
      }

      args = args->next;
    }
    *StandardSolvables = icl_NewList(newArgs);

    return TRUE;
  }
  return FALSE;
}

/*
 * remarks:
 *    icl_readable_solvable(solvable(Goal, [], []), Goal).
 *    icl_readable_solvable(solvable(Goal, Params, []), solvable(Goal, Params)).
 *    icl_readable_solvable(solvable(Goal, Params, Perms),
 *                       solvable(Goal, Params, Perms)).
 */
int
icl_readable_solvable(ICLTerm *StandardSolvable,
          ICLTerm **ShorthandSolvable)
{
  int isStruct = icl_IsStruct(StandardSolvable);
  int arity = icl_NumTerms(StandardSolvable);

  if (isStruct && (arity == 3) &&
      STREQ(icl_Str(StandardSolvable),"solvable")) {
    ICLTerm *params = icl_NthTerm(StandardSolvable, 2);
    ICLTerm *perms  = icl_NthTerm(StandardSolvable, 2);

    if (icl_IsList(perms) && (icl_NumTerms(perms) == 0)) {
      if (icl_IsList(params) && (icl_NumTerms(params) == 0))
        *ShorthandSolvable = icl_CopyTerm(icl_NthTerm(StandardSolvable,1));
      else
        *ShorthandSolvable = icl_NewStruct("solvable", 2,
                                           icl_CopyTerm(icl_NthTerm(StandardSolvable,1)),
                                           icl_CopyTerm(icl_NthTerm(StandardSolvable,2)));
    }
    else
      *ShorthandSolvable = icl_CopyTerm(StandardSolvable);
  }
  else
    *ShorthandSolvable = icl_CopyTerm(StandardSolvable);
  return TRUE;
}


int
icl_readable_solvables(ICLTerm *StandardSolvables,
                       ICLTerm **ShorthandSolvables)
{
  if (icl_IsList(StandardSolvables)) {
    ICLListType *args, *newArgs = NULL, *endp = NULL;
    ICLTerm *shortsolve = NULL;

    args = icl_List(StandardSolvables);
    while (args) {

      if (icl_readable_solvable(args->elt, &shortsolve)) {
        /* Keep: add to result list */
        if (!newArgs) {
          newArgs = icl_NewCons(shortsolve, NULL);
          endp = newArgs;
        }
        else {
          endp->next = icl_NewCons(shortsolve, NULL);
          endp = endp->next;
        }
      }

      args = args->next;
    }
    *ShorthandSolvables = icl_NewList(newArgs);
    return TRUE;
  }
  else return FALSE;
}



int
icl_minimally_instantiate_solvable(ICLTerm *Shorthand,
                                   ICLTerm **Minimal)
{
  int isStruct = icl_IsStruct(Shorthand);
  int arity = icl_NumTerms(Shorthand);
  int res = TRUE;
  ICLTerm *perms, *params;

  /* solvable(Goal), solvable(Goal,Params), solvable(Goal,Params,Perms) */
  /* Goal may be simple or (G :- Test) */
  if (isStruct && STREQ(icl_Str(Shorthand), "solvable")) {
    ICLTerm *goal = icl_NthTerm(Shorthand, 1);
    ICLTerm *g;

    params = icl_NewVar("Params");
    perms = icl_NewVar("Perms");

    /* Handles all cases where goal is (Goal :- Test) */
    if (icl_IsStruct(goal) && (icl_NumTerms(goal) == 2) &&
        STREQ(icl_Str(goal), ":-")) {

      g = icl_CopyTerm(icl_NthTerm(goal, 1));
    }
    else  /* Normal "simple" goal */
      g = icl_CopyTerm(goal);
    *Minimal = icl_NewStruct("solvable", 3, g, params, perms);
  }
  else

    /* (Goal :- Test) */
    if (isStruct && (arity == 2) && STREQ(icl_Str(Shorthand), ":-")) {
      ICLTerm *goal = icl_NthTerm(Shorthand, 1);

      *Minimal = icl_NewStruct("solvable", 3, icl_CopyTerm(icl_NthTerm(goal, 1)),
                               icl_NewVar("Params"), icl_NewVar("Perms"));
    }
    else  /* goal */
      *Minimal = icl_NewStruct("solvable", 3, icl_CopyTerm(Shorthand),
                               icl_NewVar("Params"), icl_NewVar("Perms"));

  return res;
}



int
icl_minimally_instantiate_solvables(ICLTerm *ShorthandSolvables,
              ICLTerm **MinimalSolvables)
{
  if (icl_IsList(ShorthandSolvables)) {
    ICLListType *args, *newArgs = NULL, *endp = NULL;
    ICLTerm *minimal = NULL;

    args = icl_List(ShorthandSolvables);
    while (args) {

      if (icl_minimally_instantiate_solvable(args->elt, &minimal)) {
        /* Keep: add to result list */
        if (!newArgs) {
          newArgs = icl_NewCons(minimal, NULL);
          endp = newArgs;
        }
        else {
          endp->next = icl_NewCons(minimal, NULL);
          endp = endp->next;
        }
      }

      args = args->next;
    }
    *MinimalSolvables = icl_NewList(newArgs);
    return TRUE;
  }
  else return FALSE;
}


int
oaa_goal_matches_solvables(ICLTerm *Goal, ICLTerm *Solvables,
         ICLTerm **RealGoal, ICLTerm **RealMatched)
{

  ICLTerm *Matched = NULL;
  ICLTerm *allSolvables = NULL;
  ICLTerm *t1;
  int result = TRUE;

  icl_Union(oaa_built_in_solvables(), Solvables, &allSolvables);
  /*
  {
    char* alls = icl_NewStringFromTerm(allSolvables);
    printf("All solvables: %s\n", alls);
    icl_stFree(alls);
  }
  */

  CHECK_LEAKS();
  if (oaa_goal_in_solvables(Goal, allSolvables, &Matched)) {
    /* Matched = solvable(Goal,Params,Perms) */
    ICLTerm *Params = icl_NthTerm(Matched, 2);
    ICLTerm *Value = NULL;

    icl_Free(allSolvables);
    /* See if Goal is a synonym predicate */
    t1 = icl_NewStruct("synonym",
           2,
           icl_CopyTerm(Goal),
           icl_NewVar("SynGoal"));
    if (icl_GetParamValue(t1, Params, &Value)) {
      result = oaa_goal_matches_solvables(icl_NthTerm(Value, 2),
            Solvables,
            RealGoal,
            RealMatched);
      icl_Free(Matched);
      icl_Free(Value);
    }
    else {
      *RealGoal = icl_CopyTerm(Goal);
      *RealMatched = Matched;
      /* Doesn't free Matched: OK */
    }
    icl_Free(t1);
  }
  else {
    icl_Free(allSolvables);
    result = FALSE;
  }
  /*icl_Free(allSolvables);*/
  return result;
}

int
oaa_goal_in_solvables(ICLTerm *Goal, ICLTerm *Solvables,
          ICLTerm **MatchedSolvable)
{
  int result = TRUE;
  int done = FALSE;

  if (icl_IsList(Solvables)) {
    ICLListType *args = NULL;

    args = icl_List(Solvables);
    while (args && !done) {
      /* Note: args->elt = solvable(G1,Params,Perms) */
      ICLTerm *G1     = icl_NthTerm(args->elt, 1);
      ICLTerm *Params = icl_NthTerm(args->elt, 2);
      ICLTerm *t1, *t2;

      if (icl_Unify(Goal, G1, NULL)) {
  t1 = icl_NewStruct("synonym",
         2,
         icl_CopyTerm(Goal),
         icl_NewVar("SynGoal"));
  if (icl_GetParamValue(t1, Params, NULL)) {
    done = TRUE;
    *MatchedSolvable = icl_CopyTerm(args->elt);
    icl_Free(t1);
  }
  else

    icl_Free(t1);

  /* Make sure calling permissions are OK */
  if (icl_GetPermValue((t1 = icl_NewTermFromData("call(true)",10)),
           Params,
           NULL)) {
    ICLTerm *Test;
    ICLTerm *WholeTest;

    /* If a test, then execute it... */
    t2 = icl_NewStruct("test",
           1,
           icl_NewVar("T"));
    if (icl_GetPermValue(t2,
             Params,
             &Test)) {

      /* Check test: */
      /*    WholeTest = ( G1 = Goal, Test ) */
      WholeTest = icl_NewGroup(
       '(',
       ",",
       icl_NewCons(
        icl_NewStruct("=",
          2,
          icl_CopyTerm(G1),
          icl_CopyTerm(Goal)),
        icl_NewCons(icl_CopyTerm(Test), NULL)));

      /* MAKE SURE oaa_Interpret can handle compound goals
       * and '='(A,B)!!!
       */
      done = oaa_Interpret(WholeTest, ICL_EMPTY, NULL);

      if (done) {
        *MatchedSolvable = icl_CopyTerm(args->elt);
      }

      icl_Free(Test);
      icl_Free(WholeTest);
    } else {
      done = TRUE;
      *MatchedSolvable = icl_CopyTerm(args->elt);
    }
    icl_Free(t2);
  }
  icl_Free(t1);
      }
      args = args->next;
    }
    /* If we've come to the end of the list without success, failure */
    if (!done && !args) {
      result = FALSE;
    }
  }
  else {
    result = FALSE;
  }
  return result;
}


int
oaa_data_matches_solvables(ICLTerm *Clause, ICLTerm *Solvables, ICLTerm *Perm,
         ICLTerm **RealClause, ICLTerm **RealMatched)
{

  ICLTerm *Matched = NULL;
  ICLTerm *Head = NULL, *Body = NULL;
  ICLTerm *t1;
  int result = TRUE;

  if (oaa_data_in_solvables(Clause, oaa_built_in_solvables(),Perm,&Matched) ||
      oaa_data_in_solvables(Clause, Solvables,Perm,&Matched)) {

    /* Matched = solvable(Clause,Params,Perms) */
    ICLTerm *Params = icl_NthTerm(Matched, 2);
    ICLTerm *Value = NULL;

    if (icl_IsStruct(Clause) && STREQ(icl_Functor(Clause), ":-")) {
      Head = icl_NthTerm(Clause, 1);
      Body = icl_NthTerm(Clause, 2);
    }
    else {
      Head = Clause;
    }

    /* See if Clause is a synonym predicate */
    t1 = icl_NewStruct("synonym",
           2,
           icl_CopyTerm(Head),
           icl_NewVar("SynHead"));
    if (icl_GetParamValue(t1, Params, &Value)) {
      ICLTerm *SynClause;

      if (Body) {
  SynClause = icl_NewStruct(":-", 2,
          icl_CopyTerm(icl_NthTerm(Value, 2)),
          icl_CopyTerm(Body));
      }
      else {
  SynClause = icl_CopyTerm(icl_NthTerm(Value, 2));
      }

      result = oaa_data_matches_solvables(SynClause,
            Solvables,
            Perm,
            RealClause,
            RealMatched);
      icl_Free(SynClause);
      icl_Free(Matched);
      icl_Free(Value);
    }
    else {
      *RealClause = icl_CopyTerm(Clause);
      *RealMatched = Matched;
      /* Doesn't free Matched: OK */
    }
    icl_Free(t1);
  }
  else {
    result = FALSE;
  }

  return result;
}



int
oaa_data_in_solvables(ICLTerm *Clause, ICLTerm *Solvables, ICLTerm *Perm,
                      ICLTerm **MatchedSolvable)
{
  int result = TRUE;
  int done = FALSE;

  if (icl_IsList(Solvables)) {
    ICLListType *args = NULL;
    ICLTerm *Head = NULL, *Body = NULL;

    if (icl_IsStruct(Clause) && STREQ(icl_Functor(Clause), ":-")) {
      Head = icl_NthTerm(Clause, 1);
      Body = icl_NthTerm(Clause, 2);
    }
    else {
      Head = Clause;
    }

    args = icl_List(Solvables);
    while (args && !done) {

      /* Note: args->elt = solvable(G1,Params,Perms) */
      ICLTerm *G1     = icl_NthTerm(args->elt, 1);
      ICLTerm *Params = icl_NthTerm(args->elt, 2);
      ICLTerm *Perms = icl_NthTerm(args->elt, 3);

      if (icl_Unify(Head, G1, NULL)) {
  ICLTerm *t1;

  if (icl_GetParamValue((t1 = icl_NewStruct("synonym",
              2,
              icl_CopyTerm(Head),
              icl_NewVar("_RealHead"))),
            Params, NULL)) {
    done = TRUE;
    *MatchedSolvable = icl_CopyTerm(args->elt);
  }
  else { /* Perform a number of additional test */
    ICLTerm *t2;

    t2 = icl_NewTermFromData("type(data)",10);
    done = icl_GetParamValue(t2, Params, NULL);
    icl_Free(t2);
    if (done && Body) {
      t2 = icl_NewTermFromData("rules_ok(true)",14);
      done = icl_GetParamValue(t2,Params, NULL);
      icl_Free(t2);
    }
    if (done) {
      if(STREQ(icl_Str(Perm), "write")) {
        t2 = icl_NewTermFromData("write(true)",11);
        done = icl_GetPermValue(t2, Perms, NULL);
        icl_Free(t2);
      }
      else {
        t2 = icl_NewTermFromData("read(true)",10);
        done = icl_GetPermValue(t2, Perms, NULL);
        icl_Free(t2);
      }
    }
    if (done) { /* Passed all tests */
      *MatchedSolvable = icl_CopyTerm(args->elt);
    }
  }
  icl_Free(t1);
      }
      args = args->next;
    }

    /* If we've come to the end of the list without success, failure */
    if (!done && !args) {
      result = FALSE;
    }
  }
  else {
    result = FALSE;
  }

  return result;
}


/****************************************************************************
 * Retrieving and managing events
 ***************************************************************************/


EXPORT_MSCPP
void EXPORT_BORLAND
oaa_MainLoop(int ShouldPrint)
{
  ICLTerm *Event, *Params;
  oaa_Ready(ShouldPrint);

  while (TRUE) {
    oaa_GetEvent(&Event, &Params, 0);
    CHECK_LEAKS();
    oaa_ProcessEvent(Event, Params);
    CHECK_LEAKS();
    icl_Free(Event);
    icl_Free(Params);
  }
}


EXPORT_MSCPP
void EXPORT_BORLAND
oaa_ProcessAllEvents()
{
  ICLTerm *Event = NULL, *Params = NULL;
  oaa_GetEvent(&Event, &Params, 0);
  oaa_ProcessEvent(Event, Params);
  icl_Free(Event);
  icl_Free(Params);
}


static char* oaa_getConnectionIdFromParams(ICLTerm *params)
{
  ICLTerm* connId;
  char* toReturn;
  if(!icl_ParamValue("connection_id", NULL, params, &connId)) {
    char* paramString = icl_NewStringFromTerm(params);
    fprintf(stderr, "No connection_id in: %s", paramString);
    icl_stFree(paramString);
    return NULL;
  }
  toReturn = strdup(icl_Str(icl_NthTerm(connId, 1)));
  icl_Free(connId);
  return toReturn;
}

static void oaa_got_heartbeat(char* connection)
{
  GTimeVal now;
  ICLTerm* hb;

  g_get_current_time(&now);
  hb = icl_NewStruct("last_heartbeat", 1, icl_NewInt(now.tv_sec));
  com_UpdateInfo(connection, hb);
  icl_Free(hb);
}

/*
static int oaa_last_heartbeat(char* connection)
{
  ICLTerm* toFind = icl_NewStruct("last_heartbeat", 1, icl_NewVar("_"));
  ICLTerm* last;
  if(!com_GetInfo(connection, toFind, &last)) {
    return 0;
  }
  else {
    return icl_Int(icl_NthTerm(last, 1));
  }
}
*/

static void oaa_send_heartbeat_reply(char* conn)
{
  ICLTerm* reply = icl_NewStruct("event", 2, icl_NewStr("ev_heartbeat_reply"), icl_NewList(NULL));
  com_SendTerm(conn, reply);
}

static void oaa_resend_unacked(char* connId)
{
  ICLTerm* unackedMatcher = icl_NewStruct("unacked", 1, icl_NewVar("_"));
  ICLTerm* unacked;
  if(com_GetInfo(connId, unackedMatcher, &unacked)) {
    ICLListType* toSend;
    for(toSend = icl_List(unacked); toSend; toSend = icl_ListNext(toSend)) {
      com_SendTerm(connId, icl_ListElt(toSend));
    }
    icl_Free(unacked);
  }

  icl_Free(unackedMatcher);
}

static void oaa_handle_reconnect_handshake(ICLTerm* reconnectEvent)
{
  char* connId = icl_Str(icl_NthTerm(reconnectEvent, 1));
  char* name = icl_Str(icl_NthTerm(reconnectEvent, 2));
  ICLTerm* reconnectTerm = icl_CopyTerm(icl_NthTerm(reconnectEvent, 3));
  ICLTerm* addressTerm = icl_CopyTerm(icl_NthTerm(reconnectEvent, 4));
  ICLTerm* nameTerm = icl_CopyTerm(icl_NthTerm(reconnectEvent, 5));
  ICLTerm* params = icl_NewList(NULL);
  icl_AddToList(params, reconnectTerm, FALSE);
  icl_AddToList(params, addressTerm, FALSE);
  icl_AddToList(params, nameTerm, FALSE);

  if(oaa_handshake(connId, name, params)) {
    oaa_resend_unacked(connId);
  }
  icl_Free(params);
}

EXPORT_MSCPP
void EXPORT_BORLAND
oaa_ProcessEvent(ICLTerm *Event, ICLTerm *Params)
{
  if (icl_IsStr(Event) && STREQ(icl_Str(Event),"timeout")) {
    oaa_CheckTriggers("task", NULL, NULL);

    /* TBD: fill-in appropriate 2nd and 3rd arguments; NULLs supplied
     * as a stop gap.  REL
     */
    oaa_call_callback("app_idle", (ICLTerm *)NULL, (ICLTerm *)NULL, (ICLTerm *)NULL);
  }
  if(icl_IsStr(Event) && STREQ(icl_Str(Event), "ev_heartbeat")) {
    char* conn = oaa_getConnectionIdFromParams(Params);
    oaa_send_heartbeat_reply(conn);
    oaa_got_heartbeat(conn);
    free(conn);
  }
  else if(icl_IsStr(Event) && STREQ(icl_Str(Event), "ev_heartbeat_reply")) {
    char* conn = oaa_getConnectionIdFromParams(Params);
    oaa_got_heartbeat(conn);
    free(conn);
  }
  else if(icl_IsStruct(Event) && STREQ(icl_Str(Event), "ev_reconnected_needs_handshake")) {
    oaa_handle_reconnect_handshake(Event);
  }
  else {
    /* oaa_Interpret will add to solutions */
    ICLTerm *solutions = NULL;
    oaa_Interpret(Event, Params, &solutions);
    if(solutions != NULL) {
      icl_Free(solutions);
    }
    /* TO BE IMPLEMENTED
       oaa_CheckTriggers("task", NULL, NULL);
    */
  }
}


EXPORT_MSCPP
void EXPORT_BORLAND
oaa_SetTimeout(double NSecs)
{
  if (NSecs < 0)
    oaa_timeout = 0.0;
  else oaa_timeout = NSecs;

  //oaa_TraceMsg("\n Setting event timeout to : %f\n", oaa_timeout, NULL);
}


EXPORT_MSCPP
void EXPORT_BORLAND
oaa_GetEvent(ICLTerm **Event, ICLTerm **Params, int LowestPriority)
{

  double   TimeoutSecs = 0;
  int    FlushPriority = 0;
  ICLTerm *MoreEvents = icl_NewList(NULL);
#ifdef UNNEEDED_DEBUG
  char    *debugString = NULL;
#endif

  *Event = NULL;

  /* If at least one event can be found with an appropriate priority
   * from among the saved events, no timeout needed -- flush tcp
   * buffer, and read_all available
   * In other words, oaa_choose_event is called to :
   *   - Check if there is an event that matches the priority constraint
   *   - Therefore, choosing the timeout policy to be utilised in
   *     oaa_read_all_events that will actually read the socket.
   */
  if(icl_ListLen(oaa_saved_events) > 0) {
    TimeoutSecs = 0.01; // Since we have an event to process, we make sure
                        // we don't block on the socket
  }
  else {
    TimeoutSecs = oaa_timeout;
  }
  oaa_read_all_events(TimeoutSecs, (ICLListType **)&(MoreEvents->p),
          &FlushPriority);
  CHECK_LEAKS();

#ifdef UNNEEDED_DEBUG
  {
    char* debugString = icl_NewStringFromTerm(MoreEvents);
    debugPrint(1, "%s:%i MoreEvents %s\n", __PRETTY_FUNCTION__, __LINE__, debugString);
    icl_stFree(debugString);
  }
#endif /* UNNEEDED_DEBUG */

  /* if one of the new events has a flush in it, see if it
   *    flushes any of the saved events
   *    % note: MoreEvents have already been flushed by FlushPriority
   */

  if (oaa_saved_events) {
    oaa_flush_events(&oaa_saved_events, FlushPriority);
    icl_AppendCopy(oaa_saved_events, MoreEvents);
  }
  CHECK_LEAKS();

  /* DEBUG */
  /* printf("Saved events %s\n", icl_NewStringFromTerm(oaa_saved_events)); */

  if (!oaa_sort_and_get_event(oaa_saved_events, LowestPriority,
                              Event, Params)){
    icl_Free(*Event);
    *Event = icl_NewStr("timeout");
    *Params = icl_CopyTerm(ICL_EMPTY);
  }
  else {
    ICLTerm *t1;

    t1 = icl_NewStruct("event",
           2,
           icl_CopyTerm(*Event),
           icl_CopyTerm(*Params));
    oaa_CheckTriggers("comm", t1, "receive");
    icl_Free(t1);
  }
  icl_Free(MoreEvents);
  CHECK_LEAKS();

}


int oaa_sort_and_get_event(ICLTerm *EventList, int LowestPriority,
                           ICLTerm **Event, ICLTerm **Params)
{

  ICLTerm *RawEvent;

  icl_SortList(EventList, oaa_priority_compare);

  if (oaa_choose_event(LowestPriority, EventList, &RawEvent)) {
    oaa_extract_event(RawEvent, Event, Params);
    icl_Free(RawEvent);
    return TRUE;
  }
  else return FALSE;
}


int oaa_priority_compare(ICLTerm *Elt1, ICLTerm *Elt2)
{
  ICLTerm *param1, *param2;
  int p1 = 0, p2 = 0;

  oaa_extract_event_param(Elt1, "priority", &param1);
  oaa_extract_event_param(Elt2, "priority", &param2);

  if (icl_IsInt(param1))
    p1 = icl_Int(param1);
  else p1 = 5;
  if (icl_IsInt(param2))
    p2 = icl_Int(param2);
  else p2 = 5;

  icl_Free(param1);
  icl_Free(param2);

  return p1 >= p2;
}


int oaa_choose_event(int LowestPriority, ICLTerm *EventList, ICLTerm **Event) {

  if (EventList) {
    ICLListType *list = icl_List(EventList);
    ICLListType *prev = list;
    ICLTerm *p = NULL;
    ICLTerm *pAsStruct = NULL;
    int found = FALSE;

    if (Event) {
      *Event = NULL;
    }

    while (list && (list->elt != NULL) && !found) {
      oaa_extract_event_param(list->elt, "priority", &pAsStruct);
      if (pAsStruct) {
  p = icl_NthTerm(pAsStruct,1);
      }

      if (icl_IsInt(p) && (icl_Int(p) > LowestPriority)) {
  if (Event) {
    *Event = icl_CopyTerm(list->elt);
  }
  found = TRUE;
  icl_Free(pAsStruct);

  /* remove elt from list */
  if (list == prev) {   /* first element in list */
    EventList->p = list->next;
    icl_Free(list->elt);
    free(list);
    return TRUE;
  }
  else {
    prev->next = list->next;
    icl_Free(list->elt);
    free(list);
    return TRUE;
  }
      }
      if (pAsStruct) {
  icl_Free(pAsStruct);
      }

      prev = list;
      list = list->next;
    }
    /*
      if (found)
      free(list);
    */
    return found;
  }
  return FALSE;
}

int oaa_read_all_events(double TimeOut, ICLListType **Events,
                        int *FlushPriority)
{
  ICLTerm *e = NULL, *ok_event = NULL, *param = NULL, *paramAsStruct = NULL;
  ICLListType *RestEvents = NULL;
  int RestFlushPriority = 0, p;

  CHECK_LEAKS();
  if(oaa_select_event(TimeOut, &e) == FALSE) {
    if(e != NULL) {
      icl_Free(e);
    }
    *Events = NULL;
    *FlushPriority = 0; /* need to set this? */
    CHECK_LEAKS();
    return FALSE;
  }
  CHECK_LEAKS();

  /* select event must have succeeded, check to see if returned
     event is a timeout */
  if(icl_IsStr(e) && STREQ(icl_Str(e), "timeout")) {
    *Events = NULL;
    *FlushPriority = 0;
    CHECK_LEAKS();
    return FALSE;
  } else {
    /* read one event so read all the rest
       Note timeout forced to some value != zero, so we do not block.
    */
    // double TimeoutSecs = 0.0001;

    CHECK_LEAKS();
    //oaa_read_all_events(TimeoutSecs, &RestEvents, &RestFlushPriority);
    /* check if read Event is acceptable (security hook) */
    CHECK_LEAKS();
    if(oaa_ValidateEvent(e, &ok_event)) {
      /* For oaa_ComTraceMsg */
      // the icl_NewStringFromTerm() below
      // can be expensive, so only do it if
      // com_trace is actually on
      if (oaa_com_trace_on) {
        char *debugStr;
        CHECK_LEAKS();
        debugStr = icl_NewStringFromTerm(ok_event);
        oaa_ComTraceMsg("\n[COM received]:\n %s\n", debugStr,NULL);
        icl_stFree(debugStr);
      }

      icl_Free(e);
      /* get event's priority */
      oaa_extract_event_param(ok_event, "priority", &paramAsStruct);
      if (paramAsStruct) {
  param = icl_NthTerm(paramAsStruct,1);
      }

      if(icl_IsInt(param)) {
  p = icl_Int(param);
      }
      else {
  p = 0; /* ??? - what should default action be? */
      }

      CHECK_LEAKS();
      /* if less than some higher priority flush event, discard
   event and perhaps notify sender */
      if(p < RestFlushPriority) {
  CHECK_LEAKS();
  /* event will be removed */
  oaa_flush_notification(ok_event);
  *FlushPriority = RestFlushPriority;
  *Events = RestEvents;
  icl_Free(ok_event);
  CHECK_LEAKS();
      }
      else {
  ICLTerm *flushevents;
  CHECK_LEAKS();
  flushevents = icl_NewTermFromData("flush_events(true)",18);
  /* keep event: not flushed */
  *Events = icl_NewCons(ok_event, RestEvents);
  CHECK_LEAKS();

  /* see if this event adds a flush: if so, record new flush
     priority */
  if(oaa_event_param(ok_event, flushevents)) {
    *FlushPriority = p;
  }
  else {
    *FlushPriority = RestFlushPriority;
  }
  icl_Free(flushevents);
  CHECK_LEAKS();
      }
      icl_Free(paramAsStruct);
      CHECK_LEAKS();
    } else {
      /* Not validated, skip event */
      printf("Invalid event\n");
      *Events = RestEvents;
      if(ok_event != NULL) {
  icl_Free(ok_event);
      }
      icl_Free(e);
      CHECK_LEAKS();
    }
  }
  CHECK_LEAKS();
  return FALSE;
}

int oaa_ValidateEvent(ICLTerm *E, ICLTerm **OkEvent)
{
  /* if oaa_AppValidateEvent is defined, use it */
  /* ??? - I think this comment should read ...
     if oaa_AppValidateProperty is defined, use it */

  /* ??? - how to handle this mechanism of determining if a predicate
     is defined?*/
  /*
    predicate_property(user:oaa_AppValidateProperty(_,_), _),
    !,
    user:oaa_AppValidateProperty(E, OkEvent).
  */

  /* currently, no security checks are performed */
  *OkEvent = icl_CopyTerm(E);
  return TRUE;
}

int oaa_flush_events(ICLTerm **original_events, int flush_priority)
{
  ICLListType *eventlist;
  ICLTerm* events = NULL;

  /* Not sure what action to take when incorrect data is passed in */
  /*
    if(!icl_IsList(events)) {
    return FALSE;
    }
  */

  events = *original_events;
  /* create an empty list */
  *original_events = icl_NewList(NULL);

  eventlist = icl_List(events);
  while(icl_ListHasMoreElements(eventlist)) {
    ICLTerm *event = icl_ListElement(eventlist);
    ICLTerm *param = NULL, *paramAsStruct = NULL;
    int p=0;
    /* get event's priority */
    oaa_extract_event_param(event, "priority", &paramAsStruct);
    if (paramAsStruct) {
      param = icl_NthTerm(paramAsStruct,1);
    }

    if(icl_IsInt(param)) {
      p = icl_Int(param);
    }
    if(p < flush_priority) {
      oaa_flush_notification(event);
    }
    else {
      icl_AddToList(*original_events, icl_CopyTerm(event), TRUE);
    }
    eventlist = icl_ListNextElement(eventlist);
    icl_Free(paramAsStruct);
  }
  icl_Free(events);
  return TRUE;
}

int oaa_flush_notification(ICLTerm *raw_event)
{
  ICLTerm *event, *params, *notify_event;

  oaa_extract_event(raw_event, &event, &params);
  if(oaa_get_flush_notify(event, &notify_event)) {
    ICLTerm *emptyParams = icl_NewList(NULL);
    oaa_PostEvent(notify_event, emptyParams);
    icl_Free(emptyParams);
  }
  icl_Free(event);
  icl_Free(params);
  icl_Free(notify_event);
  return TRUE;
}

int oaa_get_flush_notify(ICLTerm *event, ICLTerm **notify_event)
{
  /* set default return values */
  int result = FALSE;
  *notify_event = NULL;
  /* check to make sure event is a structure term */
  if(icl_IsStr(event)) {
    /* check to make sure it's a real event to be solved */
    char *functor = icl_Functor(event);
    if(STREQ(functor, "ev_solve")) {
      ICLTerm *id = icl_NthTerm(event, 1);
      ICLTerm *goal = icl_NthTerm(event, 2);
      ICLTerm *params = icl_NthTerm(event, 3);
      ICLTerm *reply_none = icl_NewTermFromData("reply(none)",11);
      if(!icl_GetParamValue(reply_none, params, NULL)) {
        ICLTerm *my_id;
        result = oaa_PrimaryAddress(&my_id);
        if(result) {
          /* ??? - Copy these terms for reuse in another solveable? */
          *notify_event = icl_NewStruct("ev_solved", 5,
                                        icl_CopyTerm(id),
                                        icl_CopyTerm(id),
                                        my_id,
                                        getEvSolvedGoal(goal),
                                        icl_CopyTerm(params),
                                        icl_NewList(NULL));
        }
      }
      icl_Free(reply_none);
    }
  }
  return result;
}

static void oaa_acked(char* connId, int ackNum)
{
  ICLTerm* unackedMatcher = icl_NewStruct("unacked", 1, icl_NewVar("_"));
  ICLTerm* unackedTerm;
  ICLTerm* unackedList;
  ICLTerm* nextUnackedTerm = icl_NewStruct("unacked", 1, icl_NewList(NULL));
  ICLTerm* remainder = icl_NthTerm(nextUnackedTerm, 1);
  ICLListType* listElt;
  ICLTerm* sequenceMatcher = icl_NewStruct("sequence", 1, icl_NewVar("_"));
  ICLTerm* sequenceTerm;

  if(!com_GetInfo(connId, unackedMatcher, &unackedTerm)) {
    goto cleanup;
  }
  unackedList = icl_NthTerm(unackedTerm, 1);
  for(listElt = icl_List(unackedList); listElt != NULL; listElt = icl_ListNext(listElt)) {
    if(icl_Member(sequenceMatcher, icl_NthTerm(icl_ListElt(listElt), 2), &sequenceTerm)) {
      int eltSeqNum = icl_Int(icl_NthTerm(sequenceTerm, 1));
      if(oaa_SeqNumLessThan(ackNum, eltSeqNum)) {
        break;
      }
    }
    icl_Free(sequenceTerm);
  }
  for(; listElt != NULL; listElt = icl_ListNext(listElt)) {
    icl_AddToList(remainder, icl_CopyTerm(icl_ListElt(listElt)), TRUE);
  }
  icl_Free(unackedTerm);

  com_UpdateInfo(connId, nextUnackedTerm);

cleanup:
  icl_Free(nextUnackedTerm);
  icl_Free(unackedMatcher);
  icl_Free(sequenceMatcher);
}

static void oaa_record_outgoing_event(char* connId, ICLTerm* event)
{
  ICLTerm* unackedMatcher = icl_NewStruct("unacked", 1, icl_NewVar("_"));
  ICLTerm* unackedTerm;
  ICLTerm* unackedList;
  
  if(!com_GetInfo(connId, unackedMatcher, &unackedTerm)) {
    unackedTerm = icl_NewStruct("unacked", 1, icl_NewList(NULL));
  }
  unackedList = icl_NthTerm(unackedTerm, 1);
  icl_AddToList(unackedList, icl_CopyTerm(event), TRUE);
  com_UpdateInfo(connId, unackedTerm);
  icl_Free(unackedTerm);
  icl_Free(unackedMatcher);
}

static void oaa_update_seq_num(ICLTerm* event)
{
  char* connId;
  if(!icl_IsStruct(event) || icl_NumTerms(event) != 2 || !STREQ(icl_Functor(event), "event")) {
    return;
  }
  else {
    ICLTerm* eventParams = icl_NthTerm(event, 2);
    ICLTerm* connMatcher = icl_NewStruct("connection_id", 1, icl_NewVar("_"));
    ICLTerm* sequenceMatcher = icl_NewStruct("sequence", 1, icl_NewVar("_"));
    ICLTerm* sequenceTerm;
    ICLTerm* connTerm;
  
    if(!icl_Member(connMatcher, eventParams, &connTerm)) {
      goto cleanup;
    }
    connId = icl_Str(icl_NthTerm(connTerm, 1));
  
    if(icl_Member(sequenceMatcher, eventParams, &sequenceTerm)) {
      ICLTerm* otherSequenceTerm = icl_NewStruct("other_sequence", 1, icl_CopyTerm(icl_NthTerm(sequenceTerm, 1)));
      com_UpdateInfo(connId, otherSequenceTerm);
      icl_Free(otherSequenceTerm);
      icl_Free(sequenceTerm);
    }
    icl_Free(connTerm);
  
cleanup:
    icl_Free(connMatcher);
    icl_Free(sequenceMatcher);
  }
}

static void oaa_update_last_acked(ICLTerm* event)
{
  char* connId;
  if(!icl_IsStruct(event) || icl_NumTerms(event) != 2 || !STREQ(icl_Functor(event), "event")) {
    return;
  }
  else {
    ICLTerm* eventParams = icl_NthTerm(event, 2);
    ICLTerm* connMatcher = icl_NewStruct("connection_id", 1, icl_NewVar("_"));
    ICLTerm* ackMatcher = icl_NewStruct("ack", 1, icl_NewVar("_"));
    ICLTerm* ackTerm;
    ICLTerm* connTerm;
  
    if(!icl_Member(connMatcher, eventParams, &connTerm)) {
      goto cleanup;
    }
    connId = icl_Str(icl_NthTerm(connTerm, 1));
  
    if(icl_Member(ackMatcher, eventParams, &ackTerm)) {
      ICLTerm* otherAckTerm = icl_NewStruct("other_acked", 1, icl_CopyTerm(icl_NthTerm(ackTerm, 1)));
      com_UpdateInfo(connId, otherAckTerm);
      oaa_acked(connId, icl_Int(icl_NthTerm(ackTerm, 1)));
      icl_Free(otherAckTerm);
      icl_Free(ackTerm);
    }
    icl_Free(connTerm);
  
cleanup:
    icl_Free(connMatcher);
    icl_Free(ackMatcher);
  }
}


int oaa_select_event(double timeout, ICLTerm **event)
{
  ICLTerm *in_event = NULL;
  ICLTerm *translated_event = NULL;
  char *connection_id;

  int selected = FALSE;

  selected = com_SelectEventFromAllIds(timeout, &in_event);
  CHECK_LEAKS();
  /*
  {
    char* inevent;
    inevent = icl_NewStringFromTerm(in_event);
    printf("oaa_select_event got term [%s]\n", inevent);
    icl_stFree(inevent);
  }
  */

  if(selected) {
#ifdef FACILITATOR_OK
    oaa_translate_incoming_event(in_event, &translated_event);
#else
    translated_event = in_event;
#endif

    oaa_unwrap_event(translated_event, &connection_id, event);
    oaa_update_seq_num(*event);
    oaa_update_last_acked(*event);
    icl_stFree(connection_id);
    /*
    {
      char* unwrapped;
      unwrapped = icl_NewStringFromTerm(*event);
      printf("oaa_select_event got unwrapped term [%s]\n", unwrapped);
      icl_stFree(unwrapped);
    }
    */
  }


  /* ??? - should in_event be freed? */
#ifdef FACILITATOR_OK
  icl_Free(in_event);
#endif
  icl_Free(translated_event);
  CHECK_LEAKS();
  return selected;
}


/* timeout is the ONLY event that doesn't get embedded in event/2: */
int oaa_unwrap_event(ICLTerm *in_event,
                     char **connection_id,
                     ICLTerm **out_event)
{
  ICLTerm *content, *new_params;
  char *errfmt =
    "%s: incoming event from an unrecognized connection (%s):\n  %s\n";

  /* check to see if event is a timeout */
  if(icl_IsStr(in_event) && STREQ(icl_Str(in_event), "timeout")) {
    *connection_id = strdup("unknown");
    *out_event = icl_CopyTerm(in_event);
    return TRUE;
  }

  /* Get connection ID */
  *connection_id = com_GetDefaultConnectionId();

  /*
   * check to make sure in_event is of the form:
   * term(Connection, event(Content, Params))
   */
  if(icl_IsStruct(in_event)) {
    char *functor = icl_Functor(in_event);

    if(STREQ(functor, "term")) {
      /*
    This handles ev_connected/2
      */
      if(icl_NumTerms(in_event) == 1) {
  if (strlen(*connection_id) < strlen("unknown")) {
    icl_stFree(*connection_id);
    *connection_id = strdup("unknown");
  }
  else {
    strcpy(*connection_id, "unknown");
  }
  *out_event = icl_CopyTerm(icl_NthTerm(in_event, 1));
      }
      else if(icl_NumTerms(in_event) == 2) {
  /* everything appears to be OK, extract terms and create
     the new_params list */
  ICLTerm *res;
  ICLTerm *connection = icl_NthTerm(in_event, 1);
  ICLTerm *event = icl_NthTerm(in_event, 2);
  ICLTerm *params = icl_NthTerm(event, 2);
  ICLTerm *cid;
  ICLTerm *t1;

  content = icl_NthTerm(event, 1);
  t1 = icl_NewStruct("connection", 1, connection);
  if(!com_GetInfo(*connection_id, t1, &res)) {
    char *debug1 = icl_NewStringFromTerm(connection);
    char *debug2 = icl_NewStringFromTerm(icl_NthTerm(in_event, 2));
    fprintf(stderr, errfmt, "INTERNAL ERROR",
      debug1, debug2);
    *connection_id = strdup("unknown");
    icl_stFree(debug1);
    icl_stFree(debug2);
  }
  icl_Free(t1);
  icl_Free(res);

  /* ??? - in the following if-then-else block, reverse the
     order of from() and connection_id() in the new_params
     list from the prolog version for more convenient and
     easier to read control flow */
  if(oaa_from_param(*out_event)) {
    new_params = icl_CopyTerm(params);
  }
  else {
    ICLTerm *id, *from_id;
    if(oaa_content_fac_id(content, &id)) {
    }
    else if(oaa_is_parent_fac_id(*connection_id, &id)) {
    }
    else if(oaa_is_oaa_id(*connection_id, &id)) {
    }
    else {
      id = icl_NewStr("unknown");
    }
    from_id = icl_NewStruct("from", 1, id);
    new_params = icl_NewList(icl_NewCons(from_id, icl_ListCopy(params)));
  }
  cid = icl_NewStruct("connection_id", 1,
          icl_NewStr(*connection_id));
  icl_AddToList(new_params, cid, FALSE);
  *out_event = icl_NewStruct("event", 2, icl_CopyTerm(content), new_params);
      } /* end term/2 */
    } /* end term(X) */
    else {
      if (strlen(*connection_id) < strlen("unknown")) {
  icl_stFree(*connection_id);
  *connection_id = strdup("unknown");
      }
      else {
  strcpy(*connection_id, "unknown");
      }
    }
  }
  return TRUE;
}

/*
 * Helper function for oaa_unwrap_event().
 */
int oaa_from_param(ICLTerm *event)
{
  ICLTerm *from = icl_NewStruct("from", 1, icl_NewVar("_"));

  if(oaa_event_param(event, from)) {
    icl_Free(from);
    return TRUE;
  }

  icl_Free(from);
  return FALSE;
}

/*
 * Helper function for oaa_unwrap_event().
 */
int oaa_content_fac_id(ICLTerm *content, ICLTerm **id)
{
  if(icl_IsStruct(content)) {
    char *functor = icl_Functor(content);
    if(STREQ(functor, "ev_connected")) {
      /* get the value of InfoList */
      ICLTerm *res = NULL;
      ICLTerm *fac_id = icl_NewStruct("fac_id", 1, icl_NewVar("Id"));
      ICLTerm *infolist = icl_NthTerm(content, 1);
      if(icl_GetParamValue(fac_id, infolist, &res)) {
        *id = res;
        icl_Free(fac_id);
        return TRUE;
      }
      icl_Free(fac_id);
    }
  }
  return FALSE;
}

/*
 * Helper function for oaa_unwrap_event().
 */
int oaa_is_parent_fac_id(char *connection_id, ICLTerm **id)
{
  ICLTerm *res = NULL;
  ICLTerm *fac_id = icl_NewStruct("fac_id", 1, icl_NewVar("Id"));
  if(STREQ(connection_id, "parent"))
    if(com_GetInfo(connection_id, fac_id, &res)) {
      *id = res;
      icl_Free(fac_id);
      return TRUE;
    }
  icl_Free(fac_id);
  return FALSE;
}

/*
 * Helper function for oaa_unwrap_event().
 */
int oaa_is_oaa_id(char *connection_id, ICLTerm **id)
{
  ICLTerm *res = NULL;
  ICLTerm *oaa_id = icl_NewStruct("oaa_id", 1, icl_NewVar("Id"));

  if(com_GetInfo(connection_id, oaa_id, &res)) {
    *id = res;
    icl_Free(oaa_id);
    return TRUE;
  }

  icl_Free(oaa_id);
  return FALSE;
}


/***************************************************************************
 * name:    oaa_translate_incoming_event(+InEvent, -OutEvent).
 * NOT FULLY IMPLEMENTED YET
 * THIS FUNCTION IS ONLY FULLY NEEDED IF WE PORT THE FACILITATOR TO JAVA
 * purpose:
 *  Just makes a copy of the incoming raw_event.
 *****************************************************************************/
int oaa_translate_incoming_event(ICLTerm *raw_event_in,
                                 ICLTerm **raw_event_out)
{
#ifdef FACILITATOR_OK
  /* check to see if raw_event_in is of the form term(_, event(_,_)) */
  ICLTerm *event_in, *contents;
  if(icl_IsStruct(raw_event_in) &&
     STREQ(icl_Functor(raw_event_in), "term")) {
    if((icl_IsStruct(event_in = icl_NthTerm(raw_event_in, 2))) &&
       (strcmp(icl_Functor(event_in), "event") == 0) &&
       (contents = icl_NthTerm(event_in, 1)) &&
       (icl_IsStruct(contents)) &&
       (strcmp(icl_Functor(contents), "ev_connect") == 0)) {
      /* ??? not sure whether to copy incoming event or just repackage it */
      ICLTerm *params = icl_NthTerm(event_in, 2);
      ICLTerm *arglist = icl_NewList(icl_Arguments(contents));
      /* alter contents slightly */
      ICLTerm *event_out =
        icl_NewStruct("event", 2,
                      icl_NewStructFromList("ev_connected", arglist),
                      params);
      *raw_event_out =
        icl_NewStruct("term", 2, icl_NthTerm(raw_event_in, 1), event_out);
      return;
    }
  } else {
    /* take care of case for generic input event */
    /* ??? what do to here */
  }
#endif
  *raw_event_out = icl_CopyTerm(raw_event_in);
  return TRUE;
}

int oaa_extract_event(ICLTerm *raw_event, ICLTerm **content, ICLTerm **params)

{
  /* check to make sure this is a structure term */
  if(icl_IsStruct(raw_event)) {
    char *functor = icl_Functor(raw_event);
    /* check to make sure it's an event */
    if(STREQ(functor, "event")) {
      *content = icl_CopyTerm(icl_NthTerm(raw_event, 1));
      *params = icl_CopyTerm(icl_NthTerm(raw_event, 2));
      return TRUE; /* always succeeds */
    }

  }
  *content = *params = NULL;
  return TRUE; /* always succeeds */
}


int oaa_event_param(ICLTerm *event, ICLTerm *param) {
  if(icl_IsStruct(event) &&
     STREQ(icl_Functor(event), "event") &&
     (icl_NumTerms(event) == 2)) {

    ICLTerm *params = icl_NthTerm(event, 2);
    return icl_ParamValue(icl_Str(param), NULL, params, NULL);
  }
  return FALSE;
}

int oaa_extract_event_param(ICLTerm *event, char *param, ICLTerm **result) {
  int res = FALSE;

  if(icl_IsStruct(event) &&
     STREQ(icl_Functor(event), "event") &&
     (icl_NumTerms(event) == 2)) {
    ICLTerm* paramAsTerm = icl_NewStruct(param, 1, icl_NewVar("_"));
    ICLTerm *params = icl_NthTerm(event, 2);
    res = icl_GetParamValue(paramAsTerm, params, result);
    icl_Free(paramAsTerm);
    return res;
  }
  return res;
}

int oaa_Interpret(ICLTerm *goal, ICLTerm *params, ICLTerm **solutions) {
  char *goalstr;
  if(icl_IsVar(goal)) { /* Not supposed to happen */
    return FALSE;
  }
  if(icl_IsStr(goal)) {
    if(STREQ((goalstr = icl_Str(goal)), "true")) {
      return TRUE;
    }
    if(STREQ(goalstr, "fail")) {
      return FALSE;
    }
    if(STREQ(goalstr, "false")) {
      return FALSE;
    }
  }
  if(icl_IsGroup(goal)) {
    char *startC=NULL, *sep;
    ICLListType *goal_list = icl_List(goal);
    icl_GetGroupChars(goal, startC, &sep);
    /*
     * ??? How to handle case (/+ P) ?
     * ??? How to handle cases like (P -> Q ; R) ?
     */
    switch(*sep) {
    case ',':
      while(icl_ListHasMoreElements(goal_list)) {
  ICLTerm *subgoal =
    icl_ListElement(icl_ListNextElement(goal_list));
  if(!oaa_Interpret(subgoal, params, solutions))
    return FALSE;
      }
      return TRUE;
    case ';':
      while(icl_ListHasMoreElements(goal_list)) {
  ICLTerm *subgoal =
    icl_ListElement(icl_ListNextElement(goal_list));
  if(oaa_Interpret(subgoal, params, solutions))
    return TRUE;
      }
      return FALSE;
    }
  }
  if(icl_IsStruct(goal) &&
     STREQ(icl_Functor(goal), "findall")) {
    /*
     * ??? Don't know how to do a findall in C
     */
  }
  if(icl_BuiltIn(goal)) {
    /* ??? What does it mean to "call(goal)"
       enumerate each case */
    return FALSE;
  }
  else {
    return oaa_exec_event(goal, params, solutions);
  }
}

int oaa_exec_event(ICLTerm *goal, ICLTerm *params, ICLTerm **solutions) {
  char *goalstr = icl_Str(goal);
  int res = FALSE;
  int arity = icl_NumTerms(goal);
  if(STREQ(goalstr, "ev_trace_on")) {
    oaa_trace_on = TRUE;
    printf("\nTrace on.\n");
    res = TRUE;
  }
  else if(STREQ(goalstr, "ev_trace_off")) {
    oaa_trace_on = FALSE;
    printf("\nTrace off.\n");
    res = TRUE;
  }
  else if(STREQ(goalstr, "ev_com_trace_on")) {
    oaa_com_trace_on = TRUE;
    printf("\nCOMMUNICATION PROTOCOL trace on.\n");
    res = TRUE;
  }
  else if(STREQ(goalstr, "ev_com_trace_off")) {
    oaa_com_trace_on = FALSE;
    printf("\nCOMMUNICATION PROTOCOL trace off.\n");
    res = TRUE;
  }
  else if(STREQ(goalstr, "ev_debug_on")) {
    oaa_debug_on = TRUE;
    printf("\nDebug on.\n");
    res = TRUE;
  }
  else if(STREQ(goalstr, "ev_debug_off")) {
    oaa_debug_on = FALSE;
    printf("\nDebug off.\n");
    res = TRUE;
  }
  else if(STREQ(goalstr, "ev_set_timeout")) {
    oaa_timeout = icl_Int(icl_NthTerm(goal, 1));
    printf("\nTimeout set to %f.\n", oaa_timeout);
    res = TRUE;
  }
  else if(STREQ(goalstr, "ev_set_timeout")) {
    oaa_timeout = icl_Int(icl_NthTerm(goal, 1));
    printf("\nTimeout set to %f.\n", oaa_timeout);
    res = TRUE;
  }
  else if (STREQ(goalstr, "ev_agent_disconnected")) {
    ICLTerm *lid = icl_CopyTerm(icl_NthTerm(goal, 1));

    oaa_remove_data_owned_by(lid);
    icl_Free(lid);
    res = TRUE;
  }
  else if (STREQ(goalstr, "ev_halt")) {

    ICLTerm *tmpArgs = icl_NewList(NULL);

    printf("\nDisconnecting...\n");
    com_Disconnect("parent");
    oaa_call_callback("app_done", NULL, tmpArgs, NULL);
    icl_Free(tmpArgs);
    exit(0);
  }
  else if(STREQ(goalstr, "ev_update_data") && (arity == 4)) {

    /* MAGIC BUG */
    res = oaa_handle_ev_update_data(goal, params);
  }
  else if(STREQ(goalstr, "ev_update_trigger") &&
      (arity == 6)) {
    res = oaa_handle_ev_update_trigger(goal, params);
  }
  else if(STREQ(goalstr, "ev_solve") && (arity == 3)) {
    res = oaa_handle_ev_solve(goal, params, solutions);
  }
  else if(STREQ(goalstr, "ev_solved") && (arity == 6)) {
    res = oaa_handle_ev_solved(goal, params);
  }
  else
    /***********************************************************
   Goal unifies with : oaa_Solve(Goal, Params)
    **********************************************************/
    if(STREQ(goalstr, "oaa_Solve") && (arity == 2)) {
      res = oaa_Solve(icl_NthTerm(goal,1), icl_NthTerm(goal,2), NULL, solutions);
    }
    else
      /*************************************************************
   Goal unifies with : oaa_PostEvent(Content , Params)
      *************************************************************/
      if(STREQ(goalstr, "oaa_PostEvent") && (arity == 2)) {
        res = oaa_PostEvent(icl_NthTerm(goal,1), icl_NthTerm(goal,2));
      }
      else
        /************************************************
   Goal unifies with : oaa_AddData(Clause, Params)
        ************************************************/
        if(STREQ(goalstr, "oaa_AddData") && (arity == 2)) {
          res = oaa_AddData(icl_NthTerm(goal,1), icl_NthTerm(goal,2), NULL);
        }
        else
          /*****************************************************************
   Goal unifies with : oaa_AddTrigger(Type, Condition, Action, Params)
          *******************************************************************/
          if(STREQ(goalstr, "oaa_AddTrigger") && (arity == 4)) {
            res = oaa_AddTrigger(icl_Str(icl_NthTerm(goal,1)), icl_NthTerm(goal,2),
                                 icl_NthTerm(goal,3), icl_NthTerm(goal,4), NULL);
          }
          else
          {
            res = oaa_handle_user_event(goal, params, solutions);
          }
  return res;
}

/*
 * Helper function for oaa_exec_event()
 */
int oaa_handle_ev_update_data(ICLTerm *goal, ICLTerm *params)
{
  ICLTerm *agent_id = NULL, *updaters = NULL, *requestees = NULL, *all_params = NULL;
  ICLTerm *mode = NULL, *id = NULL, *clause = NULL, *term_params = NULL;
  ICLTerm *t1 = NULL;
  int result = 0;
  char *modestr = NULL;

  mode = icl_NthTerm(goal, 2);
  id = icl_NthTerm(goal, 1);
  clause = icl_NthTerm(goal, 3);
  term_params = icl_NthTerm(goal, 4);
  modestr = icl_Str(mode);
  all_params = NULL;

  oaa_PrimaryAddress(&agent_id);
  requestees = icl_NewList(icl_NewCons(agent_id,NULL));
  icl_append_to_list(term_params, params, &all_params);
  if(!all_params) {
    all_params = icl_NewList(NULL);
  }
  /*
   * Changing the calling order here a little bit from prolog to C for
   * the sake of efficiency - sws
   */
  if(STREQ(modestr, "add")) {
    result = oaa_add_data_local(clause, all_params);
  }
  else if(STREQ(modestr, "remove")) {
    result = oaa_remove_data_local(clause, all_params);
  }
  else if(STREQ(modestr, "replace")) {
    result = oaa_replace_data_local(clause, all_params);
  }
  else {
    result = FALSE;
  }
  t1 = icl_NewTermFromData("reply(none)",11);
  if(!icl_GetParamValue(t1, params, NULL)) {
    ICLTerm *new_term;
    ICLTerm *emptyList;
    if(result) {
      updaters = icl_NewList(icl_NewCons(agent_id, NULL));
    }
    else {
      updaters = icl_NewList(NULL);
    }
    new_term =
      icl_NewStruct("ev_data_updated", 6,
                    icl_CopyTerm(id),
                    icl_CopyTerm(mode),
                    icl_CopyTerm(clause),
                    icl_CopyTerm(params),
                    requestees,
                    updaters);
    emptyList = icl_NewList(NULL);
    oaa_PostEvent(new_term, emptyList);
    icl_Free(new_term);
    icl_Free(emptyList);
  }
  icl_Free(t1);
  icl_Free(requestees);
  icl_Free(updaters);
  icl_Free(all_params);
  return TRUE;
}

/*
 * Helper function for oaa_exec_event()
 */
int oaa_handle_ev_update_trigger(ICLTerm *goal, ICLTerm *params)
{
  ICLTerm *id = icl_NthTerm(goal, 1);
  ICLTerm *mode = icl_NthTerm(goal, 2);
  char *type = icl_Str(icl_NthTerm(goal, 3));
  ICLTerm *condition = icl_NthTerm(goal, 4);
  ICLTerm *action = icl_NthTerm(goal, 5);
  ICLTerm *trig_params = icl_NthTerm(goal, 6);
  ICLTerm *agent_id, *new_term, *updaters, *all_params;
  ICLTerm *t1 = NULL;
  ICLTerm *emptyList = NULL;
  char *modestr = icl_Str(mode);
  int result = FALSE;
  oaa_PrimaryAddress(&agent_id);
  all_params = NULL;
  icl_append_to_list(trig_params, params, &all_params);
  if(!all_params) {
    all_params = NULL;
  }

  /*
   * Changing the calling order here a little bit from prolog to C for
   * the sake of efficiency - sws
   */
  if (STREQ(modestr, "add")) {
    result = oaa_add_trigger_local(type, condition, action, all_params);
  }
  else if (STREQ(modestr, "remove")) {
    result = oaa_remove_trigger_local(type, condition, action, all_params);
  }
  else {
    result = FALSE;
  }

  if (!icl_GetParamValue((t1 = icl_NewTermFromData("reply(none)",11)),
                         params, NULL)) {
    if (result) {
      updaters = icl_NewList(icl_NewCons(agent_id, NULL));
    }
    else {
      updaters = icl_NewList(NULL);
    }
    new_term = icl_NewStruct("ev_trigger_updated", 8,
                             icl_CopyTerm(id),
                             icl_CopyTerm(mode),
                             icl_NewStr(type),
                             icl_CopyTerm(condition),
                             icl_CopyTerm(action),
                             icl_CopyTerm(params),
                             icl_CopyTerm(updaters),
                             icl_CopyTerm(updaters));
    emptyList = icl_NewList(NULL);
    oaa_PostEvent(new_term, emptyList);
    icl_Free(emptyList);
    icl_Free(new_term);
    icl_Free(updaters);
  }
  icl_Free(t1);
  icl_Free(all_params);
  /*
    if (STREQ(modestr, "add"))
    oaa_Inform(icl_NewStr("trigger"), "trigger_added(%s, %s, %s, %s)\n",
    type, condition, action, all_params);
  */
  return TRUE;
}

/*
 * Helper function for oaa_exec_event().  Finds all occurances
 * of context(X) on a list of params and returns list of values.
 */
int oaa_find_all_contexts(ICLTerm *params, ICLTerm **contexts) {
  ICLTerm *context, *test;
  ICLListType *p;
  if(!icl_IsList(params))
    return FALSE;
  test = icl_NewStruct("context", 1, icl_NewVar("X"));
  p = icl_List(params);
  *contexts = NULL;
  while(p) {
    if(icl_Unify(test, p->elt, &context)) {
      if(*contexts == NULL) {
        *contexts = icl_NewList(NULL);
      }
      icl_AddToList(*contexts, context, TRUE);
    }
    p = p->next;
  }
  if(*contexts == NULL) {
    *contexts = icl_NewList(NULL);
  }
  icl_Free(test);
  return TRUE;
}

/*
 * Helper function for oaa_exec_event()
 */
int oaa_handle_ev_solved(ICLTerm *goal, ICLTerm *params) {
  ICLTerm *local_params = icl_NthTerm(goal, 5);
  ICLTerm *local_callback = NULL;
  char* local_callback_id;
  int res;
  ICLTerm* request_for_callback = icl_NewTermFromData("callback(X)",11);
  (void)params;

  if (icl_GetParamValue(request_for_callback, local_params, &local_callback)) {
    local_callback_id = icl_Str(icl_NthTerm(local_callback,1));
  }
  else {
    local_callback_id = "app_do_event";
  }

  icl_Free(request_for_callback);
  res = oaa_call_callback(local_callback_id, goal, local_params, NULL);
  icl_Free(local_callback);
  return res;
}

/*
 * Helper function for oaa_exec_event()
 */
int oaa_handle_ev_solve(ICLTerm *goal, ICLTerm *params, ICLTerm **solutions) {
  ICLTerm *id = icl_NthTerm(goal, 1);
  ICLTerm *full_goal = icl_NthTerm(goal, 2);
  ICLTerm *solve_params = icl_NthTerm(goal, 3);
  ICLTerm *goal_params, *contexts;
  ICLTerm *tmp1, *tmp2, *user_id;
  ICLTerm *t1 = NULL;
  ICLTerm *t2 = NULL;
  ICLTerm *inherited_params;
  ICLTerm *all_params;

  if(!oaa_class("leaf"))
    return FALSE;

  inherited_params = NULL;
  all_params = NULL;
  icl_GoalComponents(full_goal, &tmp1, &tmp2, &goal_params);
  icl_Free(tmp1);
  icl_Free(tmp2);

  /*
   * More "local" params take precedence, so they to go the
   * beginning of the list
   */
  icl_append_to_list(solve_params, params, &inherited_params);
  icl_append_to_list(goal_params, inherited_params, &all_params);
  icl_Free(goal_params);

  /* Assert context */
  oaa_find_all_contexts(all_params, &contexts);
  oaa_assert_current_contexts(id, contexts);

  //oaa_TraceMsg("\n\nAttempting to solve: \n  Goal:%s\n  Params:%s\n", full_goal, inherited_params, NULL);

  /*
   * oaa_solve_local() will have to be one of those routines in C that
   * have an extra parameter beyond it's prolog counterpart.  The extra
   * parameter is a list of terms to simulate findall/3 behavior
   */
  *solutions = icl_NewList(NULL);
  oaa_solve_local(full_goal, inherited_params, solutions);

#ifdef UNNEEDED_DEBUG
  oaa_TraceMsg("\nSolutions found for %s:\n  %s\n",
               icl_NewStringFromTerm(full_goal),
               icl_NewStringFromTerm(*solutions),NULL);
#endif /* UNNEEDED_DEBUG */

  /*
   * If user has requested to delay the solution (oaaDelaySolution)
   * save current userId, Goal and Params in delay table, to be
   * sent back in an ev_solved() msg later (oaaReturnDelayedSolutions).
   */
  if(oaa_retract_delay(id, &user_id)) {
    oaa_assert_delay_table(icl_CopyTerm(id), icl_CopyTerm(user_id), icl_CopyTerm(full_goal), icl_CopyTerm(solve_params), icl_CopyTerm(all_params));
  } else {
    ICLTerm* request = icl_NewTermFromData("reply(none)",11);
    ICLTerm* post_params = NULL;
    int no_reply =  icl_GetParamValue(request, all_params, NULL);
    ICLTerm *from_ks = NULL;
    oaa_PrimaryAddress(&from_ks);

    if (!no_reply && !STREQ(icl_Str(from_ks), "unknown")) {
      ICLTerm *new_event =
        icl_NewStruct("ev_solved", 6,
                      icl_CopyTerm(id),
                      icl_NewList(icl_NewCons(icl_CopyTerm(from_ks), NULL)),
                      icl_NewList(icl_NewCons(icl_CopyTerm(from_ks), NULL)),
                      getEvSolvedGoal(full_goal),
                      icl_CopyTerm(solve_params),
                      icl_CopyTerm(*solutions));
      /* DEBUG
         printf("***************\n");
         printf("%s\n", icl_NewStringFromTerm(new_event));
         printf("***************\n");
      */
      post_params = icl_NewList(NULL);

      // if connection_id is given, the message goes there.
      t1 = icl_NewStruct("connection_id", 1, icl_NewVar("_"));
      if (icl_GetParamValue(t1, params, &t2)) {
        icl_AddToList(post_params, icl_CopyTerm(t2), FALSE);
      }
      icl_Free(t1);
      if (t2 != NULL) {
        icl_Free(t2);
      }

      oaa_PostEvent(new_event, post_params);
      icl_Free(new_event);
      icl_Free(post_params);
    }
    if(from_ks != NULL) {
      icl_Free(from_ks);
    }
    icl_Free(request);
  }
  oaa_retractall_current_contexts(id);

  icl_Free(inherited_params);
  icl_Free(all_params);

  return TRUE;        /* what to return here? */

} // end of oaa_handle_ev_solve

ICLTerm *valid_oaa_solvables() {
  if(oaa_solvables == NULL) {
    oaa_solvables = icl_NewList(NULL);
    return oaa_solvables;
  }
  else {
    return oaa_solvables;
  }
}

static char* CALLBACK_PARAM = "callback(CB)";

/*
 * Helper function for oaa_exec_event()
 */
int oaa_handle_user_event(ICLTerm *event,  ICLTerm *params, ICLTerm **solutions) {
  ICLTerm *goal = NULL, *matched = NULL;
  ICLTerm *solvables = valid_oaa_solvables();
  int res = FALSE;
  oaa_turn_on_debug();

  oaa_goal_matches_solvables(event, solvables, &goal, &matched);

  if (matched && icl_IsStruct(matched) &&
      STREQ(icl_Functor(matched), "solvable")) {

    int (*callback_proc)(ICLTerm*, ICLTerm*, ICLTerm*)=NULL;

    ICLTerm* solv_params = icl_NthTerm(matched, 2);
    ICLTerm* tempRequest = icl_NewTermFromData(CALLBACK_PARAM, strlen(CALLBACK_PARAM));
    ICLTerm* cb = NULL;
    icl_GetParamValue(tempRequest, solv_params, &cb);
    icl_Free(tempRequest);

    /* Check if we have a specific callback for this solvable */
    if (cb) {
      oaa_GetCallback(icl_Str(icl_NthTerm(cb,1)), &callback_proc);
      icl_Free(cb);
    }

    if (callback_proc) {
      callback_proc(event, params, *solutions);
    }
    oaa_turn_off_debug();
    res = TRUE;
  }
  if(goal) {
    icl_Free(goal);
  }
  if(matched) {
    icl_Free(matched);
  }
  return res;
}

/*
 * What to do about test(TEST)?
 * if test(TEST) is listed in arguments, solve
 *    it locally.
 */
int passes_tests(ICLTerm *params)
{
  ICLTerm *test;
  ICLTerm *results;
  ICLTerm *t1;
  int returnValue = TRUE;

  if (oaa_class("leaf")) {
    t1 = icl_NewStruct("test", 1, icl_NewVar("Test"));
    if (icl_GetParamValue(t1, params, &test)) {
      ICLTerm *emptyList = icl_NewList(NULL);
      returnValue = oaa_Solve(test, emptyList, &results, NULL);
      icl_Free(emptyList);
      icl_Free(results);
    }
    else {
      returnValue = TRUE;
    }
    icl_Free(t1);
  }
  else if(oaa_class("root") || oaa_class("node")) {
    /*
     * With compound goals, we also want to allow tests on the facilitator.
     * @@DLM: Is this the best way?
     */
    t1 = icl_NewStruct("test", 1, icl_NewVar("Test"));
    if(icl_GetParamValue(t1, params, &test)) {
      ICLTerm *emptyList = icl_NewList(NULL);
      (void)oaa_solve_local(test, emptyList, &results);
      icl_Free(emptyList);
      icl_Free(results);
    }
    else {
      returnValue = FALSE;
    }

    icl_Free(t1);
  }
  return returnValue;
}

int oaa_DelaySolution(ICLTerm *id) {
  ICLTerm *goal_id, *tmp;
  /*
   * ??? retrieve the first one for now, multiple solutions may be required
   */
  if(oaa_retrieve_nth_current_contexts(&goal_id, &tmp, 0)) {
    oaa_assert_delay(goal_id, id);
    return TRUE;
  }
  return FALSE;
}

int oaa_ReturnDelayedSolutions(ICLTerm *id, ICLTerm *solution_list)
{
  ICLTerm *goal_id, *goal, *solve_params, *all_params;
  ICLTerm *solutions = icl_NewList(NULL);
  ICLTerm *from_ks;

  if(oaa_retract_delay_table(&goal_id, id, &goal, &solve_params,
                             &all_params)) {
    ICLTerm *t1;

    t1 = icl_NewTermFromData("reply(none)",11);
    if(!icl_GetParamValue(t1, all_params, NULL)) {
      ICLListType *slist;

      if(!oaa_PrimaryAddress(&from_ks)) {
        from_ks = icl_NewStr("unknown");
      }

      /* make sure all Solutions unify with the original goal */
      slist = icl_List(solution_list);

      while(icl_ListHasMoreElements(slist)) {
        ICLTerm *soln = icl_ListElement(slist);

        if(icl_Unify(goal, soln, NULL)) {
          icl_AddToList(solutions, icl_CopyTerm(soln), TRUE);
        }
        slist = icl_ListNextElement(slist);
      }

      if(icl_NumTerms(solutions) > 0) {
        ICLTerm* requestees = icl_NewList(NULL);
        ICLTerm* responders;
        ICLTerm *eventToPost;
        icl_AddToList(requestees, icl_CopyTerm(from_ks), 1);
        responders = icl_CopyTerm(requestees);
        eventToPost = icl_NewStruct("ev_solved", 6, icl_CopyTerm(goal_id),
                                             requestees, responders, getEvSolvedGoal(goal), icl_CopyTerm(solve_params),
                                             solutions);
        (void)oaa_PostEvent(eventToPost, NULL);
        icl_Free(goal_id);
        icl_Free(goal);
        icl_Free(solve_params);
        icl_Free(all_params);
        icl_Free(from_ks);
        icl_Free(eventToPost);
      }
      else {
        icl_Free(goal_id);
        icl_Free(goal);
        icl_Free(solve_params);
        icl_Free(all_params);
        icl_Free(from_ks);
        icl_Free(t1);
        return FALSE;
      }
    } else {
      icl_Free(t1);
      return FALSE;
    }
    icl_Free(t1);
  }
  else
  {
    return FALSE;
  }
  return TRUE;
}

 /*
 *  example:
 *      oaa_AppDoEvent(goal(_X),_Params) :-  oaa_DelayEvent(a_goal).
 *      oaa_AppDoEvent(temp_event(Y),_Params) :-
 *    oaa_AddDelayedContextParams(a_goal, [], P),
 *    oaa_Solve(sub_goal(Y), P).
 *      oaa_AppDoEvent(final_event(S), _Params) :-
 *    oaa_ReturnDelayedSolutions(a_goal, [goal(S)]).
 *
 *  remarks: *new_params points to newly allocated memory--remember to call
 *      icl_Free(*new_params)
 *
 */
int oaa_AddDelayedContextParams(ICLTerm *id, ICLTerm *params,
                                ICLTerm **new_params)
{
  ICLTerm *goal_id, *goal, *solve_params, *all_params;
  ICLTerm *contexts = icl_NewList(NULL);

  if (oaa_retract_delay_table(&goal_id, id, &goal,
                              &solve_params, &all_params)) {
    ICLListType *allparamlist = icl_List(all_params);

    while (icl_ListHasMoreElements(allparamlist)) {
      ICLTerm *param = icl_ListElement(allparamlist);
      ICLTerm *context;
      ICLTerm *t1;

      t1 = icl_NewStruct("context", 1, icl_NewVar("C"));
      if (icl_Unify(t1, param, &context))
        icl_AddToList(contexts, context, TRUE);

      allparamlist = icl_ListNextElement(allparamlist);
      icl_Free(t1);
    }
    if (icl_NumTerms(contexts) > 0) {
      icl_append_to_list(contexts, params, new_params);
      return TRUE;
    }
  }
  return FALSE;
}

/****************************************************************************
 * Agent-Facilitator communication
 ****************************************************************************/

int oaa_address_to_comm_id(ICLTerm *inAddress, char **commId)
{
  ICLTerm* tempRequest;
  int res;

  tempRequest = icl_NewStruct("other_address", 1, icl_CopyTerm(inAddress));
  res = com_GetConnectionFromInfo(tempRequest, commId);
  icl_Free(tempRequest);
  return res;
}

int oaa_PostEvent(ICLTerm *contents, ICLTerm *params)
{
  ICLTerm *send_event;
  ICLTerm *destvar  = icl_NewVar("Dest"), *dest;
  ICLTerm *dest_id, *trans_event, *arglist;
  ICLTerm *t1 = (ICLTerm *)NULL, *t2 = (ICLTerm *)NULL;
  char *comm_id = NULL;

  /* See if any params are of interest.
   */
  t1 = icl_NewStruct("priority", 1, icl_NewVar("_"));
  t2 = icl_NewStruct("from", 1, icl_NewVar("_"));

  if (memberchk(t1, params) || memberchk(t2, params)) {

    send_event = icl_NewStruct("event", 2, icl_CopyTerm(contents),
                               icl_CopyTerm(params));
  }
  else {
    send_event = icl_NewStruct("event", 2, icl_CopyTerm(contents),
                               icl_NewList(NULL));
  }
  icl_Free(t1);
  icl_Free(t2);

  // If connection_id is given, the message goes there.
  t1 = icl_NewStruct("connection_id", 1, icl_NewVar("_"));
  if (icl_GetParamValue(t1, params, &t2)) {
    comm_id = strdup(icl_Str(icl_NthTerm(t2,1)));
  }
  icl_Free(t1);
  icl_Free(t2);

  /* Find destination: if none, dest = server */
  t1 = icl_NewStruct("address", 1, icl_CopyTerm(destvar));
  if (!icl_GetParamValue(t1, params, &dest)) {
    dest = icl_NewStr("parent");
  }
  icl_Free(t1);

  icl_standardize_addressee(dest, &dest_id);

  arglist = icl_NewList(NULL);
  icl_AddToList(arglist, dest, FALSE);

#ifdef UNNEEDED_DEBUG
  oaa_ComTraceMsg("\n[COM send to %s]:\n  %s\n",
                  icl_NewStringFromTerm(dest_id),
                  icl_NewStringFromTerm(arglist), NULL);
#endif //UNNEEDED_DEBUG
  if (comm_id == NULL) {
    oaa_address_to_comm_id(dest_id, &comm_id);
  }
  oaa_translate_outgoing_event(send_event, dest_id, comm_id, &trans_event);
  icl_AddToList(arglist, trans_event, TRUE);
  oaa_record_outgoing_event(comm_id, trans_event);

  /* send event to destination */
  com_SendTerm(comm_id, trans_event);
  icl_stFree(comm_id);
  /*
   * Use SendEvent here, because triggers always contain event/2
   * to unify with
   */
  oaa_CheckTriggers("comm", send_event, "send");
  icl_Free(destvar);
  icl_Free(dest_id);
  icl_Free(send_event);
  icl_Free(arglist);  /* this call frees "dest" too */
  return TRUE;
} // end of oaa_PostEvent

int oaa_convert_id_to_comm_id(ICLTerm *id, ICLTerm **cid)
{
  char *connid;
  int res = FALSE;
  ICLTerm *fid = icl_NewStruct("fac_id", 1, icl_NewVar("FId"));
  ICLTerm *oid = icl_NewStruct("oaa_id", 1, icl_NewVar("FId"));
  (void)id;

  /*
   * ??? Prolog calling sequence has com_GetInfo being called with the
   * the first argument an uninstantiated variable
   * (  com:com_GetInfo(CId, oaa_id(Id)) )
   * but the C version of GetInfo doesn't allow this.
   * Use com_GetConnectionId(char **, ICLTerm *) instead
   */
  if(com_GetConnectionId(&connid, fid) ||
     com_GetConnectionId(&connid, oid)) {
    *cid = icl_NewStr(connid);
    res = TRUE;
  }
  icl_Free(fid);
  icl_Free(oid);
  return res;
}

int oaa_translate_outgoing_event(ICLTerm *event, ICLTerm *dest_id, char* commId,
                                 ICLTerm **new_event) {
  ICLTerm *contents;
  ICLTerm *params;
  int nextOutSeqNum;
  int lastSeenSeqNum;
  ICLTerm *lastOutSeqNumTerm = NULL;
  ICLTerm *lastSeenSeqNumTerm = NULL;
  ICLTerm *ackTerm = NULL;
  ICLTerm *seqNumTerm = NULL;
  (void)dest_id;

  if(!oaa_outSeqNum_matcher) {
    oaa_outSeqNum_matcher = icl_NewStruct("sequence", 1, icl_NewVar("_"));
  }
  if(!oaa_lastSeenSeqNum_matcher) {
    oaa_lastSeenSeqNum_matcher = icl_NewStruct("ack", 1, icl_NewVar("_"));
  }

  com_GetInfo(commId, oaa_outSeqNum_matcher, &lastOutSeqNumTerm);
  if(lastOutSeqNumTerm) {
    nextOutSeqNum = icl_Int(icl_NthTerm(lastOutSeqNumTerm, 1)) + 1;
    seqNumTerm = icl_NewStruct("sequence", 1, icl_NewInt(nextOutSeqNum));
    com_UpdateInfo(commId, seqNumTerm);
    icl_Free(lastOutSeqNumTerm);
  }

  com_GetInfo(commId, oaa_lastSeenSeqNum_matcher, &lastSeenSeqNumTerm);
  if(lastSeenSeqNumTerm) {
    lastSeenSeqNum = icl_Int(icl_NthTerm(lastSeenSeqNumTerm, 1));
    ackTerm = icl_NewStruct("ack", 1, icl_NewInt(lastSeenSeqNum));
    icl_Free(lastSeenSeqNumTerm);
  }

  /*
   * Special cases.  There's no need to translate these.  And, it could be
   * problematical, because we don't yet know the language and version of
   * the receiver.  See comments for oaa_unwrap_event.
   */
  if(icl_IsStruct(event) &&
     STREQ(icl_Functor(event), "event")) {
    if(icl_IsStruct(contents = icl_NthTerm(event, 1)) &&
       (STREQ(icl_Functor(contents), "ev_connect") ||
        STREQ(icl_Functor(contents), "ev_connected"))) {
      *new_event = icl_CopyTerm(event);
      params = icl_NthTerm(*new_event, 2);
      if(!STREQ(icl_Functor(contents), "ev_connected")) {
        if(seqNumTerm) {
          icl_AddToList(params, seqNumTerm, FALSE);
        }
      }
      if(ackTerm) {
        icl_AddToList(params, ackTerm, FALSE);
      }
      return TRUE;
    } else {
      /*
       * ??? I'm going to noop the rest of this for now because it depends
       * on some really weird stuff, including looking for a function in
       * the user module, which we can't do in C.
       * This is going to require yet another modification to GetInfo,
       * one that looks up both the connection ID and a parameter from
       * the connection_info predicate
       */
    }
  }
#if 0
  /*
   * default action is to return the incoming event (no copy)
   */
  *new_event = event;
#endif

  /*
   * Until reference count in ICLTerm is implemented, default is to
   * make a copy of the event. (Ruth Lang, 12/21/99)
   */
  *new_event =  icl_CopyTerm(event);
  params = icl_NthTerm(*new_event, 2);
  if(seqNumTerm) {
    icl_AddToList(params, seqNumTerm, FALSE);
  }
  if(ackTerm) {
    icl_AddToList(params, ackTerm, FALSE);
  }
  return TRUE;
}

/****************************************************************************
 * name:    oaa_LibraryVersion
 * purpose:
 * remarks:
 ****************************************************************************/
int oaa_LibraryVersion(ICLTerm** version) {
  int result = FALSE;
  ICLTerm* myVersionAsTerm =
    icl_NewStruct("version", 1, icl_NewStr(oaa_library_version_str));
  result = icl_Unify(*version, myVersionAsTerm, version);
  icl_Free(myVersionAsTerm);
  return result;
}

int oaa_Version(ICLTerm *agent_id, ICLTerm **language, ICLTerm **version) {
  ICLTerm *true_id;
  ICLTerm *true_id_var = icl_NewVar("TrueId");
  ICLTerm *version_var = icl_NewVar("Version");
  ICLTerm *language_var = icl_NewVar("Language");
  ICLTerm *oaa_id_query = icl_NewStruct("oaa_id", 1, true_id_var);
  ICLTerm *fac_id_query = icl_NewStruct("fac_id", 1, true_id_var);
  ICLTerm *agent_language_query = icl_NewStruct("agent_language", 1,
                                                true_id_var);
  ICLTerm *agent_version_query = icl_NewStruct("agent_version", 1,
                                               version_var);
  char *comm_id_str;

  if (icl_true_id(agent_id, &true_id)) {
    /* Asking for my version */
    if (oaa_PrimaryAddress(&true_id) &&
        oaa_LibraryVersion(version)) {
      *language = icl_NewStr("c");
    } else if ((com_GetConnectionId(&comm_id_str, oaa_id_query) ||
                com_GetConnectionId(&comm_id_str, fac_id_query)) &&
               (com_GetInfo(comm_id_str, agent_language_query, language) ||
                (*language = icl_NewStr("unknown"))) &&
               (com_GetInfo(comm_id_str, agent_version_query, version) ||
                (*version = icl_NewStr("unknown")))) {
    } else if (oaa_class("leaf") || oaa_class("node")) {
      ICLTerm *agent_version_term =
        icl_NewStruct("agent_version", 3, true_id,
                      language_var, version_var);
      ICLTerm *paramlist = icl_NewTermFromData("[address(parent)]",17);
      ICLTerm *result, *result_list;

      if (oaa_Solve(agent_version_term, paramlist, NULL, &result_list)) {
        if (icl_IsList(result_list) &&
            (result = icl_NthTerm(result_list, 1)) &&
            icl_IsStruct(result) &&
            (icl_NumTerms(result) == 3)) {
          *language = icl_NthTerm(result, 2);
          *version = icl_NthTerm(result, 3);
        }
      }
      icl_Free(paramlist);
      icl_Free(agent_version_term);
    } else {
      *language = icl_NewStr("prolog");
      *version = icl_NewStr("1.0");
    }
  } else {
    *language = icl_NewStr("prolog");
    *version = icl_NewStr("1.0");
  }

  icl_Free(oaa_id_query);
  icl_Free(fac_id_query);
  icl_Free(agent_language_query);
  icl_Free(agent_version_query);
  icl_Free(true_id_var);
  icl_Free(version_var);
  icl_Free(language_var);
  return TRUE;
}

int oaa_CanSolve(ICLTerm *goal, ICLTerm **kslist)
{
  ICLTerm *kslist_var = icl_NewVar("KSList");
  ICLTerm *can_solve_query = icl_NewStruct("can_solve", 2, goal, kslist_var);
  ICLTerm *paramlist = icl_NewTermFromData("[address(parent)]",17);
  int res = FALSE;

  if(oaa_Solve(can_solve_query, paramlist, NULL, kslist))
    res = TRUE;
  icl_Free(can_solve_query);
  icl_Free(paramlist);
  return res;
}

int oaa_Ping(ICLTerm *agent_addr, double time_limit,
             double *total_response_time) {
  int res = FALSE;
  if(time_limit >= 0.0) {
#ifndef _WINDOWS
    double t0, t1;
    struct timeval tv0, tv1;
#endif
    ICLTerm *trueterm = icl_NewStr("true");
    ICLTerm *tlfloat = icl_NewFloat(time_limit);
    ICLTerm *addrterm = icl_NewStruct("address", 1, agent_addr);
    ICLTerm *tlterm = icl_NewStruct("time_limit", 1, tlfloat);
    ICLTerm *paramlist = icl_NewList(NULL);
    ICLTerm *result;

    icl_AddToList(paramlist, addrterm, TRUE);
    icl_AddToList(paramlist, tlterm, TRUE);
#ifndef _WINDOWS
    gettimeofday(&tv0, (void *)0);
#endif
    if(oaa_Solve(trueterm, paramlist, &result, NULL)) {
#ifndef _WINDOWS
      gettimeofday(&tv1, (void *)0);
      t0 = tv0.tv_sec*1000.0 + tv0.tv_usec;
      t1 = tv1.tv_sec*1000.0 + tv1.tv_usec;
      *total_response_time = (t1 - t0)*0.001;
#endif
      res = TRUE;
    }
    icl_Free(trueterm);
    icl_Free(paramlist);
  }
  return res;
}

/****************************************************************************
 * Declaring Solvables
 ****************************************************************************/
/*
 *    @@Future params may include 'num_context_args(N)'.
 *    @@Future solvable params may include 'shared'.
 *    @@Do we want client agents to request declarations on other client
 *      agents?
 */
int oaa_Declare(ICLTerm *solvable, ICLTerm *initial_common_perms,
                ICLTerm *initial_common_params, ICLTerm *initial_params,
                ICLTerm **declared_solvables)
{
  int res = FALSE;
  ICLTerm *solvable_list, *solvables, *common_perms;
  ICLTerm *common_params, *params, *solvables1, *new_solvables;
  int res1 = 0;
  int res2 = 0;
  int res3 = 0;
  int res4 = 0;
  int res5 = 0;
  int res6 = 0;
  int res7 = 0;

  if (icl_IsList(solvable)) {
    solvable_list = solvable;
  }
  else {
    solvable_list = icl_NewList(icl_NewCons(icl_CopyTerm(solvable), NULL));
  }

  res2 = icl_standardize_perms(initial_common_perms, FALSE, &common_perms);
  res3 = icl_standardize_params(initial_common_params, FALSE, &common_params);
  res4 = icl_standardize_params(initial_params, FALSE, &params);

  res1 = icl_ConvertSolvables(TRUE, solvable_list, &solvables);
  if(res1) {
    res5 = oaa_distribute_perms(solvables, common_perms, &solvables1);
  }
  if(res5) {
    res6 = oaa_distribute_params(solvables1, common_params, &new_solvables);
  }
  if(res6 && res4) {
    res7 = oaa_declare_aux("add", new_solvables, params, declared_solvables);
  }
  /* Note: actually suffices to check res2, res3, res4, res7 */
  if (res1 && res2 && res3 && res4 && res5 && res6 && res7) {
    res = TRUE;
  }

  if(solvable_list != solvable) {
    icl_Free(solvable_list);
  }
  icl_Free(solvables);
  icl_Free(solvables1);
  icl_Free(new_solvables);
  icl_Free(params);
  icl_Free(common_perms);
  icl_Free(common_params);

  return res;
}


int oaa_DeclareData(ICLTerm *solv, ICLTerm *params,
                    ICLTerm **declared_solvs) {
  int res = FALSE;
  if(!icl_IsList(solv)) {
    ICLTerm *solvlist = icl_NewList(icl_NewCons(solv, (ICLListType *)NULL));
    if(oaa_DeclareData(solvlist, params, declared_solvs))
      res = TRUE;
  } else if(!res) {
    ICLTerm *common_perms =
      icl_NewTermFromData("[write(true)]",13);
    ICLTerm *common_params =
      icl_NewTermFromData("[type(data)]",12);
    if(oaa_Declare(solv, common_perms, common_params,
                   params, declared_solvs))
      res = TRUE;
  }
  return res;
}

int oaa_Undeclare(ICLTerm *solvable, ICLTerm *initial_params,
                  ICLTerm **undeclared_solvables) {
  int res = FALSE;
  ICLTerm *solvable_list, *solvables, *params;

  if(icl_IsList(solvable))
    solvable_list = solvable;
  else
    solvable_list = icl_NewList(icl_NewCons(solvable, (ICLListType *)NULL));
  if(icl_minimally_instantiate_solvables(solvable_list, &solvables) &&
     icl_standardize_params(initial_params, FALSE, &params) &&
     oaa_declare_aux("remove", solvables, params, undeclared_solvables))
    res = TRUE;
  return res;
}


int oaa_Redeclare(ICLTerm *initial_solvable, ICLTerm *initial_new_solvable,
                  ICLTerm *initial_params) {
  ICLTerm *solvable, *new_solvable, *solvable_list, *new_solvable_list;
  ICLTerm *params, *with_new_solvable, *redeclared_solvables;
  ICLTerm *init_solv_list =
    icl_NewList(icl_NewCons(initial_solvable, (ICLListType *)NULL));
  ICLTerm *init_new_solv_list =
    icl_NewList(icl_NewCons(initial_new_solvable, (ICLListType *)NULL));
  int res = FALSE;
  if(icl_minimally_instantiate_solvables(init_solv_list, &solvable_list) &&
     icl_ConvertSolvables(TRUE, init_new_solv_list, &new_solvable_list) &&
     icl_standardize_params(initial_params, FALSE, &params) &&
     icl_IsList(solvable_list)) {
    solvable = icl_NthTerm(solvable_list, 1);
    if(icl_IsList(new_solvable_list)) {
      new_solvable = icl_NthTerm(new_solvable_list, 1);
      with_new_solvable = icl_NewStruct("with", 1, new_solvable);
      icl_AddToList(params, with_new_solvable, FALSE);
      if(oaa_declare_aux("replace", solvable,
                         params, &redeclared_solvables) &&
         icl_IsList(redeclared_solvables) &&
         redeclared_solvables->p) {
        res = TRUE;
      }
      /* ??? not sure whether to free with_new_solvable here */
    }
  }
  icl_Free(init_solv_list);
  icl_Free(init_new_solv_list);
  return res;
}

int select_elements(ICLTerm *list, int (*test_function)(ICLTerm*), ICLTerm** result){

  if (list && icl_IsList(list)) {
    ICLListType *local_list = NULL, *newArgs = NULL, *endp = NULL;

    local_list = icl_List(list);
    while (local_list) {

      if (test_function(local_list->elt)) {
        /* Keep: add to result list */
        if (!newArgs) {
          newArgs = icl_NewCons(icl_CopyTerm(local_list->elt), NULL);
          endp = newArgs;
        }
        else {
          endp->next = icl_NewCons(icl_CopyTerm(local_list->elt), NULL);
          endp = endp->next;
        }
      }

      local_list = local_list->next;
    }
    *result = icl_NewList(newArgs);

    return TRUE;
  }

  return FALSE;
}

/*
 * purpose: Common code for oaa_Declare, oaa_Undeclare, oaa_Redeclare.
 * Mode: add, remove, or replace.
 * Solvables: for Mode = add, a list of Solvables in standard form.
 *            for Mode = remove, a list of Solvables in
 *              "minimally instantiated" form.
 *            for Mode = replace, a list containing a single Solvable, in
 *                "minimally instantiated" form.
 * Params: whatever is appropriate for oaa_Declare, _Undeclare, _Redeclare.
 *            Must already be in standard form.
 * DeclaredSolvables: A list of all solvables successfully added (or removed
 *            or replaced), in standard form.
 * remarks:
 *   A number of params and perms are required when requesting that a
 *   parent declare solvables (see comments for oaa_Declare).  We could ensure
 *   their presence here, but it's not essential, because the facilitator will
 *   enforce this.
 */
int oaa_declare_aux(char *mode, ICLTerm *solvables, ICLTerm *params,
                    ICLTerm **declared_solvables)
{

  ICLTerm *fac_id_query = icl_NewTermFromData("fac_id(ParentId)",16);
  ICLTerm *result = (ICLTerm *)NULL;
  ICLTerm *dec_solv_var = icl_NewVar("DeclaredSolvables");
  int res = FALSE;

  /*
   * Here, a client is asking the facilitator to add, remove, or replace
   * solvables.
   */
  if (com_GetInfo("parent", fac_id_query, &result)) {

    ICLTerm *parentidlist =
      icl_NewList(icl_NewCons(icl_CopyTerm(icl_NthTerm(result, 1)),
                              (ICLListType *)NULL));
    ICLTerm *address_query = icl_NewStruct("address", 1, parentidlist);

    icl_Free(result);
    if (icl_GetParamValue(address_query, params, &result)) {
      ICLTerm *emptyList = icl_NewList(NULL);
      /* Send the request to the Facilitator*/
      ICLTerm *post = icl_NewStruct("ev_post_declare", 3,
                                    icl_NewStr(mode),
                                    icl_CopyTerm(solvables),
                                    icl_CopyTerm(params));
      ICLTerm *ev_reply_declared = icl_NewStruct("ev_reply_declared", 4,
                                                 icl_NewStr(mode),
                                                 icl_CopyTerm(solvables),
                                                 icl_CopyTerm(params),
                                                 icl_CopyTerm(dec_solv_var));

      if (oaa_PostEvent(post, emptyList) &&
          oaa_poll_until_event(ev_reply_declared, NULL)) {
        res = TRUE;
      }
      icl_Free(emptyList);
      icl_Free(post);
      icl_Free(ev_reply_declared);
      icl_Free(result);
    }
    icl_Free(address_query);
  }

  if (!res) {
    /*
     * Leaf, node or root adding, removing or replacing its own solvables:
     */
    ICLTerm *me;
    ICLTerm *addr_query = icl_NewStruct("address", 1, icl_NewVar("Addr"));
    int res1, res2, res3;

    oaa_PrimaryAddress(&me);

    res1 = icl_GetParamValue(addr_query, params, &result);
    res2 = icl_Unify(me, icl_NthTerm(result, 1), NULL);
    res3 = oaa_declare_local(mode, solvables, params, declared_solvables);
    if ((!res1 || res2) && res3) {
      /*
       * If I'm a facilitator, I must also "register" my Solvables with
       * myself. (If I'm a node, this will also register them with my
       * parent.)
       */
      if (((!oaa_class("leaf")) && (*declared_solvables)->p)) {
#if 0
        /* HAVE DIDIER LOOK AT THIS */
        ICLTerm *my_name;
        ICLTerm *event, *param_list;
        oaa_Name(&my_name);
        event =
          icl_NewStruct("ev_register_solvables", 1, icl_NewStr(mode),
                        dec_solv_var, my_name, params);
        param_list = icl_NewList(icl_NewCons(icl_NewStruct("from", 1, me),
                                             NULL));
        /* BOGUS : Removed */
        /* oaa_AppDoEvent(event, param_list); */
#endif
      } else {
        /*
         * If I'm a leaf, post public solvables to parent facilitator:
         */
        ICLTerm *public_solvables;
        CHECK_LEAKS();
        select_elements(*declared_solvables, oaa_is_public_solvable,
                        &public_solvables);
        CHECK_LEAKS();
        if (oaa_class("leaf") && public_solvables->p) {
          ICLTerm *tempRequest = icl_NewTermFromData("oaa_name(MyName)",16);
          if(res1) {
            icl_Free(result);
          }
          CHECK_LEAKS();
          com_GetInfo("parent", tempRequest, &result);
          CHECK_LEAKS();

          if(result && icl_IsStruct(result)) {
            ICLTerm *my_name_c = icl_CopyTerm(icl_NthTerm(result, 1));
            ICLTerm *event =
              icl_NewStruct("ev_register_solvables", 4, icl_NewStr(mode),
                            public_solvables, my_name_c, icl_CopyTerm(params));
            ICLTerm *postParams = icl_NewList(NULL);
            CHECK_LEAKS();
            oaa_PostEvent(event, postParams);
            CHECK_LEAKS();
            icl_Free(postParams);
            icl_Free(result);
            icl_Free(event);  /* fress public_solvables, my_name_c too */
          }
          else {
            icl_Free(public_solvables);
          }
          icl_Free(tempRequest);
        }
        else {
          icl_Free(public_solvables);
        }
      }
      res = TRUE;
    }
    icl_Free(me);
    icl_Free(addr_query);
  }
  icl_Free(fac_id_query);
  icl_Free(dec_solv_var);
  return res;
}


/*
 * Solvable must be in standard from
 */
int oaa_public_solvable(ICLTerm *solvable)
{
  ICLTerm *tmpres, *params;
  ICLTerm *param = icl_NewTermFromData("private(false)",14);

  if (icl_IsStruct(solvable) &&
      (icl_NumTerms(solvable) == 3) &&
      (params = icl_NthTerm(solvable, 2)) &&
      icl_GetParamValue(param, params, &tmpres)) {

    icl_Free(param);
    return TRUE;
  }

  icl_Free(param);
  return FALSE;
}

/*
 * Solvable must be in standard from
 */
int oaa_data_solvable(ICLTerm *solvable)
{
  ICLTerm *tmpres, *params;
  ICLTerm *param = icl_NewTermFromData("type(data)",10);

  if (icl_IsStruct(solvable) &&
      (icl_NumTerms(solvable) == 3) &&
      (params = icl_NthTerm(solvable, 2)) &&
      icl_GetParamValue(param, params, &tmpres)) {

    icl_Free(param);
    return TRUE;
  }

  icl_Free(param);
  return FALSE;
}

/*
 * purpose:   Declare solvables for an agent.
 * Mode:      add, remove, or replace.
 * Solvables: The form they're in depends on the mode.  See oaa_declare_aux.
 * DeclaredSolvables: Returns those members of Solvables for which
 *     the operation was successful (more specifically, those that should
 *     be passed up to the parent in ev_register_solvables).  Always returned
 *     in STANDARD FORM.
 * Also see:  comments for oaa_Declare, oaa_Undeclare, oaa_Redeclare.
 * remarks:
 *   - This performs the local processing needed by calls to oaa_Declare,
 *     and by ev_declare events.
 *   - Solvables and Params must already be in standard form.
 *
 *   @@DLM: Could do more careful testing to be sure the solvables are
 *   all valid for the requested operation.
 *
 *   *returned_solvables is newly allocated memory
 */
int oaa_declare_local(char *mode, ICLTerm *solvable0, ICLTerm *params,
                      ICLTerm **returned_solvables) {
  ICLTerm *current_solvables;
  ICLTerm *db_solvables, *solvables;
  ICLTerm *all_solvables = NULL;
  int res = FALSE;

  if (!icl_IsList(solvable0)) {
    solvables = icl_NewList(icl_NewCons(solvable0, NULL));
  }
  else {
    solvables = solvable0;
  }

  if (STREQ(mode, "add")) {

    ICLTerm *initial_solvables = solvables;
    ICLTerm *declared_solvables = NULL;
    ICLTerm *ifexistsfalse = icl_NewTermFromString("if_exists(overwrite)");

    if (icl_GetParamValue(ifexistsfalse, params, NULL)) {
      current_solvables = icl_NewList(NULL);
    }
    else {
      current_solvables = valid_oaa_solvables();
    }
    icl_Free(ifexistsfalse);

    /*
     * This will eliminate those that unify with an already declared
     * solvable.
     * @@DLM: Should do more, though: warnings.
     */
    solvables_to_be_added(initial_solvables, current_solvables, &declared_solvables);
    /*
     * Make sure Quintus has the correct properties for each DB solvable.
     * ??? - sws
     */
    select_elements(declared_solvables, oaa_is_data_solvable, &db_solvables);

    /* BOGUS, REMOVED */
    /* oaa_declare_for_prolog(db_solvables); */

    icl_append_to_list(current_solvables, declared_solvables, &all_solvables);
    if(oaa_solvables != NULL) {
      icl_Free(oaa_solvables);
    }
    oaa_solvables = all_solvables;
    if(oaa_solvables == NULL) {
      oaa_solvables = icl_NewList(NULL);
    }
    if (returned_solvables != NULL) {
      *returned_solvables = declared_solvables;
    }
    else {
      icl_Free(declared_solvables);
    }

    icl_Free(current_solvables);
    icl_Free(db_solvables);
    res = TRUE;
  }
  else if (STREQ(mode, "remove")) {
    ICLTerm *removed_solvables, *new;
    ICLTerm *current = valid_oaa_solvables();

    /*
     * See which ones are really declared
     */
    solvables_to_be_removed(solvables, current, &removed_solvables);
    /*
     * Retract all clauses from data solvables:
     */
    select_elements(removed_solvables, oaa_is_data_solvable, &db_solvables);
    oaa_remove_solvables_data(db_solvables);
    /*
     * Assert the new solvables list:
     */
    icl_subtract(current, removed_solvables, &new);
    if(oaa_solvables != NULL) {
      icl_Free(oaa_solvables);
    }
    oaa_solvables = new;
    if(oaa_solvables == NULL) {
      oaa_solvables = icl_NewList(NULL);
    }
    *returned_solvables = removed_solvables;
    icl_Free(db_solvables);
    res = TRUE;
  }
  else if (STREQ(mode, "replace") &&
           (icl_NumTerms(solvables) == 1)) {

    ICLTerm *new_solvable, *result, *current, *new;
    ICLTerm *solvable = icl_NthTerm(solvables, 1);
    ICLTerm *t1;

    if (icl_Member((t1 = icl_NewTermFromString("with(NewSolvable)")),
                   icl_CopyTerm(params), &result)) {
      new_solvable = icl_CopyTerm(icl_NthTerm(result, 1));
      icl_Free(result);
      /*
       * Make sure solvables is really declared
       */
      current = valid_oaa_solvables();
      if (icl_Member(solvable, current, NULL)) {
        /*
         * if a data solvable, maybe retract all its clauses
         */
        if (oaa_data_solvable(solvable))
          oaa_remove_solvables_data(solvables);
        /*
         * Assert thenew solvables list:
         */
        replace_element(solvable, current, new_solvable, &new);
        if(oaa_solvables != NULL) {
          icl_Free(oaa_solvables);
        }
        oaa_solvables = new;
        if(oaa_solvables == NULL) {
          oaa_solvables = icl_NewList(NULL);
        }
        *returned_solvables = solvables;
        res = TRUE;
      }
    }
    icl_Free(t1);

    if (!res) {
      ICLTerm *goal;
      if (icl_IsStruct(solvable) &&
          STREQ(icl_Functor(solvable), "solvable") &&
          (goal = icl_NthTerm(solvable, 1))) {
        printf("WARNING: Ignoring attempt to replace a non-existent solvable:\n  %s\n",
               icl_NewStringFromTerm(goal));
      }
      *returned_solvables = icl_NewList(NULL);
      res = TRUE;
    }
  }
  return res;
}

int icl_subtract(ICLTerm *list1, ICLTerm *list2, ICLTerm **result) {
  *result = icl_NewList(NULL);
  if(icl_IsList(list1) && icl_IsList(list2)) {
    ICLListType *iterator = icl_List(list1);
    while(icl_ListHasMoreElements(iterator)) {
      ICLTerm *el = icl_ListElement(iterator);
      if(!icl_Member(el, list2, NULL)) {
        icl_AddToList(*result, el, TRUE);
      }
      iterator = icl_ListNextElement(iterator);
    }
    return TRUE;
  }
  return FALSE;
}

/*
 * remarks: @@Should warn when a solvables has a param that conflicts with
 *          CommonParams.  Also, should have an arg that says which version of
 *          of the conflicting param to keep.
 */
int oaa_distribute_params(ICLTerm *solvables, ICLTerm *common_params,
                          ICLTerm **new_solvables) {
  *new_solvables = icl_NewList(NULL);
  if(icl_IsList(solvables)) {
    ICLListType *solvable_list = icl_List(solvables);
    while(icl_ListHasMoreElements(solvable_list)) {
      ICLTerm *solvable = icl_ListElement(solvable_list);

      if(icl_IsStruct(solvable) &&
         STREQ(icl_Functor(solvable), "solvable") &&
         (icl_NumTerms(solvable) == 3)) {

        ICLTerm *goal = icl_NthTerm(solvable, 1);
        ICLTerm *params = icl_NthTerm(solvable, 2);
        ICLTerm *perms = icl_NthTerm(solvable, 3);
        ICLTerm *new_params, *new_solvable;
        icl_Union(params, common_params, &new_params);

        new_solvable = icl_NewStruct("solvable", 3, icl_CopyTerm(goal),
                                     new_params, icl_CopyTerm(perms));
        icl_AddToList(*new_solvables, new_solvable, TRUE);
      }
      solvable_list = icl_ListNextElement(solvable_list);
    }
    return TRUE;
  }
  return FALSE;
}

int oaa_distribute_perms(ICLTerm *solvables, ICLTerm *common_perms,
                         ICLTerm **new_solvables) {

  *new_solvables = icl_NewList(NULL);
  if(icl_IsList(solvables)) {
    ICLListType *solvable_list = icl_List(solvables);
    while(icl_ListHasMoreElements(solvable_list)) {
      ICLTerm *solvable = icl_ListElement(solvable_list);

      if(icl_IsStruct(solvable) &&
         STREQ(icl_Functor(solvable), "solvable") &&
         (icl_NumTerms(solvable) == 3)) {
        ICLTerm *goal = icl_NthTerm(solvable, 1);
        ICLTerm *params = icl_NthTerm(solvable, 2);
        ICLTerm *perms = icl_NthTerm(solvable, 3);
        ICLTerm *new_perms, *new_solvable;
        icl_Union(perms, common_perms, &new_perms);

        new_solvable = icl_NewStruct("solvable", 3, icl_CopyTerm(goal),
                                     icl_CopyTerm(params), new_perms);
        icl_AddToList(*new_solvables, new_solvable, TRUE);
      }
      solvable_list = icl_ListNextElement(solvable_list);
    }
    return TRUE;
  }
  return FALSE;
}


/*
 * ProposedSolvs: Must be in STANDARD FORM.
 * CurrentSolvs: This agent's current solvables.
 * SolvsToBeAdded: A subset of ProposedSolvs.
 */
int solvables_to_be_added(ICLTerm *solvables, ICLTerm *current,
                          ICLTerm **ok_solvables) {
  *ok_solvables = icl_NewList(NULL);
  if(icl_IsList(solvables)) {
    ICLListType *solvable_list = icl_List(solvables);
    while(icl_ListHasMoreElements(solvable_list)) {
      ICLTerm *solvable = icl_ListElement(solvable_list);
      if(icl_IsStruct(solvable) &&
         STREQ(icl_Functor(solvable), "solvable") &&
         (icl_NumTerms(solvable) == 3)) {
        ICLTerm *goal = icl_NthTerm(solvable, 1);
        if(icl_Member(goal, current, NULL)) {

          char *debugString = icl_NewStringFromTerm(goal);
          printf("WARNING: Ignoring attempt to declare an already"
                 " existing solvable:\n  %s", debugString);
          icl_stFree(debugString);
          continue;
        }
        icl_AddToList(*ok_solvables, icl_CopyTerm(solvable), TRUE);
      }
      solvable_list = icl_ListNextElement(solvable_list);
    }
  }
  return TRUE;
}

/*
 * ProposedSolvs: Must be in MINIMALLY INSTANTIATED FORM.
 * CurrentSolvs: This agent's current solvables.
 * SolvsToBeRemoved: A subset of ProposedSolvs, but returned in standard form,
 *   fully instantiated.
 */
int solvables_to_be_removed(ICLTerm *solvables, ICLTerm *current,
                            ICLTerm **ok_solvables) {
  *ok_solvables = icl_NewList(NULL);
  if(icl_IsList(solvables)) {
    ICLListType *solvable_list = icl_List(solvables);
    while(icl_ListHasMoreElements(solvable_list)) {
      ICLTerm *solvable = icl_ListElement(solvable_list);
      if(icl_IsStruct(solvable) &&
         STREQ(icl_Functor(solvable), "solvable") &&
         (icl_NumTerms(solvable) == 3)) {
        ICLTerm *goal = icl_NthTerm(solvable, 1);
        if(!icl_Member(goal, current, NULL)) {
          printf("WARNING: Ignoring attempt to remove a "
                 "non-existent solvable:\n  %s",
                 icl_NewStringFromTerm(goal));
          continue;
        }
        icl_AddToList(*ok_solvables, solvable, TRUE);
      }
      solvable_list = icl_ListNextElement(solvable_list);
    }
  }
  return TRUE;
}


/****************************************************************************
 * Updating Data Solvables
 ****************************************************************************/


int oaa_AddData(ICLTerm *clause, ICLTerm *in_params, ICLTerm **out_params) {
  return oaa_update("add", clause, in_params, out_params);
}

/*
 * Remove a clause from a DATA solvable (locally and/or remotely).
 * <p>Params:</p>
 * <ul>
  *   <li>address(X): a list including 'self', 'parent', and/or the
 *      addresses of other client agents.  The default (no address)
 *      behavior is the same as with oaa_Solve and oaa_AddData.</li>
 *    <li>reflexive(T_F): Save as with oaa_Solve.  Default: true.</li>
 *    <li>do_all(T_F): If true, removes all predicate values that match the Clause
 *      Default: false (removes only the first)</li>
 *    <li>get_address(X): Returns a list of addresses (ids) of agents that
 *      were sent the request.</li>
 *    <li>get_satisfiers(X): Returns a list of addresses (ids) of agents that
 *      successfully completed the request.</li>
 *    <li>owner(LocalId): if bookkeeping(true) for this solvable, remove only
 *      data owned by LocalId.
 *      Default: ignore owner in removing data.</li>
 *    <li>reply({true,none}): When data is being removed on
 *      a remote agent or agents, this tells whether reply message(s) are
 *      desired.</li>
 *    <li>block(Mode) : true: Block until the reply arrives.
 *                 : false: Don't block.  In
 *                         this case, the reply events (ev_reply_updated)
 *                         can be handled by the user's app_do_event callback
 *                 Default: true.  Note that reply(none) overrides
 *                         block(true).</li>
 *</ul>
 * <p><b>Remarks:</b></p><ul>
 *    <li>Clause is normally a fact (no body), but with Prolog agents, and
 *      with rules_ok(true), it's possible for it to have a body.</li>
 *    <li>Triggers will be examined with the 'on_Retract' operation mask.</li>
 *    <li>Not for backtracking.</li>
 *</ul>
 */
int oaa_RemoveData(ICLTerm *clause, ICLTerm *in_params, ICLTerm **out_params) {
  return oaa_update("remove", clause, in_params, out_params);
}

int oaa_ReplaceData(ICLTerm *clause1, ICLTerm *clause2,
                    ICLTerm *in_params, ICLTerm **out_params) {
  ICLTerm *new_param_list = icl_NewList(icl_List(in_params));
  icl_AddToList(new_param_list, icl_NewStruct("with", 1, clause2), FALSE);
  return oaa_update("replace", clause1, new_param_list, out_params);
}

int icl_replace_param_value(ICLTerm *param, ICLTerm *param_list) {
  int res = FALSE;
  if (icl_IsStruct(param) &&
      (icl_NumTerms(param) == 1) &&
      icl_IsList(param_list)) {
    ICLListType *plist = icl_List(param_list);
    while(icl_ListHasMoreElements(plist)) {
      ICLTerm *p = icl_ListElement(plist);
      ICLTerm *result;
      if(icl_Unify(param, p, &result)) {
        plist->elt = result;
        icl_Free(p);
        res = TRUE;
        break;
      }
      plist = icl_ListNextElement(plist);
    }
  }
  return res;
}

int oaa_update(char *mode, ICLTerm *clause, ICLTerm *initial_params,
               ICLTerm **out_params)
{
  ICLTerm *params = NULL, *addr = NULL, *me = NULL;
  ICLTerm *new_addr = NULL, *params1 = NULL, *params2 = NULL, *solvables = NULL;
  ICLTerm *updaters1 = NULL, *updaters2 = NULL, *updaters = NULL;
  ICLTerm *requestees1 = NULL, *requestees2 = NULL, *requestees = NULL;
  ICLTerm *t1 = NULL;
  int self = FALSE, res = FALSE;
  ICLTerm *reflexive_true = icl_NewTermFromString("reflexive(true)");

  icl_standardize_params(initial_params, FALSE, &params);

  /* is there a specific address ? */
  if (!icl_param_arg("address", NULL, params, &addr)) {
    addr = icl_NewList(NULL);
  }

  /* decide whether or not to update locally: */
  if (oaa_PrimaryAddress(&me) &&
      icl_Member(me, addr, NULL)) {

    icl_ListDelete(addr, me, &new_addr);
    t1 = icl_NewStruct("address", 1, icl_CopyTerm(addr));
    replace_element(t1, params,
                    icl_NewStruct("address", 1, new_addr), &params1);
    icl_Free(t1);
    self = TRUE;
  } else {
    new_addr = icl_CopyTerm(addr);
    params1 = icl_CopyTerm(params);
  }

  if ((!addr->p) &&
      icl_GetParamValue(reflexive_true, params1, NULL)) {
    ICLTerm *write = icl_NewTermFromString("write");
    ICLTerm *real_clause, *real_matched;
    /* do NOT use remove_element here: */
    icl_ListDelete(params1, reflexive_true, &params2);
    solvables = valid_oaa_solvables();
    if (oaa_data_matches_solvables(clause, solvables, write, &real_clause,
                                   &real_matched))
      self = TRUE;
    icl_Free(write);
  } else {
    params2 = params1;
  }
  icl_Free(reflexive_true);

  /* update locally if appropriate */
  if (self) {
    requestees1 = icl_NewList(icl_NewCons(icl_CopyTerm(me), NULL));
    if (STREQ(mode, "add")) {
      res = oaa_add_data_local(clause, params2);
    }
    else if (STREQ(mode, "replace")) {
      res = oaa_replace_data_local(clause, params2);
    }
    else if (STREQ(mode, "remove")) {
      res = oaa_remove_data_local(clause, params2);
    }
    if(res) {
      updaters1 = icl_NewList(icl_NewCons(icl_CopyTerm(me), NULL));
    } else {
      updaters1 = icl_NewList(NULL);
    }
  } else {
    requestees1 = icl_NewList(NULL);
    updaters1 = icl_NewList(NULL);
  }
  icl_Free(me);

  /* Update remotely if appropriate:
   */
  if (oaa_class("leaf") &&
      ((!addr->p) || (new_addr->p))) {

    ICLTerm *reply;
    char    *goalIdStr = new_goal_id();

    /* Send the ev_update_data event to the Facilitator
     */
    ICLTerm* toBeSent = icl_NewStruct("ev_update_data", 4,
                                      icl_NewStr(goalIdStr),
                                      icl_NewStr(mode), icl_CopyTerm(clause),
                                      icl_CopyTerm(params2));
    oaa_PostEvent(toBeSent, ICL_EMPTY);
    icl_Free(toBeSent);
    icl_stFree(goalIdStr);
    /* In the return event, Requestees2 lists all agents to whom
     * the update request wassent; Updaters2 lists those who succeeded
     */
    if ( !(icl_param_arg("reply", NULL, params, &reply) &&
           (STREQ("asynchronous", icl_Str(reply)) ||
            STREQ("none", icl_Str(reply)))) ) {
      ICLTerm *ev_reply_updated =
        icl_NewStruct("ev_data_updated", 6, icl_NewVar("G"), icl_NewStr(mode),
                      icl_CopyTerm(clause), icl_CopyTerm(params2),
                      icl_NewVar("Requestees"), icl_NewVar("Updaters"));
      oaa_poll_until_event(ev_reply_updated, NULL);
      icl_Free(ev_reply_updated);
    }
  }
  icl_Free(addr);
  icl_Free(new_addr);

  requestees2 = icl_NewList(NULL);
  updaters2 = icl_NewList(NULL);

  /*
   * The following section replaces a variable parameter value in the
   * parameter list for return to the calling function
   */
  icl_append_to_list(updaters1, updaters2, &updaters);
  icl_Free(updaters1);
  icl_Free(updaters2);

  /* Return Updaters if requested:
   */
  t1 = icl_NewStruct("get_satisfiers", 1, updaters);
  icl_replace_param_value(t1, params);
  icl_Free(t1);   /* frees updaters too */

  /*  Return Requestees if requested:
   */
  icl_append_to_list(requestees1, requestees2, &requestees);
  t1 = icl_NewStruct("get_address", 1, requestees);
  icl_replace_param_value(t1, params);
  icl_Free(requestees1);
  icl_Free(requestees2);
  icl_Free(t1);
  if(params2 == params1) {
    icl_Free(params2);
  }
  else {
    icl_Free(params2);
    icl_Free(params1);
  }

  if (out_params != NULL) {
    *out_params = params;
  }
  else {
    icl_Free(params);
  }

  return TRUE;
}

/*
 * name:    asserta
 *          assertz
 *          retract
 *          retract_all
 * purpose: Asserts or retracts clauses in the database just like the
 *          equivalent prolog built-in clauses
 */
int asserta(ICLTerm *clause)
{
  int res;
  ICLTerm *t1;

  if(!db_IsValid(local_db))
    local_db = db_NewDB();
  res =
    db_Assert(local_db, clause,
              (t1 = icl_NewTermFromString("[at_beginning(true)]")));
  icl_Free(t1);
  return res;
}

int assertz(ICLTerm *clause)
{
  int res;
  ICLTerm *t1;

  if(!db_IsValid(local_db))
    local_db = db_NewDB();
  res =
    db_Assert(local_db, clause,
              (t1 = icl_NewTermFromString("[at_beginning(false)]")));
  icl_Free(t1);
  return res;
}

int retract(ICLTerm *clause) {
  if(!db_IsValid(local_db))
    local_db = db_NewDB();
  return db_Retract(local_db, clause, ICL_EMPTY);
}

/*
 * mimics asserta/2, assertz/2
 */

/* for use in asserts with ref.  Hopefully, this won't wrap around */
static int db_ref_number = 0;

/*
 * maintain a table of ref numbers associated with asserted clauses
 */
static DICTIONARY *oaa_db_ref = (DICTIONARY *)NULL;


int asserta_ref(ICLTerm *clause, ICLTerm **ref) {
  *ref = icl_NewInt(db_ref_number++);
  if(!oaa_db_ref)
    oaa_db_ref = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  dict_put(oaa_db_ref, (void *)icl_CopyTerm(clause), (void *)*ref);
  return asserta(clause);
}

int assertz_ref(ICLTerm *clause, ICLTerm **ref) {
  *ref = icl_NewInt(db_ref_number++);
  if(!oaa_db_ref)
    oaa_db_ref = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  dict_put(oaa_db_ref, (void *)icl_CopyTerm(clause), (void *)*ref);
  return assertz(clause);
}

int ref_for_clause(ICLTerm *clause, ICLTerm **ref) {
  int result = FALSE;
  if(oaa_db_ref) {
    *ref = (ICLTerm *)dict_get(oaa_db_ref, (void *)clause);
    if (*ref)
      result = TRUE;
  }
  return result;
}

int erase_ref(ICLTerm *clause, ICLTerm *ref) {
  if(oaa_db_ref) {
    ICLTerm *val = (ICLTerm *)dict_get(oaa_db_ref, clause);
    while(val != NULL) {
      if(icl_Unify(val, ref, NULL)) {
        dict_remove_specific(oaa_db_ref, clause, ref);
        return TRUE;
      }
      val = (ICLTerm *)dict_get(oaa_db_ref, clause);
    }
  }
  return TRUE;
}


int oaa_add_data_local(ICLTerm *clause1, ICLTerm *params)
{
  ICLTerm *clause = NULL, *matched = NULL;
  ICLTerm *head = NULL, *body = NULL;
  ICLTerm *pred = NULL, *decl_params = NULL, *all_params = NULL;
  ICLTerm *callback = NULL, *result = NULL;
  ICLTerm *t1 = NULL, *t2 = NULL;
  ICLTerm *dummyvar = NULL, *single_value_true = NULL;
  ICLTerm *solvables = valid_oaa_solvables();
  ICLTerm *permRequest = icl_NewStr("write");

  oaa_data_matches_solvables(clause1, solvables,
                             permRequest,
                             &clause, &matched);
  icl_Free(permRequest);

  if (icl_IsStruct(matched) &&
      (icl_NumTerms(matched) == 3) &&
      STREQ(icl_Functor(matched), "solvable")) {

    pred = icl_NthTerm(matched, 1);
    decl_params = icl_NthTerm(matched, 2);
  } else {
    return FALSE;
  }
  if (icl_IsStruct(clause) &&
      STREQ(icl_Functor(clause), ":-") &&
      (icl_NumTerms(clause) == 2)) {

    head = icl_NthTerm(clause, 1);
    body = icl_NthTerm(clause, 2);
  } else {
    head = clause;
    body = ICL_TRUE;
  }
  icl_append_to_list(params, decl_params, &all_params);

  /* If there's no callback, leave Callback a var:
   */
  dummyvar = icl_NewVar("dummy");
  t1 = icl_NewStruct("callback", 1, icl_CopyTerm(dummyvar));

  if (! icl_GetParamValue(t1, all_params, &callback)) {
    /* ??? Not really sure what to do in C  */
    callback = icl_NewVar("Callback");
  }
  icl_Free(t1);

  /* if single value, erase all old values */
  single_value_true = icl_NewTermFromString("single_value(true)");
  if (icl_GetParamValue(single_value_true, all_params, &result)) {
    if (!icl_ParamValue("bookkeeping", ICL_FALSE, decl_params, NULL)) {
      oaa_retractall(pred, dummyvar, callback);
    }
    else {
      retract_all(pred);
    }
  }

  icl_Free(dummyvar);
  icl_Free(single_value_true);

  /* if unique_values(true), make sure fact not already in database */
  t1 = icl_NewTermFromString("unique_values(true)");
  if (db_Solve(local_db, pred, ICL_EMPTY, NULL) &&
      icl_GetParamValue(t1, all_params, NULL)) {
    icl_Free(all_params);
    icl_Free(t1);
    return TRUE;
  }
  icl_Free(t1);

  t1 = icl_NewTermFromString("bookkeeping(true)");
  if (icl_GetParamValue(t1, decl_params, NULL)) {
    ICLTerm *owner;

    icl_Free(t1);
    oaa_data_owner(params, &owner);
    if(icl_GetParamValue((t1 = icl_NewTermFromString("at_beginning(true)")),
                         all_params, NULL)) {
      oaa_asserta(clause, owner, callback);
    }
    else {
      oaa_assertz(clause, owner, callback);
    }
    icl_Free(t1);
  } else {
    if (icl_GetParamValue((t2 = icl_NewTermFromString("at_beginning(true)")),
                          all_params, NULL)) {
      asserta(clause);
    }
    else {
      assertz(clause);
    }
  }
  icl_Free(t1);
  icl_Free(t2);
  icl_Free(all_params);
  oaa_CheckTriggers("data", head, "add");
  return TRUE;
}

int oaa_remove_data_local(ICLTerm *clause1, ICLTerm *params)
{
  ICLTerm *matched = NULL;
  ICLTerm *clause, *decl_params;
  ICLTerm *head, *body, *all_params, *callback;
  ICLTerm *local_solvables = valid_oaa_solvables();
  ICLTerm *permRequest = icl_NewStr("write");
  ICLTerm *t1 = (ICLTerm *)NULL, *t2 = (ICLTerm *)NULL;

  oaa_data_matches_solvables(clause1, local_solvables,
                             permRequest,
                             &clause, &matched);
  icl_Free(permRequest);
  if(matched && icl_IsStruct(matched) &&
     (icl_NumTerms(matched) == 3) &&
     STREQ(icl_Functor(matched), "solvable")) {
    decl_params = icl_NthTerm(matched, 2);
  } else {
    return FALSE;
  }
  if(icl_IsStruct(clause) &&
     STREQ(icl_Functor(clause), ":-") &&
     (icl_NumTerms(clause) == 2)) {
    head = icl_NthTerm(clause, 1);
    body = icl_NthTerm(clause, 2);
  } else {
    head = clause;
    body = ICL_TRUE;
  }
  icl_append_to_list(params, decl_params, &all_params);
  if(!icl_param_arg("callback", NULL, all_params, &callback)) {
    /* ??? Not really sure if this is correct thing to do in C  */
    callback = icl_NewVar("Callback");
  }

  t1 = icl_NewTermFromString("bookkeeping(true)");
  if (icl_GetParamValue(t1, decl_params, NULL)) {
    ICLTerm *owner;

    if (!icl_param_arg("owner", NULL, params, &owner)) {
      owner = icl_NewVar("Owner");
    }
    if (icl_ParamValue("do_all", ICL_TRUE, all_params, NULL)) {
      oaa_retractall(clause, owner, callback);
    }
    else {
      oaa_retract(clause, owner, callback);
    }
  }
  else {
    t2 = icl_NewTermFromString("do_all(true)");
    if (icl_GetParamValue(t2, all_params, NULL)) {
      retract_all(clause);
    }
    else {
      retract(clause);
    }
  }
  icl_Free(t1);
  icl_Free(t2);
  icl_Free(all_params);
  oaa_CheckTriggers("data", head, "remove");
  return TRUE;
}

int oaa_replace_data_local(ICLTerm *clause1_in, ICLTerm *params) {
  ICLTerm *clause2_in, *result = (ICLTerm *)NULL, *clause1, *clause2;
  ICLTerm *decl_params = NULL;
  ICLTerm *all_params;
  ICLTerm *head, *body, *matched;
  ICLTerm *solvables = valid_oaa_solvables();
  ICLTerm *dummyvar = icl_NewVar("dummy");
  ICLTerm *callback = NULL;
  ICLTerm *owner = NULL;
  ICLTerm *t1;

  if (icl_Member((t1 = icl_NewStruct("with", 1, dummyvar)), params,
                 &result)) {
    clause2_in = icl_CopyTerm(icl_NthTerm(result, 1));
    icl_Free(result);
  }
  else {
    icl_Free(t1);
    return FALSE;
  }
  icl_Free(t1);

  print_dictionary(oaa_db_ref);

  oaa_data_matches_solvables(clause1_in, solvables,
                             (t1 = icl_NewStr("write")),
                             &clause1, &matched);
  icl_Free(t1);

  oaa_data_matches_solvables(clause2_in, solvables,
                             (t1 = icl_NewStr("write")),
                             &clause2, &result);
  icl_Free(t1);

  if(icl_IsStruct(matched) &&
     (icl_NumTerms(matched) == 3) &&
     STREQ(icl_Functor(matched), "solvable")) {
    decl_params = icl_CopyTerm(icl_NthTerm(matched, 2));
  } else {
    return FALSE;
  }
  if(icl_IsStruct(clause1) &&
     STREQ(icl_Functor(clause1), ":-") &&
     (icl_NumTerms(clause1) == 2)) {
    head = icl_NthTerm(clause1, 1);
    body = icl_NthTerm(clause1, 2);
  } else {
    head = clause1;
    body = ICL_TRUE;
  }

  icl_append_to_list(params, decl_params, &all_params);
  icl_param_arg("callback", dummyvar, all_params, &callback);

  /* ??? Not really sure what to do in C  */
  if (callback==NULL) {
    callback = icl_NewVar("Callback");
  }

  if(!icl_ParamValue("bookkeeping",ICL_FALSE, decl_params, NULL)) {
    oaa_data_owner(params, &owner);
    if(icl_ParamValue("do_all", ICL_TRUE, params, NULL)) {
      oaa_replace_all(clause1, clause2, owner, callback);
    }
    else {
      if (oaa_retract(clause1, owner, callback)) {
        if(icl_ParamValue("at_beginning", ICL_TRUE, all_params, NULL)) {
          oaa_asserta(clause2, owner, callback);
        }
        else {
          oaa_assertz(clause2, owner, callback);
        }
      }
    }
  } else {
    if(icl_ParamValue("do_all", ICL_TRUE, params, NULL)) {
      replace_all(clause1, clause2);
    }
    else {
      if (retract(clause1)) {
        if(icl_ParamValue("at_beginning", ICL_TRUE, all_params, NULL)) {
          asserta(clause2);
        }
        else {
          assertz(clause2);
        }
      }
    }
  }
  oaa_CheckTriggers("data", clause1, "remove");
  oaa_CheckTriggers("data", clause2, "add");

  icl_Free(head);
  icl_Free(body);
  icl_Free(clause1);
  icl_Free(result);
  icl_Free(decl_params);
  icl_Free(all_params);
  icl_Free(owner);
  return TRUE;
}

int retract_all(ICLTerm *clause)
{
  ICLTerm *t1;

  if(!db_IsValid(local_db))
    local_db = db_NewDB();
  db_Retract(local_db, clause,
             (t1 = icl_NewTermFromString("[do_all(true)]")));
  icl_Free(t1);
  return TRUE;
}

int replace_all(ICLTerm *clause1, ICLTerm *clause2)
{
  ICLTerm *t1;

  if(!db_IsValid(local_db))
    local_db = db_NewDB();
  db_Retract(local_db, clause1,
             (t1 = icl_NewTermFromString("[do_all(true)]")));
  db_Assert(local_db, clause2, ICL_EMPTY);
  icl_Free(t1);
  return TRUE;
}

int oaa_data_owner(ICLTerm *params, ICLTerm **owner) {
  ICLTerm *dummyvar = icl_NewVar("_");
  if(icl_param_arg("owner", dummyvar, params, owner))
    return TRUE;
  else if(icl_param_arg("from", dummyvar, params, owner))
    return TRUE;
  else if(oaa_PrimaryAddress(owner))
    return TRUE;
  *owner = icl_NewStr("unknown");
  return TRUE;
}

int oaa_Id(ICLTerm **my_id) {
  ICLTerm *result, *t1;

  if(com_GetInfo("parent",
                 (t1 = icl_NewTermFromString("oaa_id(MyId)")),
                 &result)) {

    *my_id = icl_CopyTerm(icl_NthTerm(result, 1));
    icl_Free(result);
    icl_Free(t1);
    return TRUE;
  } else {
    char *conn_id;
    ICLTerm *type_server = icl_NewTermFromString("type(server)");

    icl_Free(t1);
    if(com_GetConnectionId(&conn_id, type_server) &&
       com_GetInfo(conn_id,
                   (t1 = icl_NewTermFromString("oaa_id(MyId)")),
                   &result)) {
      *my_id = icl_CopyTerm(icl_NthTerm(result, 1));
      icl_Free(result);
      icl_Free(t1);
      icl_Free(type_server);
      return TRUE;
    }
  }
  icl_Free(t1);
  return FALSE;
}

/*
 * Note : Type not used ?
 */
int oaa_Address(char* connectionId, ICLTerm* Type, ICLTerm **myAddress)
{
  (void)Type;
  *myAddress = icl_NewList(NULL);

  if (connectionId != NULL) {
    if (!com_Connected(connectionId)) {
      printWarning(1, "Address requested for connection %s but no such "
                   "connection exists",connectionId);
      icl_AddToList(*myAddress, icl_NewStr("no_address"), FALSE);
    } else {
      ICLTerm *t1, *tempTerm = NULL;

      com_GetInfo(connectionId,
                  (t1 = icl_NewTermFromString("oaa_address(MyAddress)")),
                  &tempTerm);
      icl_AddToList(*myAddress, icl_CopyTerm(icl_NthTerm(tempTerm, 1)), FALSE);
      icl_Free(t1);
      icl_Free(tempTerm);
      return TRUE;
    }
  }
  else {
    /*
       Here, connectionId is null.
       First, we look for all connections of the incoming Type that
       are currently valid (actually connected).
    */
    int index;
    ICLTerm* validConnections = NULL;

    com_GetAllValidConnections(&validConnections);

    if (validConnections != NULL) {
      ICLTerm* requestInfo = icl_NewTermFromString("oaa_address(MyAddress)");
      /*
        Retreives all Id from the list of connected connections Not the best
        optimized way to to it (n^2 order), but lists of connections are not
        going to be huge.
      */
      char* connectionIdAsString = NULL;

      for (index = 1; index <=icl_ListLen(validConnections) ; index ++) {
        ICLTerm* tempTerm = NULL;
        connectionIdAsString = icl_Str(icl_NthTerm(validConnections, index));
        /*
          Makes the request to the connections database about the address
          of the current valid connection's id
        */
        com_GetInfo(connectionIdAsString, requestInfo, &tempTerm);
        icl_AddToList(*myAddress, icl_CopyTerm(icl_NthTerm(tempTerm, 1)),
                      TRUE);
        icl_Free(tempTerm);
      }
      icl_Free(validConnections);
      icl_Free(requestInfo);
      return TRUE;
    }
  }
  return FALSE;
} // end of oaa_Address

int oaa_PrimaryAddress(ICLTerm** primaryAddress)
{
  if (com_Connected("parent")) {
    ICLTerm* tempResult = NULL;
    ICLTerm* requestInfo = icl_NewTermFromString("oaa_address(MyAddress)");

    com_GetInfo("parent", requestInfo, &tempResult);
    *primaryAddress = icl_CopyTerm(icl_NthTerm(tempResult,1));
    icl_Free(tempResult);
    icl_Free(requestInfo);
    return TRUE;
  }
  else {
    printf("liboaa.c::oaa_PrimaryAddress: not connected\n");
  }
  return FALSE;
}

int oaa_PrimaryId(ICLTerm** primaryId) {
  ICLTerm* tempAddress = NULL;

  if (oaa_PrimaryAddress(&tempAddress)) {

    int returnValue = icl_address_to_id(tempAddress, primaryId);
    icl_Free(tempAddress);
    return returnValue;
  }
  return FALSE;
}

/****************************************************************************
 * Given a full address return only the Id
 ***************************************************************************/

int icl_address_to_id(ICLTerm* inFullAddress, ICLTerm** result) {
  int success = FALSE;
  ICLTerm *tempTerm = icl_NewTermFromString("addr(FacAddr, Id)");
  if (icl_Unify(inFullAddress, tempTerm, NULL)) {
    *result = icl_CopyTerm(icl_NthTerm(inFullAddress, 2));
    success = TRUE;
  }
  icl_Free(tempTerm);
  return success;
}

int oaa_Name(ICLTerm **my_name) {
  ICLTerm *result, *t1;

  if (com_GetInfo("parent",
                  (t1 = icl_NewTermFromString("oaa_name(MyName)")),
                  &result)) {

    *my_name = icl_CopyTerm(icl_NthTerm(result, 1));
    icl_Free(result);
    icl_Free(t1);
    return TRUE;
  } else {

    char *conn_id;
    ICLTerm *type_server = icl_NewTermFromString("type(server)");

    icl_Free(t1);
    if (com_GetConnectionId(&conn_id, type_server) &&
        com_GetInfo(conn_id,
                    (t1 = icl_NewTermFromString("oaa_name(MyName)")),
                    &result)) {

      *my_name = icl_CopyTerm(icl_NthTerm(result, 1));
      icl_Free(result);
      icl_Free(t1);
      return TRUE;
    }
    icl_Free(t1);
  }
  return FALSE;
}

char *oaa_name_string()
{
  ICLTerm *name;

  if (oaa_Name(&name)) {

    char *nameStr = strdup(icl_Str(name));
    icl_Free(name);
    return nameStr;
  }
  else
    return NULL;
}


int oaa_class(char *class) {
  int res = FALSE;

    if(STREQ(class, "leaf") &&
         !com_Connected("fac_listener"))
       res = TRUE;
    else if(STREQ(class, "node") &&
         com_Connected("fac_listener") &&
         com_Connected("parent"))
      res = TRUE;
    else if(STREQ(class, "root") &&
         com_Connected("fac_listener") &&
         !com_Connected("parent"))
      res = TRUE;

  return res;
} // end of oaa_class

/*
 *       oaa_assertz(Clause, Owner, SpecifiedCallback)
 *       oaa_retract(Clause, Owner, SpecifiedCallback)
 *       oaa_retractall(Clause, Owner, SpecifiedCallback)
 *       oaa_replace_all(Clause1, Clause2, Owner, SpecifiedCallback)
 * purpose: Perform data updates with bookkeeping info (in oaa_data_ref/3)
 * remarks: These should only be used with data solvables having param
 *          bookkeeping(true).
 *          There are still a couple limitations related to data callbacks.
 *          First, callbacks don't work when bookkeeping(false).
 *          Second, oaa_replace_all assumes the same callback is appropriate
 *          for both the old and new facts.
 */
int oaa_asserta(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback)
{
  ICLTerm *ref, *now, *t1;
#ifndef _WINDOWS
  struct timeval tv;
#else
  time_t ltime;;
#endif
  (void)callback;

  asserta_ref(clause, &ref);

  /* Time in seconds since UTC 1/1/70 */
#ifndef _WINDOWS
  gettimeofday(&tv, (void *)0);
  now = icl_NewFloat(tv.tv_sec*1000.0 + tv.tv_usec);
#else
  time( &ltime );
  now = icl_NewFloat(ltime*1000.0);
#endif
  asserta(icl_NewStruct("oaa_data_ref", 3, ref, owner, now));
  oaa_call_callback("app_on_data_change", (t1 = icl_NewStruct("add", 1, clause)), NULL, NULL);
  icl_Free(t1);
  return TRUE;
}

int oaa_assertz(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback)
{
  ICLTerm *ref, *now, *t1;
#ifndef _WINDOWS
  struct timeval tv;
#else
  time_t ltime;;
#endif
  (void)callback;

  // Stores the clause in the database and
  // returns (create) a unique id for it (ref).
  assertz_ref(clause, &ref);
  /* Time in seconds since UTC 1/1/70 */
#ifndef _WINDOWS
  gettimeofday(&tv, (void *)0);
  now = icl_NewFloat(tv.tv_sec*1000.0 + tv.tv_usec);
#else
  time( &ltime );
  now = icl_NewFloat(ltime*1000.0);
#endif
  asserta(icl_NewStruct("oaa_data_ref", 3, ref, owner, now));
  oaa_call_callback("app_on_data_change", (t1 = icl_NewStruct("add", 1, icl_CopyTerm(clause))),NULL,NULL);
  icl_Free(t1);
  return TRUE;
}

int oaa_retract(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback)
{
  ICLTerm *ref, *t1;
  (void)callback;

  if (ref_for_clause(clause, &ref)) {
    t1 = icl_NewStruct("oaa_data_ref", 3, ref, icl_CopyTerm(owner),
                       icl_NewVar("_"));
    if (retract(t1)) {
      erase_ref(clause, ref);
      icl_Free(t1);

      t1 = icl_NewStruct("remove", 1, icl_CopyTerm(clause));
      oaa_call_callback("app_on_data_change", t1, NULL, NULL);
      icl_Free(t1);
      retract(clause);
      return TRUE;
    }
    icl_Free(t1);
  }
  return FALSE;
}

int oaa_retractall(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback)
{
  while (oaa_retract(clause, owner, callback));
  return TRUE;
}

int oaa_replace_all(ICLTerm *clause1, ICLTerm *clause2, ICLTerm *owner,
                    ICLTerm *callback) {
  ICLTerm *dummyvar = icl_NewVar("_old_owner");
  /* ??? Hopefully, dummyvar will unify properly with any owner */
  while(oaa_retract(clause1, dummyvar, callback))
    oaa_assertz(clause2, owner, callback);
  icl_Free(dummyvar);
  return TRUE;
}

/*****************************************************************************
 * Requesting Services
 *****************************************************************************/

static int oaaSolveRec = 0;
int oaa_Solve(ICLTerm *goal, ICLTerm *initial_params, ICLTerm **out_params,
              ICLTerm **solutions) {
  int compound, res = FALSE;
  ICLTerm *params=NULL, *new_params = NULL, *id = NULL, *contexts = NULL, *t1 = NULL;
  ICLTerm *tmp_params = NULL;
  ++oaaSolveRec;

  icl_standardize_params(initial_params, FALSE, &params);
  /* Trace message */
#ifdef UNNEEDED_DEBUG
  arglist = (icl_NewList(
              icl_NewCons(
               icl_CopyTerm(goal),
               icl_NewCons(icl_CopyTerm(params),NULL))));
  {
    char *debugStr = icl_NewStringFromTerm(arglist);
    oaa_TraceMsg("\n\nStarting oaa_Solve request:\n %s\n", debugStr,NULL);
    icl_stFree(debugStr);
    icl_Free(arglist);
  }
#endif /* UNNEEDED_DEBUG */

  /* check for inappropriate params */
  t1 = icl_NewTermFromString("cache(true)");
  if (icl_GetParamValue(t1, params, NULL) &&
      icl_compound_goal(goal)) {
    char *debugStr = icl_NewStringFromTerm(goal);

    printf("%s: %s (%s)\n  Goal: %s\n", "Warning",
           "Ignoring 'cache' parameter", "cannot be used with compound goal",
           debugStr);
    icl_stFree(debugStr);
    compound = TRUE;
  }
  else {
    compound = FALSE;
  }
  icl_Free(t1);

  /* Add context to params.  Regarding the condition, see comments in
     the corresponding code of oaa.pl */
  t1 = icl_NewTermFromString("reply(true)");
  if (icl_GetParamValue(t1, params, NULL) &&
      oaa_retrieve_nth_current_contexts(&id, &contexts, 0)) {
    icl_append_to_list(contexts, params, &new_params);
  }
  else {
    new_params = params;
  }
  icl_Free(t1);

  /* check cache */
  /*
   * ??? Not sure how to handle exception in C.  Prolog version has:
   * on_exception(_, oaa_InCache(Goal, Solutions), fail) ->
   */
  t1 = icl_NewTermFromString("cache(true)");
  if (icl_GetParamValue(t1, new_params, NULL) &&
      !compound &&
      oaa_InCache(goal, solutions)) {

#ifdef UNNEEDED_DEBUG
    {
      char *debugStr = icl_NewStringFromTerm(*solutions);
      oaa_TraceMsg("\n\nSolutions found in cache:\n    %s.\n",
                   debugStr,NULL);
      icl_stFree(debugStr);
    }
#endif /* UNNEEDED_DEBUG */
    icl_Free(t1);
    res = TRUE;
  }
  else { /* me */
    /* Should I solve this only locally? */
    ICLTerm *me;
    int meRes;

    /*
    {
      char* ds = icl_NewStringFromTerm(params);
      fprintf(stderr, "%i Params me: %s\n", oaaSolveRec, ds);
      icl_stFree(ds);
    }
    */
    icl_Free(t1);
    meRes = oaa_PrimaryAddress(&me);
    if(meRes == FALSE) {
      fprintf(stderr, "oaa_Solve: could not get my address--not connected?\n");
      --oaaSolveRec;
      return FALSE;
    }
    t1 = icl_NewStruct("address", 1, me);
    if (meRes && icl_GetParamValue(t1, params, NULL)) {
      icl_Free(t1);
      res = oaa_solve_local(goal, new_params, solutions);
    }
    else { /* send request to facilitator */
      char* newId = new_goal_id();
      ICLTerm* local_goal_id = icl_NewStr(newId);
      /*
      {
        char* ds = icl_NewStringFromTerm(params);
        fprintf(stderr, "%i Params after send request to fac: %s\n", oaaSolveRec, ds);
        icl_stFree(ds);
      }
      */
      icl_Free(t1);
      icl_stFree(newId);
      /*
      {
        char* ds = icl_NewStringFromTerm(params);
        fprintf(stderr, "%i Params before cont_solve: %s\n", oaaSolveRec, ds);
        fflush(stderr);
        icl_stFree(ds);
      }
      */
      /* printf("calling oaa_cont_solve\n");*/
      res = oaa_cont_solve(local_goal_id,
                           goal,
                           new_params,
                           solutions,
                           &tmp_params);

      /* printf("oaa_cont_solve done\n");*/
      /*
      {
        char* ds = icl_NewStringFromTerm(params);
        fprintf(stderr, "%i Params before free: %s\n", oaaSolveRec, ds);
        icl_stFree(ds);
      }
      */
      icl_Free(local_goal_id);
      if (res) {
        if(new_params != NULL) {
          if(new_params == params) {
            /*
            {
              char* ds = icl_NewStringFromTerm(params);
              fprintf(stderr, "%i Freeing params: %s\n", oaaSolveRec, ds);
              icl_stFree(ds);
            }
            */
            icl_Free(params);
          }
          else {
            icl_Free(params);
            icl_Free(new_params);
          }
        }
        new_params = tmp_params; /* copy output params */
        /* print appropriate trace message */
#ifdef UNNEEDED_DEBUG
        t1 = icl_NewTermFromString("reply(none)");
        if (icl_GetParamValue(t1, new_params, NULL)){
          //oaa_TraceMsg("\n\nMessage broadcast.\n", NULL); UNEEDED_DEBUG
        }
        else {
          //oaa_TraceMsg("\n\nSolutions returned:\n    %s.\n", UNNEDED_DEBUG
          //  icl_NewStringFromTerm(*solutions),NULL);
        }
        icl_Free(t1);
#endif /* UNNEEDED_DEBUG */
        /* cache returned solutions if necessary */
        t1 = icl_NewTermFromString("cache(true)");
        if (icl_GetParamValue(t1, new_params, NULL) &&
            (*solutions)->p) {
          oaa_AddToCache(goal, *solutions);
          //oaa_TraceMsg("Solutions cached.\n",NULL);
        }
        icl_Free(t1);
      }

      if (out_params && new_params) {
        *out_params = icl_CopyTerm(new_params);
      }

      icl_Free(local_goal_id);
    }
  }
  if (new_params == tmp_params) {
    new_params = NULL;
  }
  if(tmp_params != NULL) {
    icl_Free(tmp_params);
  }
  if ((new_params != params)) {
    icl_Free(new_params);
    icl_Free(params);
  }
  else {
    icl_Free(params);
  }
  --oaaSolveRec;
  return res;
}

int oaa_solve_local(ICLTerm *full_goal, ICLTerm *params, ICLTerm **solutions)
{
  // chantier
  ICLTerm *tmp=NULL;
  ICLTerm *goal_params=NULL;
  ICLTerm *solvables=NULL;
  ICLTerm *goal1=NULL;
  ICLTerm *goal=NULL;
  ICLTerm *new_params=NULL;
  ICLTerm *t1 = NULL;
  ICLTerm *matched=NULL;
  ICLTerm *all_params = NULL;
  int res = FALSE;


  /* validate the goal */
  icl_GoalComponents(full_goal, &tmp, &goal1, &goal_params);
  solvables = valid_oaa_solvables();

  {

  }

  // Rhaa
  if (!(icl_compound_goal(goal1) || icl_BuiltIn(goal1))) {
    oaa_goal_matches_solvables(goal1, solvables, &goal, &matched);
  }

  /* If the goal is not found, returns false */
  if (goal == NULL) {
    if(!*solutions) {
      *solutions = icl_NewList(NULL);
    }
  }
  else {
    /*
     * More "local" params take precedence, so they go to the
     * beginning of the list:
     */
    icl_append_to_list(goal_params, params, &all_params);

    /*
     * We don't want tests to be performed repeatedly with compound goals,
     * so we remove them after testing.
     */
    if (passes_tests(all_params)) {
      ICLTerm* tempTerm=NULL;
      ICLTerm* solvParams = icl_NthTerm(matched, 2);
      ICLTerm *empty_list = icl_NewList(NULL);

      t1 = icl_NewTermFromString("test(_)");
      icl_ListDelete(all_params, t1, &new_params);
      icl_Free(t1);

      /* Checks wether the solvable is a Data one */
      tempTerm = icl_NewTermFromString("type(data)");
      if (icl_GetParamValue(tempTerm, solvParams, NULL)) {
        res = db_Solve(local_db, goal, empty_list, solutions);
      }
      else {
        res = oaa_Interpret(goal, new_params, solutions);
      }

      icl_Free(empty_list);
      icl_Free(tempTerm);

      /*
        icl_ParamValueAsInt("solution_limit", all_params, &n);
      */
    } else {
      //oaa_TraceMsg("\nDoesn't pass test in: %s\n", icl_NewStringFromTerm(full_goal),NULL); UNNEDED_DEBUG
    }
    /* DEBUG
       if (!res)
       printf("\nError: do not know how to solve: %s\n",
       icl_NewStringFromTerm(full_goal));
    */

    icl_Free(all_params);
  icl_Free(goal);
  }
  icl_Free(tmp);
  icl_Free(goal1);
  icl_Free(goal_params);
  icl_Free(matched);
  icl_Free(new_params);
  return res;
}

int oaa_cont_solve(ICLTerm  *goal_id,   ICLTerm  *goal, ICLTerm *global_params,
                   ICLTerm **solutions, ICLTerm **out_params) {

  int answer = FALSE;
  ICLTerm *anAddress = NULL;
  ICLTerm *fullGoal = NULL;
  ICLTerm *actualGoal = NULL;
  ICLTerm *new_global_params = NULL;
  int freeFullGoal = FALSE;
  static ICLTerm *full_goal_struct = NULL;
  static ICLTerm *addr_struct = NULL;
  static ICLTerm *d_c_struct = NULL;

  if (!icl_IsValid(full_goal_struct)) {
    full_goal_struct = icl_NewTermFromData("full_goal(_)", 12);
    addr_struct      = icl_NewTermFromData("address(AnAddress)", 18);
    d_c_struct       = icl_NewTermFromData("direct_connect(true)", 20);
  }

  if (icl_GetParamValue(full_goal_struct, global_params, &fullGoal)) {
    actualGoal = icl_NthTerm(fullGoal,1);
    // "goal" is just a template for planning...
    // remove full_goal from global params since it could be big...
    icl_ListDelete(global_params, full_goal_struct, &new_global_params);
    freeFullGoal = TRUE;
  }
  else {
    actualGoal = goal;
    new_global_params = global_params;
    freeFullGoal = FALSE;
  }

  if (icl_GetParamValue(addr_struct, global_params, &anAddress)
   && icl_GetParamValue(d_c_struct, global_params, NULL)) {
    // address AND direct_connect specified
    ICLTerm *addr = icl_NthTerm(anAddress,1);
    /*
    {
      fprintf(stderr, "Calling oaa_cont_solve_direct with addr\n");
    }
    */
    answer = oaa_cont_solve_direct(goal_id, actualGoal, addr, new_global_params,
                                                          solutions, out_params);
  }
  else if (!icl_GetParamValue(addr_struct, global_params, NULL)
         && icl_GetParamValue(d_c_struct, global_params, NULL)) {
    // direct_connect specified without address
    /*
    {
      fprintf(stderr, "Calling oaa_cont_plan\n");
    }
    */
    answer = oaa_cont_plan(goal_id, goal, actualGoal, new_global_params,
                                                  solutions, out_params);
  }
  else {
    // "OAA Classic"...no direct_connect
    /*
    {
      fprintf(stderr, "Calling oaa_cont_solve_direct with NULL addr\n");
    }
    */
    answer = oaa_cont_solve_direct(goal_id, actualGoal, NULL, new_global_params,
                                                          solutions, out_params);
  }

  icl_Free(anAddress);
  if (freeFullGoal) {
    icl_Free(fullGoal);
    icl_Free(new_global_params);
  }
  return answer;
}

/*****************************************************************************
 * purpose: Convenience function:  oaa_Solve with default parameters
 ****************************************************************************/

/* ??? Can't do function name overloading in C
   oaa_Solve(Goal) :- oaa_Solve(Goal, []). */


int oaa_InCache(ICLTerm *goal, ICLTerm **solutions) {
  /* ??? Don't currently have a way to check for subsumption,
     Use plain old unify for now */
  return oaa_retrieve_all_cache(goal, solutions);
}

int oaa_AddToCache(ICLTerm *goal, ICLTerm *solutions) {
  ICLListType *slist = NULL;
  /* safety check */
  if(icl_IsList(solutions)) {
    slist = icl_List(solutions);
  }
  while(icl_ListHasMoreElements(slist)) {
    ICLTerm *soln = icl_ListElement(slist);
    oaa_assert_cache(goal, soln);
    slist = icl_ListNextElement(slist);
  }
  return TRUE;
}

int oaa_ClearCache() {
  ICLTerm *dummyvar = icl_NewVar("_");
  ICLTerm *allcache = icl_NewStruct("oaa_cache", 2, dummyvar, dummyvar);
  oaa_retractall_cache(allcache);
  icl_Free(allcache);
  icl_Free(dummyvar);
  return TRUE;
}

int oaa_poll_until_event(ICLTerm *event, ICLTerm **solution) {
  ICLTerm *pterm;
  int p;
  static ICLTerm *temp_term = NULL;
  int answer;

  if (!icl_IsValid(temp_term)) {
    temp_term = icl_NewTermFromData("priority(P)",11);
  }
  icl_param_default(temp_term, &pterm);
  p = icl_Int(icl_NthTerm(pterm,1));
  icl_Free(pterm);
  answer = oaa_poll_until_event_priority(event, p, solution);
  return answer;
}

int oaa_poll_until_event_priority(ICLTerm *event, int priority,
                                  ICLTerm **solutions) {
  int res;
  ICLTerm *event_list = icl_NewList(icl_NewCons(icl_CopyTerm(event), NULL));

  /* Determines wether solutions should be returned or not */
  if (solutions) {
    /* note that oaa_poll_until_all_events can take an initialized list */
    ICLTerm* local_solutions = icl_NewList(NULL);
    res = oaa_poll_until_all_events(event_list, priority, &local_solutions);
    /* Since oaa_poll_until_all_events returns a list of solution
       and oaa_poll_until_event_priority returns one solution, we
       extract it from the returned list.
    */
    if (local_solutions && (icl_NumTerms(local_solutions)>0)) {
      *solutions = icl_CopyTerm(icl_NthTerm(local_solutions, 1));
    }
    icl_Free(local_solutions);
  }
  else {
    res = oaa_poll_until_all_events(event_list, priority, NULL);
  }
  icl_Free(event_list);
  return res;
}

/*
 * Note :
 * event_list : The list of events we are waiting for.
 */
int oaa_poll_until_all_events(ICLTerm *event_list, int priority,
                              ICLTerm **solutions) {
  ICLTerm *event = (ICLTerm *)NULL, *params = (ICLTerm *)NULL;
  ICLTerm *dummyvar = icl_NewVar("_");
  int res = FALSE;

//  {
//    char* eventList = icl_NewStringFromTerm(event_list);
//    icl_stFree(eventList);
//  }

  if(solutions != NULL) {
    if(*solutions == NULL) {
      *solutions = icl_NewList(NULL);
    }
  }

  if(!event_list->p) {
    return TRUE; /* no more events, we're done! */
  }

  while(!res) {
    int otherres = 0;
    /*
     * If we have a waiting event, grab it (see problem description in
     * oaa_is_waiting_for()
     */
    event = NULL;
    otherres = oaa_grab_waiting_event(event_list, &event);
    CHECK_LEAKS();
    if(!otherres) {
      oaa_GetEvent(&event, &params, 0);
      CHECK_LEAKS();
    }
    CHECK_LEAKS();
    /*
     * if timeout returned, check triggers and call user:oaa_AppIdle
     * the fail (continue with next clause)
     */
    CHECK_LEAKS();
    if (STREQ(icl_Str(event), "timeout")) {
      if (oaa_CheckTriggers("task", dummyvar, "_")) {
        ICLTerm *tmpArgs = icl_NewList(NULL);
        oaa_call_callback("oaa_AppIdle", dummyvar, tmpArgs, NULL);
        icl_Free(tmpArgs);
      }
    }
    else {
      CHECK_LEAKS();
      oaa_cont_poll_until_all_events(event_list, event, params,
                                     priority, solutions);
      CHECK_LEAKS();
      res = TRUE;
    }
    icl_Free(event);
    icl_Free(params);
  }
  icl_Free(dummyvar);
  return res;
}

/**********************************************************************
 * Note :
 *   event_list : Events we are waiting for
 *   event : New event coming from oaa_GetEvent
 **********************************************************************/

int oaa_cont_poll_until_all_events(ICLTerm *event_list, ICLTerm *event,
                                   ICLTerm *params, int priority,
                                   ICLTerm **solutions) {
  static int cntr = 0;
  char buf[128];
  ICLTerm *new_event_list, *wait_id, *tmp_event_list;
  /* The incoming event is in the list of the events we
     are waiting for.
  */
  ICLTerm *removed_from_list = NULL;

  CHECK_LEAKS();
  removed_from_list = remove_element(event, event_list, &new_event_list);
  /*
  {
    char* gotEvent;
    char* eventList;
    char* removed;
    gotEvent = icl_NewStringFromTerm(event);
    eventList = icl_NewStringFromTerm(event_list);
    if(removed_from_list != NULL) {
      removed = icl_NewStringFromTerm(removed_from_list);
    }
    else {
      removed = "(nil)";
    }
    printf("  Event: [%s]\n  Event list: [%s]\n  Removed: [%s]\n", gotEvent, eventList, removed);
    icl_stFree(gotEvent);
    icl_stFree(eventList);
    if(removed_from_list != NULL) {
      icl_stFree(removed);
    }
  }
  */
  CHECK_LEAKS();
  /* Something is wrong here--either we use new_event_list and free
   * event_list, or we don't free removed_from_list
   */
  if (removed_from_list) {
    if (solutions) {
      if(*solutions == NULL) {
        *solutions = icl_NewList(NULL);
      }
      icl_AddToList(*solutions, icl_CopyTerm(event), TRUE);
    }
    icl_Free(new_event_list);
    /*icl_Free(removed_from_list);*/
    return TRUE;
  }
  else {
    //if (oaa_poll_until_all_events(new_event_list, priority, solutions)) {
    /*
     * if the new event is a ev_solved() message for which we
     * are waiting at a higher recursive level, save this for
     * a later time, until we pop back out to the correct level.
     */
    if(oaa_is_waiting_for(event)) {
      oaa_assert_waiting_event(event);
    }
    else {
      /* record what events we are waiting for on this processing level */
      sprintf(buf, "wait%d", cntr);
      ++cntr;
      wait_id = icl_NewStr(buf);
      oaa_assert_waiting_for(wait_id, event_list);
      oaa_ProcessEvent(event, params);
      /* level over, remove waiting statement */
      oaa_retract_waiting_for(wait_id, &tmp_event_list);
    }
    return oaa_poll_until_all_events(event_list, priority, solutions);
  }
  return FALSE;
}


/*****************************************************************************
 * Callbacks
 *****************************************************************************/


int oaa_RegisterCallback(char* callback_id, int (*callback_proc)(ICLTerm*, ICLTerm*, ICLTerm*)) {
  ICLTerm* callbackId;

  // For backwards compatibility:
  if (strcmp(callback_id, "oaa_AppDoEvent") == 0) {
    callback_id = "app_do_event";
  }
  else if (strcmp(callback_id,  "oaa_AppIdle") == 0) {
    callback_id = "app_idle";
  }
  else if (strcmp(callback_id,  "oaa_AppDone") == 0) {
    callback_id = "app_done";
  }

  callbackId = icl_NewStr(callback_id);
  /*
  printf("liboaa.c oaa_RegisterCallback() mapping callback named %s to function pointer %p\n",
         callback_id,
         callback_proc);
  */
  oaa_assert_callback(callbackId, callback_proc);
  CHECK_LEAKS();
  icl_Free(callbackId);
  CHECK_LEAKS();
  return TRUE;
}

int oaa_GetCallback(char* callback_id, int (**callback_proc)(ICLTerm*, ICLTerm*, ICLTerm*)) {
  ICLTerm* tempTerm = icl_NewStr(callback_id);
  int result = oaa_retrieve_callback(tempTerm, callback_proc);
  icl_Free(tempTerm);
  return result;
}

int oaa_call_callback(char* callback_id, ICLTerm *goal, ICLTerm* params, ICLTerm* solutions) {
  char* goalStr;
  /* Pointer to the callback we are looking for */
  int (*callback_proc)(ICLTerm*, ICLTerm*, ICLTerm*)=NULL;
  /* Check if we have a specific callback for this solvable */
  oaa_GetCallback(callback_id, &callback_proc);

  if (callback_proc) {
    goalStr = icl_NewStringFromTerm(goal);
    icl_stFree(goalStr);
    return callback_proc(goal, params, solutions);
  }
  else if(goal != NULL && strcmp("oaa_AppIdle",callback_id)) {
    goalStr = icl_NewStringFromTerm(goal);
    printf("oaa_call_callback no callback for id %s and goal %s from term pointer %p\n", callback_id, goalStr, goal);
    icl_stFree(goalStr);
  }
  return FALSE;
}

/*
 * Generates a unique ID for a goal.
 * remarks:
 *   - ID's should be unique across Facilitators which is why we use the
 *     Name prefix
 *   - Goal counters are used to make sure the solution really matches the
 *     query.
 */
char* new_goal_id()
{
// re-worked so that icl_NewStringFromTerm()
// is called only once
  char *res = NULL;
  static char *idStr = NULL;
  ICLTerm *myPrimId = NULL;
  char temp[255];

  if (idStr == NULL) {
    if (oaa_PrimaryId(&myPrimId)) {
      idStr = icl_NewStringFromTerm(myPrimId);
      icl_Free(myPrimId);
    }
  }
  sprintf(temp, "g_%s%d", idStr, globalCounter++);
  res = strdup(temp);

  if(idStr == NULL) {
    printf("liboaa.c::new_goal_id() Warning: No result\n");
  }

  return res;
}

/****
 * Generates a unique ID for a trigger assertion.
 ***/

char* new_trigger_id() {
  char *res = NULL;

  ICLTerm *myPrimId = NULL;
  if (oaa_PrimaryId(&myPrimId)) {
    char temp [255];
    sprintf(temp, "t_%s%d", icl_NewStringFromTerm(myPrimId),globalCounter++);
    res = strdup(temp);
    icl_Free(myPrimId);
  }
  return res;
}

/*****************************************************************************
 * Debugging
 ****************************************************************************/

int oaa_TraceMsg(char *format_string, ...) {
  if (oaa_trace_on) {
    char buf[1000];
    va_list ptr;
    va_start(ptr,format_string);
    vsprintf(buf,format_string,ptr);
    printf("%s\n", buf);
    va_end(ptr);
  }
  return TRUE;
}

int oaa_ComTraceMsg(char *format_string, ...) {
  if (oaa_com_trace_on){
    char buf[10000];
    va_list ptr;
    va_start(ptr,format_string);
    vsprintf(buf,format_string,ptr);
    printf("%s\n", buf);
    va_end(ptr);
  }
  return TRUE;
}

/*
 * Start debugging if debug mode is on.
 * Use predicate_property and call so as to avoid errors in
 * building and running a Quintus runtime system.
 */
int oaa_turn_on_debug() {
  if(oaa_debug_on) {
    /* ??? Again, there's no user module, so what to do with
       ( predicate_property(user:trace, built_in) ->
       call(user:trace)
       ??? */
  }
  return TRUE;
}
/*
 * Stop debugging if debug mode is on.
 * Use predicate_property and call so as to avoid errors in
 * building and running a Quintus runtime system.
 */
int oaa_turn_off_debug() {
  if(oaa_debug_on) {
    /* ??? Again, there's no user module, so what to do with
       ( predicate_property(user:trace, built_in) ->
       call(user:trace)
       ??? */
  }
  return TRUE;
}

/*****************************************************************************
 * User Interface
 ****************************************************************************/
int oaa_Inform(ICLTerm *type_info, char *format_string, ICLTerm *args) {

#ifdef OAA_INFORM

  char result[512];
  int res = FALSE;
  (void)type_info;
  (void)format_string;
  (void)args;
  if(oaa_TraceMsg(format_string, args) &&
     oaa_class("leaf")) {
    if(icl_IsList(args)) {
      ICLListType *plist = icl_List(args);
      va_list ap;
      /* convert terms into strings that can be passed as an
         argument list into fprintf() */
      va_start(ap);
      while(icl_ListHasMoreElements(plist)) {
        char *term_string = icl_Str(icl_ListElement(plist));
        va_arg(ap, char *) = term_string;
        plist = icl_ListNextElement(plist);
      }
      va_end(ap);
      vsprintf(result, format_string, ap);
      res = oaa_Solve(icl_NewStruct("inform", 2, type_info,
                                    icl_NewStr(result)),
                      icl_NewList(
                       icl_NewCons(
                        icl_NewTermFromString("strategy(inform)"),
                        NULL)));
    }
  }
  return res;

#endif

  (void)type_info;
  (void)format_string;
  (void)args;
  return FALSE;
}

/*****************************************************************************
 * Connection primitives
 ****************************************************************************/

/*****************************************************************************
%%% BUG/HACK!!!!!
% tcp_send/1 is not currently defined (new version of quintus)
% so these predicates should fail.  This means we can't have
% multilevel facilitators.
% However, if we fix it by the tcp_send/2 version (commented out),
% killing the agent doesn't shut down both connections and the
% facilitator server doesn't register the agent as disconnected.
% This must be fixed, but I don't have time now...

% Ask the root agent for the address of facilitator FacName.
% Either FacId or FacName may be bound.
% IMPORTANT: This assumes the root agent is the only connection when
% this is called.
% @@Not happy with the use of a Connection number in the address param here.
% Can an address be a connection number as well as an id or name???  [No.]

% get_address(FacId, FacName, Port, Host):-
%         tcp_connected(RootConnection),
%   oaa_Solve(agent_location(FacId, FacName, Port, Host),
%       [address(RootConnection)]).


%% succeed if FacName has not been registered with the root agent.
%%    otherwise, ask user to enter a different name for FacName

% check_name_duplication(MyName, NewMyName) :-
%         tcp_send(ev_check_agent_name(MyName)),
%         oaa_select_event(0, X),
%         oaa_extract_event(X, Result, _), %% 'UNIQUE'
%         (Result == 'UNIQUE' -> NewMyName = MyName
%                 ;
%         format('Name is duplicated~n',[]),
%         format('The following are registered ~n ~q ~n',[Result]),
%         format('Input agent name again:',[]),
%         read(NewMyName)).

% report_address_to_root(MyName, NewAddress):-
%   tcp_send(register_port_number(MyName, NewAddress)).


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% routines to fix bug:
%   blocking solve1
%      incoming event generates blocking solve2
%      solution to solve1 thrown away!!!
%      solutions to solve2
%   stuck  waiting for solve1 forever
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

****************************************************************************/

int oaa_is_waiting_for(ICLTerm *event)
{
  int result;
  ICLTerm *event_list = NULL;
  ICLTerm *dummyvar = icl_NewVar("_");

  oaa_retrieve_all_waiting_for(dummyvar, &event_list);
  icl_Free(dummyvar);

  if(icl_Member(event, event_list, NULL))
    result = TRUE;
  else
    result = FALSE;

  icl_Free(event_list);
  return(result);
}

int oaa_grab_waiting_event(ICLTerm *event_list, ICLTerm **event)
{
  ICLTerm     *test_events, *an_event, *unified_event;
  ICLListType *elist;
  int          returnValue = FALSE;

  oaa_retrieve_all_waiting_events(&test_events);
  elist = icl_List(test_events);

  while(icl_ListHasMoreElements(elist)) {
    an_event = icl_ListElement(elist);
    elist = icl_ListNextElement(elist);

    if(icl_Member(an_event, event_list, &unified_event)) {
      oaa_retract_waiting_event(unified_event);
      *event = unified_event;
      returnValue = TRUE;
      break;
    }
  }
  icl_Free(test_events);
  return returnValue;
}

/*****************************************************************************
 * OAA Utilities
 ****************************************************************************/
int oaa_remove_solvables_data(ICLTerm *solvables) {
  int res = FALSE;
  if(icl_IsList(solvables)) {
    ICLListType *slist = icl_List(solvables);
    ICLTerm *dummyvar = icl_NewVar("_");
    ICLTerm *type_data = icl_NewTermFromString("type(data)");
    ICLTerm *synonym = icl_NewStruct("synonym", 2, dummyvar, dummyvar);
    while(icl_ListHasMoreElements(slist)) {
      ICLTerm *solvable = icl_ListElement(slist);
      res = FALSE;
      if(icl_IsStruct(solvable) &&
         (icl_Arity(solvable) == 3)) {

        ICLTerm *goal = icl_NthTerm(solvable, 1);
        ICLTerm *params = icl_NthTerm(solvable, 2);
        ICLTerm *t1;

        if (icl_GetParamValue(type_data, params, NULL) &&
            (!icl_GetParamValue(synonym, params, NULL))) {
          /* This should have already been done, but to be safe: */
          /* ??? We can't really do the following in C:
             (clause(Goal, _, _) -> true | true),
          */
          ICLTerm *skeleton;
          predicate_skeleton(goal, &skeleton);
          if (oaa_remove_data_local(skeleton,
                                    (t1 = icl_NewTermFromString(
                                     "[do_all(true)]"))))
            res = TRUE;
          else
            printf(
             "%s: Problem in removing all data form solvable: %s\n",
             "! ERROR", icl_NewStringFromTerm(goal));
          icl_Free(t1);
        }
      }
      slist = icl_ListNextElement(slist);
    }
    icl_Free(synonym);
    icl_Free(dummyvar);
    icl_Free(type_data);
  }
  return res;
}

int oaa_remove_data_owned_by(ICLTerm *id)
{
  ICLTerm *solvables = valid_oaa_solvables();
  ICLTerm *built_ins = oaa_built_in_solvables();
  ICLTerm *all_solvables=NULL;
  ICLListType *slist = NULL;
  ICLTerm *type_data = icl_NewTermFromString("type(data)");
  ICLTerm *persistent_true = icl_NewTermFromString("persistent(true)");
  ICLTerm *dummyvar = icl_NewVar("_");
  ICLTerm *synonym = icl_NewStruct("synonym", 2, icl_CopyTerm(dummyvar), icl_CopyTerm(dummyvar));
  int res= FALSE;

  icl_append_to_list(built_ins, solvables, &all_solvables);
  slist = icl_List(all_solvables);
  while(icl_ListHasMoreElements(slist)) {
    ICLTerm *solvable = icl_ListElement(slist);
    res = FALSE;
    if(icl_IsStruct(solvable) &&
       (icl_Arity(solvable) == 3)) {
      ICLTerm *goal = icl_NthTerm(solvable, 1);
      ICLTerm *params = icl_NthTerm(solvable, 2);
      if(icl_GetParamValue(type_data, params, NULL) &&
         !icl_GetParamValue(persistent_true, params, NULL) &&
         !icl_GetParamValue(synonym, params, NULL)) {
        /* This should have already been done, but to be safe: */
        /* ??? We can't really do the following in C:
           (clause(Goal, _, _) -> true | true),
        */
        ICLTerm *skeleton=NULL;
        ICLTerm *rparams =
          icl_NewList(icl_NewCons(icl_NewStruct("owner", 1, icl_CopyTerm(id)),
                                  icl_NewCons(icl_NewTermFromString("do_all(true)"), NULL)));
        predicate_skeleton(goal, &skeleton);
        if (oaa_remove_data_local(skeleton, rparams)) {
          res = TRUE;
        }
        else {
          char *debugStr = icl_NewStringFromTerm(goal);
          printf("%s: Problem in removing all data form solvable: %s\n",
                 "! ERROR", debugStr);
          icl_stFree(debugStr);
        }
        icl_Free(rparams);
      }
    }
    slist = icl_ListNextElement(slist);
  }
  icl_Free(synonym);
  icl_Free(dummyvar);
  icl_Free(persistent_true);
  icl_Free(type_data);
  return res;
}

/*****************************************************************************
 * General Utilities
 ****************************************************************************/


/*****************************************************************************
 * name:    oaa_consult(+FilePath, -AbsFileName).
 * purpose:
 * remarks: We don't use Quintus' builtin consult, because it's too picky
 *          about associating predicates with files.
 ****************************************************************************/
/* This has to do with Prolog compilation and doesn't translate into C */

/*****************************************************************************
 * name:    load_clauses(+Stream).
 * purpose:
 ****************************************************************************/
/* This has to do with Prolog compilation and doesn't translate into C */

/*****************************************************************************
 * name:    load_clause(+Term).
 * purpose:
 ****************************************************************************/
/* This has to do with Prolog compilation and doesn't translate into C */

/*****************************************************************************
 * name:    oaa_declare_for_prolog(Solvables).
 * purpose: For each solvable, make sure it's known to Prolog as a dynamic
 *          predicate.  This will prevent exceptions and warnings from
 *          calls and retracts before there have been any asserts.
 * remarks: Solvables must be in standard form, and should include only
 *          data solvables.
 *          This is probably Quintus-specific.
 *          We are assuming that none of these predicates are known to
 *          Prolog as compiled predicates.  Would be better to check for this.
 ****************************************************************************/
/* This has to do with Prolog compilation and doesn't translate into C */

/*****************************************************************************
 * name:    predicate_skeleton(+Goal, +Skeleton).
 ****************************************************************************/
int predicate_skeleton(ICLTerm *goal, ICLTerm **skeleton) {
  if(icl_IsStruct(goal)) {
    ICLTerm *dummyvar = icl_NewVar("_");
    char *functor = icl_Functor(goal);
    int arity = icl_Arity(goal);
    ICLTerm *arglist = icl_NewList(NULL);
    int i;
    for(i=0; i<arity; i++) {
      icl_AddToList(arglist, icl_CopyTerm(dummyvar), TRUE);
    }
    *skeleton = icl_NewStructFromList(functor, arglist);
    icl_Free(dummyvar);
    return TRUE;
  }
  return FALSE;
}

/*****************************************************************************
 * name:    memberchk_nobind
 * purpose: like memberchk, but doesn't bind variables in Elt when doing test.
 ****************************************************************************/
/* ??? This function doesn't seem to be used anywhere */

/*****************************************************************************
 * name:    would_unify
 * purpose: succeeds if X and Y WOULD unify, but doesn't actually do the
 *          unification (no variables are bound by test)
 ****************************************************************************/
/* This function is unecessary in C */

ICLTerm* remove_element(ICLTerm *elt, ICLTerm *list, ICLTerm **rest) {
  ICLTerm* removed = NULL;
  ICLListType *elist = icl_List(list);
  *rest = icl_NewList(NULL);
  while(icl_ListHasMoreElements(elist)) {
    ICLTerm *test = icl_ListElement(elist);
//    {
//      char* element;
//      char* testStr;
//      element = icl_NewStringFromTerm(elt);
//      testStr = icl_NewStringFromTerm(test);
//      icl_stFree(element);
//      icl_stFree(testStr);
//    }
    if(icl_Unify(elt, test, NULL)) {
      removed = test;
    }
    else {
      icl_AddToList(*rest, icl_CopyTerm(test), TRUE);
    }
    elist = icl_ListNextElement(elist);
  }
  return removed;
}

int replace_element(ICLTerm *elt, ICLTerm *old_list, ICLTerm *new_elt,
                    ICLTerm **new_list)
{
  int res = FALSE;
  ICLListType *elist = icl_List(old_list);
  (void)new_elt;
  *new_list = icl_NewList(NULL);
  while(icl_ListHasMoreElements(elist)) {
    ICLTerm *unified, *test = icl_ListElement(elist);
    if(icl_Unify(elt, test, &unified)) {
      icl_AddToList(unified, icl_CopyTerm(*new_list), TRUE);
      res = TRUE;
    } else {
      icl_AddToList(test, icl_CopyTerm(*new_list), TRUE);
    }
    elist = icl_ListNextElement(elist);
  }
  return res;
}

// added for direct_connect

/*
 * Check for an existing connection with the given agent.  If
 * there is none, establish one.  If that's not possible, FAIL.
 */
static int ensure_direct_connection(ICLTerm *AgentAddress, char **ConnectionId) {
  int answer = FALSE;
  ICLTerm *other_address = icl_NewStruct("other_address", 1, icl_CopyTerm(AgentAddress));
  answer = com_GetConnectionId(ConnectionId, other_address);
  if (!answer) {
    ICLTerm *goal =  icl_NewStruct("agent_listener", 2,
                                   icl_CopyTerm(AgentAddress),
                                   icl_NewVar("X"));

    ICLTerm *solveParams = icl_NewTermFromData("[address(parent)]", 17);
    ICLTerm *solutions = icl_NewList(NULL);
    ICLTerm *myName = NULL;
    char *myNameString = NULL;
    ICLTerm *ConnectAddress = NULL;
    ICLTerm *connectParams = icl_NewList(NULL);
    icl_AddToList(connectParams, icl_NewStruct("resolve_vars", 1, icl_NewStr("false")), TRUE);
    icl_AddToList(connectParams, icl_CopyTerm(other_address), TRUE);
    oaa_Solve(goal, solveParams, NULL, &solutions);
    ConnectAddress = icl_CopyTerm(icl_NthTerm(icl_NthTerm(icl_NthTerm(solutions,1),2),1));
    if (ConnectAddress == NULL) {
      icl_Free(connectParams);
      icl_Free(ConnectAddress);
      icl_Free(goal);
      icl_Free(connectParams);
      icl_Free(solutions);
      icl_Free(solveParams);
      answer = FALSE;
    }
    else {
      *ConnectionId = new_direct_connection_id();

      oaa_Name(&myName);
      myNameString = icl_NewStringFromTerm(myName);
      answer = oaa_Connect(*ConnectionId, ConnectAddress, myNameString, connectParams);

      icl_Free(goal);
      icl_Free(solveParams);
      icl_Free(solutions);
      icl_Free(myName);
      icl_stFree(myNameString);
      icl_Free(ConnectAddress);
      icl_Free(connectParams);
    }
    CHECK_LEAKS();
  }
  icl_Free(other_address);
  CHECK_LEAKS();
  return answer;
} // end of ensure_direct_connection


/*
 *
 */
static int isClientConnection(char *ConnectionId) {
  ICLTerm *t2 = NULL;
  ICLTerm *type = NULL;
  int answer = TRUE;

  t2 = icl_NewStruct("type", 1, icl_NewVar("T"));
  if (com_GetInfo(ConnectionId, t2, &type)) {
    answer = STREQ(icl_Str(type), "client");
  }
  icl_Free(type);
  icl_Free(t2);
  return answer;
} // end of isClientConnection

EXPORT_MSCPP
int EXPORT_BORLAND
memberchk(ICLTerm *Param, ICLTerm *ParamList) {
  int res = FALSE;

  // return FALSE quickly if args are NULL or list is empty
  if ((Param == NULL) ||
      (ParamList == NULL) ||
      (icl_ListLen(ParamList) == 0)) {
    return FALSE;
  }

  if (icl_IsStruct(Param) && (icl_NumTerms(Param) == 1) &&
      icl_IsList(ParamList)) {
    ICLTerm *p;
    if (icl_ParamValue(icl_Str(Param), NULL, ParamList, &p)) {
      res = icl_Unify(Param, p, NULL);
      icl_Free(p);
    }
    return res;
  }
  else {
    return FALSE;
  }
} // end of memberchk


/*
 * Generates a unique ConnectionId for a direct connection.
 */
static char* new_direct_connection_id() {
    static int counter = 1;
    char temp[255];
    sprintf(temp, "direct%d", counter++);
    return strdup(temp);
}

EXPORT_MSCPP
int EXPORT_BORLAND
oaa_Connect(char *ConnectionId, ICLTerm *Address, char *InitialAgentName, ICLTerm *Params) {

    if (comConnectFormat(ConnectionId, Params, Address, COM_BEST_FORMAT) <= 0) {
        return FALSE;
    }

    if(!oaa_handshake(ConnectionId, InitialAgentName, Params)) {
        return FALSE;
    }

    return TRUE;

} // end of oaa_Connect

/*
 * If SingleAgentAddress is NULL, perform a "classic" oaa_solve().
 */
static int oaa_cont_solve_direct(ICLTerm* goal_id,
                                 ICLTerm *goal,
                                 ICLTerm *SingleAgentAddress,
                                 ICLTerm *global_params,
                                 ICLTerm **solutions,
                                 ICLTerm **out_params) {
  ICLTerm *tmp1 = NULL;
  ICLTerm *tmp2 = NULL;
  ICLTerm *params = NULL;
  ICLTerm *requestees = NULL;
  ICLTerm *solvers = NULL;
  ICLTerm *solved_params = NULL;
  ICLTerm *dummyvar = icl_NewVar("_");
  ICLTerm *t1 = (ICLTerm *)NULL, *t2 = (ICLTerm *)NULL, *t3 = (ICLTerm *)NULL;
  ICLTerm *all_params = NULL;
  int res = FALSE;

  ICLTerm *conn_id = NULL;
  ICLTerm *post_params = icl_NewList(NULL);
  char *ConnectionId = NULL;

  int direct_connect_used = FALSE;
  static ICLTerm *get_direct_connect_used_true = NULL;
  static ICLTerm *get_direct_connect_used_false = NULL;

  if (!icl_IsValid(get_direct_connect_used_true)) {
    get_direct_connect_used_true
      = icl_NewTermFromData("get_direct_connect_used(true)",29);
    get_direct_connect_used_false
      = icl_NewTermFromData("get_direct_connect_used(false)",30);
  }

  // if we have an address, we must be trying to use direct_connect...
  // ...add the connection_id to post_params, if a direct_connection
  // is really available. This allows "fail-over" to a "regular"
  // oaa_Solve() if d_c is not set up
  if((SingleAgentAddress != NULL) &&
     ensure_direct_connection(SingleAgentAddress, &ConnectionId)) {
    direct_connect_used = TRUE;
    icl_AddToList(global_params, icl_CopyTerm(SingleAgentAddress), FALSE);
    conn_id = icl_NewStruct("connection_id", 1, icl_NewStr(ConnectionId));
    icl_AddToList(post_params, conn_id, FALSE);
    // TODO: ALA add timeout check for direct connect
  }
  t1 = icl_NewStruct("ev_solve", 3,
                     icl_CopyTerm(goal_id),
                     icl_CopyTerm(goal),
                     icl_CopyTerm(global_params));

  oaa_PostEvent(t1, post_params);
  icl_Free(t1);
  /* compound goals may also contain relevant params */
  icl_GoalComponents(goal, &tmp1, &tmp2, &params);
  icl_append_to_list(params, global_params, &all_params);

  icl_Free(tmp1);
  icl_Free(tmp2);
  icl_Free(params);

  t1 = icl_NewTermFromData("reply(false)",12);
  t2 = icl_NewTermFromData("reply(none)",11);
  t3 = icl_NewTermFromData("blocking(false)",15);
  /* If delayed reply or no reply OK, suceed immediately */
  if (icl_GetParamValue(t1, all_params, NULL) ||
      icl_GetParamValue(t2, all_params, NULL) ||
      icl_GetParamValue(t3, all_params, NULL)) {

    if (solutions) {
      *solutions = icl_CopyTerm(goal);
    }
    requestees = icl_NewList(NULL);
    solvers = icl_NewList(NULL);
  }
  else {
    /* otherwise wait for solutions to return */
    ICLTerm *result;
    ICLTerm *ev_reply_solved_term;
    ev_reply_solved_term = icl_NewStruct("ev_solved", 6,
                                         icl_CopyTerm(goal_id),
                                         icl_CopyTerm(dummyvar),
                                         icl_CopyTerm(dummyvar),
                                         icl_CopyTerm(dummyvar),
                                         icl_CopyTerm(dummyvar),
                                         icl_CopyTerm(dummyvar));
    /* Never used */
    /* icl_param_arg("priority", icl_CopyTerm(dummyvar), all_params, &p);*/

    /*
     * in prolog:
     * ev_solved(GoalId, Requestees, Solvers, Goal, SolvedParams, Solutions),
     */
    if (oaa_poll_until_event(ev_reply_solved_term, &result)) {
      if (icl_IsStruct(result) && (icl_Arity(result) == 6)) {
        requestees = icl_CopyTerm(icl_NthTerm(result, 2));
        solvers = icl_CopyTerm(icl_NthTerm(result, 3));
        solved_params = icl_CopyTerm(icl_NthTerm(result, 5));
        if(*solutions != NULL) {
          icl_Free(*solutions);
        }
        *solutions = icl_CopyTerm(icl_NthTerm(result, 6));
        icl_Free(result);
        if (icl_ListLen(*solutions)>0) {
          res = TRUE;
        }
        if (!icl_Unify(global_params, solved_params, NULL)) {
          char *debugStr = icl_NewStringFromTerm(solved_params);
          printf("%s: %s %s\n  %s: %s\n", "WARNING",
                 "Params in solved event don't unify",
                 "with original params", "SolvedParams",
                 debugStr);
          icl_stFree(debugStr);
        }
      }
    }
    icl_Free(ev_reply_solved_term);
  }
  icl_Free(t1); icl_Free(t2); icl_Free(t3);

  if (res) {
    /* Return Solvers if requested: */
    if (out_params) {
      *out_params = icl_CopyTerm(global_params);
      t1 = icl_NewStruct("get_satisfiers", 1, icl_CopyTerm(solvers));
      icl_replace_param_value(t1, *out_params);
      icl_Free(t1);

      /* Return Requestees if requested: */
      t1 = icl_NewStruct("get_address", 1, icl_CopyTerm(requestees));
      icl_replace_param_value(t1, *out_params);
      icl_Free(t1);

      // return direct connect status if requested
      if (direct_connect_used) {
        icl_replace_param_value(get_direct_connect_used_true,*out_params);
      }
      else {
        icl_replace_param_value(get_direct_connect_used_false,*out_params);
      }
    }
  }
  icl_Free(solved_params);
  icl_Free(solvers);
  icl_Free(requestees);
  icl_Free(dummyvar);
  icl_Free(all_params);
  icl_Free(post_params);
  icl_stFree(ConnectionId);
  return res;

} // end of oaa_cont_solve_direct()

/*
 *
 */
static int oaa_cont_plan(ICLTerm *goal_id,
                         ICLTerm *templateGoal,
                         ICLTerm *actualGoal,
                         ICLTerm *global_params,
                         ICLTerm **solutions,
                         ICLTerm **out_params) {
  int answer = FALSE;
  ICLTerm *result = NULL;
  ICLTerm *ev_reply_planned_term = NULL;
  ICLTerm *t1 = NULL;
  ICLTerm *t2 = NULL;
  ICLTerm *t3 = NULL;
  ICLTerm *SingleAgentAddress = NULL;

  t1 = icl_NewStruct("ev_plan", 3,
                     icl_CopyTerm(goal_id),
                     icl_CopyTerm(templateGoal),
                     icl_CopyTerm(global_params));
  t2 = icl_NewStruct("connection_id", 1, icl_NewStr("parent"));
  t3 = icl_NewList(NULL);
  icl_AddToList(t3,t2,TRUE);

  oaa_PostEvent(t1, t3);

  ev_reply_planned_term = icl_NewStruct("ev_planned", 4,
                                         icl_NewVar("_"),
                                         icl_CopyTerm(templateGoal),
                                         icl_NewVar("_"),
                                         icl_NewVar("_"));

  oaa_poll_until_event(ev_reply_planned_term, &result);


 if (oaa_get_single_address_from_plan(result, &SingleAgentAddress)) {
   answer = oaa_cont_solve_direct(goal_id, actualGoal, SingleAgentAddress, global_params, solutions, out_params);
 }
 else {
   // not suitable for direct connect
   answer = oaa_cont_solve_direct(goal_id, actualGoal, NULL, global_params, solutions, out_params);
 }

   icl_Free(SingleAgentAddress);
   icl_Free(ev_reply_planned_term);
   icl_Free(t1);
   icl_Free(t3);
   icl_Free(result);

   return answer;

} // end of oaa_cont_plan

EXPORT_MSCPP
int EXPORT_BORLAND
oaa_Disconnect(char* ConnectionId, ICLTerm *Params) {
  // next line is used to eliminate a gcc compile
  // warning on Linux...warnings are now treated as errors
  (void)Params;

  return com_Disconnect(ConnectionId);
} // end of oaa_Disconnect

/*
 *
 */
static int oaa_get_single_address_from_plan(ICLTerm *ev_planned_term,
                                            ICLTerm **SingleAgentAddress) {
  ICLTerm *AgentAddressList = icl_NthTerm(icl_NthTerm(ev_planned_term, 4), 1);
  int answer = FALSE;
  *SingleAgentAddress = NULL;

  if (AgentAddressList != NULL &&
      icl_IsList(AgentAddressList) &&
      icl_ListLen(AgentAddressList) == 1) {
    *SingleAgentAddress = icl_CopyTerm(icl_NthTerm(AgentAddressList, 1));
    answer = TRUE;
    if(!icl_IsValid(ev_planned_term) ||
       !icl_IsValid(AgentAddressList) ||
       !icl_IsValid(*SingleAgentAddress)) {
      ev_planned_term = NULL;
      ev_planned_term->magic_cookie = 0;
    }
  }

  return answer;

} // end of oaa_get_single_address_from_plan


/*
 *
 */
static int oaa_handshake(char *ConnectionId, char *InitialAgentName, ICLTerm *Params) {
  int isClient = TRUE;
  ICLTerm *ConnEvent = NULL;
  ICLTerm *EventTerm = NULL;
  ICLTerm* agent_name_cmdline = NULL;
  ICLTerm *myId = NULL;
  ICLTerm *t1   = NULL;
  char *AgentName = NULL;
  char     buf[1000];
  int result = TRUE;
  ICLTerm* usePassword = NULL;
  ICLTerm* passwordTerm = NULL;
  char* password = NULL;
  ICLTerm* reconnectMatcher = icl_NewStruct("reconnect", 1, icl_NewVar("true"));
  int isReconnect = FALSE;
  (void)Params;

  memset(buf, 0, 1000);

  /* Creates oaa_saved_events */
  if (oaa_saved_events==NULL) {
    oaa_saved_events = icl_NewList(NULL);
  }

  /* Determine whether connection is server or client type */
  isClient = isClientConnection(ConnectionId);
  isReconnect = icl_Member(reconnectMatcher, Params, NULL);
  icl_Free(reconnectMatcher);

  /* Uses the command line info to figure out wether the
     agent's name should be changed
  */
  oaa_ResolveVariable("-oaa_name", &agent_name_cmdline);
  if(agent_name_cmdline) {
    AgentName = icl_NewStringFromTerm(agent_name_cmdline);
  }
  else {
    AgentName = strdup(InitialAgentName);
  }

  icl_stFixQuotes(AgentName); //icl_stRemovesQuotes() is deprecated...

  com_AddInfo(ConnectionId,
        (t1 = icl_NewStruct("oaa_name",
          1,
          icl_NewStr(AgentName))));
  icl_Free(t1);

  if (isClient) {   /* CLIENT AGENT */
    ICLTerm* ev_connect;
    /* Makes sure the local database has been created */
    if(!db_IsValid(local_db))
      local_db = db_NewDB();

    oaa_ResolveVariable("use_password", &usePassword);

    if(usePassword != NULL) {
      if(icl_IsStr(usePassword) && 
         (strlen(icl_Str(usePassword)) == 4) &&
         (strncmp(icl_Str(usePassword), "true", 4) == 0)) {
        oaa_ResolveVariable("client_password", &passwordTerm);
        if(passwordTerm != NULL) {
          password = icl_NewStringFromTerm(passwordTerm);
        }
        else {
          password = strdup("_");
        }
      }
    }

    /* Handshaking with Facilitator -- exchange information...
     *  note: for this first communication, no format is defined for the
     *  connection, so it will be sent using default (ascii) format.
     *  Information coming back from Facilitator will update the
     *  format() field for the connection, possibly improving future
     *  communication (if the comm library support it -- libcom_tcp doesn't.
     */

    if(password != NULL) {
      sprintf(buf, "event(ev_connect([other_name('%s'),"
              "other_language(c),other_type(client),"
              "other_version(%s),password(%s)]),[])",
              AgentName, oaa_library_version_str, password);
      icl_stFree(password);
    }
    else {
      sprintf(buf, "event(ev_connect([other_name('%s'),"
              "other_language(c),other_type(client),"
              "other_version(%s)]),[])",
              AgentName, oaa_library_version_str);
    }
    ev_connect = icl_NewTermFromString(buf);
    if(isReconnect) {
      ICLTerm* connectParams = icl_NthTerm(icl_NthTerm(ev_connect, 1), 1);
      ICLTerm* reconnectTerm;
      ICLTerm* nameTerm;
      ICLTerm* addressTerm;
      ICLTerm* reconnectMatcher = icl_NewStruct("reconnect", 1, icl_NewVar("_"));
      ICLTerm* nameMatcher = icl_NewStruct("other_name", 1, icl_NewVar("_"));
      ICLTerm* addressMatcher = icl_NewStruct("other_address", 1, icl_NewVar("_"));
      if(!icl_Member(reconnectMatcher, Params, &reconnectTerm)) {
        fprintf(stderr, "Reconnecting handshake requires reconnect(_) in Params, but none found");
      }
      else {
        icl_AddToList(connectParams, reconnectTerm, FALSE);
      }
      if(!icl_Member(nameMatcher, Params, &nameTerm)) {
        fprintf(stderr, "Reconnecting handshake requires other_name(_) in Params, but none found");
      }
      else {
        icl_AddToList(connectParams, nameTerm, FALSE);
      }
      if(!icl_Member(addressMatcher, Params, &addressTerm)) {
        fprintf(stderr, "Reconnecting handshake requires other_addres(_) in Params, but none found");
      }
      else {
        icl_AddToList(connectParams, addressTerm, FALSE);
      }
    }
    com_SendTerm(ConnectionId, ev_connect);
    icl_Free(ev_connect);

    // Get the connection acknowledgement from the same ConnectionId.
    // A timeout of 0.0 means we'll block on this socket.
    com_GetEventFromConnection(ConnectionId, 0.0, &EventTerm);

    ConnEvent = icl_NthTerm(icl_NthTerm(EventTerm, 1), 1);
    
    t1 = icl_NewStruct("ev_connected",
                       1,
                       icl_NewVar("FacInfoList"));
    if(icl_Unify(ConnEvent, t1, NULL)) {
      if(icl_IsStruct((icl_NthTerm(ConnEvent, 1)))) {
        ICLTerm* resStruct = icl_NthTerm(ConnEvent, 1);
        char* functor = icl_Functor(resStruct);
        if(functor != NULL) {
          if((strlen(functor) == 9) &&
             (strncmp(functor, "exception", 9) == 0)) {
            char* exceptionData = icl_NewStringFromTerm(icl_NthTerm(resStruct, 1));
            fprintf(stderr, "Exception in oaa_handlshake: %s\n", exceptionData);
            icl_stFree(exceptionData);
            result = FALSE;
          }
        }
      }

      if(result != FALSE) {
        com_UpdateInfo(ConnectionId, icl_NthTerm(ConnEvent, 1));
      }
    }
    else {
      printf("oaa_handshake no ev_connected\n");
      result = FALSE;
    }

    icl_Free(t1);
    icl_Free(EventTerm);
  }
  else {    /* FACILITATOR */

    /* Add the agent's name and ID to the connection info
     * For a client agent, this is done through handshaking with the
     * faciliator.
     */
    com_AddInfo(ConnectionId,
    (t1 = icl_NewStruct("oaa_name",
                        1,
                        icl_NewStr(AgentName))));
    icl_Free(t1);

    /* A Facilitator's ID is always 0.
     */
    com_AddInfo(ConnectionId,
    (t1 = icl_NewStruct("oaa_id", 1, icl_NewInt(0))));
    icl_Free(t1);

    result = oaa_PrimaryAddress(&myId);

    /* I didn't do anything about the following comment.  If we ever
     * have a Facilitator written in C, this might cause a problem
     * and should be looked into...
     *
     * The fac. records its own agent_data in the same way as its clients'.
     * Note that we can't call oaa_add_data_local until after the solvables
     * have been declared, and we can't declare solvables until we're
     * open - so we have to bootstrap this assertion:
     *
     * oaa_assertz(agent_data(AgentId, open, [], AgentName), AgentId)
     */
  }
  icl_stFree(agent_name_cmdline);
  icl_stFree(AgentName);
  return result;
} // end of oaa_handshake

EXPORT_MSCPP
int EXPORT_BORLAND
oaa_SetupCommunication(char *InitialAgentName) {
    ICLTerm *RequestedAddress = NULL;
    ICLTerm* var;
    char *requestedAddressString;

    var = icl_NewVar("_");
    if (!oaa_Connect("parent", var, InitialAgentName, ICL_EMPTY)) {
      icl_Free(var);
      return FALSE;
    }
    icl_Free(var);

    oaa_ResolveVariable("oaa_listen", &RequestedAddress);   // setup file
    requestedAddressString = getenv("OAA_LISTEN");          // env var
    if (requestedAddressString) {
        RequestedAddress = icl_NewTermFromString(requestedAddressString);
    }
    oaa_ResolveVariable("-oaa_listen", &RequestedAddress);  // cmd line

    if (RequestedAddress != NULL) {
        if (com_ListenAt("client_listener", NULL, RequestedAddress)) {
            char *tmp = icl_NewStringFromTerm(RequestedAddress);
            printf("Agent listening at %s\n", tmp);
            icl_stFree(tmp);
        }
        else {
            printf("Unable to open a client listener connection;");
            printf(" continuing without it\n");
        }
        icl_Free(RequestedAddress);
    }
    return TRUE;
} //end of oaa_SetupCommunication

int oaa_SeqNumLessThan(int a, int b)
{
  if(a < b) {
    return (b - a) <= (2147483647 / 3);
  }
  else {
    return (a - b) >= ((2147483647 / 3) * 2);
  }
}

int oaa_version_atleast(int major, int minor, int level, ICLTerm* toCheck)
{
  int size;
  if(!icl_IsList(toCheck)) {
    return FALSE;
  }

  size = icl_NumTerms(toCheck);
  if(size > 0) {
    ICLTerm* majorTerm = icl_NthTerm(toCheck, 1);
    int majorCheck = icl_Int(majorTerm);
    if(majorCheck > major) {
      return TRUE;
    }
    else if(majorCheck < major) {
      return FALSE;
    }
    else if(size > 1) {
      ICLTerm* minorTerm = icl_NthTerm(toCheck, 2);
      int minorCheck = icl_Int(minorTerm);
      if(minorCheck > minor) {
        return TRUE;
      }
      else if(minorCheck < minor) {
        return FALSE;
      }
      else if(size > 2) {
        ICLTerm* levelTerm = icl_NthTerm(toCheck, 3);
        int levelCheck = icl_Int(levelTerm);
        if(levelCheck >= level) {
          return TRUE;
        }
        else {
          return FALSE;
        }
      }
    }
    else {
      return minor < 0;
    }
  }
  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
oaa_SupportsSequenceNumbers(char* connectionId)
{
  ICLTerm* otherVersionTerm;
  ICLTerm* toMatch = icl_NewStruct("other_version", 1, icl_NewVar("_"));
  ICLTerm* versionList;
  int result = FALSE;
  if(!com_GetInfo(connectionId, toMatch, &otherVersionTerm)) {
    goto finally;
  }
  
  versionList = icl_NthTerm(otherVersionTerm, 1);
  result = oaa_version_atleast(2, 3, 3, versionList);

finally:
  icl_Free(toMatch);
  icl_Free(otherVersionTerm);
  return result;
}

// doxygen content

---