Remove support for compiling with -DFASTEST

4 files changed, 3 insertions, 100 deletions

diff --git a/deflate.c b/deflate.c
index c97c1bf..f8afb30 100644
--- a/deflate.c
+++ b/deflate.c
@@ -76,9 +76,7 @@ local block_state deflate_stored (deflate_state *s, int flush);
 local block_state deflate_fast   (deflate_state *s, int flush);
 block_state deflate_quick  (deflate_state *s, int flush);
 local block_state deflate_medium (deflate_state *s, int flush);
-#ifndef FASTEST
 local block_state deflate_slow   (deflate_state *s, int flush);
-#endif
 local block_state deflate_rle    (deflate_state *s, int flush);
 local block_state deflate_huff   (deflate_state *s, int flush);
 local void lm_init        (deflate_state *s);
@@ -125,12 +123,6 @@ typedef struct config_s {
    compress_func func;
 } config;
 
-#ifdef FASTEST
-local const config configuration_table[2] = {
-/*      good lazy nice chain */
-/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
-/* 1 */ {4,    4,  8,    4, deflate_fast}}; /* max speed, no lazy matches */
-#else
 local const config configuration_table[10] = {
 /*      good lazy nice chain */
 /* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
@@ -157,7 +149,6 @@ local const config configuration_table[10] = {
 /* 7 */ {8,   32, 128, 256, deflate_slow},
 /* 8 */ {32, 128, 258, 1024, deflate_slow},
 /* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
-#endif
 
 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
  * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
@@ -179,8 +170,6 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
  * Insert string str in the dictionary and set match_head to the previous head
  * of the hash chain (the most recent string with same hash key). Return
  * the previous length of the hash chain.
- * If this file is compiled with -DFASTEST, the compression level is forced
- * to 1, and no hash chains are maintained.
  * IN  assertion: all calls to to INSERT_STRING are made with consecutive
  *    input characters and the first MIN_MATCH bytes of str are valid
  *    (except for the last MIN_MATCH-1 bytes of the input file).
@@ -215,11 +204,7 @@ local inline Pos insert_string_c(deflate_state *z_const s, z_const Pos str)
     Pos ret;
 
     UPDATE_HASH(s, s->ins_h, str);
-#ifdef FASTEST
-    ret = s->head[s->ins_h];
-#else
     ret = s->prev[str & s->w_mask] = s->head[s->ins_h];
-#endif
     s->head[s->ins_h] = str;
 
     return ret;
@@ -313,11 +298,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
         strm->zfree = zcfree;
 #endif
 
-#ifdef FASTEST
-    if (level != 0) level = 1;
-#else
     if (level == Z_DEFAULT_COMPRESSION) level = 6;
-#endif
 
     if (windowBits < 0) { /* suppress zlib wrapper */
         wrap = 0;
@@ -443,9 +424,7 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
         n = s->lookahead - (MIN_MATCH-1);
         do {
             UPDATE_HASH(s, s->ins_h, str);
-#ifndef FASTEST
             s->prev[str & s->w_mask] = s->head[s->ins_h];
-#endif
             s->head[s->ins_h] = (Pos)str;
             str++;
         } while (--n);
@@ -576,11 +555,7 @@ int ZEXPORT deflateParams(strm, level, strategy)
     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     s = strm->state;
 
-#ifdef FASTEST
-    if (level != 0) level = 1;
-#else
     if (level == Z_DEFAULT_COMPRESSION) level = 6;
-#endif
     if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
         return Z_STREAM_ERROR;
     }
@@ -1204,11 +1179,9 @@ local void lm_init (s)
     s->match_length = s->prev_length = MIN_MATCH-1;
     s->match_available = 0;
     s->ins_h = 0;
-#ifndef FASTEST
 #ifdef ASMV
     match_init(); /* initialize the asm code */
 #endif
-#endif
 }
 
 #include "match.c"
@@ -1343,7 +1316,6 @@ local void fill_window_c(s)
             
 #endif /* NOT_TWEAK_COMPILER */
             n = wsize;
-#ifndef FASTEST
             p = &s->prev[n];
 #ifdef NOT_TWEAK_COMPILER
             do {
@@ -1365,7 +1337,6 @@ local void fill_window_c(s)
                 }
             }
 #endif /* NOT_TWEAK_COMPILER */
-#endif
             more += wsize;
         }
         if (s->strm->avail_in == 0) break;
@@ -1397,9 +1368,7 @@ local void fill_window_c(s)
 #endif
             while (s->insert) {
                 UPDATE_HASH(s, s->ins_h, str);
-#ifndef FASTEST
                 s->prev[str & s->w_mask] = s->head[s->ins_h];
-#endif
                 s->head[s->ins_h] = (Pos)str;
                 str++;
                 s->insert--;
@@ -1596,7 +1565,6 @@ local block_state deflate_fast(s, flush)
             /* Insert new strings in the hash table only if the match length
              * is not too large. This saves time but degrades compression.
              */
-#ifndef FASTEST
             if (s->match_length <= s->max_insert_length &&
                 s->lookahead >= MIN_MATCH) {
                 s->match_length--; /* string at strstart already in table */
@@ -1609,7 +1577,6 @@ local block_state deflate_fast(s, flush)
                 } while (--s->match_length != 0);
                 s->strstart++;
             } else
-#endif
             {
                 s->strstart += s->match_length;
                 s->match_length = 0;
@@ -1646,7 +1613,6 @@ local block_state deflate_fast(s, flush)
 #include "deflate_medium.c"
 #endif
 
-#ifndef FASTEST
 /* ===========================================================================
  * Same as above, but achieves better compression. We use a lazy
  * evaluation for matches: a match is finally adopted only if there is
@@ -1792,7 +1758,6 @@ local block_state deflate_slow(s, flush)
         FLUSH_BLOCK(s, 0);
     return block_done;
 }
-#endif /* FASTEST */
 
 /* ===========================================================================
  * For Z_RLE, simply look for runs of bytes, generate matches only of distance
diff --git a/fill_window_sse.c b/fill_window_sse.c
index 12abd35..bb4f521 100644
--- a/fill_window_sse.c
+++ b/fill_window_sse.c
@@ -73,7 +73,6 @@ void fill_window_sse(deflate_state *s)
             } while (n > 0);
 
             n = wsize;
-#ifndef FASTEST
             p = &s->prev[n];
             p -= 8;
             do {
@@ -86,7 +85,6 @@ void fill_window_sse(deflate_state *s)
                 p -= 8;
                 n -= 8;
             } while (n > 0);
-#endif
             more += wsize;
         }
         if (s->strm->avail_in == 0) break;
@@ -118,9 +116,7 @@ void fill_window_sse(deflate_state *s)
 #endif
             while (s->insert) {
                 UPDATE_HASH(s, s->ins_h, str);
-#ifndef FASTEST
                 s->prev[str & s->w_mask] = s->head[s->ins_h];
-#endif
                 s->head[s->ins_h] = (Pos)str;
                 str++;
                 s->insert--;
diff --git a/match.c b/match.c
index 22077bf..a8e7c9e 100644
--- a/match.c
+++ b/match.c
@@ -12,12 +12,10 @@
 
 #include "deflate.h"
 
-#ifdef FASTEST
-#define longest_match fastest_longest_match
-#elif (defined(UNALIGNED_OK) && MAX_MATCH == 258)
-#define longest_match std2_longest_match
+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
+#  define longest_match std2_longest_match
 #else
-#define longest_match std1_longest_match
+#  define longest_match std1_longest_match
 #endif
 
 /*
@@ -258,56 +256,3 @@ local unsigned std2_longest_match(deflate_state *z_const s, IPos cur_match)
 		return best_len;
 	return s->lookahead;
 }
-
-/*
- * FASTEST-only longest_match
- *
- */
-local unsigned fastest_longest_match(deflate_state *z_const s, IPos cur_match)
-{
-	unsigned char *scan, *match, *strend;
-	int len;
-
-	/*
-	 * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple 
-	 * of 16. It is easy to get rid of this optimization if necessary
-	 */
-	Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
-
-	Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD,
-		"need lookahead");
-
-	Assert(cur_match < s->strstart, "no future");
-
-	match = s->window + cur_match;
-	scan = s->window + s->strstart;
-	strend = s->window + s->strstart + MAX_MATCH;
-
-	if (*match++ != *scan++ || *match++ != *scan++)
-		return MIN_MATCH-1;
-
-	/*
-	 * The check at best_len-1 can be removed because it will be made
-	 * again later. (This heuristic is not always a win.) It is not
-	 * necessary to compare scan[2] and match[2] since they are always
-	 * equal when the other bytes match, given that the hash keys are equal
-	 * and that HASH_BITS >= 8.
-	 */
-	Assert(*scan == *match, "match[2]?");
-
-	do {
-	} while (*++scan == *++match && *++scan == *++match &&
-		 *++scan == *++match && *++scan == *++match &&
-		 *++scan == *++match && *++scan == *++match &&
-		 *++scan == *++match && *++scan == *++match &&
-		 scan < strend);
-	
-	Assert(scan <= s->window+(unsigned int)(s->window_size-1), "wild scan");
-
-	len = MAX_MATCH - (long)(strend - scan);
-	if (len < MIN_MATCH)
-		return MIN_MATCH-1;
-	
-	s->match_start = cur_match;
-	return len <= s->lookahead ? len : s->lookahead;
-}
diff --git a/zutil.c b/zutil.c
index cdbd7a5..e109407 100644
--- a/zutil.c
+++ b/zutil.c
@@ -85,9 +85,6 @@ uLong ZEXPORT zlibCompileFlags()
 #ifdef PKZIP_BUG_WORKAROUND
     flags += 1L << 20;
 #endif
-#ifdef FASTEST
-    flags += 1L << 21;
-#endif
     return flags;
 }