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

#ifdef _WINDOWS
#include <windows.h>
#include <winsock.h>
#include "oaa-windows.h"
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>     /* close        */
#include <sys/time.h>   /* For polling time */
#include <sys/stat.h>
#include <fcntl.h>
#endif

#include "stdpccts.h"

#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include "liboaa.h"

#include "filetermreader.h"
#include "libicl_private.h"
#include "stringbuffer.h"
#include "stringbuffer_private.h"

#ifdef _WINDOWS
// VC++ does not support const ints inside of array
// sizes. The following is an "enum hack" to get around
// this bug.
enum { INITBUFFERSZ = 8388608 };
enum { AMOUNTTOREAD = 8192 };
#else
static const size_t INITBUFFERSZ = 8;
static const size_t AMOUNTTOREAD = 8192;
#endif

struct FileTermReaderStruct
{
  TermReader* superReader;
  char* currentBuffer;
  size_t bufCapacity;
  size_t bufUsed;
  FILE* fileHandle;
  stringbuffer_filter_t filterFunction;
  void* filterState;
}
;

struct FilterPercentStateStruct
{
  int currentlyDiscarding;
  int discardNewlineIfNext;
};

void fileTermReader_cleanup(TermReader*);
ICLTerm* fileTermReader_getNext(TermReader*, double);
void fileTermReader_fillData(FileTermReader* sr);
void fileTermReader_addToCurrentBuffer(FileTermReader* sr, char* buf, ssize_t len);

static const char NEWLINE_CHAR = '\n';
static const char CARRIAGE_RETURN = '\r'; 
static const char PERCENT = '%';

FilterPercentState* filterPercent_createState()
{
  FilterPercentState* result = (FilterPercentState*)malloc(sizeof(FilterPercentState));
  if(result) {
    memset(result, 0, sizeof(FilterPercentState));
  }

  return result;
}

int* filterPercent_filter(void* voidState, char toFilter, int* spaceForChar)
{
  FilterPercentState* state = (FilterPercentState*)voidState;
  if(state->currentlyDiscarding) {
    if(toFilter == NEWLINE_CHAR || toFilter == CARRIAGE_RETURN) {
      /*
      printf("Reached end of line\n");
      */
      state->currentlyDiscarding = FALSE;
    }
    else {
      /*
      printf("Discarding %i\n", toFilter);
      */
    }
    return NULL;
  }
  else if(toFilter == PERCENT) {
    /*
    printf("Found percent\n");
    */
    state->currentlyDiscarding = TRUE;
    return NULL;
  }
  else {
    /*
    printf("Not filtering %i\n", toFilter);
    */
    *spaceForChar = toFilter;
    return spaceForChar;
  }
}

FileTermReader* fileTermReader_create(TermReader* t, FILE* fileHandle)
{
  FileTermReader* r = (FileTermReader*)malloc(sizeof(FileTermReader));
  memset(r, 0, sizeof(FileTermReader));
  r->superReader = t;
  r->currentBuffer = (char*)malloc(INITBUFFERSZ);
  r->bufUsed = 0;
  r->bufCapacity = INITBUFFERSZ;
  /*
   * printf("File handle pointer = %p\n", fileHandle);
   */
  r->fileHandle = fileHandle;
  termReader_setReaderSpecificData(t, r);
  termReader_setType(t, FILETERMREADERTYPE);
  termReader_setGetNextCallback(t, fileTermReader_getNext);
  termReader_setCleanupCallback(t, fileTermReader_cleanup);
  termReader_setError(t, TERMREADER_OKAY);
  return r;
}

FileTermReader* fileTermReader_createWithFilter(TermReader* t, FILE* fileHandle, stringbuffer_filter_t filterFunction, void* filterState)
{
  FileTermReader* r = (FileTermReader*)malloc(sizeof(FileTermReader));
  memset(r, 0, sizeof(FileTermReader));
  r->superReader = t;
  r->currentBuffer = (char*)malloc(INITBUFFERSZ);
  r->bufUsed = 0;
  r->bufCapacity = INITBUFFERSZ;
  r->fileHandle = fileHandle;
  r->filterFunction = filterFunction;
  r->filterState = filterState;
  termReader_setReaderSpecificData(t, r);
  termReader_setType(t, FILETERMREADERTYPE);
  termReader_setGetNextCallback(t, fileTermReader_getNext);
  termReader_setCleanupCallback(t, fileTermReader_cleanup);
  termReader_setError(t, TERMREADER_OKAY);
  return r;
}

void fileTermReader_cleanup(TermReader* reader)
{
  FileTermReader* sr = (FileTermReader*)termReader_getReaderSpecificData(reader);
  if(sr->currentBuffer != NULL) {
    free(sr->currentBuffer);
  }
  if(sr != NULL) {
    free(sr);
  }
}

ICLTerm* fileTermReader_getNext(TermReader* reader, double unusedTimeout)
{
  ICLTerm* nextEvent = NULL;
  stringbuffer_t sbuf;
  gboolean done = FALSE;
  gboolean hadOldData = FALSE;
  gboolean forceFill = FALSE;
  int lookedAhead = 0;
  FileTermReader* sr = (FileTermReader*)termReader_getReaderSpecificData(reader);
  unusedTimeout = unusedTimeout;
  
  CHECK_LEAKS();
  /*
  printf("fileTermReader_getNext\n");
  */
  while(!done) {
    if((sr->bufUsed == 0) || forceFill) {
      /*
      printf("fileTermReader_getNext calling fillData\n");
      */
      fileTermReader_fillData(sr);
    }
    else {
      /*
      printf("fileTermReader_getNext hadOldData\n");
      */
      forceFill = FALSE;
      hadOldData = TRUE;
    }

    /*
    printf("fileTermReader_getNext bufUsed = %li\n", sr->bufUsed);
    {
      unsigned int i;
      printf("fileTermReader_getNext buffer contents: ");
      for(i = 0; i < sr->bufUsed; ++i) {
        printf(" %o ", sr->currentBuffer[i]);
      }
      printf("\n");

      {
        char* data = (char*)malloc(sr->bufUsed + 1);
        memset(data, 0, sr->bufUsed + 1);
        memcpy(data, sr->currentBuffer, sr->bufUsed);
        printf("fileTermReader_getNext current buffer contains [%s]\n", data);
        free(data);
      }
    }
    parser_setDebug(TRUE);
    */

    sbuf.data = sr->currentBuffer;
    sbuf.len = sr->bufUsed;
    sbuf.index = 0;
    if(sr->filterFunction) {
      /*
      {
        char* data = (char*)malloc(sr->bufUsed + 1);
        memset(data, 0, sr->bufUsed + 1);
        memcpy(data, sr->currentBuffer, sr->bufUsed);
        fprintf(stderr, "Filtering [%s]\n", data);
        free(data);
      }
      */
      (void)stringbuffer_filter(sr->filterState, sr->filterFunction, &sbuf);
      sr->bufUsed = sbuf.len;
    }
    CHECK_LEAKS();
    if((sr->bufUsed > 0) &&
       (parser_getTermFromBuf(&nextEvent, &sbuf, &lookedAhead) != FALSE)) {
      size_t newUsed;
      size_t read = stringbuffer_getIndex(&sbuf);
      /*
      printf("looked ahead %i\n", lookedAhead);
      */
      read -= lookedAhead;
      CHECK_LEAKS();
      newUsed = sr->bufUsed - read;
      sr->currentBuffer = memmove(sr->currentBuffer,
                                  sr->currentBuffer + read,
                                  newUsed);
      sr->bufUsed = newUsed;
      sr->currentBuffer[sr->bufUsed] = '\0';
      done = TRUE;

      /*
      {
        char* ds = icl_NewStringFromTerm(nextEvent);
        printf("fileTermReader_getNext looks good from file:  got term %s\n", ds);
        icl_stFree(ds);
        {
          char* data = (char*)malloc(sr->bufUsed + 1);
          memset(data, 0, sr->bufUsed + 1);
          memcpy(data, sr->currentBuffer, sr->bufUsed);
          printf("fileTermReader_getNext current buffer contains [%s]\n", data);
          free(data);
        }
      }
      */

      parser_setDebug(FALSE);
      CHECK_LEAKS();
      return nextEvent;
    }
    CHECK_LEAKS();
    parser_setDebug(FALSE);

    if(termReader_getError(reader) != TERMREADER_OKAY) {
      /*
      printf("fileTermReader_getNext termReader_getError != TERMREADER_OKAY\n");
      */
      CHECK_LEAKS();
      return NULL;
    }
    else if(hadOldData) {
      /*
      printf("fileTermReader_getNext hadOldData, now forceFill\n");
      */
      forceFill = TRUE;
      hadOldData = FALSE;
      CHECK_LEAKS();
      continue;
    }
    else {
      /*
      printf("fileTermReader_getNext just continuing\n");
      */
      CHECK_LEAKS();
      continue;
    }
  }
  /*
  printf("fileTermReader_getNext NULL return\n");
  */
  CHECK_LEAKS();
  return NULL;
}

void fileTermReader_fillData(FileTermReader* sr)
{
  char buf[AMOUNTTOREAD + 1];
  ssize_t numBytes = 0;
  int nextChar = EOF;
  size_t i;

  for(i = 0; i < AMOUNTTOREAD; ++i) {
    nextChar = fgetc(sr->fileHandle);
    if(nextChar == EOF) {
      break;
    }
    else {
      buf[i] = (char)nextChar;
      ++numBytes;
    }
  }

  /*
  printf("Filled with %li bytes\n", numBytes);
  */

  buf[numBytes] = '\0';

  if(numBytes == 0) {
    termReader_setError(sr->superReader, TERMREADER_EOF);
    return;
  }

  fileTermReader_addToCurrentBuffer(sr, buf, numBytes);
  termReader_setError(sr->superReader, TERMREADER_OKAY);
}

void fileTermReader_addToCurrentBuffer(FileTermReader* sr, char* buf, ssize_t len)
{
  // Check our current buffer capacity--double or halve it as appropriate
  // Actually, I don't know if halving it is efficient or not...
  size_t needCapacity = len + sr->bufUsed + 1;

  if(needCapacity > sr->bufCapacity) {
    while(sr->bufCapacity < needCapacity) {
      sr->bufCapacity *= 2;
    }
    sr->currentBuffer = realloc(sr->currentBuffer, sr->bufCapacity);
  }
  else if(needCapacity < (sr->bufCapacity / 2)) {
    sr->bufCapacity /= 2;
    sr->currentBuffer = realloc(sr->currentBuffer, sr->bufCapacity);
  }
  else {
    // Just leave it alone
  }

  memcpy(sr->currentBuffer + sr->bufUsed, buf, len);
  sr->bufUsed += len;
  sr->currentBuffer[sr->bufUsed] = '\0';
}

---