Changeset 9611


Ignore:
Timestamp:
2005-04-08T15:35:12+12:00 (19 years ago)
Author:
kjdon
Message:

added in x++ -> ++x changes submitted by Emanuel Dejanu

Location:
trunk/gsdl/src/mgpp/text
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/gsdl/src/mgpp/text/FIvfLevelInfo.cpp

    r2468 r9611  
    8888    levelInfo[thisLevel.levelTag] = thisLevel;
    8989   
    90     arrSize--;
     90    --arrSize;
    9191  }
    9292
    … …  
    108108    if (!(*here).second.Write (f)) return false;
    109109   
    110     here++;
     110    ++here;
    111111  }
    112112
    … …  
    123123  while (here != end) {
    124124    s << (*here).second;
    125     here++;
     125    ++here;
    126126  }
    127127 

  • trunk/gsdl/src/mgpp/text/FText.cpp

    r2468 r9611  
    9494    levelInfo[thisLevel.levelTag] = thisLevel;
    9595   
    96     arrSize--;
     96    --arrSize;
    9797  }
    9898
    … …  
    110110    if (!(*here).second.Write (f)) return false;
    111111   
    112     here++;
     112    ++here;
    113113  }
    114114
    … …  
    121121  while (here != end) {
    122122    s << (*here).second;
    123     here++;
     123    ++here;
    124124  }
    125125 
    … …  
    185185    if (!idx.Read(f)) return false;
    186186    a.push_back (idx);
    187     arrSize --;
     187    --arrSize;
    188188  }
    189189
    … …  
    196196  while (here != end) {
    197197    if (!(*here).Write(f)) return false;
    198     here++;
     198    ++here;
    199199  }
    200200 

  • trunk/gsdl/src/mgpp/text/FileBuf.h

    r2514 r9611  
    6565
    6666  inline bool Next () {
    67     if (here != end || NextBuf()) { here++; return true; }
     67    if (here != end || NextBuf()) { ++here; return true; }
    6868    return false;
    6969  }

  • trunk/gsdl/src/mgpp/text/FragLevelConvert.cpp

    r3347 r9611  
    4747  unsigned long fragNum = 0;
    4848  unsigned long i;
    49   for (i=0; i<numLevelDocs; i++) {
     49  for (i=0; i<numLevelDocs; ++i) {
    5050    unsigned long delta = buffer.bblock_decode (B, NULL)-1;
    5151    fragNum += delta;

  • trunk/gsdl/src/mgpp/text/GSDLQueryParser.cpp

    r8691 r9611  
    156156    return 4; // incorrect format
    157157 
    158   here++;
     158  ++here;
    159159  unsigned char c2 = 'a';
    160160  if (here !=end) {

  • trunk/gsdl/src/mgpp/text/QueryResultsSort.h

    r2468 r9611  
    7070    if (comp(*(parallelHeap + secondChild),
    7171         *(parallelHeap + (secondChild - 1))))
    72       secondChild--;
     72      --secondChild;
    7373    swap (*(parallelHeap+holeIndex), *(parallelHeap+secondChild));
    7474    swap (*(docNumHeap+holeIndex), *(docNumHeap+secondChild));
    … …  
    102102 
    103103  unsigned long i = 0;
    104   for (i=1; i<=size; i++)
     104  for (i=1; i<=size; ++i)
    105105    PushHeap (docNumHeap, parallelHeap, i, comp);
    106106}
    … …  
    115115
    116116  unsigned long i;
    117   for (i=size; i>1; i--)
     117  for (i=size; i>1; --i)
    118118    PopHeap (docNumHeap, parallelHeap, i, comp);
    119119}
    … …  
    129129            const Compare &comp) {
    130130  unsigned long i;
    131   for (i=0; i<addSize; i++) {
     131  for (i=0; i<addSize; ++i) {
    132132    if (comp(*(parallelAdd+i), *(parallelHeap))) {
    133133      swap (*(docNumHeap), *(docNumAdd+i));

  • trunk/gsdl/src/mgpp/text/Weights.cpp

    r2468 r9611  
    7474  // read in the weights
    7575  unsigned long i;
    76   for (i=0; i<arrSize; i++) {
     76  for (i=0; i<arrSize; ++i) {
    7777    ReadUL (approxWeightsFile, weightBuf[i]);
    7878  }
    … …  
    8484    table = new float[tableSize];
    8585    table[0] = L;
    86     for (i = 1; i < tableSize; i++)
     86    for (i = 1; i < tableSize; ++i)
    8787      table[i] = table[i - 1] * B;
    8888  }

  • trunk/gsdl/src/mgpp/text/comp_dict.cpp

    r2541 r9611  
    8989    }
    9090
    91   for (i = 0; i < cfh->hd.num_codes; i++, words++)
     91  for (i = 0; i < cfh->hd.num_codes; ++i, ++words)
    9292    {
    9393      register int val, copy;
    … …  
    171171    goto error;
    172172
    173   for (which = 0; which < 2; which++)
     173  for (which = 0; which < 2; ++which)
    174174    switch (cdh.dict_type)
    175175      {

  • trunk/gsdl/src/mgpp/text/hash.h

    r2468 r9611  
    2929        register unsigned long hval;        \
    3030        if (len>25) len = 25;           \
    31         for (hval=0; len; len--)        \
     31        for (hval=0; len; --len)        \
    3232          hval = (hval << 5) - hval + *p++; \
    3333        step = hval % (tablesize - 2) + 1;  \

  • trunk/gsdl/src/mgpp/text/invf.cpp

    r8244 r9611  
    115115 
    116116  unsigned long i;
    117   for (i=0; i<numLevels; i++) {
     117  for (i=0; i<numLevels; ++i) {
    118118    if (!ReadUL (f, levelFreqs[i])) return false;
    119119  }
    … …  
    129129
    130130  unsigned long i;
    131   for (i=0; i<numLevels; i++) {
     131  for (i=0; i<numLevels; ++i) {
    132132    if (!WriteUL (f, levelFreqs[i])) return false;
    133133  }
    … …  
    240240 
    241241  unsigned long i;
    242   for (i=0; i<numLevels; i++) {
     242  for (i=0; i<numLevels; ++i) {
    243243    if (!ReadUL (f, levelFreqs[i])) return false;
    244244  }
    … …  
    254254 
    255255  unsigned long i;
    256   for (i=0; i<numLevels; i++) {
     256  for (i=0; i<numLevels; ++i) {
    257257    if (!WriteUL (f, levelFreqs[i])) return false;
    258258  }
    … …  
    297297    blockIdx.push_back (bi);
    298298   
    299     arraySize--;
     299    --arraySize;
    300300  }
    301301 
    … …  
    311311  while (here != end) {
    312312    if (!(*here).Write (f)) return false;
    313     here++;
     313    ++here;
    314314  }
    315315
    … …  
    392392    equivWords.push_back (wordNum);
    393393   
    394     arraySize--;
     394    --arraySize;
    395395  }
    396396 
    … …  
    408408  while (here != end) {
    409409    if (!WriteUL (f, (*here))) return false;
    410     here++;
     410    ++here;
    411411  }
    412412
    … …  
    428428 
    429429  int i;
    430   for (i=0; i<16; i++) params[i] = 0;
     430  for (i=0; i<16; ++i) params[i] = 0;
    431431}
    432432 
    … …  
    438438
    439439  int i;
    440   for (i=0; i<16; i++) {
     440  for (i=0; i<16; ++i) {
    441441    if (!ReadUL (f, params[i])) return false;
    442442  }
    … …  
    452452
    453453  int i;
    454   for (i=0; i<16; i++) {
     454  for (i=0; i<16; ++i) {
    455455    if (!WriteUL (f, params[i])) return false;
    456456  }
    … …  
    565565    else if (res > 0) break; // not here
    566566   
    567     elNum++;
     567    ++elNum;
    568568  }
    569569
    … …  
    626626    else if (res > 0) break; // not here
    627627   
    628     elNum++;
     628    ++elNum;
    629629  }
    630630
    … …  
    685685    else if (res > 0) break; // not here
    686686   
    687     elNum++;
     687    ++elNum;
    688688  }
    689689
    … …  
    733733    } // else keep looking
    734734   
    735     elNum++;
     735    ++elNum;
    736736  }
    737737  // if we get here, we are either still searching for the first
    … …  
    746746      if (casefold || StartsWith(dictEl.el, el)) {
    747747    elNumList.push_back(elNum);
    748     elNum++;
     748    ++elNum;
    749749      }
    750750
    … …  
    757757      elNumList.push_back(elNum);
    758758    }
    759     elNum++;
     759    ++elNum;
    760760    dictEl.Read (dictFile, numLevels);
    761761  }
    … …  
    798798   }
    799799   
    800     elNum++;
     800    ++elNum;
    801801  }
    802802  // it must be the last term
    … …  
    845845    dictEl.Read(dictFile, numLevels);
    846846    terms.push_back(dictEl.el);
    847     curElNum++;
     847    ++curElNum;
    848848  }
    849849 
    … …  
    899899    dictEl.levelFreqs = NULL;
    900900    terms.push_back(dictEl);
    901     curElNum++;
    902   }
    903 
    904   return true;
    905 }
    906 
    907 
    908 
    909 
    910 
    911 
    912 
    913 
    914 
     901    ++curElNum;
     902  }
     903
     904  return true;
     905}
     906
     907
     908
     909
     910
     911
     912
     913
     914

  • trunk/gsdl/src/mgpp/text/ivf.pass1.cpp

    r3008 r9611  
    207207    blankLevel.levelTag = *levelHere;
    208208    ivfLevel.levelInfo[*levelHere] = blankLevel;
    209     levelHere++;
     209    ++levelHere;
    210210  }
    211211 
    … …  
    219219  // check for start of next fragment
    220220  if (!wordLevelIndex && el.tagName == tagInfo.indexLevel) {
    221     numFrags++;
    222     numChunkFrags++;
     221    ++numFrags;
     222    ++numChunkFrags;
    223223    inFrag = true;
    224224  }
    … …  
    231231    ivfTagInfoOccurOrder.push_back (iIt);
    232232  }
    233   i.tagCount++;
     233  ++i.tagCount;
    234234
    235235  // all open tags count as new tags
    236   numChunkEntries++;
    237   i.fragCount++;
    238   i.chunkFragCount++;
     236  ++numChunkEntries;
     237  ++i.fragCount;
     238  ++i.chunkFragCount;
    239239  i.lastFragNum = numFrags;
    240240 
    … …  
    243243  if (levelIt != ivfLevel.levelInfo.end()) {
    244244    // is a level tag
    245     (*levelIt).second.numEntries++;
    246     (*levelIt).second.workInLevel = true;
     245    ++levelIt->second.numEntries;
     246    levelIt->second.workInLevel = true;
    247247  }
    248248}
    … …  
    289289
    290290    if (!word.empty()) {
    291       numWords++;
     291      ++numWords;
    292292
    293293      if (wordLevelIndex) {
    294     numFrags++;
    295     numChunkFrags++;
     294    ++numFrags;
     295    ++numChunkFrags;
    296296      }
    297297     
    … …  
    310310      }
    311311
    312       i.wordCount++;
    313       i.chunkWordCount++;
     312      ++i.wordCount;
     313      ++i.chunkWordCount;
    314314      if (numFrags > i.lastFragNum) {
    315     numChunkEntries++;
    316     i.fragCount++;
    317     i.chunkFragCount++;
     315    ++numChunkEntries;
     316    ++i.fragCount;
     317    ++i.chunkFragCount;
    318318    i.lastFragNum = numFrags;
    319319      }
    … …  
    335335      if ((*levelHere).second.numEntries > (*levelWorkerPtr).lastLevelDocNum) {
    336336        (*levelWorkerPtr).lastLevelDocNum = (*levelHere).second.numEntries;
    337         (*levelWorkerPtr).count ++;
     337        ++levelWorkerPtr->count;
    338338      }
    339339     
    340       levelHere++;
    341       levelWorkerPtr++;
     340      ++levelHere;
     341      ++levelWorkerPtr;
    342342    }
    343343      }
    … …  
    362362    }
    363363   
    364     wordHere++;
     364    ++wordHere;
    365365  }
    366366
    … …  
    376376    }
    377377   
    378     tagHere++;
     378    ++tagHere;
    379379  }
    380380 
    … …  
    400400    cout << (*tagMapHere).first << " " << tagNum
    401401     << " " << (*tagMapHere).second.chunkFragCount << "\n";
    402     tagNum++;
    403     tagMapHere++;
     402    ++tagNum;
     403    ++tagMapHere;
    404404  }
    405405}
    … …  
    407407
    408408static void OutputChunkInfo (unsigned long mem, bool /*wordLevelIndex*/) {
    409   chunksWritten++;
     409  ++chunksWritten;
    410410
    411411  // sanity check
    … …  
    446446    ivfWordInfo.chunkFragCount = 0;
    447447   
    448     wordHere++;
     448    ++wordHere;
    449449  }
    450450
    … …  
    460460    ivfTagInfo.chunkFragCount = 0;
    461461   
    462     tagHere++;
     462    ++tagHere;
    463463  }
    464464
    … …  
    474474  if (wordLevelIndex) inFrag = true; // unconditional
    475475 
    476   numDocs++;
    477   numChunkDocs++;
     476  ++numDocs;
     477  ++numChunkDocs;
    478478
    479479  // process each text element in this document
    … …  
    488488      ProcessText (tagInfo, *here, inFrag);
    489489   
    490     here++;
     490    ++here;
    491491  }
    492492
    … …  
    533533    lastWord = &((*wordHere).first);
    534534   
    535     wordHere++;
     535    ++wordHere;
    536536  }
    537537
    … …  
    548548    lastWord = &((*tagHere).first);
    549549   
    550     tagHere++;
     550    ++tagHere;
    551551  }
    552552}
    … …  
    613613    while (lwHere != lwEnd) {
    614614      WriteUL (sp, (*lwHere).count);
    615       lwHere++;
     615      ++lwHere;
    616616    }
    617617   
    618618    lastWord = &thisWord;
    619     wordHere++;
     619    ++wordHere;
    620620  }
    621621
    … …  
    638638   
    639639    lastTag = &thisTag;
    640     tagHere++;
     640    ++tagHere;
    641641  }
    642642
    … …  
    669669  while (wordHere != wordEnd) {
    670670    (*wordHere).second.lastFragNum = i;
    671     i++; wordHere++;
     671    ++i; ++wordHere;
    672672  }
    673673
    … …  
    678678  while (tagHere != tagEnd) {
    679679    (*tagHere).second.lastFragNum = i;
    680     i++; tagHere++;
     680    ++i; ++tagHere;
    681681  }
    682682 
    … …  
    698698    register IvfWordInfo &ivfWordInfo = (*(*wordItHere)).second;
    699699    buffer.binary_encode (ivfWordInfo.lastFragNum + 1, wordDictSize + 1, NULL);
    700     oN++;
    701     wordItHere++;
     700    ++oN;
     701    ++wordItHere;
    702702  }
    703703
    … …  
    709709    register IvfTagInfo &ivfTagInfo = (*(*tagItHere)).second;
    710710    buffer.binary_encode (ivfTagInfo.lastFragNum + 1, tagDictSize + 1, NULL);
    711     oN++;
    712     tagItHere++;
     711    ++oN;
     712    ++tagItHere;
    713713  }
    714714

  • trunk/gsdl/src/mgpp/text/ivf.pass2.cpp

    r3008 r9611  
    132132    if (wordBitPtrs == NULL) return;
    133133    unsigned long i;
    134     for (i=0; i<size; i++) wordBitPtrs[i].Clear();
     134    for (i=0; i<size; ++i) wordBitPtrs[i].Clear();
    135135  }
    136136 
    … …  
    235235  void ClearCache () {
    236236    unsigned int i = 0;
    237     for (i=0; i<ISR_SIZE; i++) recCache[i].Clear();
     237    for (i=0; i<ISR_SIZE; ++i) recCache[i].Clear();
    238238  }
    239239 
    … …  
    312312    else
    313313      val = rbs.binary_decode (tagDictSize + 1, NULL) - 1;
    314     pos++;
     314    ++pos;
    315315  }
    316316  return val;
    … …  
    437437  unsigned long tagNum;
    438438  dict_el thisEl;
    439   for (tagNum = 0; tagNum < _idh.tag_dict_size; tagNum++) {
     439  for (tagNum = 0; tagNum < _idh.tag_dict_size; ++tagNum) {
    440440    thisEl.Read (dictFile);
    441441    tagMapDict[thisEl.el].tagNum = tagNum;
    … …  
    483483  mg_ullong lastTotalIBits;
    484484  unsigned long N = _idh.num_frags;
    485   for (dictWordNum=0; dictWordNum<_idh.word_dict_size; dictWordNum++) {
     485  for (dictWordNum=0; dictWordNum<_idh.word_dict_size; ++dictWordNum) {
    486486    // lastTotalIBits is used to detect integer overflow
    487487    lastTotalIBits = totalIBits;
    … …  
    522522  unsigned long dictTagNum;
    523523  N = _idh.num_frags;
    524   for (dictTagNum=0; dictTagNum<_idh.tag_dict_size; dictTagNum++) {
     524  for (dictTagNum=0; dictTagNum<_idh.tag_dict_size; ++dictTagNum) {
    525525    // lastTotalIBits is used to detect integer overflow
    526526    lastTotalIBits = totalIBits;
    … …  
    559559                unsigned long numChunkTags) {
    560560  static unsigned long chunksRead = 0;
    561   chunksRead++;
     561  ++chunksRead;
    562562  cout << "Chunk Number: " << chunksRead << "\n";
    563563  cout << "numChunkDocs " << numDocsInChunk << "\n";
    … …  
    573573    cout << (*tagMapHere).first << " " << tagMapNum << " "
    574574     << bitPtrs.GetTagBitPtr(tagMapNum).here << "\n";
    575     tagMapHere++;
     575    ++tagMapHere;
    576576  }
    577577}
    … …  
    607607  unsigned long numOccur;
    608608  unsigned long wordNum;
    609   for (numOccur=0; numOccur<numChunkWords; numOccur++) {
     609  for (numOccur=0; numOccur<numChunkWords; ++numOccur) {
    610610    wordNum = occurConvert.TranslateWord (numOccur);
    611611    BitPtr &wordPtr = bitPtrs.GetWordBitPtr (wordNum);
    … …  
    616616  }
    617617  unsigned long tagNum;
    618   for (numOccur=0; numOccur<numChunkTags; numOccur++) {
     618  for (numOccur=0; numOccur<numChunkTags; ++numOccur) {
    619619    tagNum = occurConvert.TranslateTag (numOccur);
    620620    BitPtr &tagPtr = bitPtrs.GetTagBitPtr (tagNum);
    … …  
    629629  unsigned long totalIBits = 0; // only dealing with memory
    630630  unsigned long chunkWordCount, chunkFragCount;
    631   for (wordNum=0; wordNum<_idh.word_dict_size; wordNum++) {
     631  for (wordNum=0; wordNum<_idh.word_dict_size; ++wordNum) {
    632632    BitPtr &wordPtr = bitPtrs.GetWordBitPtr (wordNum);
    633633    chunkWordCount = wordPtr.start;
    … …  
    647647    }
    648648  }
    649   for (tagNum=0; tagNum<_idh.tag_dict_size; tagNum++) {
     649  for (tagNum=0; tagNum<_idh.tag_dict_size; ++tagNum) {
    650650    BitPtr &tagPtr = bitPtrs.GetTagBitPtr (tagNum);
    651651    chunkFragCount = tagPtr.here;
    … …  
    783783  bool wordLevelIndex = ivfLevel.indexLevel.empty();
    784784  if (!wordLevelIndex && el.tagName == ivfLevel.indexLevel) {
    785     numFrags++;
     785    ++numFrags;
    786786    inFrag = true;
    787787  }
    … …  
    819819
    820820    if (mgWord[0] > 0) {
    821       if (wordLevelIndex) numFrags++;
     821      if (wordLevelIndex) ++numFrags;
    822822
    823823      unsigned long wordNum = perf_hash (wordHashDict, mgWord);
    … …  
    885885  unsigned long delta;
    886886  unsigned long currFreq;
    887   for (wordNum=0; wordNum<idh.word_dict_size; wordNum++) {
     887  for (wordNum=0; wordNum<idh.word_dict_size; ++wordNum) {
    888888    // go to the end of the last inverted file entry
    889889    InvfStateRec &wordDiskState = invfState.GetRec (wordNum);
    … …  
    918918  unsigned long currTagStart;
    919919  unsigned long currTagEnd;
    920   for (tagNum=0; tagNum<idh.tag_dict_size; tagNum++) {
     920  for (tagNum=0; tagNum<idh.tag_dict_size; ++tagNum) {
    921921    // go to the end of the last inverted file entry
    922922    InvfStateRec &tagDiskState = invfState.GetRec (tagNum+idh.word_dict_size);
    … …  
    974974    else ProcessText (*here, inFrag);
    975975   
    976     here++;
     976    ++here;
    977977  }
    978978
    … …  
    982982  while (tdHere != tdEnd) {
    983983    CloseTextTag ((*tdHere).second, (*tdHere).first);
    984     tdHere++;
     984    ++tdHere;
    985985  }
    986986 
    987987  // we've processed one more document
    988   numDocs++;
    989   numChunkDocs++;
     988  ++numDocs;
     989  ++numChunkDocs;
    990990
    991991  // merge the memory based inverted file with the one on
    … …  
    10191019  unsigned long entryNum;
    10201020  mg_ullong lastStart = 0;
    1021   for (entryNum = 0; entryNum < numEntries; entryNum++) {
     1021  for (entryNum = 0; entryNum < numEntries; ++entryNum) {
    10221022    InvfStateRec &stateRec = invfState.GetRec (entryNum);
    10231023
    … …  
    10451045      }
    10461046      putc (c, outInvfFile);
    1047       bytesOutput++;
    1048       oldEntryStart++;
     1047      ++bytesOutput;
     1048      ++oldEntryStart;
    10491049    }
    10501050  } 
    … …  
    10691069  unsigned long numEntries = idh.word_dict_size + idh.tag_dict_size;
    10701070  unsigned long entryNum;
    1071   for (entryNum = 0; entryNum < numEntries; entryNum++) {
     1071  for (entryNum = 0; entryNum < numEntries; ++entryNum) {
    10721072    InvfStateRec &stateRec = invfState.GetRec (entryNum);
    10731073

  • trunk/gsdl/src/mgpp/text/locallib.cpp

    r2928 r9611  
    3636  double bits = 0.0;
    3737
    38   for (i = 0; i < n; i++)
     38  for (i = 0; i < n; ++i)
    3939    total += A[i];
    40   for (i = 0; i < n; i++)
     40  for (i = 0; i < n; ++i)
    4141    if (A[i])
    4242      bits += A[i] * log2 (1.0 * total / A[i]);
    … …  
    7070{
    7171  int i;
    72   for (i = n / 2 - 1; i >= 0; i--)
     72  for (i = n / 2 - 1; i >= 0; --i)
    7373    siftdown (A, i, n);
    7474}
    … …  
    8181  B = (int *) Xmalloc (n * sizeof (int));
    8282  j = 0;
    83   for (i = 0; i < n; i++)
     83  for (i = 0; i < n; ++i)
    8484    {
    8585      if (A[i])
    … …  
    9898      v1 = B[0];
    9999      B[0] = B[n - 1];
    100       n--;
     100      --n;
    101101      siftdown (B, 0, n);
    102102      v2 = B[0];
    … …  
    116116
    117117  last = -1;
    118   for (i = 0; i < n; i++)
     118  for (i = 0; i < n; ++i)
    119119    {
    120120      if (A[i])
    … …  
    122122      bits += BIO_Gamma_Length (i - last) + BIO_Gamma_Length (A[i]);
    123123      last = i;
    124       N++;
     124      ++N;
    125125    }
    126126    }
    … …  
    146146      int j;
    147147      while (limit * limit < p)
    148     limit++;
     148    ++limit;
    149149      for (j = 3; j <= limit && p % j; j += 2)
    150150    ;           /* NULLBODY */
    … …  
    170170      NTOHUL(cdh->dict_type);
    171171      NTOHUL(cdh->novel_method);
    172       for (i = 0; i < TEXT_PARAMS; i++)
     172      for (i = 0; i < TEXT_PARAMS; ++i)
    173173    NTOHUL(cdh->params[i]);
    174174      NTOHUL(cdh->num_words[0]);
    … …  
    208208
    209209  /* [RPAP - Jan 97: Endian Ordering] */
    210   for (i = cfh->hd.mincodelen; i < cfh->hd.maxcodelen + 1; i++)
     210  for (i = cfh->hd.mincodelen; i < cfh->hd.maxcodelen + 1; ++i)
    211211    NTOHUL(cfh->huff_words_size[i]);
    212212

  • trunk/gsdl/src/mgpp/text/mg.special.cpp

    r2468 r9611  
    4848    }
    4949   
    50     here++;
     50    ++here;
    5151  }
    5252 

  • trunk/gsdl/src/mgpp/text/mgpp_invf_dict.cpp

    r3015 r9611  
    8787  word_dict_el wordEl;
    8888  wordEl.SetNumLevels (idh.num_levels);
    89   for (wordNum=0; wordNum<idh.word_dict_size; wordNum++) {
     89  for (wordNum=0; wordNum<idh.word_dict_size; ++wordNum) {
    9090    // read in the next word and inverted file pointer
    9191    wordEl.Read (dictFile, idh.num_levels);
    … …  
    116116    wordBlockEl.invf_ptr = wordInvfPtr;
    117117    unsigned long tempI;
    118     for (tempI=0; tempI<idh.num_levels; tempI++)
     118    for (tempI=0; tempI<idh.num_levels; ++tempI)
    119119      wordBlockEl.levelFreqs[tempI] = wordEl.levelFreqs[tempI];
    120120
    … …  
    141141  dict_el tagEl;
    142142  lastEl.erase (lastEl.begin(), lastEl.end());
    143   for (tagNum=0; tagNum<idh.tag_dict_size; tagNum++) {
     143  for (tagNum=0; tagNum<idh.tag_dict_size; ++tagNum) {
    144144    // read in the next tag and inverted file pointer
    145145    tagEl.Read (dictFile);

  • trunk/gsdl/src/mgpp/text/mgpp_invf_dict_dump.cpp

    r3015 r9611  
    7474    word_dict_el wordEl;
    7575    wordEl.SetNumLevels (idh.num_levels);
    76     for (wordNum=0; wordNum<idh.word_dict_size; wordNum++) {
     76    for (wordNum=0; wordNum<idh.word_dict_size; ++wordNum) {
    7777      wordEl.Read (dictFile, idh.num_levels);
    7878      cout << "\"" << wordEl.el << "\"\n";// (" << wordNum << ")\n";
    … …  
    8888    unsigned long tagNum;
    8989    dict_el tagEl;
    90     for (tagNum=0; tagNum<idh.tag_dict_size; tagNum++) {
     90    for (tagNum=0; tagNum<idh.tag_dict_size; ++tagNum) {
    9191      // read in the next tag and inverted file pointer
    9292      tagEl.Read (dictFile);

  • trunk/gsdl/src/mgpp/text/mgpp_invf_dump.cpp

    r3015 r9611  
    6464    unsigned long fragNum = 0;
    6565    unsigned long i;
    66     for (i=0; i<wordEl.frag_occur; i++) {
     66    for (i=0; i<wordEl.frag_occur; ++i) {
    6767      unsigned long delta = buffer.bblock_decode (B, NULL);
    6868      fragNum += delta;
    … …  
    101101    unsigned long fragNum = 0;
    102102    unsigned long i;
    103     for (i=0; i<tagEl.frag_occur; i++) {
     103    for (i=0; i<tagEl.frag_occur; ++i) {
    104104      unsigned long delta = buffer.bblock_decode (B, NULL)-1;
    105105      fragNum += delta;
    … …  
    172172    word_dict_el wordEl;
    173173    wordEl.SetNumLevels (idh.num_levels);
    174     for (wordNum=0; wordNum<idh.word_dict_size; wordNum++) {
     174    for (wordNum=0; wordNum<idh.word_dict_size; ++wordNum) {
    175175      wordEl.Read (dictFile, idh.num_levels);
    176176      ReadUL (invfIdxFile, wordStart);
    … …  
    184184    unsigned long tagStart;
    185185    dict_el tagEl;
    186     for (tagNum=0; tagNum<idh.tag_dict_size; tagNum++) {
     186    for (tagNum=0; tagNum<idh.tag_dict_size; ++tagNum) {
    187187      tagEl.Read (dictFile);
    188188      ReadUL (invfIdxFile, tagStart);

  • trunk/gsdl/src/mgpp/text/mgpp_passes.cpp

    r8691 r9611  
    118118  if ((in_fd = open (files[0], O_RDONLY)) == -1)
    119119    FatalError (1, "Cannot open %s", files[0]);
    120   files++;
    121   num_files--;
     120  ++files;
     121  --num_files;
    122122  return (in_fd);
    123123}
    … …  
    134134
    135135  // initialise all the passes
    136   for (pass = 0; pass < MAX_PASSES; pass++) {
     136  for (pass = 0; pass < MAX_PASSES; ++pass) {
    137137    if (Passes & (1 << pass)) {
    138138      if (PassData[pass].init (tagInfo, file_name) == COMPERROR)
    … …  
    155155
    156156      // give this document to each pass
    157       for (pass = 0; pass < MAX_PASSES; pass++) {
     157      for (pass = 0; pass < MAX_PASSES; ++pass) {
    158158    if (Passes & (1 << pass)) {
    159159      if (PassData[pass].process (tagInfo, doc) == COMPERROR)
    … …  
    164164      // another document has been processed
    165165      numBytes += docLen;
    166       numDocs++;
     166      ++numDocs;
    167167    }
    168168   
    … …  
    171171 
    172172  // do done for each pass
    173   for (pass = 0; pass < MAX_PASSES; pass++) {
     173  for (pass = 0; pass < MAX_PASSES; ++pass) {
    174174    if (Passes & (1 << pass)) {
    175175      if (PassData[pass].done (tagInfo, file_name) == COMPERROR)

  • trunk/gsdl/src/mgpp/text/mgpp_perf_hash_build.cpp

    r3015 r9611  
    8080  word_dict_el wordEl;
    8181  wordEl.SetNumLevels (idh.num_levels);
    82   for (i = 0; i < idh.word_dict_size; i++) {
     82  for (i = 0; i < idh.word_dict_size; ++i) {
    8383    // read the next word and associated information
    8484    wordEl.Read (dictFile, idh.num_levels);

  • trunk/gsdl/src/mgpp/text/mgpp_stem_idx.cpp

    r3015 r9611  
    7171  UCArray stemEl;
    7272  wordEl.SetNumLevels (idh.num_levels);
    73   for (wordNum=0; wordNum<idh.word_dict_size; wordNum++) {
     73  for (wordNum=0; wordNum<idh.word_dict_size; ++wordNum) {
    7474    // read in the next word
    7575    wordEl.Read (dictFile, idh.num_levels);
    … …  
    163163    stemEl.Write (stemDictFile, &lastEl);
    164164   
    165     here++; stemNum++;
     165    ++here; ++stemNum;
    166166  }
    167167

  • trunk/gsdl/src/mgpp/text/mgpp_weights_build.cpp

    r3015 r9611  
    8585  unsigned long tagPtr;
    8686  dict_el thisEl;
    87   for (tagNum = 0; tagNum < idh.tag_dict_size; tagNum++) {
     87  for (tagNum = 0; tagNum < idh.tag_dict_size; ++tagNum) {
    8888    thisEl.Read (dictFile);
    8989    ReadUL (invfIdxFile, tagPtr);
    … …  
    126126  word_dict_el wordEl;
    127127  wordEl.SetNumLevels (idh.num_levels);
    128   for (wordNum=0; wordNum<idh.word_dict_size; wordNum++) {
     128  for (wordNum=0; wordNum<idh.word_dict_size; ++wordNum) {
    129129#ifndef SILENT
    130130    // give a little feedback every 4096 words
    … …  
    149149   
    150150    unsigned long count, i;
    151     for (i=0; i<wordEl.frag_occur; i++) {
     151    for (i=0; i<wordEl.frag_occur; ++i) {
    152152      fragNum += buffer.bblock_decode (B, NULL);
    153153      if (!ifh.word_level_index) count = buffer.gamma_decode (NULL);
    … …  
    171171    if (lastLevelDocNum > 0) {
    172172      AddWeight (w, lastLevelDocNum, termFreq, idf);
    173       checkLevelFreq++;
     173      ++checkLevelFreq;
    174174    }
    175175    lastLevelDocNum = levelDocNum;
    … …  
    181181    if (lastLevelDocNum > 0) {
    182182      AddWeight (w, lastLevelDocNum, termFreq, idf);
    183       checkLevelFreq++;
     183      ++checkLevelFreq;
    184184    }
    185185
    … …  
    209209//      cout << *here << "\n";
    210210    WriteF (weightsFile, sqrt (*here));
    211     here++;
     211    ++here;
    212212  }
    213213}
    … …  
    229229    if (wgt > U) U = wgt;
    230230    if (wgt > 0 && wgt < L) L = wgt;
    231     here++;
     231    ++here;
    232232  }
    233233
    … …  
    271271    }
    272272
    273     here++; i++;
     273    ++here; ++i;
    274274  }
    275275
    … …  
    376376            w, bits);
    377377   
    378     levelHere++; levelNum++;
     378    ++levelHere; ++levelNum;
    379379  }
    380380 

  • trunk/gsdl/src/mgpp/text/stemmer.cpp

    r2468 r9611  
    4444
    4545  /* casefold and simplify-fold */
    46   for (i=0; i<len; i++) {
     46  for (i=0; i<len; ++i) {
    4747    out[i+1] = unicode_tosimplified(unicode_tolower(out[i+1]));
    4848  }
    … …  
    5959  /* copy and case-fold the description */
    6060  for (i=0; (stemmerdescription[i] != '\0') &&
    61      (i < MAX_STEM_DESCRIPTION_LEN-1); i++)
     61     (i < MAX_STEM_DESCRIPTION_LEN-1); ++i)
    6262    descript[i] = tolower (stemmerdescription[i]);
    6363  descript[i] = '\0';

  • trunk/gsdl/src/mgpp/text/text.cpp

    r2468 r9611  
    8181compression_dict::compression_dict () {
    8282  int which;
    83   for (which = 0; which < 2; which++) {
     83  for (which = 0; which < 2; ++which) {
    8484    cfh[which] = NULL;
    8585    values[which] = NULL;
    … …  
    102102void compression_dict::Clear () {
    103103  int which;
    104   for (which = 0; which < 2; which++) {
     104  for (which = 0; which < 2; ++which) {
    105105    if (cfh[which] != NULL) {
    106106      delete cfh[which];

  • trunk/gsdl/src/mgpp/text/text.pass1.cpp

    r3008 r9611  
    102102  ChangeMem (POOL_SIZE);
    103103 
    104   for (which = 1; which >= 0; which--) {
     104  for (which = 1; which >= 0; --which) {
    105105    u_char *word;
    106106    hash_rec *ent;
    … …  
    122122    word = Pool;
    123123    *Pool++ = '\0';
    124     PoolLeft--;
     124    --PoolLeft;
    125125    {
    126126      register u_char *wptr;
    … …  
    165165    else PARSE_NON_WORD (Word, s_in, end);
    166166   
    167     dd->wordnum++;
     167    ++dd->wordnum;
    168168    inputbytes += *Word;
    169     dd->words_read++;
     169    ++dd->words_read;
    170170   
    171171    /* Search the hash table for Word */
    … …  
    196196      Pool += len;
    197197      PoolLeft -= len;
    198       dd->HashUsed++;
     198      ++dd->HashUsed;
    199199      dd->bytes_diff += Word[0];
    200200      break;
    … …  
    205205    s2 = ent->word;
    206206    len = *s1 + 1;
    207     for (; len; len--)
     207    for (; len; --len)
    208208      if (*s1++ != *s2++) break;
    209209   
    … …  
    212212      if (hashval >= (unsigned long)hsize) hashval -= hsize;
    213213    } else {
    214       ent->wcnt++;
     214      ++ent->wcnt;
    215215      break;
    216216    }
    … …  
    231231      memset (ht, '\0', sizeof (hash_rec) * size);
    232232
    233       for (i = 0; i < dd->HashSize; i++)
     233      for (i = 0; i < dd->HashSize; ++i)
    234234    if (dd->HashTable[i].word) {
    235235      register u_char *wptr;
    … …  
    272272    if (retValue != COMPALLOK) return retValue;
    273273   
    274     here++;
     274    ++here;
    275275  }
    276276
    … …  
    279279
    280280  // update header information
    281   csh.num_docs++;
     281  ++csh.num_docs;
    282282  csh.num_bytes += docLen;
    283283 
    … …  
    288288static int PackHashTable (dict_data * dd) {
    289289  int s, d;
    290   for (s = d = 0; (unsigned int)s < dd->HashSize; s++)
     290  for (s = d = 0; (unsigned int)s < dd->HashSize; ++s)
    291291    if (dd->HashTable[s].word)
    292292      dd->HashTable[d++] = dd->HashTable[s];
    … …  
    321321  fsh.num_frags = dd->HashSize;
    322322  fsh.mem_for_frags = dd->HashSize;
    323   for (j = 0; j < dd->HashSize; j++)
     323  for (j = 0; j < dd->HashSize; ++j)
    324324    fsh.mem_for_frags += dd->HashTable[j].word[0];
    325325 
    … …  
    330330  fwrite (&fsh, sizeof (fsh), 1, fp);
    331331 
    332   for (j = 0; j < dd->HashSize; j++) {
     332  for (j = 0; j < dd->HashSize; ++j) {
    333333    curr = dd->HashTable[j].word;
    334334   

  • trunk/gsdl/src/mgpp/text/words.h

    r8691 r9611  
    129129                     ++numeric <= MAXNUMERIC))) {  \
    130130      while (charlength-- > 0) {                                   \
    131         *wptr++ = *(s_in)++; length++;                             \
     131        *wptr++ = *(s_in)++; ++length;                             \
    132132      }                                                            \
    133133      charlength = parse_utf8_char((s_in),(end),&c);               \
    … …  
    157157       !is_unicode_letdig(c)) {                                \
    158158      while (charlength-- > 0) {                                   \
    159         *wptr++ = *(s_in)++; length++;                             \
     159        *wptr++ = *(s_in)++; ++length;                             \
    160160      }                                                            \
    161161      charlength = parse_utf8_char((s_in),(end),&c);               \
Note: See TracChangeset for help on using the changeset viewer.