Merging upstream version 1.1~rc2.

Signed-off-by: Daniel Baumann <mail@daniel-baumann.ch>

1 files changed, 146 insertions, 142 deletions

diff --git a/encoder.h b/encoder.h
index 975fe01..ebd6a69 100644
--- a/encoder.h
+++ b/encoder.h
@@ -1,4 +1,4 @@
-/*  Clzip - A data compressor based on the LZMA algorithm
+/*  Clzip - Data compressor based on the LZMA algorithm
     Copyright (C) 2010 Antonio Diaz Diaz.
 
     This program is free software: you can redistribute it and/or modify
@@ -24,8 +24,9 @@ extern Dis_slots dis_slots;
 
 static inline void Dis_slots_init()
   {
-  for( int slot = 0; slot < 4; ++slot ) dis_slots[slot] = slot;
-  for( int i = 4, size = 2, slot = 4; slot < 24; slot += 2 )
+  int i, size, slot;
+  for( slot = 0; slot < 4; ++slot ) dis_slots[slot] = slot;
+  for( i = 4, size = 2, slot = 4; slot < 24; slot += 2 )
     {
     memset( &dis_slots[i], slot, size );
     memset( &dis_slots[i+size], slot + 1, size );
@@ -49,13 +50,13 @@ extern Prob_prices prob_prices;
 static inline void Prob_prices_init()
   {
   const int num_bits = ( bit_model_total_bits - 2 );
-  for( int i = num_bits - 1; i >= 0; --i )
+  int i, j = 1, end = 2;
+  prob_prices[0] = bit_model_total_bits << price_shift;
+  for( i = num_bits - 1; i >= 0; --i, end <<= 1 )
     {
-    int start = 1 << ( num_bits - i - 1 );
-    int end = 1 << ( num_bits - i);
-    for( int j = start; j < end; ++j )
-      prob_prices[j] = (i << price_shift) +
-          ( ((end - j) << price_shift) >> (num_bits - i - 1) );
+    for( ; j < end; ++j )
+      prob_prices[j] = ( i << price_shift ) +
+                       ( ((end - j) << price_shift) >> (num_bits - i - 1) );
     }
   }
 
@@ -73,10 +74,11 @@ static inline int price_bit( const Bit_model bm, const int bit )
   { if( bit ) return price1( bm ); else return price0( bm ); }
 
 
-static inline int price_symbol( const Bit_model bm[], int symbol, const int num_bits )
+static inline int price_symbol( const Bit_model bm[], int symbol,
+                                const int num_bits )
   {
-  symbol |= ( 1 << num_bits );
   int price = 0;
+  symbol |= ( 1 << num_bits );
   while( symbol > 1 )
     {
     const int bit = symbol & 1;
@@ -92,7 +94,8 @@ static inline int price_symbol_reversed( const Bit_model bm[], int symbol,
   {
   int price = 0;
   int model = 1;
-  for( int i = num_bits; i > 0; --i )
+  int i;
+  for( i = num_bits; i > 0; --i )
     {
     const int bit = symbol & 1;
     symbol >>= 1;
@@ -108,8 +111,9 @@ static inline int price_matched( const Bit_model bm[], const int symbol,
   {
   int price = 0;
   int model = 1;
+  int i;
 
-  for( int i = 7; i >= 0; --i )
+  for( i = 7; i >= 0; --i )
     {
     const int match_bit = ( match_byte >> i ) & 1;
     int bit = ( symbol >> i ) & 1;
@@ -130,86 +134,87 @@ static inline int price_matched( const Bit_model bm[], const int symbol,
   }
 
 
-enum { // bytes to keep in buffer before dictionary
-       mf_before_size = max_num_trials + 1,
-       // bytes to keep in buffer after pos
-       mf_after_size = max_match_len,
-       mf_num_prev_positions4 = 1 << 20,
-       mf_num_prev_positions3 = 1 << 18,
-       mf_num_prev_positions2 = 1 << 16,
-       mf_num_prev_positions = mf_num_prev_positions4 + mf_num_prev_positions3 +
-                               mf_num_prev_positions2 };
+enum { /* bytes to keep in buffer before dictionary */
+       before_size = max_num_trials + 1,
+       /* bytes to keep in buffer after pos */
+       after_size = max_match_len,
+       num_prev_positions4 = 1 << 20,
+       num_prev_positions3 = 1 << 18,
+       num_prev_positions2 = 1 << 16,
+       num_prev_positions = num_prev_positions4 + num_prev_positions3 +
+                               num_prev_positions2 };
 
 struct Matchfinder
   {
   long long partial_data_pos;
-  int dictionary_size_;		// bytes to keep in buffer before pos
+  uint8_t * buffer;		/* input buffer */
+  int32_t * prev_positions;	/* last seen position of key */
+  int32_t * prev_pos_tree;
+  int dictionary_size_;		/* bytes to keep in buffer before pos */
   int buffer_size;
-  uint8_t * buffer;
-  int pos;
-  int cyclic_pos;
-  int stream_pos;		// first byte not yet read from file
-  int pos_limit;		// when reached, a new block must be read
-  int infd_;			// input file descriptor
+  int pos;			/* current pos in buffer */
+  int cyclic_pos;		/* current pos in dictionary */
+  int stream_pos;		/* first byte not yet read from file */
+  int pos_limit;		/* when reached, a new block must be read */
   int match_len_limit_;
-  int32_t * prev_positions;	// last seen position of key
-  int32_t * prev_pos_tree;
-  bool at_stream_end;		// stream_pos shows real end of file
+  int cycles;
+  int infd;			/* input file descriptor */
+  bool at_stream_end;		/* stream_pos shows real end of file */
   };
 
-bool Mf_read_block( struct Matchfinder * const matchfinder );
+bool Mf_read_block( struct Matchfinder * const mf );
 
-void Mf_init( struct Matchfinder * const matchfinder,
-              const int dict_size, const int len_limit, const int infd );
+void Mf_init( struct Matchfinder * const mf,
+              const int dict_size, const int len_limit, const int ifd );
 
-static inline void Mf_free( struct Matchfinder * const matchfinder )
+static inline void Mf_free( struct Matchfinder * const mf )
   {
-  free( matchfinder->prev_pos_tree ); matchfinder->prev_pos_tree = 0;
-  free( matchfinder->prev_positions ); matchfinder->prev_positions = 0;
-  free( matchfinder->buffer ); matchfinder->buffer = 0;
+  free( mf->prev_pos_tree ); mf->prev_pos_tree = 0;
+  free( mf->prev_positions ); mf->prev_positions = 0;
+  free( mf->buffer ); mf->buffer = 0;
   }
 
-static inline uint8_t Mf_peek( struct Matchfinder * const matchfinder, const int i )
-  { return matchfinder->buffer[matchfinder->pos+i]; }
-static inline int Mf_available_bytes( struct Matchfinder * const matchfinder )
-  { return matchfinder->stream_pos - matchfinder->pos; }
-static inline long long Mf_data_position( struct Matchfinder * const matchfinder )
-  { return matchfinder->partial_data_pos + matchfinder->pos; }
-static inline int Mf_dictionary_size( struct Matchfinder * const matchfinder )
-  { return matchfinder->dictionary_size_; }
-static inline bool Mf_finished( struct Matchfinder * const matchfinder )
-  { return matchfinder->at_stream_end && matchfinder->pos >= matchfinder->stream_pos; }
-static inline int Mf_match_len_limit( struct Matchfinder * const matchfinder )
-  { return matchfinder->match_len_limit_; }
-static inline const uint8_t * Mf_ptr_to_current_pos( struct Matchfinder * const matchfinder )
-  { return matchfinder->buffer + matchfinder->pos; }
-
-static inline bool Mf_dec_pos( struct Matchfinder * const matchfinder,
+static inline uint8_t Mf_peek( struct Matchfinder * const mf, const int i )
+  { return mf->buffer[mf->pos+i]; }
+static inline int Mf_available_bytes( struct Matchfinder * const mf )
+  { return mf->stream_pos - mf->pos; }
+static inline long long Mf_data_position( struct Matchfinder * const mf )
+  { return mf->partial_data_pos + mf->pos; }
+static inline int Mf_dictionary_size( struct Matchfinder * const mf )
+  { return mf->dictionary_size_; }
+static inline bool Mf_finished( struct Matchfinder * const mf )
+  { return mf->at_stream_end && mf->pos >= mf->stream_pos; }
+static inline int Mf_match_len_limit( struct Matchfinder * const mf )
+  { return mf->match_len_limit_; }
+static inline const uint8_t * Mf_ptr_to_current_pos( struct Matchfinder * const mf )
+  { return mf->buffer + mf->pos; }
+
+static inline bool Mf_dec_pos( struct Matchfinder * const mf,
                                const int ahead )
   {
-  if( ahead < 0 || matchfinder->pos < ahead ) return false;
-  matchfinder->pos -= ahead;
-  matchfinder->cyclic_pos -= ahead;
-  if( matchfinder->cyclic_pos < 0 )
-    matchfinder->cyclic_pos += matchfinder->dictionary_size_;
+  if( ahead < 0 || mf->pos < ahead ) return false;
+  mf->pos -= ahead;
+  mf->cyclic_pos -= ahead;
+  if( mf->cyclic_pos < 0 ) mf->cyclic_pos += mf->dictionary_size_;
   return true;
   }
 
-static inline int Mf_true_match_len( struct Matchfinder * const matchfinder,
-                                     const int index, const int distance, int len_limit )
+static inline int Mf_true_match_len( struct Matchfinder * const mf,
+                                     const int index, const int distance,
+                                     int len_limit )
   {
-  if( index + len_limit > Mf_available_bytes( matchfinder ) )
-    len_limit = Mf_available_bytes( matchfinder ) - index;
-  const uint8_t * const data = matchfinder->buffer + matchfinder->pos + index - distance;
+  const uint8_t * const data = mf->buffer + mf->pos + index - distance;
   int i = 0;
+
+  if( index + len_limit > Mf_available_bytes( mf ) )
+    len_limit = Mf_available_bytes( mf ) - index;
   while( i < len_limit && data[i] == data[i+distance] ) ++i;
   return i;
   }
 
-bool Mf_reset( struct Matchfinder * const matchfinder );
-bool Mf_move_pos( struct Matchfinder * const matchfinder );
-int Mf_longest_match_len( struct Matchfinder * const matchfinder,
-                          int * const distances );
+void Mf_reset( struct Matchfinder * const mf );
+void Mf_move_pos( struct Matchfinder * const mf );
+int Mf_longest_match_len( struct Matchfinder * const mf, int * const distances );
 
 
 enum { re_buffer_size = 65536 };
@@ -218,28 +223,15 @@ struct Range_encoder
   {
   uint64_t low;
   long long partial_member_pos;
-  uint8_t * buffer;
-  int pos;
+  uint8_t * buffer;		/* output buffer */
+  int pos;			/* current pos in buffer */
   uint32_t range;
   int ff_count;
-  int outfd_;			// output file descriptor
+  int outfd;			/* output file descriptor */
   uint8_t cache;
   };
 
-static inline void Re_flush_data( struct Range_encoder * const range_encoder )
-  {
-  if( range_encoder->pos > 0 )
-    {
-    if( range_encoder->outfd_ >= 0 )
-      {
-      const int wr = writeblock( range_encoder->outfd_, range_encoder->buffer, range_encoder->pos );
-      if( wr != range_encoder->pos )
-        { show_error( "write error", errno, false ); cleanup_and_fail( 1 ); }
-      }
-    range_encoder->partial_member_pos += range_encoder->pos;
-    range_encoder->pos = 0;
-    }
-  }
+void Re_flush_data( struct Range_encoder * const range_encoder );
 
 static inline void Re_put_byte( struct Range_encoder * const range_encoder,
                                 const uint8_t b )
@@ -263,36 +255,37 @@ static inline void Re_shift_low( struct Range_encoder * const range_encoder )
   }
 
 static inline void Re_init( struct Range_encoder * const range_encoder,
-                            const int outfd )
+                            const int ofd )
   {
   range_encoder->low = 0;
   range_encoder->partial_member_pos = 0;
   range_encoder->buffer = (uint8_t *)malloc( re_buffer_size );
   if( !range_encoder->buffer )
     {
-    show_error( "not enough memory. Try a smaller dictionary size", 0, false );
+    show_error( "Not enough memory. Try a smaller dictionary size.", 0, false );
     cleanup_and_fail( 1 );
     }
   range_encoder->pos = 0;
   range_encoder->range = 0xFFFFFFFFU;
   range_encoder->ff_count = 0;
-  range_encoder->outfd_ = outfd;
+  range_encoder->outfd = ofd;
   range_encoder->cache = 0;
   }
 
 static inline void Re_free( struct Range_encoder * const range_encoder )
   { free( range_encoder->buffer ); range_encoder->buffer = 0; }
 
-static inline void Re_flush( struct Range_encoder * const range_encoder )
-  { for( int i = 0; i < 5; ++i ) Re_shift_low( range_encoder ); }
-
 static inline long long Re_member_position( struct Range_encoder * const range_encoder )
   { return range_encoder->partial_member_pos + range_encoder->pos + range_encoder->ff_count; }
 
+static inline void Re_flush( struct Range_encoder * const range_encoder )
+  { int i; for( i = 0; i < 5; ++i ) Re_shift_low( range_encoder ); }
+
 static inline void Re_encode( struct Range_encoder * const range_encoder,
                               const int symbol, const int num_bits )
   {
-  for( int i = num_bits - 1; i >= 0; --i )
+  int i;
+  for( i = num_bits - 1; i >= 0; --i )
     {
     range_encoder->range >>= 1;
     if( (symbol >> i) & 1 ) range_encoder->low += range_encoder->range;
@@ -325,7 +318,8 @@ static inline void Re_encode_tree( struct Range_encoder * const range_encoder,
   {
   int mask = ( 1 << ( num_bits - 1 ) );
   int model = 1;
-  for( int i = num_bits; i > 0; --i, mask >>= 1 )
+  int i;
+  for( i = num_bits; i > 0; --i, mask >>= 1 )
     {
     const int bit = ( symbol & mask );
     Re_encode_bit( range_encoder, &bm[model], bit );
@@ -338,7 +332,8 @@ static inline void Re_encode_tree_reversed( struct Range_encoder * const range_e
                                             Bit_model bm[], int symbol, const int num_bits )
   {
   int model = 1;
-  for( int i = num_bits; i > 0; --i )
+  int i;
+  for( i = num_bits; i > 0; --i )
     {
     const int bit = symbol & 1;
     Re_encode_bit( range_encoder, &bm[model], bit );
@@ -351,7 +346,8 @@ static inline void Re_encode_matched( struct Range_encoder * const range_encoder
                                       Bit_model bm[], int symbol, int match_byte )
   {
   int model = 1;
-  for( int i = 7; i >= 0; --i )
+  int i;
+  for( i = 7; i >= 0; --i )
     {
     const int match_bit = ( match_byte >> i ) & 1;
     int bit = ( symbol >> i ) & 1;
@@ -405,18 +401,19 @@ static inline void Lee_update_prices( struct Len_encoder * const len_encoder,
 static inline void Lee_init( struct Len_encoder * const len_encoder,
                              const int len_limit )
   {
+  int i, j;
   Bm_init( &len_encoder->choice1 );
   Bm_init( &len_encoder->choice2 );
-  for( int i = 0; i < pos_states; ++i )
-    for( int j = 0; j < len_low_symbols; ++j )
+  for( i = 0; i < pos_states; ++i )
+    for( j = 0; j < len_low_symbols; ++j )
       Bm_init( &len_encoder->bm_low[i][j] );
-  for( int i = 0; i < pos_states; ++i )
-    for( int j = 0; j < len_mid_symbols; ++j )
+  for( i = 0; i < pos_states; ++i )
+    for( j = 0; j < len_mid_symbols; ++j )
       Bm_init( &len_encoder->bm_mid[i][j] );
-  for( int i = 0; i < len_high_symbols; ++i )
+  for( i = 0; i < len_high_symbols; ++i )
     Bm_init( &len_encoder->bm_high[i] );
   len_encoder->len_symbols = len_limit + 1 - min_match_len;
-  for( int i = 0; i < pos_states; ++i ) Lee_update_prices( len_encoder, i );
+  for( i = 0; i < pos_states; ++i ) Lee_update_prices( len_encoder, i );
   }
 
 void Lee_encode( struct Len_encoder * const len_encoder,
@@ -433,16 +430,17 @@ struct Literal_encoder
   Bit_model bm_literal[1<<literal_context_bits][0x300];
   };
 
+static inline int Lie_state( const int prev_byte )
+  { return ( prev_byte >> ( 8 - literal_context_bits ) ); }
+
 static inline void Lie_init( struct Literal_encoder * const literal_encoder )
   {
-  for( int i = 0; i < 1<<literal_context_bits; ++i )
-    for( int j = 0; j < 0x300; ++j )
+  int i, j;
+  for( i = 0; i < 1<<literal_context_bits; ++i )
+    for( j = 0; j < 0x300; ++j )
       Bm_init( &literal_encoder->bm_literal[i][j] );
   }
 
-static inline int Lie_state( const int prev_byte )
-  { return ( prev_byte >> ( 8 - literal_context_bits ) ); }
-
 static inline void Lie_encode( struct Literal_encoder * const literal_encoder,
                                struct Range_encoder * const range_encoder,
                                uint8_t prev_byte, uint8_t symbol )
@@ -450,29 +448,28 @@ static inline void Lie_encode( struct Literal_encoder * const literal_encoder,
 
 static inline void Lie_encode_matched( struct Literal_encoder * const literal_encoder,
                                        struct Range_encoder * const range_encoder,
-                                       uint8_t prev_byte, uint8_t match_byte, uint8_t symbol )
+                                       uint8_t prev_byte, uint8_t symbol, uint8_t match_byte )
   { Re_encode_matched( range_encoder, literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, match_byte ); }
 
-static inline int Lie_price_matched( struct Literal_encoder * const literal_encoder,
-                                     uint8_t prev_byte, uint8_t symbol, uint8_t match_byte )
-  { return price_matched( literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, match_byte ); }
-
 static inline int Lie_price_symbol( struct Literal_encoder * const literal_encoder,
                                     uint8_t prev_byte, uint8_t symbol )
   { return price_symbol( literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, 8 ); }
 
+static inline int Lie_price_matched( struct Literal_encoder * const literal_encoder,
+                                     uint8_t prev_byte, uint8_t symbol, uint8_t match_byte )
+  { return price_matched( literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, match_byte ); }
+
 
-enum { lze_dis_align_mask = dis_align_size - 1,
-       lze_infinite_price = 0x0FFFFFFF,
-       lze_max_marker_size = 16,
-       num_rep_distances = 4 };		// must be 4
+enum { infinite_price = 0x0FFFFFFF,
+       max_marker_size = 16,
+       num_rep_distances = 4 };		/* must be 4 */
 
 struct Trial
   {
   State state;
   int dis;
-  int prev_index;	// index of prev trial in trials[]
-  int price;		// dual use var; cumulative price, match length
+  int prev_index;	/* index of prev trial in trials[] */
+  int price;		/* dual use var; cumulative price, match length */
   int reps[num_rep_distances];
   };
 
@@ -489,14 +486,14 @@ struct LZ_encoder
   int longest_match_found;
   uint32_t crc_;
 
-  Bit_model bm_match[St_states][pos_states];
-  Bit_model bm_rep[St_states];
-  Bit_model bm_rep0[St_states];
-  Bit_model bm_rep1[St_states];
-  Bit_model bm_rep2[St_states];
-  Bit_model bm_len[St_states][pos_states];
+  Bit_model bm_match[states][pos_states];
+  Bit_model bm_rep[states];
+  Bit_model bm_rep0[states];
+  Bit_model bm_rep1[states];
+  Bit_model bm_rep2[states];
+  Bit_model bm_len[states][pos_states];
   Bit_model bm_dis_slot[max_dis_states][1<<dis_slot_bits];
-  Bit_model bm_dis[modeled_distances-end_dis_model];
+  Bit_model bm_dis[modeled_distances-end_dis_model+1];
   Bit_model bm_align[dis_align_size];
 
   struct Matchfinder * matchfinder;
@@ -521,18 +518,19 @@ void LZe_fill_distance_prices( struct LZ_encoder * const encoder );
 static inline uint32_t LZe_crc( struct LZ_encoder * const encoder )
   { return encoder->crc_ ^ 0xFFFFFFFFU; }
 
-       // move-to-front dis in/into reps
+       /* move-to-front dis in/into reps */
 static inline void LZe_mtf_reps( const int dis, int reps[num_rep_distances] )
   {
+  int i;
   if( dis >= num_rep_distances )
     {
-    for( int i = num_rep_distances - 1; i > 0; --i ) reps[i] = reps[i-1];
+    for( i = num_rep_distances - 1; i > 0; --i ) reps[i] = reps[i-1];
     reps[0] = dis - num_rep_distances;
     }
   else if( dis > 0 )
     {
     const int distance = reps[dis];
-    for( int i = dis; i > 0; --i ) reps[i] = reps[i-1];
+    for( i = dis; i > 0; --i ) reps[i] = reps[i-1];
     reps[0] = distance;
     }
   }
@@ -546,9 +544,10 @@ static inline int LZe_price_rep_len1( struct LZ_encoder * const encoder,
 static inline int LZe_price_rep( struct LZ_encoder * const encoder, const int rep,
                                  const State state, const int pos_state )
   {
+  int price;
   if( rep == 0 ) return price0( encoder->bm_rep0[state] ) +
                         price1( encoder->bm_len[state][pos_state] );
-  int price = price1( encoder->bm_rep0[state] );
+  price = price1( encoder->bm_rep0[state] );
   if( rep == 1 )
     price += price0( encoder->bm_rep1[state] );
   else
@@ -559,27 +558,33 @@ static inline int LZe_price_rep( struct LZ_encoder * const encoder, const int re
   return price;
   }
 
-static inline int LZe_price_pair( struct LZ_encoder * const encoder, const int dis,
-                                  const int len, const int pos_state )
+static inline int LZe_price_pair( struct LZ_encoder * const encoder,
+                                  const int dis, const int len,
+                                  const int pos_state )
   {
-  if( len <= min_match_len && dis >= modeled_distances )
-    return lze_infinite_price;
-  int price = Lee_price( &encoder->len_encoder, len, pos_state );
   const int dis_state = get_dis_state( len );
+  int price;
+
+  if( len <= min_match_len && dis >= modeled_distances )
+    return infinite_price;
+  price = Lee_price( &encoder->len_encoder, len, pos_state );
   if( dis < modeled_distances )
     price += encoder->dis_prices[dis_state][dis];
   else
     price += encoder->dis_slot_prices[dis_state][get_slot( dis )] +
-             encoder->align_prices[dis & lze_dis_align_mask];
+             encoder->align_prices[dis & (dis_align_size - 1)];
   return price;
   }
 
 static inline void LZe_encode_pair( struct LZ_encoder * const encoder,
-                                    const uint32_t dis, const int len, const int pos_state )
+                                    const uint32_t dis, const int len,
+                                    const int pos_state )
   {
-  Lee_encode( &encoder->len_encoder, &encoder->range_encoder, len, pos_state );
   const int dis_slot = get_slot( dis );
-  Re_encode_tree( &encoder->range_encoder, encoder->bm_dis_slot[get_dis_state(len)], dis_slot, dis_slot_bits );
+  Lee_encode( &encoder->len_encoder, &encoder->range_encoder, len, pos_state );
+  Re_encode_tree( &encoder->range_encoder,
+                  encoder->bm_dis_slot[get_dis_state(len)],
+                  dis_slot, dis_slot_bits );
 
   if( dis_slot >= start_dis_model )
     {
@@ -607,16 +612,15 @@ static inline int LZe_read_match_distances( struct LZ_encoder * const encoder )
   return len;
   }
 
-static inline bool LZe_move_pos( struct LZ_encoder * const encoder,
+static inline void LZe_move_pos( struct LZ_encoder * const encoder,
                                  int n, bool skip )
   {
   while( --n >= 0 )
     {
     if( skip ) skip = false;
     else Mf_longest_match_len( encoder->matchfinder, 0 );
-    if( !Mf_move_pos( encoder->matchfinder ) ) return false;
+    Mf_move_pos( encoder->matchfinder );
     }
-  return true;
   }
 
 static inline void LZe_backward( struct LZ_encoder * const encoder, int cur )
@@ -626,7 +630,7 @@ static inline void LZe_backward( struct LZ_encoder * const encoder, int cur )
     {
     const int prev_index = encoder->trials[cur].prev_index;
     struct Trial * const prev_trial = &encoder->trials[prev_index];
-    prev_trial->price = cur - prev_index;			// len
+    prev_trial->price = cur - prev_index;			/* len */
     cur = *dis; *dis = prev_trial->dis; prev_trial->dis = cur;
     cur = prev_index;
     }