Ignore:
Timestamp:
2004-11-29T15:04:28+13:00 (20 years ago)
Author:
kjdon
Message:

Added the changes from Emanuel Dejanu (Simple Words) - mostly efficiency changes. For example, changing i++ to ++i, delete xxx to delete []xxx, some stuff to do with UCArrays...

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/gsdl/src/mgpp/text/TextGet.cpp

    r2928 r8691  
    2020 **************************************************************************/
    2121
     22// is important to be first, so we escape the truncation warning on VC++
     23#include "TextGet.h"
    2224// need this to avoid bizarre compiler problems under VC++ 6.0
    2325#if defined (__WIN32__) && !defined (GSDL_USE_IOS_H)
     
    2527#endif
    2628
    27 #include "TextGet.h"
    2829#include "mg_files.h"
    2930#include "netorder.h"
     
    4950  memset (ad, '\0', sizeof (*ad));
    5051
    51   for (i = 0; i <= 1; i++)
     52  for (i = 0; i <= 1; ++i)
    5253    {
    5354      int j;
     
    7778
    7879      pos = ad->word_data[i];
    79       for (j = 0; j < (int)ad->afh[i].num_frags; j++)
     80      for (j = 0; j < (int)ad->afh[i].num_frags; ++j)
    8081    {
    8182      ad->words[i][j] = pos;
     
    9394          ad->blk_end[i][num] = ad->blk_start[i][num] +
    9495        (ad->blk_end[i][num - 1] - ad->blk_start[i][num - 1]) * 2;
    95           num++;
     96          ++num;
    9697        }
    9798    }
     
    115116  lookback = cd.cdh.lookback;
    116117
    117   for (i = cfh->hd.mincodelen; i <= cfh->hd.maxcodelen; i++) {
     118  for (i = cfh->hd.mincodelen; i <= cfh->hd.maxcodelen; ++i) {
    118119    ptrs_reqd += (cfh->hd.lencount[i] + ((1 << lookback) - 1)) >> lookback;
    119120    mem_reqd += cfh->huff_words_size[i];
     
    135136  values[0] = vals;
    136137  values[0][0] = next_word[0];
    137   for (i = 1; i <= cfh->hd.maxcodelen; i++)
     138  for (i = 1; i <= cfh->hd.maxcodelen; ++i)
    138139    {
    139140      int next_start = (values[i - 1] - vals) +
     
    146147  memset (num_set, '\0', sizeof (num_set));
    147148
    148   for (i = 0; i < cfh->hd.num_codes; i++)
     149  for (i = 0; i < cfh->hd.num_codes; ++i)
    149150    {
    150151      register int val, copy;
     
    175176    }
    176177      memcpy (last_word[len], word, *word + 1);
    177       num_set[len]++;
     178      ++num_set[len];
    178179    }
    179180  if (cfh->hd.clens)
    180     delete cfh->hd.clens;
     181    delete []cfh->hd.clens;
    181182  cfh->hd.clens = NULL;
    182183  return values;
     
    196197    return 3;
    197198  if (hd->clens)
    198     delete hd->clens;
     199    delete []hd->clens;
    199200  hd->clens = NULL;
    200201  if (type == chars)
     
    239240    return false;
    240241
    241   for (which = 0; which < 2; which++)
     242  for (which = 0; which < 2; ++which)
    242243    switch (cd.cdh.dict_type)
    243244      {
     
    353354  fread (fixup, fixup_mem, sizeof (u_char), text_fast_comp_dict);
    354355
    355   for (p = (u_long *) cd; (u_long) p < (u_long) end; p++)
     356  for (p = (u_long *) cd; (u_long) p < (u_long) end; ++p)
    356357    if (IS_FIXUP (p))
    357358      {
     
    364365  NTOHUL(cd->cdh.dict_type);
    365366  NTOHUL(cd->cdh.novel_method);
    366   for (i = 0; i < TEXT_PARAMS; i++)
     367  for (i = 0; i < TEXT_PARAMS; ++i)
    367368    NTOHUL(cd->cdh.params[i]);
    368369  NTOHUL(cd->cdh.num_words[0]);
     
    372373  NTOHUL(cd->cdh.lookback);
    373374  /* cfh */
    374   for (i = 0; i <= 1; i++)
     375  for (i = 0; i <= 1; ++i)
    375376    {
    376377      int j;
     
    379380      NTOHSI(cd->cfh[i]->hd.mincodelen);
    380381      NTOHSI(cd->cfh[i]->hd.maxcodelen);
    381       for (j = 0; j < MAX_HUFFCODE_LEN + 1; j++)
     382      for (j = 0; j < MAX_HUFFCODE_LEN + 1; ++j)
    382383    {
    383384      NTOHSI(cd->cfh[i]->hd.lencount[j]);
     
    385386    }
    386387      NTOHUL(cd->cfh[i]->uncompressed_size);
    387       for (j = 0; j < MAX_HUFFCODE_LEN + 1; j++)
     388      for (j = 0; j < MAX_HUFFCODE_LEN + 1; ++j)
    388389    NTOHUL(cd->cfh[i]->huff_words_size[j]);
    389390    }
     
    392393  if (cd->cdh.novel_method == MG_NOVEL_DELTA ||
    393394      cd->cdh.novel_method == MG_NOVEL_HYBRID)
    394     for (i = 0; i <= 1; i++)
     395    for (i = 0; i <= 1; ++i)
    395396      {
    396397    int j;
     
    398399    NTOHUL(cd->ad->afh[i].num_frags);
    399400    NTOHUL(cd->ad->afh[i].mem_for_frags);
    400     for (j = 0; j < 33; j++)
     401    for (j = 0; j < 33; ++j)
    401402      {
    402403        NTOHSI(cd->ad->blk_start[i][j]);
     
    406407  NTOHSI(cd->fast_loaded);
    407408
    408   delete fixup;
     409  delete []fixup;
    409410
    410411  // the whole fast comp dict is a bit of a hack so I don't
     
    584585  unsigned long bits = 0;
    585586
     587  if (docText.capacity() < docText.size() + num_bits + 1) {
     588    docText.reserve(docText.size() + num_bits + 1);
     589  }
    586590  // keep decoding bits until enough bits have been decoded
    587591  while (bits < num_bits) {
     
    616620      len = buffer.huff_decode(cd.lens_huff[which]->min_code,
    617621                   cd.lens_vals[which], &bits);
    618       for (i = 0; i < len; i++) {
     622      for (i = 0; i < len; ++i) {
    619623        c = buffer.huff_decode(cd.chars_huff[which]->min_code,
    620624                   cd.chars_vals[which], &bits);
     
    633637          {
    634638        idx = buffer.delta_decode (&bits);
    635         idx--;
     639        --idx;
    636640          }
    637641          break;
     
    640644        int k;
    641645        k = buffer.gamma_decode (&bits);
    642         k--;
     646        --k;
    643647        idx = buffer.binary_decode(ad->blk_end[which][k] -
    644648                       ad->blk_start[which][k] + 1,
     
    650654      base = ad->words[which][idx];
    651655      len = *base++;
    652       for (; len; len--)
     656      for (; len; --len)
    653657        {
    654658          docText.push_back (*base++);
Note: See TracChangeset for help on using the changeset viewer.