libicl.c

Go to the documentation of this file.

/****************************************************************************
 *   File    : libicl.c
 *   Author  : Adam Cheyer
 *   Purpose : Contains C version of ICL constructor and accessor routines
 *   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
 */

#define EXPORT_BORLAND

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

/****************************************************************************
 * RCS Header
 ****************************************************************************/
#ifndef lint
/*char *rcsid= "$Header: /home/zuma1/OAA/CVSRepository/oaa2/src/oaalib/c/src/libicl.c,v 1.52 2006/12/11 13:32:30 agno Exp $";*/
#endif


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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <malloc.h>
#include <stdarg.h>   /* Variable length argument lists */
#include <ctype.h>
#include "libicl.h"
#include "libutils.h"
#include "libicl_private.h"
#include "libicl_depr.h"
#include "stdpccts.h"

#ifdef _WINDOWS
#include "oaa-windows.h"
#endif

/****************************************************************************
 * Global variables and definitions
 ****************************************************************************/

extern char* ICLDATAQSTART;
extern size_t ICLDATAQSTARTLEN;
static int rename_vars_index;

#ifndef STREQ
#define STREQ(str1, str2) (strcmp((str1), (str2)) == 0)
#endif

#ifdef NORMAL_GC
char* gc_strdup(char* s)
{
  int i = strlen(s);
  char* p = (char*)malloc(i + 1);
  strcpy(p, s);
  p[i] = '\0';
  return p;
}
#endif

/*****************************************************************************
 * Local utility routines for dynamic arrays (used for unification)
 *****************************************************************************/

/****************************************************************************
 * Forward references for some static functions
 ****************************************************************************/
static void icl_deref(ICLTerm **var, struct dyn_array var_bindings);
static ICLListType *
icl_copy_list_type(ICLListType *list, struct dyn_array *vars);

EXTERN void printDebug(int level, char *str, ...);

/****************************************************************************
 * More forward references
 ****************************************************************************/
static void iclIncRef(ICLTerm* t);
int iclDecRef(ICLTerm* t);
static void icl_FreeTermMulti(ICLTerm *elt, int n, void* pc);

/****************************************************************************
 * name:    iclIncRef
 * purpose: Increment the reference count of a term
 ****************************************************************************/
static void iclIncRef(ICLTerm* t)
{
  t->refCount++;
}

int iclDecRef(ICLTerm* t)
{
  if(t != NULL) {
    t->refCount -= 1;
    return t->refCount;
  }
  return -1;
}

EXPORT_MSCPP
void EXPORT_BORLAND icl_init_const_dyn_array(struct const_dyn_array *da)
{
  (*da).allocated = 0;
  (*da).count = 0;
  (*da).item = NULL;
}
EXPORT_MSCPP
void EXPORT_BORLAND icl_init_dyn_array(struct dyn_array *da)
{
  (*da).allocated = 0;
  (*da).count = 0;
  (*da).item = NULL;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_stIsVar(char *t)
{
  return ((t != NULL) && ((*t == '_') || ((*t >= 'A') && (*t <= 'Z'))));
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_stIsOperation(char *t){
  return icl_stOperationArgs(t, NULL, NULL, NULL);
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_stIsIclDataQ(char* t, size_t len)
{
  static size_t dataqMarkerLen = 0;
  if(dataqMarkerLen == 0) {
    dataqMarkerLen = strlen(ICLDATAQSTART);
  }
  if(len >= 9) {
    if(strncmp(t, ICLDATAQSTART, dataqMarkerLen) == 0) {
      return TRUE;
    }
  }

  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_stIsInt(char *t)
{
  char *p;

  strtol(t, &p, 10);
  return ((p != t) && (*p == '\0'));
}


EXPORT_MSCPP
int EXPORT_BORLAND
icl_stIsFloat(char *t)
{
  char *p;

  strtod(t, &p);
  if (p == t)     /* strtod failed */
    return (FALSE);

  if (*p == '\0')   /* String contains only 1.0 */
    return (TRUE);

  if ((*p == 'E'))
    return (((*(p+1) == '+') ||
             (*(p+1) == '-')) &&
            (atoi(p+2) > 0));
  else return (FALSE);
}

EXPORT_MSCPP
void EXPORT_BORLAND
icl_stUndoubleQuotes(char *s)
{
  char c;
  char cc;
  char* in_ptr;
  char* out_ptr;

  in_ptr = s;
  out_ptr = s;

  while ((c = *in_ptr++) != (char) NULL) {
    cc = *in_ptr;
    if (c == '\'' && cc == c) {
      *out_ptr++ = c;
      in_ptr++;
    } else {
      *out_ptr++ = c;
    }
  }
  *out_ptr++ = '\0';
}

EXPORT_MSCPP
char * EXPORT_BORLAND
icl_stFixQuotes(char *s)
{
  icl_stRemoveQuotes(s);
  icl_stUndoubleQuotes(s);
  return s;
}



EXPORT_MSCPP
char * EXPORT_BORLAND
icl_stDoubleQuotes(char *s)
{
  static char *out_str = 0;
  static int out_str_len = 0;
  char *in_ptr, *out_ptr;
  char c;
  int i = 0;
  int num = 0;
  int new_len;

  /* Count number of ' chars */
  while (i < (int)strlen(s)) {
    if (s[i] == '\'') {
      num++;
    }
    i++;
  }

  new_len = strlen(s) + num + 10;

  /* Reallocate space if necessary */
  if (out_str_len < new_len) {
    if (out_str) {
      icl_stFree(out_str);
    }
    out_str = malloc(new_len);
    out_str_len = new_len;
  }

  /* Copy string to new buffer, doubling ' char */
  in_ptr = s;
  out_ptr = out_str;
  while ((c = *in_ptr++) != 0) {
    if (c == '\'') {
      *out_ptr++ = c;
      *out_ptr++ = c;
    } else {
      *out_ptr++ = c;
    }
  }
  *out_ptr++ = (char) 0;

  return out_str;

}


EXPORT_MSCPP
char * EXPORT_BORLAND
icl_stQuoteForce(char *s)
{
  static char *out_str = 0;
  static int out_str_len = 0;

  /* Code adapted from icl_DoubleQuotes */
  char *in_ptr, *out_ptr;
  char c;
  int i = 0;
  int num = 0;
  int new_len;
  
  /* Count number of ' chars */
  while (i < (int)strlen(s)) {
    if (s[i] == '\'') {
      num++;
    }
    i++;
  }
  
  new_len = strlen(s) + num + 10;
  
  /* Reallocate space if necessary */
  if (out_str_len < new_len) {
    if (out_str) {
      icl_stFree(out_str);
    }
    out_str = malloc(new_len);
    out_str_len = new_len;
  }
  
  /* Copy string to new buffer, doubling ' char, and wrapping in ' */
  in_ptr = s;
  out_ptr = out_str;
  *out_ptr++ = '\'';
  while ((c = *in_ptr++) != 0) {
    if (c == '\'') {
      *out_ptr++ = c;
      *out_ptr++ = c;
    } else {
      *out_ptr++ = c;
    }
  }
  *out_ptr++ = '\'';
  *out_ptr++ = (char) 0;
  
  return (out_str);
}

EXPORT_MSCPP
char * EXPORT_BORLAND
icl_stQuote(char *s)
{
  static char *out_str = 0;
  static int out_str_len = 0;

  if (icl_stIsStr(s))
    return (s);

  /* Code adapted from icl_DoubleQuotes */
  else {
    char *in_ptr, *out_ptr;
    char c;
    int i = 0;
    int num = 0;
    int new_len;

    /* Count number of ' chars */
    while (i < (int)strlen(s)) {
      if (s[i] == '\'') {
        num++;
      }
      i++;
    }

    new_len = strlen(s) + num + 10;

    /* Reallocate space if necessary */
    if (out_str_len < new_len) {
      if (out_str) {
        icl_stFree(out_str);
      }
      out_str = malloc(new_len);
      out_str_len = new_len;
    }

    /* Copy string to new buffer, doubling ' char, and wrapping in ' */
    in_ptr = s;
    out_ptr = out_str;
    *out_ptr++ = '\'';
    while ((c = *in_ptr++) != 0) {
      if (c == '\'') {
        *out_ptr++ = c;
        *out_ptr++ = c;
      } else {
        *out_ptr++ = c;
      }
    }
    *out_ptr++ = '\'';
    *out_ptr++ = (char) 0;

    return (out_str);
  }
}





EXPORT_MSCPP
void EXPORT_BORLAND
icl_stTrim(char *s)
{
  while (s && (*s) && (*s <= ' '))
    strcpy(s, &s[1]);
  while (s && (*s) && (s[strlen(s)-1] <= ' '))
    s[strlen(s)-1] = '\0';
}



EXPORT_MSCPP
void EXPORT_BORLAND
icl_stAppend(char **str1, char *str2)
{
  char *p;
  int str2len = strlen(str2);

  if (!str2 || !*str2) return;

  if (*str1 == NULL) {

    *str1 = (char*)malloc(sizeof(char) * (str2len + 1));
    *str1 = strdup(str2);
    (*str1)[str2len] = '\0';
  }
  else {
    p = malloc(strlen(*str1) + strlen(str2)+1);
    strcpy(p, *str1);
    strcat(p, str2);
    icl_stFree(*str1);
    *str1 = p;
  }
}





static
void icl_rename_vars_termhelper(ICLTerm **term, hthash_table *knownVars)
{
  ICLListType *l;
  char *hashedVal = NULL;

  /* Validate incoming arguments */
  if (icl_IsValid(*term)) {
    if (icl_IsVar(*term)) {
      if((strncmp((*term)->p,"_",1) == 0) &&
         (strlen((*term)->p) == 1)) {
        char tempName[10];
        hashedVal = NULL;
        do {
          sprintf(tempName, "_%d", rename_vars_index++);
        }
        while((hashedVal = (char*)htlookup(tempName, knownVars)) != NULL);
        free((*term)->p);
        (*term)->p = strdup(tempName);
      }
      else {
        hashedVal = (char *)htlookup((char *)((*term)->p), knownVars);
      }
      if(hashedVal != NULL) {
        free((*term)->p);
        (*term)->p = strdup(hashedVal);
      }
      else {
        char tempName[10];
        sprintf(tempName, "_%d", rename_vars_index);
        rename_vars_index++;
        htinsert((char *)((*term)->p),strdup(tempName),knownVars);
        free((*term)->p);
        (*term)->p = strdup(tempName);
      }
    }
    else
      if (((*term)->iclType == icl_list_type) ||
          ((*term)->iclType == icl_group_type) ||
          ((*term)->iclType == icl_struct_type)) {
        l = icl_List(*term);

        while (l) {
          icl_rename_vars_termhelper(&l->elt, knownVars);
          l = l->next;
        }
      }
  }
}

static
void icl_rename_vars_term(ICLTerm **term)
{
  hthash_table knownVars;
  htconstruct_table(&knownVars, 271);
  icl_rename_vars_termhelper(term, &knownVars);
#ifdef NORMAL_GC
  htfree_table(&knownVars,GC_debug_free);
#else
  htfree_table(&knownVars,free);
#endif
}


/*****************************************************************************
 * Trace and error messages
 *****************************************************************************/


/****************************************************************************
 * Structure construction routines
 ****************************************************************************/

struct compoundInfo_s
{
  guint8* preChild;
  size_t preChildLen;
  guint8* postChild;
  size_t postChildLen;
  guint8* preAllButFirst;
  size_t preAllButFirstLen;
  guint8* postAllButLast;
  size_t postAllButLastLen;
  guint8* postPend;
  size_t postPendLen;
  int numChildrenToDo;
  int originalNumChildren;
}
;
typedef struct compoundInfo_s compoundInfo_t;

compoundInfo_t* compoundInfo_new()
{
  compoundInfo_t* res = (compoundInfo_t*)malloc(sizeof(compoundInfo_t));
  memset(res, 0, sizeof(compoundInfo_t));
  return res;
}

int compoundInfo_finished(compoundInfo_t* ci)
{
  if(ci->numChildrenToDo == 0) {
    return TRUE;
  }
  else {
    return FALSE;
  }
}

void compoundInfo_setNumChildren(compoundInfo_t* ci, int n)
{
  ci->numChildrenToDo = n;
  ci->originalNumChildren = n;
}

int compoundInfo_getCurrentChildNum(compoundInfo_t* ci)
{
  return ci->originalNumChildren - ci->numChildrenToDo;
}

void compoundInfo_setPreAllButFirst(compoundInfo_t* ci, guint8* s, size_t len)
{
  ci->preAllButFirst = s;
  ci->preAllButFirstLen = len;
}

void compoundInfo_setPostAllButLast(compoundInfo_t* ci, guint8* s, size_t len)
{
  ci->postAllButLast = s;
  ci->postAllButLastLen = len;
}

void compoundInfo_setPreChild(compoundInfo_t* ci, guint8* s, size_t len)
{
  ci->preChild = s;
  ci->preChildLen = len;
}

void compoundInfo_setPostChild(compoundInfo_t* ci, guint8* s, size_t len)
{
  ci->postChild = s;
  ci->postChildLen = len;
}

void compoundInfo_setPostPend(compoundInfo_t* ci, guint8* s, size_t len)
{
  ci->postPend = s;
  ci->postPendLen = len;
}

guint8* compoundInfo_getPreChild(compoundInfo_t* ci, int i, size_t* len)
{
  if(ci->preAllButFirst != NULL) {
    if(i != 0) {
      *len = ci->preAllButFirstLen;
      return ci->preAllButFirst;
    }
    else {
      *len = 0;
      return NULL;
    }
  }
  else {
    *len = ci->preChildLen;
    return ci->preChild;
  }
}

guint8* compoundInfo_getPostChild(compoundInfo_t* ci, int i, size_t* len)
{
  if(ci->postAllButLast != NULL) {
    if(i != ci->originalNumChildren - 1) {
      *len = ci->postAllButLastLen;
      return ci->postAllButLast;
    }
    else {
      *len = 0;
      return NULL;
    }
  }
  else {
    *len = ci->postChildLen;
    return ci->postChild;
  }
}

guint8* compoundInfo_getPostPend(compoundInfo_t* ci, size_t* len)
{
  *len = ci->postPendLen;
  return ci->postPend;
}

void compoundInfo_childFinished(compoundInfo_t* ci)
{
  --(ci->numChildrenToDo);
}

int icl_toWireString(ICLTerm* t, char** termAsString, size_t* termAsStringLen)
{
  GByteArray* bytes = g_byte_array_new();
  GPtrArray* compoundList = g_ptr_array_new();
  GPtrArray* workingList = g_ptr_array_new();
  ICLTerm* currentTerm = NULL;
  compoundInfo_t* sentinel;
  compoundInfo_t* ci;
  compoundInfo_t* currentCompound;
  char startChar;
  char* separator;
  int childNum;
  guint8* tmpData;
  size_t tmpLen;
  int numberLen;
  int isCompound;
  int numArgs;
  char* functor;
  int zeroLenCompound = FALSE;
  int compoundSize = 0;
  int i;
  unsigned int ui;

  /*
  {
    char* ds = icl_NewStringFromTerm(t);
    printf("icl_toWireString() working on %s\n", ds);
    icl_stFree(ds);
  }
  */

  g_ptr_array_add(workingList, t);

  sentinel = compoundInfo_new();
  sentinel->numChildrenToDo = 1;
  sentinel->originalNumChildren = 1;
  g_ptr_array_add(compoundList, sentinel);

  while((compoundList->len > 0) ||
        (workingList->len > 0)) {
    zeroLenCompound = FALSE;
    currentTerm = (ICLTerm*)g_ptr_array_index(workingList, workingList->len - 1);
    (void)g_ptr_array_remove_index(workingList, workingList->len - 1);
    currentCompound = (compoundInfo_t*)g_ptr_array_index(compoundList, compoundList->len - 1);
    childNum = compoundInfo_getCurrentChildNum(currentCompound);
    tmpData = compoundInfo_getPreChild(currentCompound, childNum, &tmpLen);
    if(tmpData != NULL) {
      g_byte_array_append(bytes, tmpData, tmpLen);
    }
    switch(currentTerm->iclType) {
    case icl_list_type:
      g_byte_array_append(bytes, (guint8*)"[", 1);
      numArgs = icl_NumTerms(currentTerm);
      ci = compoundInfo_new();
      compoundInfo_setPostPend(ci, (guint8*)"]", 1);
      compoundInfo_setNumChildren(ci, numArgs);
      compoundInfo_setPreAllButFirst(ci, (guint8*)",", 1);
      g_ptr_array_add(compoundList, ci);
      isCompound = TRUE;
      break;
    case icl_group_type:
      icl_GetGroupChars(currentTerm, &startChar, &separator);
      icl_stFree(separator);
      g_byte_array_append(bytes, (guint8*)&startChar, 1);
      numArgs = icl_NumTerms(currentTerm);
      ci = compoundInfo_new();
      switch(startChar) {
      case '{':
        compoundInfo_setPostPend(ci, (guint8*)"}", 1);
      default:
        compoundInfo_setPostPend(ci, (guint8*)")", 1);
      }
      compoundInfo_setNumChildren(ci, numArgs);
      compoundInfo_setPreAllButFirst(ci, (guint8*)",", 1);
      g_ptr_array_add(compoundList, ci);
      isCompound = TRUE;
      break;
    case icl_struct_type:
      functor = icl_Functor(currentTerm);
      numArgs = icl_NumTerms(currentTerm);
      ci = compoundInfo_new();
      g_byte_array_append(bytes, (guint8*)functor, strlen(functor));
      g_byte_array_append(bytes, (guint8*)"(", 1);
      compoundInfo_setPostPend(ci, (guint8*)")", 1);
      compoundInfo_setNumChildren(ci, numArgs);
      compoundInfo_setPreAllButFirst(ci, (guint8*)",", 1);
      g_ptr_array_add(compoundList, ci);
      isCompound = TRUE;
      break;
    case icl_int_type:
    case icl_float_type:
    case icl_str_type:
    case icl_var_type:
    case icl_dataq_type:
      isCompound = FALSE;
      numArgs = 0;
      break;
    default:
      fprintf(stderr, "libicl.c icl_toWireString() unknown type [%i] in term at %p\n", currentTerm->iclType, currentTerm);
      return FALSE;
    }

    if(isCompound) {
      ICLTerm* toAdd;
      /*
      printf("Found compound with %i args; compoundList has %i elements\n", numArgs, compoundList->len);
      */
      if(numArgs > 0) {
        for(i = numArgs - 1; i >= 0; --i) {
          toAdd = icl_NthTerm(currentTerm, i + 1);
          g_ptr_array_add(workingList, toAdd);

          {
            char* ds = icl_NewStringFromTerm(toAdd);
            //printf("Added child [%s] at index %i to workingList; workingList length = %i\n", ds, i, workingList->len);
            icl_stFree(ds);
          }

        }
        continue;
      }
      else {
        zeroLenCompound = TRUE;
      }
    }

    compoundSize = compoundList->len;
    currentCompound = (compoundInfo_t*)g_ptr_array_index(compoundList, compoundList->len - 1);
    if(!zeroLenCompound) {
      switch(currentTerm->iclType) {
      case icl_int_type:
        numberLen = snprintf(NULL, 0, get64BitFormat(), *((gint64*)currentTerm->p));
        if(numberLen < 0) {
          numberLen = 128;
        }
        tmpData = (guint8*)malloc(numberLen + 1);
        numberLen = snprintf((char*)tmpData, numberLen + 1, get64BitFormat(), *((gint64*)currentTerm->p));
        if(numberLen < 0) {
          numberLen = 128;
        }
        g_byte_array_append(bytes, tmpData, strlen((char*)tmpData));
        /*
        printf("Wrote %i bytes for integer %s\n", numberLen, tmpData);
        */
        free(tmpData);
        break;
      case icl_float_type:
        numberLen = snprintf(NULL, 0, "%f", *((double*)currentTerm->p));
        if(numberLen < 0) {
          numberLen = 128;
        }
        tmpData = (guint8*)malloc(numberLen + 1);
        numberLen = snprintf((char*)tmpData, numberLen + 1, "%f", *((double*)currentTerm->p));
        if(numberLen < 0) {
          numberLen = 128;
        }
        g_byte_array_append(bytes, tmpData, strlen((char*)tmpData));
        /*
        printf("Wrote %i bytes for float %s\n", numberLen, tmpData);
        */
        free(tmpData);
        break;
      case icl_var_type:
        g_byte_array_append(bytes, (guint8*)currentTerm->p, strlen((char*)currentTerm->p));
        /*
        printf("Wrote %i bytes for var %s\n", strlen((char*)currentTerm->p), (char*)currentTerm->p);
        */
        break;
      case icl_str_type:
        if(currentTerm->needsQuotes == 1) {
          tmpData = (guint8*)icl_stQuoteForce((char*)currentTerm->p);
        }
        else {
          tmpData = (guint8*)currentTerm->p;
        }
        g_byte_array_append(bytes, tmpData, strlen((char*)tmpData));

        /* printf("Wrote %i bytes for str %s\n", strlen((char*)currentTerm->p), (char*)currentTerm->p); */

        /* don't free tmpData--I'd rather icl_stQuote returned new memory, but
         * that's not the way it is
         */
        break;
      case icl_dataq_type:
        tmpData = (guint8*)currentTerm->p;
        /* printf("Writing icl_dataq_type of length %i\n", currentTerm->len); */
        g_byte_array_append(bytes, (guint8*)"icldataq(\"", 10);
        for(ui = 0; ui < currentTerm->len; ++ui) {
          if(tmpData[ui] == '"') {
            g_byte_array_append(bytes, (guint8*)"\"\"", 2);
          }
          else {
            g_byte_array_append(bytes, &tmpData[ui], 1);
          }
        }
        g_byte_array_append(bytes, (guint8*)"\")", 2);
        break;
      default:
        fprintf(stderr, "libicl.c icl_toWireString() unknown non-compound type [%i] at %p\n", currentTerm->iclType, currentTerm);
        return FALSE;
      }
      tmpData = compoundInfo_getPostChild(currentCompound, compoundInfo_getCurrentChildNum(currentCompound), &tmpLen);
      if(tmpData != NULL) {
        g_byte_array_append(bytes, tmpData, tmpLen);
      }
      compoundInfo_childFinished(currentCompound);
      /*
      printf("Child finished for current compound\n");
      */
    }
    else {
      /* nothing */
    }

    while(compoundInfo_finished(currentCompound)) {
      tmpData = compoundInfo_getPostPend(currentCompound, &tmpLen);
      if(tmpData != NULL) {
        g_byte_array_append(bytes, tmpData, tmpLen);
        /*
        printf("Wrote %i bytes for postPend on compound %s\n", tmpLen, tmpData);
        */
      }
      (void)g_ptr_array_remove_index(compoundList, compoundList->len - 1);
      free(currentCompound);
      /*
      printf("Compound finished compoundList length = %i\n", compoundList->len);
      */
      if(compoundList->len == 0) {
#ifdef NORMAL_GC
        *termAsString = (char*)malloc(bytes->len);
        memcpy(*termAsString, bytes->data, bytes->len);
        *termAsStringLen = bytes->len;
        g_byte_array_free(bytes, FALSE);
        g_ptr_array_free(compoundList, TRUE);
        g_ptr_array_free(workingList, TRUE);
#else
        *termAsString = (char*)bytes->data;
        *termAsStringLen = bytes->len;
        g_byte_array_free(bytes, FALSE);
        g_ptr_array_free(compoundList, TRUE);
        g_ptr_array_free(workingList, TRUE);
#endif
        return TRUE;
      }
      currentCompound = (compoundInfo_t*)g_ptr_array_index(compoundList, compoundList->len - 1);
      tmpData = compoundInfo_getPostChild(currentCompound, compoundInfo_getCurrentChildNum(currentCompound), &tmpLen);
      if(tmpData != NULL) {
        g_byte_array_append(bytes, tmpData, tmpLen);
      }
      compoundInfo_childFinished(currentCompound);
      /*
      printf("Child finished for current compound (through adding another compound)\n");
      */
    }
  }
  fprintf(stderr, "libicl.c icl_toWireString() This should never be reached\n");
  g_byte_array_free(bytes, TRUE);
  g_ptr_array_free(compoundList, TRUE);
  g_ptr_array_free(workingList, TRUE);
  return FALSE;
}

EXPORT_MSCPP
ICLTerm* EXPORT_BORLAND
icl_NewTermFromData(char* data, size_t len)
{
  ICLTerm* res = parser_getTermFromString(data, len);
  CHECK_LEAKS();
  return res;
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewTermFromString(char* t)
{
  ICLTerm* res = NULL;
  if(t != NULL) {
    res = icl_NewTermFromData(t, strlen(t));
    CHECK_LEAKS();
    return res;
  }
  else {
    return NULL;
  }
}


EXPORT_MSCPP
char * EXPORT_BORLAND
icl_NewStringFromTerm(ICLTerm const*t)
{
  char *res = NULL;
  char* tmp = NULL;
  int tmpBufSz = 0;


  if (t==NULL)
    return NULL;

  /* Make sure the term is OK */
  if (!icl_IsValid(t))
    return NULL;

  if (icl_IsVar(t)) {
    res = strdup(t->p);
  }
  else if (icl_IsInt(t)) {
    tmpBufSz = snprintf(tmp, 0, get64BitFormat(), icl_Int(t));
    if(tmpBufSz < 0) {
      tmpBufSz = 128;
    }
    ++tmpBufSz;
    tmp = (char*)malloc(tmpBufSz * sizeof(char));
    (void)memset(tmp, 0, tmpBufSz);
    snprintf(tmp, tmpBufSz, get64BitFormat(), icl_Int(t));
    res = tmp;
  }
  else if (icl_IsFloat(t)) {
    tmpBufSz = snprintf(tmp, 0, "%f", icl_Float(t));
    if(tmpBufSz < 0) {
      tmpBufSz = 128;
    }
    ++tmpBufSz;
    tmp = (char*)malloc(tmpBufSz * sizeof(char));
    (void)memset(tmp, 0, tmpBufSz);
    snprintf(tmp, tmpBufSz, "%f", icl_Float(t));
    res = tmp;
  }
  else if (icl_IsStr(t)) {
    if(t->needsQuotes == 1) {
      res = strdup(icl_stQuoteForce(t->p));
    }
    else {
      res = strdup(t->p);
    }
  }
  else if(icl_IsDataQ(t)) {
    /* icldataq("") */
    res = (char*)malloc(icl_Len(t) + 1);
    res = memcpy(res, icl_DataQ(t), icl_Len(t));
    res[icl_Len(t)] = '\0';
  }
  else if (icl_IsStruct(t)) {
    int first = TRUE;
    ICLListType *args;

    /* Checks for struct that are operators */
    if (icl_stIsOperator(icl_Functor(t))>0) {
      args = icl_Arguments(t);
      /* Left operand */
      icl_stAppend(&res, icl_NewStringFromTerm(args->elt));
      /* Operator */
      icl_stAppend(&res, icl_Functor(t));
      /* Right operand */
      args = args->next;
      if (args) {
        icl_stAppend(&res, icl_NewStringFromTerm(args->elt));
      }
    }
    else {
      res = strdup(icl_Functor(t));
      args = icl_Arguments(t);
      icl_stAppend(&res, "(");
      while (args) {
        char *arg;
        arg = icl_NewStringFromTerm(args->elt);
        if (first) {
          first = FALSE;
        }
        else {
          icl_stAppend(&res, ",");
        }
        icl_stAppend(&res, arg);
        icl_stFree(arg);
        args = args->next;
      }
      icl_stAppend(&res, ")");
    }
  }
  else if (icl_IsList(t)) {
    int first = TRUE;
    ICLListType *args;
    args = icl_List(t);
    res = strdup("[");
    while (args) {
      char *arg;
      arg = icl_NewStringFromTerm(args->elt);
      if (first)
        first = FALSE;
      else icl_stAppend(&res, ",");
      icl_stAppend(&res, arg);
      icl_stFree(arg);
      args = args->next;
    }
    icl_stAppend(&res, "]");
  }
  else if (icl_IsGroup(t)) {
    int first = TRUE;
    ICLListType *args;
    char start;
    char *separator;

    icl_GetGroupChars(t, &start, &separator);
    args = icl_List(t);
    res = strdup("[");
    res[0] = start;
    while (args) {
      char *arg;
      arg = icl_NewStringFromTerm(args->elt);
      if (first)
        first = FALSE;
      else icl_stAppend(&res, separator);
      icl_stAppend(&res, arg);
      icl_stFree(arg);
      args = args->next;
    }
    icl_stAppend(&res, "]");
    if (start == '(')
      res[strlen(res)-1] = start + 1;  /* () */
    else
      res[strlen(res)-1] = start + 2;  /* {|} and [\] */

    icl_stFree(separator);
  }
  else {
    fprintf(stderr, "Unknown term type for icl_NewStringFromTerm: %i\n", t->iclType);
  }

  return (res);
}

EXPORT_MSCPP
char* EXPORT_BORLAND
icl_UnquotedStringFromStr(ICLTerm* t)
{
  if(!icl_IsStr(t)) {
    return NULL;
  }

  return strdup(t->p);
}

EXPORT_MSCPP
char* EXPORT_BORLAND
icl_ForcedQuotedStringFromStr(ICLTerm* t)
{
  if(!icl_IsStr(t)) {
    return NULL;
  }

  return strdup(icl_stQuoteForce(t->p));
}

EXPORT_MSCPP
char* EXPORT_BORLAND
icl_MinimallyQuotedStringFromStr(ICLTerm* t)
{
  if(!icl_IsStr(t)) {
    return NULL;
  }

  return icl_NewStringFromTerm(t);
}

/****************************************************************************
 * name:    pt
 * purpose: Debug
 ****************************************************************************/

EXPORT_MSCPP
char * EXPORT_BORLAND
pt(ICLTerm *t)
{
  return icl_NewStringFromTerm(t);
}

EXPORT_MSCPP
char * EXPORT_BORLAND
icl_NewStringStructFromTerm(ICLTerm *t)
{
  char* INT64FORMAT = get64BitFormatWrapped("int(", ")");
  int tmpBufSz = 0;
  char *res = NULL;
  char* tmp = NULL;

  /* Make sure the term is OK */
  if (!icl_IsValid(t)) {
    free(INT64FORMAT);
    return NULL;
  }

  if (icl_IsVar(t)) {
    tmpBufSz = snprintf(tmp, 0, "var(%s)", (char*)(t->p));
    ++tmpBufSz;
    tmp = (char*)malloc(tmpBufSz * sizeof(char));
    memset(tmp, 0, tmpBufSz);
    snprintf(tmp, tmpBufSz, "var(%s)", (char*)(t->p));
    res = tmp;
  }
  else if (icl_IsInt(t)) {
    tmpBufSz = snprintf(tmp, 0, INT64FORMAT, icl_Int(t));
    ++tmpBufSz;
    tmp = (char*)malloc(tmpBufSz * sizeof(char));
    memset(tmp, 0, tmpBufSz);
    snprintf(tmp, tmpBufSz, INT64FORMAT, icl_Int(t));
    res = tmp;
  }
  else if (icl_IsFloat(t)) {
    tmpBufSz = snprintf(tmp, 0, "float(%f)", icl_Float(t));
    ++tmpBufSz;
    tmp = (char*)malloc(tmpBufSz * sizeof(char));
    memset(tmp, 0, tmpBufSz);
    snprintf(tmp, tmpBufSz, "float(%f)", icl_Float(t));
    res = tmp;
  }
  else if (icl_IsStr(t)) {
    tmpBufSz = snprintf(tmp, 0, "str(%s)", icl_stQuote(t->p));
    ++tmpBufSz;
    tmp = (char*)malloc(tmpBufSz * sizeof(char));
    memset(tmp, 0, tmpBufSz);
    snprintf(tmp, tmpBufSz, "str(%s)", icl_stQuote(t->p));
    res = tmp;
  }
  else if (icl_IsStruct(t)) {
    int first = TRUE;
    ICLListType *args;
    tmpBufSz = snprintf(tmp, 0, "struct(%s,", icl_Functor(t));
    ++tmpBufSz;
    tmp = (char*)malloc(tmpBufSz * sizeof(char));
    memset(tmp, 0, tmpBufSz);
    snprintf(tmp, tmpBufSz, "struct(%s,", icl_Functor(t));
    res = tmp;
    args = icl_Arguments(t);
    icl_stAppend(&res, "(");
    while (args) {
      char *arg;
      arg = icl_NewStringStructFromTerm(args->elt);
      if (first) {
  first = FALSE;
      }
      else {
  icl_stAppend(&res, ",");
      }
      icl_stAppend(&res, arg);
      icl_stFree(arg);
      args = args->next;
    }
    icl_stAppend(&res, ")");
  }
  else if (icl_IsList(t)) {
    int first = TRUE;
    ICLListType *args;
    args = icl_List(t);
    res = strdup("list([");
    while (args) {
      char *arg;
      arg = icl_NewStringStructFromTerm(args->elt);
      if (first) {
  first = FALSE;
      }
      else {
  icl_stAppend(&res, ",");
      }
      icl_stAppend(&res, arg);
      icl_stFree(arg);
      args = args->next;
    }
    icl_stAppend(&res, "])");
  }
  else if (icl_IsGroup(t)) {
    int first = TRUE;
    ICLListType *args;
    char start;
    char *separator;

    icl_GetGroupChars(t, &start, &separator);
    args = icl_List(t);
    res = strdup("group([");
    while (args) {
      char *arg;
      arg = icl_NewStringStructFromTerm(args->elt);
      if (first) {
  first = FALSE;
      }
      else {
  icl_stAppend(&res, separator);
      }
      icl_stAppend(&res, arg);
      icl_stFree(arg);
      args = args->next;
    }
    icl_stAppend(&res, "])");
    if (start == '(') {
      res[strlen(res)-1] = start + 1;  /* () */
    }
    else {
      res[strlen(res)-1] = start + 2;  /* {|} and [\] */
    }

    icl_stFree(separator);
  }
  free(INT64FORMAT);
  return (res);
}

enum CompoundType {
  compound_sentinel_type,
  compound_struct_type,
  compound_list_type,
  compound_group_type
}
;

struct CompoundInfo
{
  enum CompoundType cType;
  void* p;
  int numArgsExpected;
}
;

struct CompoundStructType
{
  char* functor;
  ICLListType* args;
}
;

struct CompoundListType
{
  ICLListType* args;
}
;

struct CompoundGroupType
{
  char startC;
  char* sep;
  ICLListType* args;
}
;

struct CompoundSentinelType
{
  ICLTerm* term;
}
;

static void icl_add_compound_argument(struct CompoundInfo* ci, ICLTerm* t)
{
  struct CompoundStructType* structCompound;
  struct CompoundListType* listCompound;
  struct CompoundGroupType* groupCompound;

  switch(ci->cType) {
  case compound_struct_type:
    structCompound = (struct CompoundStructType*)ci->p;
    if(!structCompound->args) {
      structCompound->args = icl_NewCons(t, NULL);
    }
    else {
      structCompound->args = icl_NewCons(t, structCompound->args);
    }
    ci->numArgsExpected--;
    break;
  case compound_list_type:
    listCompound = (struct CompoundListType*)ci->p;
    if(!listCompound->args) {
      listCompound->args = icl_NewCons(t, NULL);
    }
    else {
      listCompound->args = icl_NewCons(t, listCompound->args);
    }
    ci->numArgsExpected--;
    break;
  case compound_group_type:
    groupCompound = (struct CompoundGroupType*)ci->p;
    if(!groupCompound->args) {
      groupCompound->args = icl_NewCons(t, NULL);
    }
    else {
      groupCompound->args = icl_NewCons(t, groupCompound->args);
    }
    ci->numArgsExpected--;
    break;
  case compound_sentinel_type:
    ((struct CompoundSentinelType*)ci->p)->term = t;
    ci->numArgsExpected--;
    break;
  default:
    fprintf(stderr, "Unknown compound type\n");
    break;
  }
  if(ci->numArgsExpected < 0) {
    fprintf(stderr, "numArgsExpected < 0\n");
  }
}

EXPORT_MSCPP
ICLTerm *EXPORT_BORLAND
icl_copy_term_nonrec(ICLTerm const* t, struct dyn_array* vars)
{
  struct const_dyn_array termStack;
  struct dyn_array compoundStack;
  ICLTerm* currTerm = NULL;
  struct CompoundInfo* currCompound;
  struct CompoundStructType* structCompound;
  struct CompoundListType* listCompound;
  struct CompoundGroupType* groupCompound;
  struct CompoundSentinelType sentinelCompound;
  struct CompoundInfo sentinelCI;

  if(t == NULL) {
    return NULL;
  }

  icl_init_const_dyn_array(&termStack);
  icl_append_const_dyn_array(&termStack, t);
  icl_init_dyn_array(&compoundStack);
  sentinelCI.p = &sentinelCompound;
  sentinelCI.cType = compound_sentinel_type;
  sentinelCI.numArgsExpected = 1;
  icl_append_dyn_array(&compoundStack, &sentinelCI);
  if(termStack.count == 0) {
    fprintf(stderr, "icl_copy_term_nonrec termStack count is 0!\n");
  }
  while(termStack.count != 0) {
    currTerm = (ICLTerm*)termStack.item[termStack.count - 1];
    termStack.item[termStack.count - 1] = NULL;
    termStack.count--;
    if(vars) {
      icl_deref(&currTerm, *vars);
    }

    if(icl_IsVar(currTerm)) {
      currTerm = icl_NewVar(icl_Str(currTerm));
    }
    else if(icl_IsInt(currTerm)) {
      currTerm = icl_NewInt(icl_Int(currTerm));
    }
    else if(icl_IsFloat(currTerm)) {
      currTerm = icl_NewFloat(icl_Float(currTerm));
    }
    else if(icl_IsStr(currTerm)) {
      currTerm = icl_NewStr(icl_Str(currTerm));
    }
    else if(icl_IsDataQ(currTerm)) {
      currTerm = icl_NewDataQ(icl_DataQ(currTerm), icl_Len(currTerm));
    }
    else if(icl_IsStruct(currTerm)) {
      /* Take the arguments of the struct, and put them into
       * the termStack, in the current order.  Note that this
       * means when we recreate the struct, we have to reverse
       * the order of the arguments!
       */
      struct CompoundInfo* ci = (struct CompoundInfo*)malloc(sizeof(struct CompoundInfo)) ;
      struct CompoundStructType* c = (struct CompoundStructType*)malloc(sizeof(struct CompoundStructType));
      ICLListType* args = icl_Arguments(currTerm);
      ci->p = c;
      ci->cType = compound_struct_type;
      ci->numArgsExpected = 0;
      c->functor = icl_Functor(currTerm);
      c->args = NULL;
      while(args) {
  ci->numArgsExpected++;
  icl_append_const_dyn_array(&termStack, args->elt);
  args = args->next;
      }
      icl_append_dyn_array(&compoundStack, ci);
      if(ci->numArgsExpected > 0) {
  continue;
      }
    }
    else if(icl_IsList(currTerm)) {
      struct CompoundInfo* ci = (struct CompoundInfo*)malloc(sizeof(struct CompoundInfo));
      struct CompoundListType* c = (struct CompoundListType*)malloc(sizeof(struct CompoundListType));
      ICLListType* args = icl_List(currTerm);
      ci->p = c;
      ci->cType = compound_list_type;
      ci->numArgsExpected = 0;
      c->args = NULL;
      while(args) {
  ci->numArgsExpected++;
  icl_append_const_dyn_array(&termStack, args->elt);
  args = args->next;
      }
      icl_append_dyn_array(&compoundStack, ci);
      if(ci->numArgsExpected > 0) {
  continue;
      }
    }
    else if(icl_IsGroup(currTerm)) {
      struct CompoundInfo* ci = (struct CompoundInfo*)malloc(sizeof(struct CompoundInfo));
      struct CompoundGroupType* c = (struct CompoundGroupType*)malloc(sizeof(struct CompoundGroupType));
      ICLListType* args = icl_List(currTerm);
      ci->p = c;
      ci->cType = compound_group_type;
      ci->numArgsExpected = 0;
      c->args = NULL;
      icl_GetGroupChars(currTerm, &(c->startC), &(c->sep));
      while(args) {
  ci->numArgsExpected++;
  icl_append_const_dyn_array(&termStack, args->elt);
  args = args->next;
      }
      icl_append_dyn_array(&compoundStack, ci);
      if(ci->numArgsExpected > 0) {
  continue;
      }
    }
    else if(currTerm == NULL) {
      currTerm = NULL;
    }
    else {
      char* s = icl_NewStringFromTerm(t);
      fprintf(stderr, "Unknown type in icl_copy_term_nonrec: [%s]\n", s);
      icl_stFree(s);
      currTerm = NULL;
    }

    /* currTerm == NULL or some term; add it to the current compound
       info structure
    */

    currCompound = (struct CompoundInfo*)compoundStack.item[compoundStack.count - 1];

    if(currCompound->numArgsExpected > 0) {
      icl_add_compound_argument(currCompound, currTerm);
    }

    while(currCompound->numArgsExpected == 0) {
      switch(currCompound->cType) {
      case compound_struct_type:
  structCompound = (struct CompoundStructType*)currCompound->p;
  currTerm = icl_NewStructFromList(structCompound->functor, icl_NewList(structCompound->args));
  free(structCompound);
  free(currCompound);
  structCompound = NULL;
  currCompound = NULL;
  break;
      case compound_list_type:
  listCompound = (struct CompoundListType*)currCompound->p;
  currTerm = icl_NewList(listCompound->args);
  free(listCompound);
  free(currCompound);
  listCompound = NULL;
  currCompound = NULL;
  break;
      case compound_group_type:
  groupCompound = (struct CompoundGroupType*)currCompound->p;
  currTerm = icl_NewGroup(groupCompound->startC, groupCompound->sep, groupCompound->args);
  free(groupCompound);
  free(currCompound);
  groupCompound = NULL;
  currCompound = NULL;
  break;
      case compound_sentinel_type:
  if(compoundStack.count != 1) {
    fprintf(stderr, "icl_copy_term_nonrec got sentinel but nonempty compoundStack\n");
  }
  if(compoundStack.item != NULL) {
    free(compoundStack.item);
  }
  if(termStack.item != NULL) {
    free(termStack.item);
  }
  CHECK_LEAKS();
  return ((struct CompoundSentinelType*)(currCompound->p))->term;
  break;
      default:
  fprintf(stderr, "icl_copy_term_nonrec got unknown compound type\n");
  if(compoundStack.item != NULL) {
    free(compoundStack.item);
  }
  return NULL;
  break;
      }
      compoundStack.item[compoundStack.count - 1] = NULL;
      compoundStack.count--;
      currCompound = (struct CompoundInfo*)compoundStack.item[compoundStack.count - 1];
      icl_add_compound_argument(currCompound, currTerm);
    }
  }
  icl_WriteTerm(currTerm);
  printf("\n");
  fprintf(stderr, "icl_copy_term_nonrec unreachable\n");
  return NULL;
}

/****************************************************************************
 * name:    icl_copy_term
 * purpose: Creates a copy of the term, all in new memory.
 *      Dereferences variables from binding list if available
 ****************************************************************************/
/*
  EXPORT_MSCPP
  ICLTerm *EXPORT_BORLAND
  icl_copy_term(ICLTerm *t, struct dyn_array *vars)
  {
  ICLTerm *res = NULL;

  if (vars) {
  icl_deref(&t, *vars);
  }

  if (icl_IsVar(t)) {
  res = icl_NewVar(icl_Str(t));
  }
  else if (icl_IsInt(t)) {
  res = icl_NewInt(icl_Int(t));
  }
  else if (icl_IsFloat(t)) {
  res = icl_NewFloat(icl_Float(t));
  }
  else if (icl_IsStr(t)) {
  res = icl_NewStr(icl_Str(t));
  }
  else if (icl_IsStruct(t)) {
  ICLTerm *argList = icl_NewList(icl_copy_list_type(icl_Arguments(t),vars));
  res = icl_NewStructFromList(icl_Functor(t), argList);
  }
  else if (icl_IsList(t)) {
  res = icl_NewList(icl_copy_list_type(icl_List(t),vars));
  }
  else if (icl_IsGroup(t)) {
  char startC, *sep = NULL;
  icl_GetGroupChars(t, &startC, &sep);
  res = icl_NewGroup(startC, sep, icl_copy_list_type(icl_List(t), vars));
  icl_stFree(sep);
  }
  else if (t == NULL) {
  return NULL;
  }
  else {
  fprintf(stderr, "Unknown type in icl_copy_term\n");
  }

  return (res);
  }
*/

static
ICLListType *
icl_copy_list_type(ICLListType *list, struct dyn_array *vars)
{
  ICLListType *res = NULL, *end = NULL;

  while (list) {
    if (!res) {
      ICLTerm* copy = icl_copy_term_nonrec(list->elt, vars);
      res = icl_NewCons(copy, NULL);
      end = res;
    }
    else {
      end->next = icl_NewCons(icl_copy_term_nonrec(list->elt, vars), NULL);
      end = end->next;
    }
    list = list->next;
  }

  return(res);
}



EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_CopyTerm(ICLTerm const*t)
{
  return (icl_copy_term(t, NULL));
}


EXPORT_MSCPP
ICLListType * EXPORT_BORLAND
icl_CopyListType(ICLListType *list)
{
  return(icl_copy_list_type(list, NULL));
}



EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewInt(gint64 i)
{
  ICLTerm *res = malloc(sizeof(ICLTerm));
  gint64 *iptr = malloc(sizeof(gint64));

  *iptr = i;
  res->iclType = icl_int_type;
  res->p = iptr;
  res->magic_cookie = ICL_MAGIC_COOKIE;
  res->len = sizeof(gint64);

  res->refCount = 1;
  res->glibAlloc = 0;
  res->needsQuotes = 0;
  return (res);
}


EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewFloat(double f)
{
  ICLTerm *res = malloc(sizeof(ICLTerm));
  double *fptr = malloc(sizeof(double));

  *fptr = f;
  res->iclType = icl_float_type;
  res->p = fptr;
  res->magic_cookie = ICL_MAGIC_COOKIE;
  res->len = sizeof(double);

  res->refCount = 1;
  res->glibAlloc = 0;
  res->needsQuotes = 0;
  return (res);
}

static char* trimAndStrdup(char const* s)
{
  char const* start;
  char const* end;
  char* result;
  for(start = s; (*start != '\0') && (!isgraph(*start) || isspace(*start)); ++start);
  for(end = s + strlen(s) - 1; (end != start) && (!isgraph(*end) || isspace(*end)); --end);

  result = (char*)malloc(end - start + 1 + 1);
  memcpy(result, start, end - start + 1);
  result[end - start + 1] = '\0';
  return result;
}

static char* trimInPlace(char* s)
{
  char* start;
  char* end;
  for(start = s; (*start != '\0') && (!isgraph(*start) || isspace(*start)); ++start);
  for(end = s + strlen(s) - 1; (end != start) && (!isgraph(*end) || isspace(*end)); --end);

  memmove(s, start, (end - start + 1));
  s[end - start + 1] = '\0';
  
  return s;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_stIsProperlyQuoted(char* s)
{
  int quotesAllowed = 0;
  int originalLen = strlen(s);
  int i;

  if(*s == '\'') {
    if((originalLen > 1) && *(s + originalLen - 1) == '\'') {
      quotesAllowed = 1;
    }
    else {
      return FALSE;
    }
  }

  for(i = 1; i < originalLen - 1; ++i) {
    if(s[i] == '\'') {
      if(!quotesAllowed) {
        return FALSE;
      }
      if(((i + 1) < originalLen - 1) && (s[i + 1] == '\'')) {
        ++i;
        continue;
      }
      else {
        return FALSE;
      }
    }
  }

  return TRUE;
}

static char* unquoteHelper(char const* from, char* to)
{
  size_t index;
  int negativeOffset;
  size_t len = strlen(from);

  if((--len > 0) && (from[0] == '\'')) {
    // result + len points to the last single quote
    for(index = 1, negativeOffset = 1;
        index < len;
        ++index) {
      to[index - negativeOffset] = from[index];
      if(from[index] == '\'') {
        // must be doubled
        ++index;
        ++negativeOffset;
      }
    }
    to[len - negativeOffset] = '\0';
  }

  return to;
}

static char* unquoteInPlace(char* s)
{
  return unquoteHelper(s, s);
}

void icl_setStrFromProperlyQuoted(char* s, ICLTerm* res)
{
  s = unquoteInPlace(s);

  if(s[0] != '\0') {
    ICLTerm* term = icl_NewTermFromString(s);
    res->p = s;
    if(!term) {
      res->needsQuotes = TRUE;
    }
    else if(!icl_IsStr(term)) {
      res->needsQuotes = TRUE;
    }
    else {
      res->needsQuotes = FALSE;
    }
    icl_Free(term);
  }
  else {
    res->p = s;
    res->needsQuotes = FALSE;
  }
}

static void setIclStrValueFromString(char* s, ICLTerm* res)
{
  if(icl_stIsProperlyQuoted(s)) {
    icl_setStrFromProperlyQuoted(s, res);
  }
  else {
    res->needsQuotes = TRUE;
    res->p = s;
  }
  res->len = strlen(res->p);
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewStr(char const*s)
{
  ICLTerm *res = NULL;
  char* stringCopy;

  if(s) {
    res = malloc(sizeof(ICLTerm));
    stringCopy = trimAndStrdup(s);

    res->iclType = icl_str_type;
    res->magic_cookie = ICL_MAGIC_COOKIE;
    res->refCount = 1;
    res->glibAlloc = 0;

    setIclStrValueFromString(stringCopy, res);
  }

  return (res);
}

ICLTerm*
icl_NewStrNoCopy(char *s)
{
  ICLTerm *res = NULL;

  if (s) {
    res = malloc(sizeof(ICLTerm));
    s = trimInPlace(s);

    res->iclType = icl_str_type;
    res->magic_cookie = ICL_MAGIC_COOKIE;
    res->refCount = 1;
    res->glibAlloc = 0;

    setIclStrValueFromString(s, res);
    res->len = strlen(s);
  }

  return (res);
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewVar(char *name)
{
  ICLTerm *res = NULL;

  if (name && *name) {
    res = malloc(sizeof(ICLTerm));

    res->iclType = icl_var_type;
    res->p = strdup(name);
    res->magic_cookie = ICL_MAGIC_COOKIE;
    res->refCount = 1;
    res->glibAlloc = 0;
    res->needsQuotes = 0;
    res->len = strlen(name);
  }

  return (res);
}

ICLTerm *
icl_NewVarNoCopy(char *name)
{
  ICLTerm *res = NULL;

  if (name && *name) {
    res = malloc(sizeof(ICLTerm));

    res->iclType = icl_var_type;
    res->p = name;
    res->magic_cookie = ICL_MAGIC_COOKIE;
    res->refCount = 1;
    res->glibAlloc = 0;
    res->needsQuotes = 0;
    res->len = strlen(name);
  }

  return (res);
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewStructFromList(char const* functor, ICLTerm *args)
{
  ICLTerm       *res = NULL;
  ICLStructType *st = NULL;
  ICLTerm* functorAsTerm = NULL;

  //fprintf(stderr, "ALA:%s:%s:%i functor = %s\n", __FILE__, __PRETTY_FUNCTION__, __LINE__, functor);
    
  functorAsTerm = icl_NewStr(functor);

  if (icl_IsList(args) && functorAsTerm) {

    res = malloc(sizeof(ICLTerm));
    st = malloc(sizeof(ICLStructType));

    st->numArgs = icl_NumTerms(args);
    st->args = args;
    st->functor = functorAsTerm;

    res->iclType = icl_struct_type;
    res->p = st;
    res->magic_cookie = ICL_MAGIC_COOKIE;
    res->refCount = 1;
    res->glibAlloc = 0;
    res->needsQuotes = 0;
    res->len = sizeof(st);
  }

  return (res);
}



EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewStruct(char const* functor, int arity, ...)
{
  ICLTerm *arg,  *res = NULL;

  va_list ap; /* points to each unnamed arg in turn */
  int i=0;

  ICLTerm* functorAsTerm = icl_NewStr(functor);

  //fprintf(stderr, "ALA:%s:%s:%i functor = %s\n", __FILE__, __PRETTY_FUNCTION__, __LINE__, functor);

  if (functorAsTerm) {
    ICLStructType *st = malloc(sizeof(ICLStructType));
    ICLTerm *args;

    res = malloc(sizeof(ICLTerm));

    args = icl_NewList(NULL);

    /* copy args into list */
    va_start(ap, arity);  /* point ap to first unnamed arg */
    for (i=0; i< arity;i++) {
      arg = va_arg(ap, ICLTerm*);
      if (arg) {
        icl_AddToList(args, arg, TRUE);
      }
    }
    va_end(ap);

    st->numArgs = arity;
    st->args = args;
    st->functor = functorAsTerm;

    res->iclType = icl_struct_type;
    res->p = st;
    res->magic_cookie = ICL_MAGIC_COOKIE;
    res->refCount = 1;
    res->glibAlloc = 0;
    res->needsQuotes = 0;
    res->len = sizeof(st);
  }

  return (res);
}


EXPORT_MSCPP
ICLListType * EXPORT_BORLAND
icl_NewCons(ICLTerm *elt, ICLListType *tail)
{
  ICLListType *res = malloc(sizeof(ICLListType));

  res->elt = elt;
  res->next = tail;
  if(elt != NULL) {
    iclIncRef(elt);
  }

  return (res);
}

EXPORT_MSCPP
ICLTerm* EXPORT_BORLAND
icl_NewDataQ(void const* data, size_t dataLen)
{
  ICLTerm* res = malloc(sizeof(ICLTerm));
  res->p = malloc(dataLen);
  if(dataLen > 0) {
    memcpy(res->p, data, dataLen);
  }
  else {
    res->p = NULL;
  }
  res->len = dataLen;
  res->iclType = icl_dataq_type;
  res->magic_cookie = ICL_MAGIC_COOKIE;
  res->refCount = 1;
  res->glibAlloc = 0;
  res->needsQuotes = 0;

  return res;
}

ICLTerm*
icl_NewDataQNoCopy(void* data, size_t dataLen)
{
  ICLTerm* res = malloc(sizeof(ICLTerm));
  res->p = data;
  res->len = dataLen;
  res->iclType = icl_dataq_type;
  res->magic_cookie = ICL_MAGIC_COOKIE;
  res->refCount = 1;
  res->glibAlloc = 0;
  res->needsQuotes = 0;

  return res;
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewGroup(char startC, char *separator, ICLListType *list)
{
  ICLTerm *res = malloc(sizeof(ICLTerm));
  ICLGroupType *gp = malloc(sizeof(ICLGroupType));

  res->iclType = icl_group_type;
  gp->startChar = startC;
  gp->separator = strdup(separator);
  gp->list = list;
  res->p = gp;
  res->magic_cookie = ICL_MAGIC_COOKIE;
  res->refCount = 1;
  res->glibAlloc = 0;
  res->needsQuotes = 0;
  res->len = sizeof(gp);

  return (res);
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_NewList(ICLListType *list)
{
  ICLTerm *res = malloc(sizeof(ICLTerm));

  res->iclType = icl_list_type;
  res->p = list;
  res->magic_cookie = ICL_MAGIC_COOKIE;
  res->refCount = 1;
  res->glibAlloc = 0;
  res->needsQuotes = 0;
  res->len = sizeof(list);

  return (res);
}


EXPORT_MSCPP
void EXPORT_BORLAND
icl_FreeTermSingle(ICLTerm *elt)
{
  /* void* pc = current_text_addr(); */
  icl_FreeTermMulti(elt,0,0);
}

EXPORT_MSCPP
void EXPORT_BORLAND
icl_FreeTerm(ICLTerm *elt)
{
  icl_FreeTermMulti(elt,0,0);
}

EXPORT_MSCPP
void EXPORT_BORLAND
icl_stFree(void *p) {
  if (p) {
#ifdef NORMAL_GC
    GC_debug_free(p); p = 0;
#else
  free(p); p = 0;
#endif
  }
}

/****************************************************************************
 * name:    icl_FreeTermMulti
 * purpose: Frees all memory used by an object ptr
 * remarks: Use icl_Free() macro, which then sets the pointer to NIL
 ****************************************************************************/
static void
icl_FreeTermMulti(ICLTerm *elt, int n, void* pc)
{
#ifdef NORMAL_GC
  CHECK_LEAKS();
#endif
  /*
    int decRes = 0;
    int i = 0;
    int max = (n > 10 ? 10 : n);
    CHECK_LEAKS();

    if(elt != NULL) {
    iclDecRef(elt);
    }

    for(i = 0; i < max; i++) {
    fprintf(stderr, "  ");
    }
    fprintf(stderr, "icl_FreeTerm on %x called from %x recursion %i\n",
    elt, pc, n);

    if(n > 100) {
    char* abort = 0;
    fprintf(stderr, "icl_FreeTerm suspicious recursion number; aborting\n");
    abort[0] = 1;
    }

    if(decRes < 0) {
    char* abort = 0;
    fprintf(stderr, "icl_FreeTerm duplicate free; aborting\n");
    abort[0] = 1;
    }
  */

  if (icl_IsValid(elt)) {

    if ((elt->iclType == icl_int_type) ||
        (elt->iclType == icl_float_type) ||
        (elt->iclType == icl_var_type) ||
        (elt->iclType == icl_str_type) ||
        (elt->iclType == icl_dataq_type)) {
      if(elt->glibAlloc == 1) {
        g_free(elt->p);
      }
      else {
        free(elt->p);   /* frees space allocated by pointer */
        elt->p = NULL;
      }
    }
    else

      if (elt->iclType == icl_struct_type) {
        ICLStructType *st = elt->p;
        icl_FreeTermMulti(st->functor, n + 1, pc);
        st->functor = NULL;
        icl_FreeTermMulti(st->args, n + 1, pc);
        free(elt->p);
        elt->p = NULL;
      }
      else

        if (elt->iclType == icl_list_type) {
          ICLListType *list = elt->p;
          ICLListType *next;
          while (list) {
      icl_FreeTermMulti(list->elt, n + 1, pc);
      next = list->next;
            memset(list, 0, sizeof(ICLListType));
      free(list);
      list = next;
          }
          elt->p = NULL;
        }

    if (elt->iclType == icl_group_type) {
      ICLGroupType *gp = elt->p;
      ICLListType *list = gp->list;
      ICLListType *next;
      free(gp->separator);
      gp->separator = NULL;
      while (list) {
        icl_FreeTermMulti(list->elt, n + 1, pc);
        next = list->next;
        list->next = NULL;
        memset(list, 0, sizeof(ICLListType));
        free(list);
        list = next;
      }
      free(gp);
      elt->p = NULL;
    }

    memset(elt, 0, sizeof(ICLTerm));
    elt->magic_cookie = 0xdeadbeef;
    elt->iclType = icl_no_type;
    free(elt);
#ifdef NORMAL_GC
    CHECK_LEAKS();
#endif
  }
}

#if 0

/****************************************************************************
 * name:    icl_ReuseMem
 * purpose: A very simple form of garbage collection for ICLTerms.
 *    Often, a programmer wants to create a "temporary" ICL structure to
 *    pass to some procedure, such that the life of the structure needs only
 *    exist during that call.  icl_ReuseMem can be used for this purpose, to
 *    recover the memory for a temporary structure.
 * remarks:
 *    icl_ReuseMem keeps a static pointer of the last structure passed which
 *    it will free to make room for the next structure coming in.  Therefore,
 *    the "life expectancy" of a structure passed to icl_ReuseMem is only
 *    until the next call to this function.
 * warning:
 *    Do not use this function twice in the same call, since the second call
 *    will erase the value of the first (see above)
 *     ie. WRONG!!!
 *        do(icl_ReuseMem(icl_NewStr("a")), icl_ReuseMem(icl_NewStr("b")));
 ****************************************************************************/
EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_ReuseMem(ICLTerm *elt)
{
  static ICLTerm *last = NULL;

  icl_Free(last);
  last = elt;
  return elt;
}

#endif


/****************************************************************************
 * Structure testing routines
 ****************************************************************************/

EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsList(ICLTerm const*elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_list_type));
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsGroup(ICLTerm const*elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_group_type));
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsStruct(ICLTerm const*elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_struct_type));
}


EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsStr(ICLTerm const*elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_str_type));
}


EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsVar(ICLTerm const*elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_var_type));
}


EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsInt(ICLTerm const*elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_int_type));
}


EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsFloat(ICLTerm const*elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_float_type));
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsDataQ(ICLTerm const* elt)
{
  return (icl_IsValid(elt) && (elt->iclType == icl_dataq_type));
}


EXPORT_MSCPP
int EXPORT_BORLAND
icl_IsValid(ICLTerm const*elt)
{
  return (elt && (elt->magic_cookie == ICL_MAGIC_COOKIE));
}

/*****************************************************************************
 * name: icl_IsGround
 * purpose:
 *****************************************************************************/

int icl_IsGround(ICLTerm const *term)
{
  ICLListType *plist = (ICLListType *)NULL;

  if (! icl_IsValid(term))
    return FALSE;

  if(icl_IsVar(term))
    return FALSE;

  if(icl_IsStruct(term))
    plist = icl_Arguments(term);
  else if(icl_IsList(term))
    plist = icl_List(term);

  /* ??? check for any other complex types? */

  while(icl_ListHasMoreElements(plist)) {
    ICLTerm *el = icl_ListElement(plist);

    if(!icl_IsGround(el))
      return FALSE;
    plist = icl_ListNextElement(plist);
  }
  return TRUE;
}

EXPORT_MSCPP
void* EXPORT_BORLAND
icl_DataQ(ICLTerm const* elt)
{
  if(icl_IsDataQ(elt)) {
    return elt->p;
  }
  else {
    return NULL;
  }
}

EXPORT_MSCPP
size_t EXPORT_BORLAND
icl_DataQLen(ICLTerm const* elt)
{
  if(icl_IsDataQ(elt)) {
    return elt->len;
  }
  else {
    return 0;
  }
}

EXPORT_MSCPP
size_t EXPORT_BORLAND
icl_Len(ICLTerm const *elt)
{
  if(icl_IsValid(elt)) {
    return elt->len;
  }
  else {
    return 0;
  }
}

EXPORT_MSCPP
gint64 EXPORT_BORLAND
icl_Int(ICLTerm const*elt)
{
  gint64 *i;

  if (icl_IsInt(elt)) {
    i = elt->p;
    return (*i);
  }
  else return(0);
}


EXPORT_MSCPP
double EXPORT_BORLAND
icl_Float(ICLTerm const*elt)
{
  double *f;

  if (icl_IsFloat(elt)) {
    f = elt->p;
    return (*f);
  }
  else return(0.0);
}


EXPORT_MSCPP
char * EXPORT_BORLAND
icl_Str(ICLTerm const*elt)
{
  if (icl_IsStr(elt) || icl_IsVar(elt))
    return((char*)(elt->p));
  else
    if (icl_IsStruct(elt)) {
      ICLStructType *st = elt->p;
      return(icl_Str(st->functor));
    }
    else return(NULL);
}

EXPORT_MSCPP
char* EXPORT_BORLAND
icl_Functor(ICLTerm const*elt)
{
  if (icl_IsStruct(elt)) {
    ICLStructType *st = elt->p;
    return(icl_Str(st->functor));
  }
  else {
    return(NULL);
  }
}


EXPORT_MSCPP
ICLListType * EXPORT_BORLAND
icl_Arguments(ICLTerm const *elt)
{
  if (icl_IsStruct(elt)) {
    ICLStructType *st = elt->p;
    return(icl_List(st->args));
  }
  else return(NULL);
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_GetGroupChars(ICLTerm const*group, char *startC, char **sep)
{
  if (icl_IsGroup(group)) {
    ICLGroupType *gt = group->p;
    *startC = gt->startChar;
    *sep = strdup(gt->separator);
    return(TRUE);
  }
  else return(FALSE);
}


EXPORT_MSCPP
ICLListType * EXPORT_BORLAND
icl_List(ICLTerm const*elt)
{
  if (icl_IsList(elt)) {
    ICLListType *list = elt->p;
    return(list);
  }
  else
    if (icl_IsGroup(elt)) {
      ICLGroupType *gp = elt->p;
      ICLListType *list = gp->list;
      return(list);
    }
    else
      if (icl_IsStruct(elt)) {
        ICLStructType *st = elt->p;
        return(icl_List(st->args));
      }
      else return(NULL);
}

EXPORT_MSCPP
ICLListType *  EXPORT_BORLAND icl_ListNext(ICLListType const* t)
{
  return t->next;
}

EXPORT_MSCPP
ICLTerm *  EXPORT_BORLAND icl_ListElt(ICLListType const* t)
{
  return t->elt;
}


ICLListType* icl_copy_listtype(ICLListType* l)
{
  ICLListType* newList = NULL;
  ICLListType* prev = NULL;
  while(l) {
    newList = (ICLListType*)malloc(sizeof(ICLListType));
    if(prev != NULL) {
      prev->next = newList;
    }
    newList->next = NULL;
    newList->elt = icl_CopyTerm(l->elt);
    l = l->next;
    prev = newList;
  }
  return newList;
}

EXPORT_MSCPP
ICLListType * EXPORT_BORLAND
icl_ListCopy(ICLTerm const*elt)
{
  if (icl_IsList(elt)) {
    ICLListType *list = elt->p;
    return(icl_copy_listtype(list));
  }
  else
    if (icl_IsGroup(elt)) {
      ICLGroupType *gp = elt->p;
      ICLListType *list = gp->list;
      return(icl_copy_listtype(list));
    }
    else
      if (icl_IsStruct(elt)) {
        ICLStructType *st = elt->p;
        return(icl_copy_listtype(icl_List(st->args)));
      }
      else {
        return(NULL);
      }
}


/****************************************************************************
 * List manipulation
 ****************************************************************************/

EXPORT_MSCPP
int EXPORT_BORLAND
icl_AddToList(ICLTerm *list, ICLTerm *elt, int atEnd)
{
  if (icl_IsValid(elt) && (icl_IsList(list) || icl_IsGroup(list)) ) {

    /* Empty list */
    if (icl_IsList(list) && !list->p) {
      list->p = icl_NewCons(elt, NULL);
      return TRUE;
    }
    else {
      /* at beginning */
      if (!atEnd) {
  list->p = icl_NewCons(elt, list->p);
      }
      else {
  /* Group of one elt ??  */
  if (icl_IsGroup(list) && (!((ICLGroupType*)list->p)->list))
    ((ICLGroupType *)list->p)->list = icl_NewCons(elt, NULL);

  /* loop to end and add elt */
  else {
    ICLListType *p;
    p = icl_List(list);
    while (p->next)
      p = p->next;
    p->next = icl_NewCons(elt, NULL);
  }
      }
      return (TRUE);
    }
  }
  else {
    return (FALSE);
  }
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_ClearList(ICLTerm *list)
{
  if ((icl_IsList(list) || icl_IsGroup(list)) ) {
    ICLListType *p;
    ICLListType *toBeDestroyed;
    ICLTerm* t;

    p = icl_List(list);
    while (p) {
      toBeDestroyed = p;
      p = p->next;
      t = toBeDestroyed->elt;
      icl_Free(t);
      icl_stFree(toBeDestroyed);
    }
    return (TRUE);
  }
  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_SortList(ICLTerm *list, int (*user_function)(ICLTerm *Elt1, ICLTerm *Elt2))
{
  (void)list;
  (void)user_function;
  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_ListHasMoreElements(ICLListType const*l)
{
  if((l != NULL) &&
     (l->elt != NULL)) {
    return TRUE;
  }
  return FALSE;
}

EXPORT_MSCPP
ICLListType * EXPORT_BORLAND
icl_ListNextElement(ICLListType const*l)
{
  if(l)
    return l->next;
  else
    return NULL;
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_ListElement(ICLListType const*list)
{
  return list->elt;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_ListDelete(ICLTerm *list, ICLTerm *elem, ICLTerm **residue) {
  ICLListType *iterator;
  if(!icl_IsList(list))
    return FALSE;
  iterator = icl_List(list);
  *residue = icl_NewList(NULL);
  while(icl_ListHasMoreElements(iterator)) {
    ICLTerm *listel = icl_ListElement(iterator);
    if(!icl_Unify(listel, elem, NULL)) {
      icl_AddToList(*residue, icl_CopyTerm(listel), TRUE);
    }
    iterator = icl_ListNextElement(iterator);
  }
  return TRUE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_AppendCopy(ICLTerm *list1, ICLTerm const*list2) {

  if (list2==NULL)
    return FALSE;

  if(icl_IsList(list1) && icl_IsList(list2)) {
    ICLListType *l2 = icl_List(list2);
    while(icl_ListHasMoreElements(l2)) {
      icl_AddToList(list1, icl_CopyTerm(icl_ListElement(l2)), TRUE);
      l2 = icl_ListNextElement(l2);
    }
    return TRUE;
  }
  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_Append(ICLTerm *list1, ICLTerm *list2) {

  /*
    char *debugString1 = icl_NewStringFromTerm(list1);
    char *debugString2 = icl_NewStringFromTerm(list2);

    printDebug(7, "List 1 %s\n", debugString1);
    printDebug(7, "List 2 %s\n", debugString2);

    icl_stFree(debugString1);
    icl_stFree(debugString2);
  */
  if (list2==NULL)
    return FALSE;

  if(icl_IsList(list1) && icl_IsList(list2)) {
    ICLListType *l2 = icl_List(list2);
    while(icl_ListHasMoreElements(l2)) {
      icl_AddToList(list1, icl_ListElement(l2), TRUE);
      l2 = icl_ListNextElement(l2);
    }
    return TRUE;
  }
  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_Union(ICLTerm *list1, ICLTerm *list2, ICLTerm **dest)
{
  ICLTerm* tmp;
  int res;
  if (list1 && list2 && icl_IsList(list1) && icl_IsList(list2)) {
    *dest = icl_CopyTerm(list1);
    tmp = *dest;
    res = icl_AppendCopy(*dest, list2);
    return TRUE;
  }
  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_Arity(ICLTerm const*elt)
{
  return icl_NumTerms(elt);
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_NumTerms(ICLTerm const*elt)
{
  int len = 0;

  if (icl_IsList(elt) || icl_IsGroup(elt) || icl_IsStruct(elt)) {

    ICLListType *p;

    p = icl_List(elt);
    while (p) {
      p = p->next;
      ++len;
    }
  }

  return (len);
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_ListLen(ICLTerm const*elt){
  return icl_NumTerms(elt);
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND icl_NthTerm(ICLTerm const*elt, int n)
{
  ICLListType *p;

  if (icl_IsList(elt) || icl_IsStruct(elt) || icl_IsGroup(elt))
  {
    if(!icl_IsValid(elt)) {
      return NULL;
    }

    p = icl_List(elt);
  }
  else return (NULL);

  while (p && (n > 1)) {
    p = p->next;
    --n;
  }
  if (p)
    return (p->elt);
  else
    return (NULL);
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_NthTermAsInt(ICLTerm const*elt, int n, int *Value)
{
  ICLTerm *v = icl_NthTerm(elt, n);
  if (v != NULL) {
    int tempInt = icl_Int(v);
    memcpy(Value, &tempInt, sizeof(int));
    return TRUE;
  }
  return FALSE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
icl_ParamValue(char *func, ICLTerm *match, ICLTerm *paramlist, ICLTerm **value)
{
  ICLListType *p;
  ICLTerm *test = (ICLTerm *)NULL;
  int found = FALSE;


  // only prepare the string if it will be used...
  if (DEBUG_LEVEL > 7) {
    char *debugString = icl_NewStringFromTerm(paramlist);

    printDebug(7, "icl_ParamValue : func %s\n", func);
    printDebug(7, "icl_ParamValue : paramlist %s\n", debugString);
    icl_stFree(debugString);
  }

  if (icl_IsList(paramlist) && func && *func && (icl_NumTerms(paramlist)>0)) {
    p = icl_List(paramlist);
  }
  else {
    return FALSE;
  }

  if (match) {
    test = icl_NewStruct(func, 1, icl_CopyTerm(match));
  }
  else {
    test = icl_NewStruct(func, 1, icl_NewVar("_"));
  }

  while(p && !found) {

    /* For debugging */
    // only prepare the strings if they will be used...
    if (DEBUG_LEVEL > 7) {
      char *s1, *s2;

      s1 = icl_NewStringStructFromTerm(test);
      s2 = icl_NewStringStructFromTerm(p->elt);

      printDebug(7, "icl_ParamValue : %s VS %s\n", s1, s2);
      icl_stFree(s1);
      icl_stFree(s2);
    }
    /* End for debugging */

    found = icl_Unify(test, p->elt, value);
    p = p->next;
  }

  // only prepare the string if it will be used...
  if (found && value && (DEBUG_LEVEL > 7)) {
    char *debugString = icl_NewStringFromTerm(*value);

    printDebug(7, "Found %s\n", debugString);
    icl_stFree(debugString);
  }

  icl_Free(test);

  return (found);
}


EXPORT_MSCPP
gint64 EXPORT_BORLAND
icl_ParamValueAsInt(char *func, ICLTerm *paramlist, gint64 *Value)
{
  ICLTerm *v = NULL;
  int result = FALSE;

  if (Value && *Value &&
      icl_ParamValue(func, NULL, paramlist, &v)) {
    ICLTerm* temp_result = icl_NthTerm(v,1);
    if (icl_IsInt(temp_result)) {
      *Value = icl_Int(temp_result);
      result = TRUE;
    }
  }
  icl_Free(v);
  return result;
}


EXPORT_MSCPP
int EXPORT_BORLAND
icl_Member(ICLTerm const*elt, ICLTerm const*list, ICLTerm **res)
{
  ICLListType *p;
  int found = FALSE;

  if (icl_IsList(list) && elt) {
    p = icl_List(list);
  }
  else {
    return FALSE;
  }

  while(p && !found) {
    found = icl_Unify(elt, p->elt, res);
    p = p->next;
  }

  return found;
}


/****************************************************************************
 * Unification
 ****************************************************************************/

/****************************************************************************
 * name:    icl_bind_var
 * purpose: Stores a var/value pair in stringlist vars
 * inputs:
 *   - char *var: Variable name
 *   - char *value: Value
 *   - dyn_array vars: string list of var/value bindings
 * remarks:
 *   You can safely (and should!) free value after this, if necessary, as
 *   this function will copy it.
 ****************************************************************************/
static
void icl_bind_var(ICLTerm *var,
      ICLTerm *value,
      struct dyn_array *vars)
{
  icl_append_dyn_array(vars, strdup(icl_Str(var)));
  icl_append_dyn_array(vars, icl_CopyTerm(value));
}

/****************************************************************************
 * name:    icl_deref
 * purpose: See if a variable can be resolved using existing variable bindings
 * inputs:
 *   - char *var: will return value if one can be found in var_bindings
 *   - char *var_bindings[]:
 *          A list stored with var/value in l[N]/l[N+1]
 ****************************************************************************/
static
void icl_deref(ICLTerm **var,
               struct dyn_array var_bindings)
{
  int done = 0;
  int pos;

  do {
    if (!icl_IsVar(*var)) {
      return;
    }

    pos = icl_member_strlist(icl_Str(*var), var_bindings, 2, 0);
    if (pos >= 0) {
      *var = (ICLTerm *)var_bindings.item[pos+1];
    }
    else {
      done = 1;
    }
  } while (!done);

  return;
}


EXPORT_MSCPP
int EXPORT_BORLAND icl_match_terms(ICLTerm *t1, ICLTerm *t2, struct dyn_array *vars)
{
  int res;
  ICLListType *l1, *l2;

  /* Validate incoming arguments */
  if (!icl_IsValid(t1) || !icl_IsValid(t2)) {
    return FALSE;
  }

  if (vars) {
    icl_deref(&t1, *vars);
    icl_deref(&t2, *vars);
  }

  if (icl_IsVar(t1)) {
    /* Anonymous variable "_" never gets bound */
    if (vars) {
      /* && !STREQ(icl_Str(t1),"_") && !STREQ(icl_Str(t1),icl_Str(t2)))*/
      icl_bind_var(t1, t2, vars);
    }
    return TRUE;
  }
  else if (icl_IsVar(t2)) {
    /* Anonymous variable "_" never gets bound */
    if (vars) {
      /* && !STREQ(icl_Str(t2),"_") && !STREQ(icl_Str(t1),icl_Str(t2)))*/
      icl_bind_var(t2, t1, vars);
    }
    return TRUE;
  }
  else if (t1->iclType == t2->iclType) {
    /* Check that both are same types */
    if (t1->iclType == icl_float_type) {
      return (icl_Float(t1) == icl_Float(t2));
    }
    else if (t1->iclType == icl_int_type) {
      return (icl_Int(t1) == icl_Int(t2));
    }
    else if (t1->iclType == icl_str_type) {
      return (strcmp(icl_Str(t1), icl_Str(t2)) == 0);
    }
    else {
      if (t1->iclType == icl_struct_type) {
  if (strcmp(icl_Str(t1), icl_Str(t2)) != 0) {
    return FALSE;   /* check name, then fall through to args */
  }
      }

      if ((t1->iclType == icl_list_type) ||
    (t1->iclType == icl_group_type) ||
    (t1->iclType == icl_struct_type)) {

  l1 = icl_List(t1);
  l2 = icl_List(t2);
  res = TRUE;

  while (l1 && l2 && res) {
    res = icl_match_terms(l1->elt, l2->elt, vars);
    l1 = l1->next;
    l2 = l2->next;
  }

  return(!l1 && !l2 && res);
      }
      else {
  return FALSE;
      }
    }
  }
  else {
    /* t1 and t2 are not the same type */
    return FALSE;
  }
}

EXPORT_MSCPP
int EXPORT_BORLAND icl_match_terms_DEBUG(ICLTerm *t1, ICLTerm *t2, struct dyn_array *vars)
{
  int res;
  ICLListType *l1, *l2;

  printf("icl_match_terms_DEBUG\n");

  /* Validate incoming arguments */
  if (!icl_IsValid(t1) || !icl_IsValid(t2)) {
    printf("icl_match_terms_DEBUG One or the other is invalid\n");
    return FALSE;
  }

  if (vars) {
    icl_deref(&t1, *vars);
    icl_deref(&t2, *vars);
  }

  if (icl_IsVar(t1)) {
    /* Anonymous variable "_" never gets bound */
    if (vars) {
      /* && !STREQ(icl_Str(t1),"_") && !STREQ(icl_Str(t1),icl_Str(t2)))*/
      icl_bind_var(t1, t2, vars);
    }
    return TRUE;
  }
  else if (icl_IsVar(t2)) {
    /* Anonymous variable "_" never gets bound */
    if (vars) {
      /* && !STREQ(icl_Str(t2),"_") && !STREQ(icl_Str(t1),icl_Str(t2)))*/
      icl_bind_var(t2, t1, vars);
    }
    return TRUE;
  }
  else if (t1->iclType == t2->iclType) {
    /* Check that both are same types */
    if (t1->iclType == icl_float_type) {
      printf("icl_match_terms_DEBUG floats == %i\n", icl_Float(t1) == icl_Float(t2));
      return (icl_Float(t1) == icl_Float(t2));
    }
    else if (t1->iclType == icl_int_type) {
      printf("icl_match_terms_DEBUG ints == %i\n", icl_Int(t1) == icl_Int(t2));
      return (icl_Int(t1) == icl_Int(t2));
    }
    else if (t1->iclType == icl_str_type) {
      printf("icl_match_terms_DEBUG string types strcmp(%s,%s) = %i\n",
             icl_Str(t1), icl_Str(t2),
             strcmp(icl_Str(t1), icl_Str(t2)));
      return (strcmp(icl_Str(t1), icl_Str(t2)) == 0);
    }
    else {
      if (t1->iclType == icl_struct_type) {
  if (strcmp(icl_Str(t1), icl_Str(t2)) != 0) {
          printf("icl_match_terms_DEBUG mismatched struct names\n");
    return FALSE;   /* check name, then fall through to args */
  }
      }

      if ((t1->iclType == icl_list_type) ||
    (t1->iclType == icl_group_type) ||
    (t1->iclType == icl_struct_type)) {

  l1 = icl_List(t1);
  l2 = icl_List(t2);
  res = TRUE;

  while (l1 && l2 && res) {
    res = icl_match_terms_DEBUG(l1->elt, l2->elt, vars);
    l1 = l1->next;
    l2 = l2->next;
  }

  return(!l1 && !l2 && res);
      }
      else {
        printf("icl_match_terms_DEBUG bad type\n");
  return FALSE;
      }
    }
  }
  else {
    /* t1 and t2 are not the same type */
    printf("icl_match_terms_DEBUG different types: %i, %i\n", t1->iclType, t2->iclType);
    return FALSE;
  }
}


EXPORT_MSCPP
int EXPORT_BORLAND icl_Unify(ICLTerm const*t1, ICLTerm const*t2, ICLTerm **answer)
{
  struct dyn_array da;
  int result;
  int i;

  ICLTerm* renamed_t1 = icl_CopyTerm(t1);
  ICLTerm* renamed_t2 = icl_CopyTerm(t2);
  ICLTerm* toFree;

  da.count = 0;
  /* DEBUG */
  //printf("Unify t1 : %s\n", icl_NewStringFromTerm(t1));
  //printf("Unify t2 : %s\n", icl_NewStringFromTerm(t2));

  rename_vars_index=0;
  icl_rename_vars_term(&renamed_t1);
  icl_rename_vars_term(&renamed_t2);

  icl_init_dyn_array(&da);

  result = icl_match_terms(renamed_t1, renamed_t2, &da);

  if (result && answer) {
    CHECK_LEAKS();
    *answer = icl_copy_term(renamed_t1, &da);
    CHECK_LEAKS();
  }

  /* Free the dynamic array
   */
  for (i = 0; i < (da).count; i = i + 2) {
    free((da).item[i]);
    toFree = (ICLTerm*)(da.item[i + 1]);
    icl_Free(toFree);
  }
  free((da).item);

  icl_Free(renamed_t1);
  icl_Free(renamed_t2);

  CHECK_LEAKS();
  return result;
}

EXPORT_MSCPP
int EXPORT_BORLAND icl_Unify_DEBUG(ICLTerm *t1, ICLTerm *t2, ICLTerm **answer)
{
  struct dyn_array da;
  int result;
  int i;

  ICLTerm* renamed_t1 = icl_CopyTerm(t1);
  ICLTerm* renamed_t2 = icl_CopyTerm(t2);
  ICLTerm* toFree;

  /* DEBUG */
  //printf("Unify t1 : %s\n", icl_NewStringFromTerm(t1));
  //printf("Unify t2 : %s\n", icl_NewStringFromTerm(t2));

  rename_vars_index=0;
  icl_rename_vars_term(&renamed_t1);
  icl_rename_vars_term(&renamed_t2);

  icl_init_dyn_array(&da);

  result = icl_match_terms_DEBUG(renamed_t1, renamed_t2, &da);
  printf("result = %i\n", result);

  if (result && answer) {
    *answer = icl_copy_term(renamed_t1, &da);
  }

  /* Free the dynamic array
   */
  for (i = 0; i < (da).count; i = i + 2) {
    free((da).item[i]);
    toFree = (ICLTerm*)(da.item[i + 1]);
    icl_Free(toFree);
  }
  free((da).item);

  icl_Free(renamed_t1);
  icl_Free(renamed_t2);

  return result;
}


/****************************************************************************
 * Utility functions
 ****************************************************************************/

EXPORT_MSCPP
int    EXPORT_BORLAND
icl_WriteTerm(ICLTerm *t)
{
  if (icl_IsValid(t)) {
    char *s = icl_NewStringFromTerm(t);
    int res = (s != NULL);

    printf(s);

    icl_stFree(s);
    return res;
  }
  else return FALSE;
}

/****************************************************************************
 * Convenience functions for representing often-used terms
 ****************************************************************************/

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_True()
{
  static ICLTerm *icl_true = NULL;

  /* check to see if first time or somehow invalidated */
  if (!icl_IsValid(icl_true)) {
    icl_true = icl_NewStr("true");
    return icl_true;
  }
  else return icl_true;
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_False()
{
  static ICLTerm *icl_false = NULL;

  /* check to see if first time or somehow invalidated */
  if (!icl_IsValid(icl_false)) {
    icl_false = icl_NewStr("false");
    return icl_false;
  }
  else return icl_false;
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_Empty()
{
  static ICLTerm *icl_empty = NULL;

  /* check to see if first time or somehow invalidated */
  if (!icl_IsValid(icl_empty)) {
    icl_empty = icl_NewList(NULL);
    return icl_empty;
  }
  else {
    return icl_empty;
  }
}

EXPORT_MSCPP
ICLTerm * EXPORT_BORLAND
icl_Var()
{
  static ICLTerm *icl_var = NULL;

  /* check to see if first time or somehow invalidated */
  if (icl_var && !icl_IsVar(icl_var)){
    icl_Free(icl_var);
    //icl_var = NULL;
  }

  if (!icl_IsValid(icl_var)) {
    icl_var = icl_NewVar("_");
    return icl_var;
  }
  else return icl_var;
}


/****************************************************************************
 * List management utility functions
 ****************************************************************************/

int icl_list_has_more_elements(ICLListType *l)
{
  if(l && (l->elt != NULL))
    return TRUE;
  return FALSE;
}

ICLListType *icl_list_next_element(ICLListType *l)
{
  if(l)
    return l->next;
  else
    return NULL;
}

ICLTerm *icl_list_element(ICLListType *list)
{
  return list->elt;
}

int icl_list_delete(ICLTerm *list, ICLTerm *elem, ICLTerm **residue)
{
  ICLListType *iterator;
  if(!icl_IsList(list))
    return FALSE;
  iterator = icl_List(list);
  *residue = icl_NewList(NULL);
  while(icl_list_has_more_elements(iterator)) {
    ICLTerm *listel = icl_list_element(iterator);
    if(!icl_Unify(listel, elem, NULL)) {
      icl_AddToList(*residue, listel, TRUE);
    }
    iterator = icl_list_next_element(iterator);
  }
  return TRUE;
}

int icl_append_to_list(ICLTerm *list1, ICLTerm *list2, ICLTerm **list3)
{
  ICLListType *l2;

  if (!icl_IsList(list2) || !icl_IsList(list1)) {
    return FALSE;
  }

  *list3 = icl_CopyTerm(list1);
  l2 = icl_List(list2);

  while(icl_ListHasMoreElements(l2)) {
    icl_AddToList(*list3, icl_CopyTerm(icl_ListElement(l2)), TRUE);
    l2 = icl_ListNextElement(l2);
  }
  return TRUE;
}

EXPORT_MSCPP
ICLTerm* icl_GenerateSimpleUnifyingTerm(ICLTerm const*term)
{
  ICLTerm* newTerm = NULL;
  int numTerms;

  if(!(icl_IsList(term) || icl_IsGroup(term) || icl_IsStruct(term))) {
    return icl_NewVar("_");
  }

  numTerms = icl_NumTerms(term);

  if(icl_IsStruct(term)) {
    char* functor = icl_Functor(term);
    ICLTerm* args = icl_NewList(NULL);
    {
      int i;
      for(i = 0; i < numTerms; ++i) {
        icl_AddToList(args, icl_NewVar("_"), TRUE);
      }
    }
    newTerm = icl_NewStructFromList(functor, args);
  }
  else {
    int i;
    newTerm = icl_CopyTerm(term);
    for(i = 0; i < numTerms; ++i) {
      icl_ReplaceElement(newTerm, i, icl_NewVar("_"), TRUE);
    }
  }

  return newTerm;
}

EXPORT_MSCPP
int icl_ReplaceElement(ICLTerm* term, int index, ICLTerm* replacement, int freeReplaced)
{
  if(!(icl_IsList(term) || icl_IsGroup(term) || icl_IsStruct(term))) {
    return FALSE;
  }
  else {
    ICLListType *p = icl_List(term);
    int i;
    for(i = 0; p && i < index; ++i) {
      p = p->next;
    }
    if(i != index) {
      return FALSE;
    }
    if(freeReplaced && p->elt) {
      icl_FreeTerm(p->elt);
    }
    p->elt = replacement;

    return TRUE;
  }
}

EXPORT_MSCPP
int icl_ReplaceUnifying(ICLTerm* term, ICLTerm const* selector, ICLTerm const* replacement, int freeReplaced)
{
  if(!(icl_IsList(term) || icl_IsGroup(term) || icl_IsStruct(term))) {
    return FALSE;
  }
  else {
    ICLListType *p;
    int numReplaced = 0;
    for(p = icl_List(term); p; p = p->next) {
      if(icl_Unify(p->elt, selector, NULL)) {
        if(freeReplaced) {
          icl_FreeTerm(p->elt);
        }
        p->elt = icl_CopyTerm(replacement);
        ++numReplaced;
      }
    }
    return numReplaced;
  }  
}

---