libdb.c

Go to the documentation of this file.

/****************************************************************************
 *   File    : libdb.c
 *   Author  : Adam Cheyer
 *   Purpose : Contains C version of Prolog database
 *   Updated : 3/1/98
 */
/*
 * 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
 */

#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/libdb.c,v 1.22 2006/10/29 22:36:50 agno Exp $";*/
#endif


#define DB_MAGIC_COOKIE 123456

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

#include <stdio.h>
//#include <malloc.h>
#include "libdb.h"
#include "libicl_private.h"

int OAA_hash_function(char *str)
{
  int i = 0;

  while (str && *str) {
    i = i + *str;
    str = str + 1;
  }

  return(i % DB_HASH_TABLE_SIZE);
}


int
db_IsValid(ICLDatabase *db)
{
  if (db && (db->magic_cookie == DB_MAGIC_COOKIE))
    return TRUE;
  else {
    /* DEBUG */
    /*
      printf("Warning!  Trying to perform operation on uninitialized DB.\n");
    */
    return FALSE;
  }
}


EXPORT_MSCPP
ICLDatabase *  EXPORT_BORLAND
db_NewDB()
{
  int i;
  ICLDatabase *db = malloc(sizeof(ICLDatabase));

  db->magic_cookie = DB_MAGIC_COOKIE;
  for (i = 0; i < DB_HASH_TABLE_SIZE; i++)
    db->row[i] = NULL;
  return db;
}



EXPORT_MSCPP
int EXPORT_BORLAND
db_FreeDB(ICLDatabase *db)
{
  int i;

  if (db) {
    for (i = 0; i < DB_HASH_TABLE_SIZE; i++) {
      ICLListType *list = db->row[i];
      ICLListType *next;
      while (list) {
  next = list->next;
  icl_Free(list->elt);
  free(list);
  list = next;
      }
      db->row[i] = NULL;
    }
    free(db);
    return TRUE;
  }
  else return FALSE;
}



EXPORT_MSCPP
int EXPORT_BORLAND
db_Assert(ICLDatabase *db, ICLTerm *term, ICLTerm *params)
{
  if (icl_IsStruct(term) && db_IsValid(db)) {
    int index;

    index = OAA_hash_function(icl_Functor(term));

    /* If first element added to row */
    if (db->row[index] == NULL) {
      ICLTerm* copy = icl_CopyTerm(term);
      db->row[index] = icl_NewCons(copy, NULL);
      /*db_PrintDB(db);*/
      CHECK_LEAKS();
    }
    else {
      /* if adding at beginning of row */
      if (icl_ParamValue("at_beginning", ICL_TRUE, params, NULL)) {
        db->row[index] = icl_NewCons(icl_CopyTerm(term), db->row[index]);
      }
      else {
  ICLListType *p = db->row[index];
        /* Loop to end of current row */
  while (p->next)
    p = p->next;
  p->next = icl_NewCons(icl_CopyTerm(term), NULL);
      }
    }

    return TRUE;
  }
  else return FALSE;
}


EXPORT_MSCPP
int EXPORT_BORLAND
db_Retract(ICLDatabase *db, ICLTerm *term, ICLTerm *params)
{
  if (icl_IsStruct(term) && db_IsValid(db)) {
    int index = OAA_hash_function(icl_Functor(term));
    ICLListType *prev = NULL, *list;
    int found;
    int doAll = icl_ParamValue("do_all", ICL_TRUE, params, NULL);

    list = db->row[index];

    do {
      found = icl_Unify(list->elt, term, NULL);

      if (found) {
  /* first element of list */
  if (prev == NULL) {
    db->row[index] = list->next;
  }
  else {
    prev->next = list->next;
  }

  /*
          icl_Free(list);
  */
  icl_Free(list->elt);
  free(list);
  list = db->row[index];
      }
      else {
  prev = list;
  list = list->next;
      }

    } while ((!found || doAll) && list);

    return found;
  }
  else return FALSE;
}



EXPORT_MSCPP
int EXPORT_BORLAND
db_Solve(ICLDatabase *db, ICLTerm *term, ICLTerm *params, ICLTerm **answers)
{
  if (icl_IsStruct(term) && db_IsValid(db)) {
    int index = OAA_hash_function(icl_Functor(term));
    ICLListType *list, *p = (ICLListType *)NULL;
    int found;
    gint64 solutionLimit = 0;
    int n = 0;

    list = db->row[index];

    /* No information */
    if (!list)
      return FALSE;

    if (!icl_ParamValueAsInt("solution_limit", params, &solutionLimit))
      solutionLimit = 30000;

    if (answers)
      *answers = icl_NewList(NULL);

    do {
      found = icl_Unify(list->elt, term, NULL);

      if (found) {

        /* If first addition, connect to *answers */
        if (!p) {
          if (answers) {
            p = icl_NewCons(icl_CopyTerm(list->elt), NULL);
            (*answers)->p = p;
          }
          n = n + 1;
        }
        /* for other additions, add to last element (p) */
        else {
          if(answers) {
            p->next = icl_NewCons(icl_CopyTerm(list->elt), NULL);
            p = p->next;
          }
        }
      }
      list = list->next;

    } while ((n < solutionLimit) && list);

    return TRUE;
  }
  else return FALSE;
}


EXPORT_MSCPP
int EXPORT_BORLAND
db_PrintDB(ICLDatabase *db)
{
  if (db_IsValid(db)) {
    ICLListType *p;
    int i;

    printf("******* Print DB *********\n");

    for (i = 0; i < DB_HASH_TABLE_SIZE; i++) {
      p = db->row[i];
      while (p != NULL) {
  printf("p: %p p->elt: %p ", p, p->elt);
  icl_WriteTerm(p->elt);
  printf("\n");
  p = p->next;
      }
    }

    return TRUE;
  }
  else return FALSE;
}

---