Changeset 9612 for trunk/indexers/mgpp


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

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

Location:
trunk/indexers/mgpp/lib
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/indexers/mgpp/lib/bitio_m_abstract.h

    r3365 r9612  
    2222    while (_B_x != 0) {
    2323      _B_x >>= 1;
    24       reply ++;
     24      ++reply;
    2525    }
    2626    return reply;
    … …  
    3535    while (_B_x != 0) {
    3636      _B_x >>= 1;
    37       reply ++;
     37      ++reply;
    3838    }
    3939    return reply;
    … …  
    4444   
    4545    x = 1;
    46     while (!this->bit()) x++;
     46    while (!this->bit()) ++x;
    4747    if (count != NULL) {
    4848      *count += x;
    … …  
    7272      _B_logofb = ceil_log2(_B_b);
    7373      _B_thresh = (1<<_B_logofb) - _B_b;
    74       _B_logofb--;
     74      --_B_logofb;
    7575     
    7676      if (count != NULL) {
    … …  
    7878      }
    7979     
    80       for (_B_i=0; _B_i < _B_logofb; _B_i++) {
     80      for (_B_i=0; _B_i < _B_logofb; ++_B_i) {
    8181    _B_x += _B_x + this->bit();
    8282      }
    … …  
    123123   
    124124    _B_xdivb = this->unary_decode(count);
    125     _B_xdivb--;                   
     125    --_B_xdivb;                   
    126126    while (_B_xdivb--) {
    127127      _B_xx += _B_bb;
    … …  
    136136    register int _B_xdivb = 0;
    137137    check_positive("bblock", _B_xx);
    138     _B_xx--;
     138    --_B_xx;
    139139    while (_B_xx >= _B_bb) {
    140       _B_xdivb++;
     140      ++_B_xdivb;
    141141      _B_xx -= _B_bb;
    142142    }
    … …  
    154154   
    155155    _B_k = this->unary_decode(count);
    156     _B_k--;
     156    --_B_k;
    157157    while (_B_k--) {
    158158      _B_lower = _B_upper+1;
    … …  
    161161    }
    162162    _B_xx = this->binary_decode(_B_upper-_B_lower+1, count);
    163     _B_xx--;
     163    --_B_xx;
    164164    check_positive("gamma", _B_xx+_B_lower);
    165165    return _B_xx+_B_lower;
    … …  
    177177   
    178178    while ((int)_B_xx>_B_upper) {
    179       _B_k++;
     179      ++_B_k;
    180180      _B_lower = _B_upper+1;
    181181      _B_pow *= _B_s;
    … …  
    190190    register int _B_nbits = 0;
    191191   
    192     while(!this->bit()) _B_nbits++;
     192    while(!this->bit()) ++_B_nbits;
    193193    if (count != NULL) {
    194194      *count += _B_nbits*2+1;
    … …  
    219219    register int _B_logx;
    220220    _B_logx = gamma_decode(count);
    221     _B_logx--;
     221    --_B_logx;
    222222    _B_xxx = binary_decode(1<<_B_logx, count);
    223     _B_xxx--;
     223    --_B_xxx;
    224224    return (_B_xxx + (1<<_B_logx));
    225225  }
    … …  
    241241    do {
    242242      __code += __code + bit();
    243       if (count != NULL) (*count) ++;
     243      if (count != NULL) ++(*count);
    244244    } while (__code < *++__mclen);
    245245   
    … …  
    252252    register int __clen = lens[x];
    253253    register unsigned long __code = codes[x];
    254     for (__i=__clen-1; __i>=0; __i--) {
     254    for (__i=__clen-1; __i>=0; --__i) {
    255255      encodeBit((__code >> __i) & 1);
    256256    }
    … …  
    284284   
    285285    check_positive("bblock", _B_xx);
    286     _B_xx--;
     286    --_B_xx;
    287287    while (_B_xx >= _B_bb) {
    288       _B_xdivb++;
     288      ++_B_xdivb;
    289289      _B_xx -= _B_bb;
    290290    }
    … …  
    307307   
    308308    while ((int)(_B_xx)>_B_upper) {
    309       _B_k++;
     309      ++_B_k;
    310310      _B_lower = _B_upper+1;
    311311      _B_pow *= _B_s;

  • trunk/indexers/mgpp/lib/bitio_m_mem.cpp

    r3365 r9612  
    4343      if (remaining != 0) {
    4444    buffer = *pos++;
    45     remaining --;
     45    --remaining;
    4646      } else {
    4747    buffer = 0xff;
    … …  
    6060      if (remaining != 0) {
    6161    buffer = *pos++;
    62     remaining --;
     62    --remaining;
    6363      } else {
    6464    buffer = 0x00;
    … …  
    8181    } else {
    8282      buffer = *pos++;
    83       remaining--;
     83      --remaining;
    8484      btg = sizeof(buffer) * 8;
    8585    }
    … …  
    9090
    9191void mem_bitio_buffer::encodeBit(int b) {
    92   btg--;
     92  --btg;
    9393  if (b) buffer |= (1 << btg);
    9494 
    … …  
    9696    if (remaining) {
    9797      *pos++ = buffer;
    98       remaining--;
     98      --remaining;
    9999    }
    100100    buffer = 0;
    … …  
    107107    if (remaining) {
    108108      *pos++ = buffer;
    109       remaining--;
     109      --remaining;
    110110    }
    111111  }

  • trunk/indexers/mgpp/lib/bitio_m_mems.cpp

    r3365 r9612  
    4646    {
    4747      b = b + b + (base[pos>>3] & (0x80 >> (pos & 0x07)) != 0);
    48       pos ++;
     48      ++pos;
    4949    }
    5050  while(0);
    … …  
    6060int mems_bitio_buffer::bit()
    6161{
    62   pos ++;
     62  ++pos;
    6363  return ((base[(pos-1)>>3] & (0x80 >> ((pos-1) & 0x07))) != 0);
    6464}
    … …  
    7070  else
    7171    base[pos>>3] &= 0xff7f >> (pos & 0x07);
    72   pos++;
     72  ++pos;
    7373}
    7474

  • trunk/indexers/mgpp/lib/bitio_m_random.cpp

    r8692 r9612  
    3636  // make sure the length is a power of 2
    3737  while (len != 0) {
    38     shift ++;
     38    ++shift;
    3939    len = len >> 1;
    4040  }
    … …  
    107107    }
    108108      used = 1;
    109       pos ++;
     109      ++pos;
    110110
    111111      if ((pos >> 3) >= len)
    … …  
    162162{
    163163  //  fprintf(stderr, "Bit in");
    164   pos ++;
     164  ++pos;
    165165  if (((pos - 1) >> 3) >= len)
    166166    {

  • trunk/indexers/mgpp/lib/bitio_m_stdio.cpp

    r3365 r9612  
    8282void stdio_bitio_buffer::encodeBit(int b)
    8383{
    84   btg--;
     84  --btg;
    8585  if (b != 0)
    8686    buffer |= (1 << btg);

  • trunk/indexers/mgpp/lib/local_strings.cpp

    r3365 r9612  
    208208
    209209  while (i < l && *++s1 == *++s2)
    210     i++;
     210    ++i;
    211211  return (i);
    212212}
    … …  
    283283
    284284  memset (buf, '\0', sizeof(buf));
    285   for (i = 0; i < len; i++)
     285  for (i = 0; i < len; ++i)
    286286    {
    287287      strcpy (p, char2str (s[i]));
    … …  
    309309      if (*s == '\\')
    310310    {
    311       s++;
     311      ++s;
    312312      switch (*s++)
    313313        {
    314314        case '\0':
    315315          *d++ = '\\';
    316           s--;
     316          --s;
    317317          break;
    318318        case '\\':
    … …  
    402402
    403403  str_base = str;
    404   for (i = 0; i < len; i++)
     404  for (i = 0; i < len; ++i)
    405405    {
    406406      *str++ = *str255++;

  • trunk/indexers/mgpp/lib/lovinstem.cpp

    r3365 r9612  
    626626      if (rule->end_group)
    627627        break;
    628       rule++;
     628      ++rule;
    629629    }
    630630    }
    … …  
    11661166        }
    11671167    }
    1168       suffix_start++;
     1168      ++suffix_start;
    11691169    }
    11701170  while (not_done && ((ch1 = *suffix_start) != EOS));

  • trunk/indexers/mgpp/lib/mgheap.cpp

    r3365 r9612  
    2626     register int __i;                      \
    2727     register char *__a = (a), *__b = (b);          \
    28      for (__i = (s); __i; __i--)                \
     28     for (__i = (s); __i; --__i)                \
    2929       {                            \
    3030         register char __t = *__a;              \
    … …  
    3939     register int __i;                      \
    4040     register char *__dst = (dst), *__src = (src);      \
    41      for (__i = (s); __i; __i--)                \
     41     for (__i = (s); __i; --__i)                \
    4242       *__dst++ = *__src++;                 \
    4343} while(0)
    … …  
    5353      if (child < num && hc ((char *) heap + child * size,
    5454                 (char *) heap + child * size - size) < 0)
    55     child++;
     55    ++child;
    5656      if (hc ((char *) heap + (curr - 1) * size, (char *) heap + (child - 1) * size) > 0)
    5757    {
    … …  
    9191{
    9292  register int i;
    93   for (i = num / 2; i > 0; i--)
     93  for (i = num / 2; i > 0; --i)
    9494    heap_heapify (heap, size, num, i, hc);
    9595}
    … …  
    111111{
    112112  register int i;
    113   for (i = num; i > 1; i--)
     113  for (i = num; i > 1; --i)
    114114    {
    115115      SWAP (size, (char *) heap, (char *) heap + (i - 1) * size);
    … …  
    122122heap_deletehead (void *heap, int size, int *num, heap_comp hc)
    123123{
    124   (*num)--;
     124  --(*num);
    125125  SWAP (size, (char *) heap, (char *) heap + *num * size);
    126126  heap_heapify (heap, size, *num, 1, hc);
    … …  
    144144heap_additem (void *heap, int size, int *num, heap_comp hc)
    145145{
    146   (*num)++;
     146  ++(*num);
    147147  heap_pullup (heap, size, *num, hc);
    148148}

  • trunk/indexers/mgpp/lib/perf_hash.cpp

    r3365 r9612  
    213213  Stack[StackPos].v = v;
    214214  Stack[StackPos].m = 0;
    215   StackPos++;
     215  ++StackPos;
    216216  while (StackPos)
    217217    {
    218218      int m, b;
    219       StackPos--;
     219      --StackPos;
    220220      e = Stack[StackPos].e;
    221221      v = Stack[StackPos].v;
    … …  
    277277  /* build list of edges for each node */
    278278  for (v = 1; v <= n; FIRST[v++] = 0);
    279   for (e = 1; e <= m; e++)
     279  for (e = 1; e <= m; ++e)
    280280    {
    281281      NEXT[A + e] = FIRST[NODEa[e]];
    … …  
    293293  S.sp = 0;         /* empty the stack */
    294294  mk[0] = ERASED;       /* a sentinel for the test below */
    295   for (v = 1; v <= n; v++)
     295  for (v = 1; v <= n; ++v)
    296296    {
    297297      if (mk[e = norm (unique (v))] == MEMBER)
    … …  
    324324      *n = (int) (num * c + 1);
    325325      /* initialize tables of random integers */
    326       for (i = 0; i < MAX_CH; i++)
    327     for (j = 0; j < MAX_L; j++)
     326      for (i = 0; i < MAX_CH; ++i)
     327    for (j = 0; j < MAX_L; ++j)
    328328      {
    329329#ifndef STRUCT
    … …  
    340340
    341341      /* compute an edge (NODEa[e], NODEb[e], NODEc[e]) for each word */
    342       for (e = 1; e <= num; e++)
     342      for (e = 1; e <= num; ++e)
    343343    {
    344344      /*generate an edge corresponding to the ith word */
    … …  
    363363          if (++j >= MAX_L)
    364364        j = 0;
    365           w++;
     365          ++w;
    366366        }
    367367      while (--l);
    … …  
    460460
    461461  /*for each word compute its place in hash table and check if correct */
    462   for (e = 1; e <= m; e++)
     462  for (e = 1; e <= m; ++e)
    463463    {
    464464      if ((e - 1) != (g[NODEa[e]] ^ g[NODEb[e]] ^ g[NODEc[e]]))
    … …  
    538538  printf ("#define _HFM %d\n#define _HXL %d\n", m, MAX_L);
    539539  printf ("#define _HFA %d\n\nstatic int g[_HFN] = {\n", lc - fc + 1);
    540   for (i = 1; i < n; i++)
     540  for (i = 1; i < n; ++i)
    541541    {
    542542      if (i % 8 == 0)
    … …  
    547547
    548548  printf ("static int mt1[_HFA][_HXL] = {\n");
    549   for (j = fc; j < lc; j++)
     549  for (j = fc; j < lc; ++j)
    550550    {
    551551      printf ("{");
    552       for (i = 0; i < MAX_L - 1; i++)
     552      for (i = 0; i < MAX_L - 1; ++i)
    553553    printf ("%*d,", w, tb0[j][i]);
    554554      printf ("%*d},\n", w, tb0[j][MAX_L - 1]);
    555555    }
    556556  printf ("{");
    557   for (i = 0; i < MAX_L - 1; i++)
     557  for (i = 0; i < MAX_L - 1; ++i)
    558558    printf ("%*d,", w, tb0[lc][i]);
    559559  printf ("%*d}\n", w, tb0[lc][MAX_L - 1]);
    … …  
    561561
    562562  printf ("static int mt2[_HFA][_HXL] = {\n");
    563   for (j = fc; j < lc; j++)
     563  for (j = fc; j < lc; ++j)
    564564    {
    565565      printf ("{");
    566       for (i = 0; i < MAX_L - 1; i++)
     566      for (i = 0; i < MAX_L - 1; ++i)
    567567    printf ("%*d,", w, tb1[j][i]);
    568568      printf ("%*d},\n", w, tb1[j][MAX_L - 1]);
    569569    }
    570570  printf ("{");
    571   for (i = 0; i < MAX_L - 1; i++)
     571  for (i = 0; i < MAX_L - 1; ++i)
    572572    printf ("%*d,", w, tb1[lc][i]);
    573573  printf ("%*d}\n", w, tb1[lc][MAX_L - 1]);
    … …  
    575575
    576576  printf ("static int mt3[_HFA][_HXL] = {\n");
    577   for (j = fc; j < lc; j++)
     577  for (j = fc; j < lc; ++j)
    578578    {
    579579      printf ("{");
    580       for (i = 0; i < MAX_L - 1; i++)
     580      for (i = 0; i < MAX_L - 1; ++i)
    581581    printf ("%*d,", w, tb2[j][i]);
    582582      printf ("%*d},\n", w, tb2[j][MAX_L - 1]);
    583583    }
    584584  printf ("{");
    585   for (i = 0; i < MAX_L - 1; i++)
     585  for (i = 0; i < MAX_L - 1; ++i)
    586586    printf ("%*d,", w, tb2[lc][i]);
    587587  printf ("%*d}\n", w, tb2[lc][MAX_L - 1]);
    … …  
    606606
    607607  MAX_L = 1;
    608   for (i = 0; i < num; i++)
     608  for (i = 0; i < num; ++i)
    609609    {
    610610      unsigned len = keys[i][0];
    611611      u_char *s = keys[i] + 1;
    612       for (; len; len--, s++)
     612      for (; len; len--, ++s)
    613613    translate[*s] = 1;
    614614      if (i)
    … …  
    621621    }
    622622  j = 0;
    623   for (i = 0; i < 256; i++)
     623  for (i = 0; i < 256; ++i)
    624624    if (translate[i])
    625625      translate[i] = j++;
    … …  
    657657    Xfree (g);
    658658#ifndef STRUCT
    659   for (i = 0; i < MAX_CH; i++)
     659  for (i = 0; i < MAX_CH; ++i)
    660660    {
    661661      if (tb0 && tb0[i])
    … …  
    673673    Xfree (tb2);
    674674#else
    675   for (i = 0; i < MAX_CH; i++)
     675  for (i = 0; i < MAX_CH; ++i)
    676676    if (tb && tb[i])
    677677      Xfree (tb[i]);
    … …  
    697697  tb1 = Xmalloc (sizeof (int *) * MAX_CH);
    698698  tb2 = Xmalloc (sizeof (int *) * MAX_CH);
    699   for (i = 0; i < MAX_CH; i++)
     699  for (i = 0; i < MAX_CH; ++i)
    700700    {
    701701      if (tb0)
    … …  
    718718#else
    719719  tb = (tb_entry **)Xmalloc (sizeof (struct tb_entry *) * MAX_CH);
    720   for (i = 0; i < MAX_CH; i++)
     720  for (i = 0; i < MAX_CH; ++i)
    721721    if (tb)
    722722      if (!(tb[i] = (tb_entry *)Xmalloc (sizeof (struct tb_entry) * MAX_L)))
    … …  
    809809
    810810  /* [RPAP - Jan 97: Endian Ordering] */
    811   for (i = 0; i < phd->MAX_N + 1; i++)
     811  for (i = 0; i < phd->MAX_N + 1; ++i)
    812812    HTONSI(phd->g[i]);
    813813
    … …  
    815815
    816816  /* [RPAP - Jan 97: Endian Ordering] */
    817   for (i = 0; i < phd->MAX_N + 1; i++)
     817  for (i = 0; i < phd->MAX_N + 1; ++i)
    818818    NTOHSI(phd->g[i]);
    819819
    820820#ifndef STRUCT
    821   for (i = 0; i < phd->MAX_CH; i++)
     821  for (i = 0; i < phd->MAX_CH; ++i)
    822822    {
    823823      /* [RPAP - Jan 97: Endian Ordering] */
    824824      int j;
    825       for (j = 0; j < phd->MAX_L; j++)
     825      for (j = 0; j < phd->MAX_L; ++j)
    826826    {
    827827      HTONSI(phd->tb0[i][j]);
    … …  
    838838
    839839      /* [RPAP - Jan 97: Endian Ordering] */
    840       for (j = 0; j < phd->MAX_L; j++)
     840      for (j = 0; j < phd->MAX_L; ++j)
    841841    {
    842842      NTOHSI(phd->tb0[i][j]);
    … …  
    846846    }
    847847#else
    848   for (i = 0; i < phd->MAX_CH; i++)
     848  for (i = 0; i < phd->MAX_CH; ++i)
    849849    {
    850850      /* [RPAP - Jan 97: Endian Ordering] */
    851851      int j;
    852       for (j = 0; j < phd->MAX_L; j++)
     852      for (j = 0; j < phd->MAX_L; ++j)
    853853    {
    854854      HTONSL(phd->tb[i][j].tb0);
    … …  
    861861
    862862      /* [RPAP - Jan 97: Endian Ordering] */
    863       for (j = 0; j < phd->MAX_L; j++)
     863      for (j = 0; j < phd->MAX_L; ++j)
    864864    {
    865865      NTOHSL(phd->tb[i][j].tb0);
    … …  
    899899  phd->tb1 = Xmalloc (sizeof (int *) * phd->MAX_CH);
    900900  phd->tb2 = Xmalloc (sizeof (int *) * phd->MAX_CH);
    901   for (i = 0; i < phd->MAX_CH; i++)
     901  for (i = 0; i < phd->MAX_CH; ++i)
    902902    {
    903903      if (phd->tb0)
    … …  
    917917      if (phd->g)
    918918    Xfree (phd->g);
    919       for (i = 0; i < MAX_CH; i++)
     919      for (i = 0; i < MAX_CH; ++i)
    920920    {
    921921      if (phd->tb0 && phd->tb0[i])
    … …  
    939939
    940940  /* [RPAP - Jan 97: Endian Ordering] */
    941   for (i = 0; i < phd->MAX_N + 1; i++)
     941  for (i = 0; i < phd->MAX_N + 1; ++i)
    942942    NTOHSI(phd->g[i]);
    943943
    944   for (i = 0; i < phd->MAX_CH; i++)
     944  for (i = 0; i < phd->MAX_CH; ++i)
    945945    {
    946946      int j;
    … …  
    954954
    955955      /* [RPAP - Jan 97: Endian Ordering] */
    956       for (j = 0; j < phd->MAX_L; j++)
     956      for (j = 0; j < phd->MAX_L; ++j)
    957957    {
    958958      NTOHSI(phd->tb0[i][j]);
    … …  
    963963#else
    964964  phd->tb = (struct tb_entry **)Xmalloc (sizeof (struct tb_entry *) * phd->MAX_CH);
    965   for (i = 0; i < phd->MAX_CH; i++)
     965  for (i = 0; i < phd->MAX_CH; ++i)
    966966    if (phd->tb)
    967967      if (!(phd->tb[i] = (struct tb_entry *)Xmalloc (sizeof (struct tb_entry) * phd->MAX_L)))
    … …  
    973973      if (phd->g)
    974974    Xfree (phd->g);
    975       for (i = 0; i < MAX_CH; i++)
     975      for (i = 0; i < MAX_CH; ++i)
    976976    if (phd->tb && phd->tb[i])
    977977      Xfree (phd->tb[i]);
    … …  
    985985
    986986  /* [RPAP - Jan 97: Endian Ordering] */
    987   for (i = 0; i < phd->MAX_N + 1; i++)
     987  for (i = 0; i < phd->MAX_N + 1; ++i)
    988988    NTOHSI(phd->g[i]);
    989989
    990   for (i = 0; i < phd->MAX_CH; i++)
     990  for (i = 0; i < phd->MAX_CH; ++i)
    991991    {
    992992      int j;
    … …  
    996996
    997997      /* [RPAP - Jan 97: Endian Ordering] */
    998       for (j = 0; j < phd->MAX_L; j++)
     998      for (j = 0; j < phd->MAX_L; ++j)
    999999    {
    10001000      NTOHSL(phd->tb[i][j].tb0);
    … …  
    10151015  if (phd->g)
    10161016    Xfree (phd->g);
    1017   for (i = 0; i < phd->MAX_CH; i++)
     1017  for (i = 0; i < phd->MAX_CH; ++i)
    10181018    if (phd->tb && phd->tb[i])
    10191019      Xfree (phd->tb[i]);
    … …  
    10511051      if (++i >= phd->MAX_L)
    10521052    i = 0;
    1053       l--;
    1054       s++;
     1053      --l;
     1054      ++s;
    10551055    }
    10561056  if (u == v && ++v >= phd->MAX_N)

  • trunk/indexers/mgpp/lib/simplefrenchstem.cpp

    r3365 r9612  
    4646    wordstart[last-1]='l';
    4747      }
    48       last--;
     48      --last;
    4949
    5050    } else {
    51       if (last>=0 && wordstart[last]=='s') last--;
    52       if (last>=0 && wordstart[last]=='r') last--;
    53       if (last>=0 && wordstart[last]=='e') last--;
     51      if (last>=0 && wordstart[last]=='s') --last;
     52      if (last>=0 && wordstart[last]=='r') --last;
     53      if (last>=0 && wordstart[last]=='e') --last;
    5454
    5555      /* letter with accent e + ' -- there are two possible encodings  */
    5656      if (last>=0 && wordstart[last]==0xe9) {
    57     last--;
     57    --last;
    5858      } else if (last>=1 && wordstart[last-1]=='e' && wordstart[last]==0x301) {
    5959    last -= 2;
    6060      }
    6161
    62       if (last >= 1 && wordstart[last]==wordstart[last-1]) last--;
     62      if (last >= 1 && wordstart[last]==wordstart[last-1]) --last;
    6363    }  /* end else */
    6464

  • trunk/indexers/mgpp/lib/strstr.cpp

    r3365 r9612  
    2929  char *s = s1;
    3030
    31   for (p2 = s2, i = 0; *s; p2 = s2, i++, s++)
     31  for (p2 = s2, i = 0; *s; p2 = s2, ++i, ++s)
    3232    {
    33       for (p1 = s; *p1 && *p2 && *p1 == *p2; p1++, p2++)
     33      for (p1 = s; *p1 && *p2 && *p1 == *p2; ++p1, ++p2)
    3434    ;
    3535      if (!*p2)

  • trunk/indexers/mgpp/lib/unitool.cpp

    r3365 r9612  
    14191419    if (leninc > 1) {
    14201420      /* we have to shift the array along */
    1421       for (i=curlen-1; i>=curpos; i--) {
     1421      for (i=curlen-1; i>=curpos; --i) {
    14221422        input[i+leninc] = input[i];
    14231423      }
    … …  
    14271427
    14281428    /* decompose the character */
    1429     for (i=0; i<=leninc; i++) {
     1429    for (i=0; i<=leninc; ++i) {
    14301430      input[curpos+i] = decompose_info[tablepos].str[i];
    14311431    }
    … …  
    14411441    } else {
    14421442      /* the character cannot be decomposed */
    1443       curpos++;
     1443      ++curpos;
    14441444    }
    14451445  }
    … …  
    14871487    min_value = 0; /* 00 */
    14881488   
    1489     while (letter_here < letter_end && letter_here->last < i) letter_here++;
     1489    while (letter_here < letter_end && letter_here->last < i) ++letter_here;
    14901490    if (letter_here < letter_end && letter_here->last <= min_end) {
    14911491      min_start = letter_here->first;
    … …  
    14941494    }
    14951495   
    1496     while (digit_here < digit_end && digit_here->last < i) digit_here++;
     1496    while (digit_here < digit_end && digit_here->last < i) ++digit_here;
    14971497    if (digit_here < digit_end && digit_here->last <= min_end) {
    14981498      min_start = digit_here->first;
    … …  
    15011501    }
    15021502   
    1503     while (space_here < space_end && space_here->last < i) space_here++;
     1503    while (space_here < space_end && space_here->last < i) ++space_here;
    15041504    if (space_here < space_end && space_here->last <= min_end) {
    15051505      min_start = space_here->first;
    … …  
    15301530    unicode_cat_data[i/16] = (unicode_cat_data[i/16] & (~mask)) |
    15311531                  (min_value & mask);
    1532     i++;
     1532    ++i;
    15331533      }
    15341534    }
    … …  
    16161616  /* keep going till you find the null-terminator */
    16171617  while (*str != 0) {
    1618     len++;
    1619     str++;
     1618    ++len;
     1619    ++str;
    16201620  }
    16211621
    … …  
    16291629  /* keep going till you find the null-terminator */
    16301630  while (*str != 0 && len < max_length ) {
    1631     len++;
    1632     str++;
     1631    ++len;
     1632    ++str;
    16331633  }
    16341634
    … …  
    17131713      /* store the character */
    17141714      *outhere = c;
    1715       outhere++;
    1716       outlen++;
     1715      ++outhere;
     1716      ++outlen;
    17171717    }
    17181718  }
    … …  
    17471747    outhere += clen;
    17481748    outlen += clen;
    1749     in_i++;
     1749    ++in_i;
    17501750  }
    17511751
Note: See TracChangeset for help on using the changeset viewer.