source: trunk/gsdl/src/mgpp/text/StemIdx.cpp@ 711

#include "sysfuncs.h"

#include "messages.h"
#include "memlib.h"
#include "local_strings.h"
#include "netorder.h"  /* [RPAP - Jan 97: Endian Ordering] */

#include "mg_files.h"
#include "mg.h"
#include "invf.h"
#include "words.h"
#include "backend.h"
#include "StemIdx.h"

#define abort(x) abortvar=x;goto Recovery;

stemmed_idx *StemIdx_header_read(void *f, int notefile, abstractReader reader, abstractGetc creader)
{
  stemmed_idx *si;
  unsigned long i;
  u_char *buffer;
  int abortvar;

  if (!(si = new stemmed_idx))
    {
      abort(0);
    }

  si->MemForStemIdx = 0;
  if (notefile)
    {
      si->stem_idx_file = (File *) f;
    }

  reader (&(si->sih), sizeof (si->sih), 1, f);

  /* [RPAP - Jan 97: Endian Ordering] */
  NTOHUL(si->sih.lookback);
  NTOHUL(si->sih.block_size);
  NTOHUL(si->sih.num_blocks);
  NTOHUL(si->sih.blocks_start);
  NTOHUL(si->sih.index_chars);
  NTOHUL(si->sih.num_of_words);

  if (!(buffer = new u_char[si->sih.index_chars]))
    {
      abort(1);
    }
  si->MemForStemIdx += si->sih.index_chars;

  if (!(si->index = new (u_char *)[si->sih.num_blocks]))
    {
      abort(2);
    }
  si->MemForStemIdx += si->sih.num_blocks * sizeof (*si->index);

  if (!(si->pos = new (unsigned long)[si->sih.num_blocks]))
    {
      abort(3);
    }
  si->MemForStemIdx += si->sih.num_blocks * sizeof (*si->pos);

  if (!(si->buffer = new u_char[si->sih.block_size]))
    {
      abort(4);
    }
  si->MemForStemIdx += si->sih.block_size * sizeof (*si->buffer);

  si->active = -1;

  for (i = 0; i < si->sih.num_blocks; i++)
    {
      register u_char len;
      si->index[i] = buffer;
      len = creader (f);
      *buffer++ = len;
      reader (buffer, sizeof (u_char), len, f);
      buffer += len;
      reader (&si->pos[i], sizeof (*si->pos), 1, f);
      NTOHUL(si->pos[i]);  /* [RPAP - Jan 97: Endian Ordering] */
    }
  return si;

 Recovery:
  switch (abortvar)
    {
      case 4:
    delete si->pos;
      case 3:
    delete si->index;
      case 2:
    delete buffer;
      case 1:
        delete si;
      break;
    }
  return NULL;
}

void StemIdx_block_readNext(void *file, stemmed_idx *si, int block,
                unsigned long **first_word, unsigned short **num_words,
                unsigned short **index, int *num_indexes, abstractSeeker seeker,
                abstractReader reader)
{ 
  int i;

  seeker (file, si->pos[block] + si->sih.blocks_start, 0);
  reader (si->buffer, si->sih.block_size, sizeof (u_char), file);
  si->active = si->pos[block];

  *first_word = (unsigned long *) (si->buffer);
  NTOHUL(**first_word);  /* [RPAP - Jan 97: Endian Ordering] */
  *num_words = (unsigned short *) ((*first_word) + 1);
  NTOHUS(**num_words);  /* [RPAP - Jan 97: Endian Ordering] */
  *index = (*num_words) + 1;
  *num_indexes = (((**num_words) - 1) / si->sih.lookback) + 1;

  /* [RPAP - Jan 97: Endian Ordering] */
  for (i = 0; i < *num_indexes; i++)
    NTOHUS((*index)[i]);
}

void StemIdx_ReadWordString(u_char **base, u_char *prev)
{ 
  mgString::readString(base, prev);
  /*
  unsigned copy, suff;

  copy = **base;
  *base = *base + 1;
  suff = **base;
  *base = *base + 1;

  bcopy ((char *) *base, (char *) (prev + copy + 1), suff);
  *prev = copy + suff;
  *base += suff;
  */
}

void StemIdx_ReadPosEntry(u_char **base, unsigned int *num_cases, unsigned int *blk, 
              unsigned short *blk_index, unsigned short *offset)
{
  bcopy ((char *) *base, (char *) num_cases, sizeof (*num_cases));
  NTOHUI(*num_cases);  /* [RPAP - Jan 97: Endian Ordering] */
  *base += sizeof (*num_cases);
  bcopy ((char *) *base, (char *) blk, sizeof (*blk));
  NTOHUI(*blk);  /* [RPAP - Jan 97: Endian Ordering] */
  *base += sizeof (*blk);
  bcopy ((char *) *base, (char *) blk_index, sizeof (*blk_index));
  NTOHUS(*blk_index);  /* [RPAP - Jan 97: Endian Ordering] */
  *base += sizeof (*blk_index);
  bcopy ((char *) *base, (char *) offset, sizeof (*offset));
  NTOHUS(*offset);  /* [RPAP - Jan 97: Endian Ordering] */
  *base += sizeof (*offset);
}