binarytermreader.c

来自「SRI international 发布的OAA框架软件」· C语言 代码 · 共 542 行 · 第 1/2 页

          binaryTermReader_cleanupTermList(termList);
          return NULL;
        }
        offset += offsetIncr;
        bufLen -= offsetIncr;
        newTerm = icl_NewVarNoCopy(inString);
        inString = NULL;
      }
      break;
    case BTT_ICLSTR:
      /* printf("binaryTermReader_parseBuffer() hit IclStr offset for dataLen is %i\n", offset); */
      offsetIncr = javadistoglib_readJavaInt(currPos + offset, bufLen, &dataLen);
      if(offsetIncr == 0) {
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      if(dataLen <= 0) {
        fprintf(stderr, "binaryTermReader_parseBuffer() ICLSTR has datalen <= 0\n");
        termReader_setError(br->superReader, TERMREADER_BINBADICLSTR);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      inString = (char*)malloc((dataLen + 1) * sizeof(char));
      offsetIncr = javadistoglib_readJavaChars(currPos + offset, bufLen, dataLen, dataLen + 1, inString);
      if(offsetIncr == 0) {
        /* printf("binaryTermReader_parseBuffer() not enough data for chars (Str)\n"); */
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        free(inString);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      icl_safeStRemoveQuotes(inString, dataLen, &strLen);
      icl_safeStUndoubleQuotes(inString, strLen, &strLen);
      newTerm = icl_NewStrNoCopy(inString);
      inString = NULL;
      break;
    case BTT_ICLDATAQ:
      offsetIncr = javadistoglib_readJavaInt(currPos + offset, bufLen, &dataLen);
      if(offsetIncr == 0) {
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      if(dataLen <= 0) {
        fprintf(stderr, "binaryTermReader_parseBuffer() ICLDATAQ has datalen <= 0\n");
      }
      inData = (char*)malloc(dataLen * sizeof(char));
      offsetIncr = javadistoglib_readJavaBytes(currPos + offset, bufLen, dataLen, dataLen, inData);
      if(offsetIncr == 0) {
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        free(inData);
        return NULL;
      }
      offset += offsetIncr;
      newTerm = icl_NewDataQNoCopy(inData, dataLen);
      inData = NULL;
      break;
    case BTT_ICLSTRUCT:
      /* printf("binaryTermReader_parseBuffer() hit IclStruct\n"); */
      offsetIncr = javadistoglib_readJavaInt(currPos + offset, bufLen, &numArgs);
      if(offsetIncr == 0) {
        /* printf("binaryTermReader_parseBuffer() not enough data for int (numArgs for struct)\n"); */
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      offsetIncr = javadistoglib_readJavaInt(currPos + offset, bufLen, &dataLen);
      offset += offsetIncr;
      bufLen -= offsetIncr;
      if(offsetIncr == 0) {
        /* printf("binaryTermReader_parseBuffer() not enough data for int (dataLen for struct)\n"); */
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      if(dataLen <= 0) {
        fprintf(stderr, "binaryTermReader_parseBuffer() ICLSTRUCT has datalen <= 0\n");
        termReader_setError(br->superReader, TERMREADER_BINBADICLSTRUCT);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      inString = (char*)malloc((dataLen + 1) * sizeof(char));
      offsetIncr = javadistoglib_readJavaChars(currPos + offset, bufLen, dataLen, dataLen + 1, inString);
      if(offsetIncr == 0) {
        /* printf("binaryTermReader_parseBuffer() not enough data for chars (functor)\n"); */
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        free(inString);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      args = icl_NewList(NULL);
      for(i = 0; i < numArgs; ++i) {
        if(g_queue_is_empty(termList)) {
          fprintf(stderr, "binaryTermReader_parseBuffer() ICLSTRUCT not enough args\n");
          termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHARGS);
          binaryTermReader_cleanupTermList(termList);
          return NULL;
        }
        icl_AddToList(args, (ICLTerm*)g_queue_pop_tail(termList), TRUE);
      }
      newTerm = icl_NewStructFromList(inString, args);
      free(inString);
      inString = NULL;
      break;
    case BTT_ICLLIST:
      /* printf("binaryTermReader_parseBuffer() hit IclList\n"); */
      offsetIncr = javadistoglib_readJavaInt(currPos + offset, bufLen, &numArgs);
      if(offsetIncr == 0) {
        /* printf("binaryTermReader_parseBuffer() not enough data for int (numArgs for list)\n"); */
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      newTerm = icl_NewList(NULL);
      for(i = 0; i < numArgs; ++i) {
        if(g_queue_is_empty(termList)) {
          fprintf(stderr, "binaryTermReader_parseBuffer() ICLLIST not enough args\n");
          termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHARGS);
          binaryTermReader_cleanupTermList(termList);
          return NULL;
        }
        icl_AddToList(newTerm, (ICLTerm*)g_queue_pop_tail(termList), TRUE);
      }
      break;
    case BTT_ICLGROUP:
      /* printf("binaryTermReader_parseBuffer() hit IclGroup\n"); */
      offsetIncr = javadistoglib_readJavaInt(currPos + offset, bufLen, &numArgs);
      if(offsetIncr == 0) {
        /* printf("binaryTermReader_parseBuffer() not enough data for int (numArgs for group)\n"); */
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      offsetIncr = javadistoglib_readJavaChar(currPos + offset, bufLen, &starter);
      if(offsetIncr == 0) {
        /* printf("binaryTermReader_parseBuffer() not enough data for char (starter for group)\n"); */
        termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHDATA);
        binaryTermReader_cleanupTermList(termList);
        return NULL;
      }
      offset += offsetIncr;
      bufLen -= offsetIncr;
      newTerm = icl_NewGroup(starter, ",", NULL);
      for(i = 0; i < numArgs; ++i) {
        if(g_queue_is_empty(termList)) {
          fprintf(stderr, "binaryTermReader_parseBuffer() ICLGROUP not enough args\n");
          termReader_setError(br->superReader, TERMREADER_BINNOTENOUGHARGS);
          binaryTermReader_cleanupTermList(termList);
          return NULL;
        }
        icl_AddToList(newTerm, (ICLTerm*)g_queue_pop_tail(termList), TRUE);
      }
      break;
    default:
      fprintf(stderr, "binaryTermReader_parseBuffer() encountered unexpected type: [%i] at offset %i\n", type, offset - offsetIncr);
      termReader_setError(br->superReader, TERMREADER_BINUNEXPECTEDTYPE);
      binaryTermReader_cleanupTermList(termList);
      return NULL;
    }
    g_queue_push_tail(termList, newTerm);
  }
  fprintf(stderr, "binaryTermReader_parseBuffer() unexpected exit from loop\n");
  termReader_setError(br->superReader, TERMREADER_BINUNREACHABLE);
  binaryTermReader_cleanupTermList(termList);
  return NULL;
}

void binaryTermReader_fillData(BinaryTermReader* br, double timeout)
{
  char buf[AMOUNTTOREAD + 1];
  struct timeval time;
  struct timeval* timep = NULL;
  int lastFdPlusOne;
  int selectRes = 0;
  ssize_t numBytes = 0;
  fd_set readfds;

  /* printf("binaryTermReader_fillData()\n"); */
  if(timeout > 0) {
    long i = (long)floor(timeout);
    time.tv_sec = i;
    time.tv_usec = (long)floor((timeout - i) * 1e6);
    timep = &time;
  }

  lastFdPlusOne = termReader_getSocket(br->superReader) + 1;
  FD_ZERO(&readfds);
  FD_SET(termReader_getSocket(br->superReader), &readfds);

  selectRes = select(lastFdPlusOne, &readfds, NULL, NULL, timep);

  switch(selectRes) {
  case -1:
    perror("binaryTermReader_fillData bad select");
    termReader_setError(br->superReader, TERMREADER_SELECTERR);
    return;
  case 0:
    /*fprintf(stderr, "binaryTermReader_fillData time out\n"); */
    termReader_setError(br->superReader, TERMREADER_TIMEOUT);
    return;
  default:
#ifdef _WINDOWS
    numBytes = recv(termReader_getSocket(br->superReader), buf, AMOUNTTOREAD, 0);
#else
    numBytes = read(termReader_getSocket(br->superReader), buf, AMOUNTTOREAD);
#endif

    switch(numBytes) {
    case -1:
      perror("binaryTermReader_fillData bad read");
      termReader_setError(br->superReader, TERMREADER_READERR);
      return;
    case 0:
      /*fprintf(stderr, "binaryTermReader_fillData no connection\n");*/
      termReader_setError(br->superReader, TERMREADER_NOCONN);
      return;
    }
  }

  binaryTermReader_addToCurrentBuffer(br, buf, numBytes);
  termReader_setError(br->superReader, TERMREADER_OKAY);
  /*
  {
    printf("binaryTermReader_fillData() added %i bytes; buffer is now size %i\n", numBytes, br->currentBuffer->len);
  }
  */
}

void binaryTermReader_addToCurrentBuffer(BinaryTermReader* br, char* buf, ssize_t len)
{
  g_byte_array_append(br->currentBuffer, buf, len);
  /*
  size_t needCapacity = len + br->currentBuffer->len + 1;
  char* oldBuf;

  if(needCapacity > br->bufCapacity) {
    while(br->bufCapacity < needCapacity) {
      br->bufCapacity *= 2;
    }
    oldBuf = br->currentBuffer;
    br->currentBuffer = (char*)realloc(br->currentBuffer, br->bufCapacity);
    if(br->currentBuffer == NULL) {
      br->currentBuffer = (char*)malloc(br->bufCapacity);
      memcpy(br->currentBuffer, oldBuf, br->currentBuffer->len);
      free(oldBuf);
    }
  }
  memcpy(br->currentBuffer + br->currentBuffer->len, buf, len);
  br->currentBuffer->len += len;
  */
  /*
    printf("binaryTermReader_addToCurrentBuffer() used = %i\n", br->bufUsed);
  */
}