zlib 0.79v0.79

1 files changed, 148 insertions, 0 deletions

diff --git a/inffast.c b/inffast.c
new file mode 100644
index 0000000..8c3e4ce
--- /dev/null
+++ b/inffast.c
@@ -0,0 +1,148 @@
+/* inffast.c -- process literals and length/distance pairs fast
+ * Copyright (C) 1995 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "infutil.h"
+#include "inffast.h"
+
+/* simplify the use of the inflate_huft type with some defines */
+#define base more.Base
+#define next more.Next
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* macros for bit input with no checking and for returning unused bytes */
+#ifdef DEBUG
+#  undef NEXTBYTE
+#  define NEXTBYTE (n--?0:fprintf(stderr,"inffast underrun\n"),*p++)
+#endif
+#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#define UNGRAB {n+=(c=k>>3);p-=c;k&=7;}
+
+/* Called with number of bytes left to write in window at least 258
+   (the maximum string length) and number of input bytes available
+   at least ten.  The ten bytes are six bytes for the longest length/
+   distance pair plus four bytes for overloading the bit buffer. */
+
+int inflate_fast(bl, bd, tl, td, s, z)
+uInt bl, bd;
+inflate_huft *tl, *td;
+struct inflate_blocks_state *s;
+z_stream *z;
+{
+  inflate_huft *t;      /* temporary pointer */
+  int e;                /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Byte *p;              /* input data pointer */
+  uInt n;               /* bytes available there */
+  Byte *q;              /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  uInt ml;              /* mask for literal/length tree */
+  uInt md;              /* mask for distance tree */
+  uInt c;               /* bytes to copy */
+  uInt d;               /* distance back to copy from */
+  Byte *r;              /* copy source pointer */
+
+  /* load input, output, bit values */
+  LOAD
+
+  /* initialize masks in registers */
+  ml = inflate_mask[bl];
+  md = inflate_mask[bd];
+
+  /* do until not enough input or output space for fast loop */
+  do {                          /* assume called with m >= 258 && n >= 10 */
+    /* get literal/length code */
+    GRABBITS(20)                /* max bits for literal/length code */
+    if ((e = (t = tl + ((uInt)b & ml))->exop) < 0)
+      do {
+        if (e == -128)
+        {
+          z->msg = "invalid literal/length code";
+          UNGRAB
+          UPDATE
+          return Z_DATA_ERROR;
+        }
+        DUMPBITS(t->bits)
+        e = -e;
+        if (e & 64)             /* end of block */
+        {
+          UNGRAB
+          UPDATE
+          return Z_STREAM_END;
+        }
+      } while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
+    DUMPBITS(t->bits)
+
+    /* process literal or length (end of block already trapped) */
+    if (e & 16)                 /* then it's a literal */
+    {
+      *q++ = (Byte)t->base;
+      m--;
+    }
+    else                        /* it's a length */
+    {
+      /* get length of block to copy (already have extra bits) */
+      c = t->base + ((uInt)b & inflate_mask[e]);
+      DUMPBITS(e);
+
+      /* decode distance base of block to copy */
+      GRABBITS(15);             /* max bits for distance code */
+      if ((e = (t = td + ((uInt)b & md))->exop) < 0)
+        do {
+          if (e == -128)
+          {
+            z->msg = "invalid distance code";
+            UNGRAB
+            UPDATE
+            return Z_DATA_ERROR;
+          }
+          DUMPBITS(t->bits)
+          e = -e;
+        } while ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) < 0);
+      DUMPBITS(t->bits)
+
+      /* get extra bits to add to distance base */
+      GRABBITS(e)           /* get extra bits (up to 13) */
+      d = t->base + ((uInt)b & inflate_mask[e]);
+      DUMPBITS(e)
+
+      /* do the copy */
+      m -= c;
+      if (q - s->window >= d)           /* if offset before destination, */
+      {                                 /*  just copy */
+        r = q - d;
+        *q++ = *r++;  c--;              /* minimum count is three, */
+        *q++ = *r++;  c--;              /*  so unroll loop a little */
+        do {
+          *q++ = *r++;
+        } while (--c);
+      }
+      else                              /* else offset after destination */
+      {
+        e = d - (q - s->window);        /* bytes from offset to end */
+        r = s->end - e;                 /* pointer to offset */
+        if (c > e)                      /* if source crosses, */
+        {
+          c -= e;                       /* copy to end of window */
+          do {
+            *q++ = *r++;
+          } while (--e);
+          r = s->window;                /* copy rest from start of window */
+        }
+        do {                            /* copy all or what's left */
+          *q++ = *r++;
+        } while (--c);
+      }
+    }
+  } while (m >= 258 && n >= 10);
+
+  /* not enough input or output--restore pointers and return */
+  UNGRAB
+  UPDATE
+  return Z_OK;
+}