Patch origin: in-house

Patch status: inffast.c part: submitted back to community without feedback

Patch status: deflate.c part: Solaris-specific; not suitable for upstream

--- zlib-1.2.8/zlib.h	2013-04-28 17:23:49.000000000 -0700

+++ zlib-1.2.8/zlib.h	2014-04-18 05:32:31.316290241 -0700

@@ -37,8 +37,8 @@

 extern "C" {

 #endif

-#define ZLIB_VERSION "1.2.8"

-#define ZLIB_VERNUM 0x1280

+#define ZLIB_VERSION "1.2.8-T4mods"

+#define ZLIB_VERNUM 0x128f

 #define ZLIB_VER_MAJOR 1

 #define ZLIB_VER_MINOR 2

 #define ZLIB_VER_REVISION 8

--- zlib-1.2.8/inffast.c	2013-03-24 22:47:59.000000000 -0700

+++ zlib-1.2.8/inffast.c	2014-02-28 01:57:57.075708259 -0800

@@ -87,7 +87,7 @@

     code const FAR *dcode;      /* local strm->distcode */

     unsigned lmask;             /* mask for first level of length codes */

     unsigned dmask;             /* mask for first level of distance codes */

-    code here;                  /* retrieved table entry */

+    code *here;                 /* retrieved table entry */

     unsigned op;                /* code bits, operation, extra bits, or */

                                 /*  window position, window bytes to copy */

     unsigned len;               /* match length, unused bytes */

@@ -124,20 +124,20 @@

             hold += (unsigned long)(PUP(in)) << bits;

             bits += 8;

         }

-        here = lcode[hold & lmask];

+        here = (code *)(&(lcode[hold & lmask]));

       dolen:

-        op = (unsigned)(here.bits);

+        op = (unsigned)(here->bits);

         hold >>= op;

         bits -= op;

-        op = (unsigned)(here.op);

+        op = (unsigned)(here->op);

         if (op == 0) {                          /* literal */

-            Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?

+            Tracevv((stderr, here->val >= 0x20 && here->val < 0x7f ?

                     "inflate:         literal '%c'\n" :

-                    "inflate:         literal 0x%02x\n", here.val));

-            PUP(out) = (unsigned char)(here.val);

+                    "inflate:         literal 0x%02x\n", here->val));

+            PUP(out) = (unsigned char)(here->val);

         }

         else if (op & 16) {                     /* length base */

-            len = (unsigned)(here.val);

+            len = (unsigned)(here->val);

             op &= 15;                           /* number of extra bits */

             if (op) {

                 if (bits < op) {

@@ -155,14 +155,14 @@

                 hold += (unsigned long)(PUP(in)) << bits;

                 bits += 8;

             }

-            here = dcode[hold & dmask];

+            here = (code *)(&(dcode[hold & dmask]));

           dodist:

-            op = (unsigned)(here.bits);

+            op = (unsigned)(here->bits);

             hold >>= op;

             bits -= op;

-            op = (unsigned)(here.op);

+            op = (unsigned)(here->op);

             if (op & 16) {                      /* distance base */

-                dist = (unsigned)(here.val);

+                dist = (unsigned)(here->val);

                 op &= 15;                       /* number of extra bits */

                 if (bits < op) {

                     hold += (unsigned long)(PUP(in)) << bits;

@@ -281,7 +281,7 @@

                 }

             }

             else if ((op & 64) == 0) {          /* 2nd level distance code */

-                here = dcode[here.val + (hold & ((1U << op) - 1))];

+                here = (code *)(&(dcode[here->val + (hold & ((1U << op) - 1))]));

                 goto dodist;

             }

             else {

@@ -291,7 +291,7 @@

             }

         }

         else if ((op & 64) == 0) {              /* 2nd level length code */

-            here = lcode[here.val + (hold & ((1U << op) - 1))];

+            here = (code *)(&(lcode[here->val + (hold & ((1U << op) - 1))]));

             goto dolen;

         }

         else if (op & 32) {                     /* end-of-block */

--- zlib-1.2.8/deflate.c	2013-04-28 15:57:10.000000000 -0700

+++ zlib-1.2.8/deflate.c	2014-02-28 02:32:02.517988885 -0800

@@ -60,6 +60,7 @@

   copyright string in the executable of your product.

  */

+#ifndef LONGEST_MATCH_ONLY

 /* ===========================================================================

  *  Function prototypes.

  */

@@ -89,13 +90,18 @@

       void match_init OF((void)); /* asm code initialization */

       uInt longest_match  OF((deflate_state *s, IPos cur_match));

 #else

+#ifdef ORIG_LONGEST_MATCH

 local uInt longest_match  OF((deflate_state *s, IPos cur_match));

+#else

+uInt longest_match  OF((deflate_state *s, IPos cur_match));

+#endif

 #endif

 #ifdef DEBUG

 local  void check_match OF((deflate_state *s, IPos start, IPos match,

                             int length));

 #endif

+#endif /* ! LONGEST_MATCH_ONLY */

 /* ===========================================================================

  * Local data

@@ -104,6 +110,7 @@

 #define NIL 0

 /* Tail of hash chains */

+#ifndef LONGEST_MATCH_ONLY

 #ifndef TOO_FAR

 #  define TOO_FAR 4096

 #endif

@@ -1130,7 +1137,9 @@

 #endif

 #endif

 }

+#endif /* ! LONGEST_MATCH_ONLY */

+#if defined(ORIG_LONGEST_MATCH) || defined(ORIG_LONGEST_MATCH_GLOBAL)

 #ifndef FASTEST

 /* ===========================================================================

  * Set match_start to the longest match starting at the given string and

@@ -1145,7 +1154,11 @@

 /* For 80x86 and 680x0, an optimized version will be provided in match.asm or

  * match.S. The code will be functionally equivalent.

  */

+#ifdef ORIG_LONGEST_MATCH_GLOBAL

+uInt longest_match(s, cur_match)

+#else

 local uInt longest_match(s, cur_match)

+#endif

     deflate_state *s;

     IPos cur_match;                             /* current match */

 {

@@ -1288,6 +1301,7 @@

     return s->lookahead;

 }

 #endif /* ASMV */

+#endif /* ORIG_LONGEST_MATCHT */

 #else /* FASTEST */

@@ -1349,6 +1363,7 @@

 #endif /* FASTEST */

+#ifndef LONGEST_MATCH_ONLY

 #ifdef DEBUG

 /* ===========================================================================

  * Check that the match at match_start is indeed a match.

@@ -1965,3 +1980,4 @@

         FLUSH_BLOCK(s, 0);

     return block_done;

 }

+#endif /* ! LONGEST_MATCH_ONLY */