libutils.c

Go to the documentation of this file.

/*
 * 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
 */

#include <stdio.h>
#include <string.h>
//#include <malloc.h>

#ifndef _WINDOWS
#include <pwd.h>        /* used by expandFileName */
#endif

#include <stdarg.h>   /* Variable length argument lists */
#include <stdlib.h>

#include "libutils.h"
#include "filetermreader.h"

/****************************************************************************
 * Global variables and forward declarations
 ****************************************************************************/

#define EXPORT_BORLAND

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

/* Exported by liboaa */
extern int oaa_argc;
extern char** oaa_argv;
#define SETUP_FILE_NAME "setup.pl"
/* Each line in a setup file should be less than this length: */
#define SETUP_FILE_BUFSIZ 1024

char *expand_filename(char* nm, char* startDir);

/****************************************************************************
 * name:    oaa_ResolveVariable
 * purpose:
 * remarks:
 * returns:
 ****************************************************************************/
EXPORT_MSCPP
int EXPORT_BORLAND
oaa_ResolveVariable(char* inVarName, ICLTerm **resolvedVar){
  int i = 1;
  int found = FALSE;

  ICLTerm* varNameAsIclStruct;
  ICLTerm* varNameAsIclStr;
  ICLTerm* resultOfUnification = NULL;
  ICLTerm* var;

  var = icl_NewVar("_");
  varNameAsIclStruct = icl_NewStruct(inVarName, 1, var);
  if(varNameAsIclStruct == NULL) {
    icl_Free(var);
  }
  CHECK_LEAKS();
  varNameAsIclStr = icl_NewStr(inVarName);
  CHECK_LEAKS();

  /* First looks at the command line */
  while ((i<oaa_argc) && !found) {
    ICLTerm* currentParamAsTerm = icl_NewStr(oaa_argv[i]);
    CHECK_LEAKS();

    /* Looks at the term as a struct */
    if (currentParamAsTerm && icl_IsStruct(currentParamAsTerm)) {
      CHECK_LEAKS();
      if (icl_Unify(currentParamAsTerm, varNameAsIclStruct, &resultOfUnification)) {
        CHECK_LEAKS();
        if (resolvedVar) {
          *resolvedVar = icl_CopyTerm(icl_NthTerm(resultOfUnification, 1));
          CHECK_LEAKS();          
        }
        found = TRUE;
      }
      icl_Free(resultOfUnification);
      CHECK_LEAKS();
    }

    /* Looks at the term as an icl str */
    if (currentParamAsTerm && icl_IsStr(currentParamAsTerm)) {
      if (icl_Unify(currentParamAsTerm, varNameAsIclStr, &resultOfUnification)) {
        /* The -oaa parameter does not take any parameters */
        if (strcmp(oaa_argv[i],"-oaa")==0) {
          if (resolvedVar)
            *resolvedVar = icl_CopyTerm(icl_NthTerm(resultOfUnification, 1));
        }
        else{
          if (resolvedVar)
            *resolvedVar = icl_NewTermFromString(oaa_argv[++i]);
        }
        found = TRUE;
      }
      icl_Free(resultOfUnification);
    }

    icl_Free(currentParamAsTerm);
    i++;
  }

  /*
     If not found within the arguments, looks in the setup.pl file.
     First in the current directory, then in the user's root directory
     on UNIX (LINUX) systems, or in c:\ on Windows based machines.
  */

  if (!found) {
    FILE *setup_file;
    char buf[SETUP_FILE_BUFSIZ];
#ifndef _WINDOWS /* --------------------------------------------------------- */
    char *filename;
    strcpy(buf, "./");
    strcat(buf, SETUP_FILE_NAME);
#else /* ----------------------------------------------------------------- */
    strcpy(buf, SETUP_FILE_NAME);
#endif  /* ---------------------------------------------------------------- */
    if ((setup_file = fopen(buf, "r")) == NULL) {
#ifdef _WINDOWS  /* ----------------------------------------------------- */
      strcpy(buf,"C:\\");
      strcat(buf, SETUP_FILE_NAME);
#else  /* ---------------------------------------------------------------- */
      strcpy(buf, "~/");
      strcat(buf, SETUP_FILE_NAME);
      filename = expand_filename(buf, NULL);
      strncpy(buf, filename, 512);
      icl_stFree(filename);
#endif  /* ---------------------------------------------------------------- */
      setup_file = fopen(buf, "r");
    }

    

    // One remaining issue with this is that comments aren't handled correctly;
    // don't use percent characters except for comments.
    if (setup_file != NULL) {
      TermReader* tr = termReader_create();
      void* filterState = filterPercent_createState();
      ICLTerm* currentTerm;
      (void)fileTermReader_createWithFilter(tr, setup_file, filterPercent_filter, filterState);
      for(currentTerm = termReader_getNextTerm(tr, 0); currentTerm != NULL; currentTerm = termReader_getNextTerm(tr, 0)) {
        if(icl_Unify(currentTerm, varNameAsIclStruct, &resultOfUnification)) {
          *resolvedVar = icl_CopyTerm(icl_NthTerm(resultOfUnification, 1));
          icl_Free(resultOfUnification);
          icl_Free(currentTerm);
          break;
        }
        icl_Free(currentTerm);
      }
      
      free(filterState);
      termReader_free(tr);
      fclose(setup_file);
    }
    else {
      printf("no setup.pl file\n");
    }
  }

  CHECK_LEAKS();
  icl_Free(varNameAsIclStruct);
  CHECK_LEAKS();
  icl_Free(varNameAsIclStr);
  CHECK_LEAKS();

  return found;
}

/****************************************************************************
 * name:    filename_as_directory
 * purpose: concatenate a slash onto a filename if necessary
 * inputs:
 *    - char  *in: file to work on
 *    - char *out: result
 * remarks:
 *    Internal static command
 ****************************************************************************/
static char *
filename_as_directory (out, in)
     char *out, *in;
{
  int size = strlen (in) - 1;

  strcpy (out, in);

  /* For Unix syntax, Append a slash if necessary */
  if (out[size] != '/')
    strcat (out, "/");
  return out;
}

char *
expand_filename(char* nm, char* startDir) {

  register char *newdir, *p, *o;
  int tlen;
  char *target;
  int lose;

#ifndef _WINDOWS
  struct passwd *pw;
#endif

  /* If nm is absolute, flush ...// and detect /./ and /../.
     If no /./ or /../ we can return right away. */
  if (nm[0] == '/') {
    p = nm;
    lose = 0;
    while (*p){
      if (p[0] == '/' && p[1] == '/')
  nm = p + 1;
      if (p[0] == '/' && p[1] == '~')
  nm = p + 1, lose = 1;
      if (p[0] == '/' && p[1] == '.'
    && (p[2] == '/' || p[2] == 0
        || (p[2] == '.' && (p[3] == '/' || p[3] == 0))))
  lose = 1;
      p++;
    }
    if (!lose) {
      printf("expand_filename !lose\n");
      return strdup (nm);
    }
  }

  /* Now determine directory to start with and put it in NEWDIR.  */

  newdir = 0;

#ifndef _WINDOWS
  if (nm[0] == '~'){
    if (nm[1] == '/' || nm[1] == 0){
      /* Handle ~ on its own.  */
      newdir = getenv ("HOME");
    }
    else {
      /* Handle ~ followed by user name.  */
      char *user = nm + 1;

      /* Find end of name.  */
      char *ptr = strchr (user, '/');
      int len = ptr ? (int) (ptr - user) : (int) strlen (user);

      /* Copy the user name into temp storage.  */
      o = strdup(user);
      o[len] = 0;

      /* Look up the user name.  */
      pw = (struct passwd *) getpwnam (o);
      if (!pw) {
  printf("User \"%s\" is not known", o);
      }

      newdir = pw->pw_dir;

      /* Discard the user name from NM.  */
      nm += len;
    }

    /* Discard the ~ from NM.  */
    nm++;

    if (newdir == 0) {
      newdir = "";
    }
  }
#endif

  if (nm[0] != '/' && !newdir){
    if (startDir[0] == 0)
      newdir = getenv("PWD");
    else
      newdir = startDir;
  }

  if (newdir != 0){
    /* Get rid of any slash at the end of newdir.  */
    int length = strlen (newdir);
    if (length > 1 && newdir[length - 1] == '/'){
      char *temp = strdup(newdir);
      temp[length - 1] = 0;
      newdir = temp;
    }
    tlen = length + 1;
  }
  else {
    tlen = 0;
  }

  /* Now concatenate the directory and name to new space in the stack frame */

  tlen += strlen (nm) + 1;
  target = (char *) malloc (tlen);
  *target = 0;

  if (newdir){
    if (nm[0] == 0 || nm[0] == '/') {
      strcpy (target, newdir);
    }
    else {
      filename_as_directory (target, newdir);
    }
  }

  strcat (target, nm);

  /* Now canonicalize by removing /. and /foo/.. if they appear */
  /* This could be done by using realpath(), but realpath only  */
  /* works if the file actually exists.        */

  p = target;
  o = target;

  while (*p){
    if (*p != '/'){
      *o++ = *p++;
    }
    else
      if (!strncmp (p, "//", 2)){
        o = target;
        p++;
      }
      else
        if (p[0] == '/' && p[1] == '.' &&
            (p[2] == '/' || p[2] == 0)){
          if (o == target && p[2] == '\0') {
            *o++ = *p;
          }
          p += 2;
        }
        else if (!strncmp (p, "/..", 3)
                 && o != target
                 && (p[3] == '/' || p[3] == 0)){
          while (o != target && *--o != '/');
          if (o == target && *o == '/') {
            ++o;
          }
          p += 3;
        }
        else {
          *o++ = *p++;
        }
  }
  target[o-target] = 0;
  return (char *)target;
}

EXTERN void printDebug(int level, char *str, ...) {
  if (level < DEBUG_LEVEL) {
    char buf[512];
    va_list ptr;
    va_start(ptr,str);
    vsprintf(buf,str,ptr);
    printf("DEBUG : %s\n",  buf);
    va_end(ptr);
  }
}

EXTERN void printWarning(int level, char *str, ...) {
  if (level < DEBUG_LEVEL) {
    char buf[512];
    va_list ptr;
    va_start(ptr,str);
    vsprintf(buf,str,ptr);
    printf("WARNING : %s\n",  buf);
    va_end(ptr);
  }
}

void print_dictionary(DICTIONARY *d) {
  int i, n;

  printf("Print dictionary of size %d\n", d->size);
  for(i=0, n=d->size; i<n; i++)
    printf("Key %s Value : %s\n",
           icl_NewStringFromTerm((ICLTerm*)d->key[i]),
           icl_NewStringFromTerm((ICLTerm*)d->value[i]));
}

hthash_table *htconstruct_table(hthash_table *table, size_t size)
{
  size_t i;
  htbucket **temp;

  table -> size  = size;
  table -> table = (htbucket * *)malloc(sizeof(htbucket *) * size);
  temp = table -> table;

  if ( temp == NULL )
  {
    table -> size = 0;
    return table;
  }

  for (i=0;i<size;i++)
    temp[i] = NULL;
  return table;
}


/*
 * Hashes a string to produce an unsigned short, which should be
 * sufficient for most purposes.
 */
static unsigned hthash(char *string)
{
  unsigned ret_val = 0;
  int i;

  while (*string)
  {
    i = (int)(*string);
    ret_val ^= i;
    ret_val <<= 1;
    string ++;
  }
  return ret_val;
}

void *htinsert(char *key, void *data, hthash_table *table)
{
  unsigned val = hthash(key) % table->size;
  htbucket *ptr;

  /*
   * NULL means this bucket hasn't been used yet.  We'll simply
   * allocate space for our new bucket and put our data there, with
   * the table pointing at it.
   */

  if (NULL == (table->table)[val])
  {
    (table->table)[val] = (htbucket *)malloc(sizeof(htbucket));
    if (NULL==(table->table)[val])
      return NULL;

    (table->table)[val] -> key = strdup(key);
    (table->table)[val] -> next = NULL;
    (table->table)[val] -> data = data;
    return (table->table)[val] -> data;
  }

  /*
   * This spot in the table is already in use.  See if the current string
   * has already been inserted, and if so, increment its count.
   */

  for (ptr = (table->table)[val];NULL != ptr; ptr = ptr -> next)
    if (0 == strcmp(key, ptr->key))
    {
      void *old_data;

      old_data = ptr->data;
      ptr -> data = data;
      return old_data;
    }

  /*
   * This key must not be in the table yet.  We'll add it to the head of
   * the list at this spot in the hash table.  Speed would be
   * slightly improved if the list was kept sorted instead.  In this case,
   * this code would be moved into the loop above, and the insertion would
   * take place as soon as it was determined that the present key in the
   * list was larger than this one.
   */

  ptr = (htbucket *)malloc(sizeof(htbucket));
  if (NULL==ptr)
    return 0;
  ptr -> key = strdup(key);
  ptr -> data = data;
  ptr -> next = (table->table)[val];
  (table->table)[val] = ptr;
  return data;
}


void *htlookup(char *key, hthash_table *table)
{
  unsigned val = hthash(key) % table->size;
  htbucket *ptr;

  if (NULL == (table->table)[val])
    return NULL;

  for ( ptr = (table->table)[val];NULL != ptr; ptr = ptr->next )
  {
    if (0 == strcmp(key, ptr -> key ) ) {
      return ptr->data;
    }
  }
  return NULL;
}

void *htdel(char *key, hthash_table *table)
{
  unsigned val = hthash(key) % table->size;
  void *data;
  htbucket *ptr, *last = NULL;

  if (NULL == (table->table)[val])
    return NULL;

  /*
   * Traverse the list, keeping track of the previous node in the list.
   * When we find the node to delete, we set the previous node's next
   * pointer to point to the node after ourself instead.  We then delete
   * the key from the present node, and return a pointer to the data it
   * contains.
   */

  for (last = NULL, ptr = (table->table)[val];
       NULL != ptr;
       last = ptr, ptr = ptr->next)
  {
    if (0 == strcmp(key, ptr -> key))
    {
      if (last != NULL )
      {
  data = ptr -> data;
  last -> next = ptr -> next;
  free(ptr->key);
  free(ptr);
  return data;
      }

      /*
       * If 'last' still equals NULL, it means that we need to
       * delete the first node in the list. This simply consists
       * of putting our own 'next' pointer in the array holding
       * the head of the list.  We then dispose of the current
       * node as above.
       */

      else
      {
  data = ptr->data;
  (table->table)[val] = ptr->next;
  free(ptr->key);
  free(ptr);
  return data;
      }
    }
  }

  /*
   * If we get here, it means we didn't find the item in the table.
   * Signal this by returning NULL.
   */

  return NULL;
}

void htfree_node(char *key, void *data, void *otherData)
{
  htfreeNodeData *oData;
  (void)data;
  oData = (htfreeNodeData *)otherData;

  if (oData->function) {
    void *toFree = htdel(key,oData->the_table);
    oData->function(toFree);
  }
  else {
    htdel(key,oData->the_table);
  }
}

void htfree_table(hthash_table *table, void (*func)(void *))
{
  htfreeNodeData freeData;
  freeData.function = func;
  freeData.the_table = table;
  htenumerate( table, htfree_node, &freeData);
  free(table->table);
  table->table = NULL;
  table->size = 0;
}

void htenumerate( hthash_table *table, void (*func)(char *, void *, void *), void *otherData)
{
  unsigned i;
  htbucket *temp;

  htbucket *nextPtr;
  for (i=0;i<table->size; i++)
  {
    if ((table->table)[i] != NULL)
    {
      nextPtr = (table->table)[i]->next;
      for (temp = (table->table)[i];
     NULL != temp;
     temp = nextPtr)
      {
  nextPtr = temp->next;
  func(temp -> key, temp->data, otherData);
      }
    }
  }
}

void printer(char *key, void *data, void *otherData)
{
  (void)otherData;
  printf("Key = [%s], data = %s\n", key, (char *)data);
}

void htprint(hthash_table *table)
{
  printf("Printing table\n");
  htenumerate(table, printer, NULL);
}

char* get64BitFormatWrapped(char* pre, char* post)
{
  long int i = 0;
  char* middle = "";
  char* result;
  int len;
  if(!pre) {
    pre = "";
  }
  if(!post) {
    post = "";
  }
  if(sizeof(i) == 4) {
    middle = "%lld";
  }
  else if(sizeof(i) == 8) {
    middle = "%ld";
  }
  else if(sizeof(i) == 16) {
    middle = "%hd";
  }

#ifdef _WINDOWS
  len = _snprintf(NULL, 0, "%s%s%s", pre, middle, post);
#else
  len = snprintf(NULL, 0, "%s%s%s", pre, middle, post);
#endif
  if(len < 0) {
    len = strlen(pre) + strlen(post) + strlen(middle);
  }
  result = (char*)malloc((len + 1) * sizeof(char));
#ifdef _WINDOWS
  _snprintf(result, len, "%s%s%s", pre, middle, post);
#else
  snprintf(result, len, "%s%s%s", pre, middle, post);
#endif

  return result;
}

char* get64BitFormat()
{
  long int i = 0;
  if(sizeof(i) == 4) {
    return "%lld";
  }
  else if(sizeof(i) == 8) {
    return "%d";
  }
  else if(sizeof(i) == 16) {
    return "%hd";
  }
}

---