sync with crosswire 20021021-1300

2 files changed, 205 insertions, 205 deletions

diff --git a/src/utilfuns/zlib/infcodes.c b/src/utilfuns/zlib/infcodes.c
index 9abe541..0d54ea7 100644
--- a/src/utilfuns/zlib/infcodes.c
+++ b/src/utilfuns/zlib/infcodes.c
@@ -92,7 +92,7 @@ int r;
   uInt n;               /* bytes available there */
   Bytef *q;             /* output window write pointer */
   uInt m;               /* bytes to end of window or read pointer */
-  Bytef *f;             /* pointer to copy strings from */
+  unsigned long csf;             /* pointer to copy strings from */
   inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */
 
   /* copy input/output information to locals (UPDATE macro restores) */
@@ -103,120 +103,120 @@ int r;
   {             /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
     case START:         /* x: set up for LEN */
 #ifndef SLOW
-      if (m >= 258 && n >= 10)
-      {
-        UPDATE
-        r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
-        LOAD
-        if (r != Z_OK)
-        {
-          c->mode = r == Z_STREAM_END ? WASH : BADCODE;
-          break;
-        }
-      }
+	 if (m >= 258 && n >= 10)
+	 {
+	   UPDATE
+	   r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
+	   LOAD
+	   if (r != Z_OK)
+	   {
+		c->mode = r == Z_STREAM_END ? WASH : BADCODE;
+		break;
+	   }
+	 }
 #endif /* !SLOW */
-      c->sub.code.need = c->lbits;
-      c->sub.code.tree = c->ltree;
-      c->mode = LEN;
+	 c->sub.code.need = c->lbits;
+	 c->sub.code.tree = c->ltree;
+	 c->mode = LEN;
     case LEN:           /* i: get length/literal/eob next */
-      j = c->sub.code.need;
-      NEEDBITS(j)
-      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
-      DUMPBITS(t->bits)
-      e = (uInt)(t->exop);
-      if (e == 0)               /* literal */
-      {
-        c->sub.lit = t->base;
-        Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
-                 "inflate:         literal '%c'\n" :
-                 "inflate:         literal 0x%02x\n", t->base));
-        c->mode = LIT;
-        break;
-      }
-      if (e & 16)               /* length */
-      {
-        c->sub.copy.get = e & 15;
-        c->len = t->base;
-        c->mode = LENEXT;
-        break;
-      }
-      if ((e & 64) == 0)        /* next table */
-      {
-        c->sub.code.need = e;
-        c->sub.code.tree = t + t->base;
-        break;
-      }
-      if (e & 32)               /* end of block */
-      {
-        Tracevv((stderr, "inflate:         end of block\n"));
-        c->mode = WASH;
-        break;
-      }
-      c->mode = BADCODE;        /* invalid code */
-      z->msg = (char*)"invalid literal/length code";
-      r = Z_DATA_ERROR;
-      LEAVE
+	 j = c->sub.code.need;
+	 NEEDBITS(j)
+	 t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+	 DUMPBITS(t->bits)
+	 e = (uInt)(t->exop);
+	 if (e == 0)               /* literal */
+	 {
+	   c->sub.lit = t->base;
+	   Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+			  "inflate:         literal '%c'\n" :
+			  "inflate:         literal 0x%02x\n", t->base));
+	   c->mode = LIT;
+	   break;
+	 }
+	 if (e & 16)               /* length */
+	 {
+	   c->sub.copy.get = e & 15;
+	   c->len = t->base;
+	   c->mode = LENEXT;
+	   break;
+	 }
+	 if ((e & 64) == 0)        /* next table */
+	 {
+	   c->sub.code.need = e;
+	   c->sub.code.tree = t + t->base;
+	   break;
+	 }
+	 if (e & 32)               /* end of block */
+	 {
+	   Tracevv((stderr, "inflate:         end of block\n"));
+	   c->mode = WASH;
+	   break;
+	 }
+	 c->mode = BADCODE;        /* invalid code */
+	 z->msg = (char*)"invalid literal/length code";
+	 r = Z_DATA_ERROR;
+	 LEAVE
     case LENEXT:        /* i: getting length extra (have base) */
-      j = c->sub.copy.get;
-      NEEDBITS(j)
-      c->len += (uInt)b & inflate_mask[j];
-      DUMPBITS(j)
-      c->sub.code.need = c->dbits;
-      c->sub.code.tree = c->dtree;
-      Tracevv((stderr, "inflate:         length %u\n", c->len));
-      c->mode = DIST;
+	 j = c->sub.copy.get;
+	 NEEDBITS(j)
+	 c->len += (uInt)b & inflate_mask[j];
+	 DUMPBITS(j)
+	 c->sub.code.need = c->dbits;
+	 c->sub.code.tree = c->dtree;
+	 Tracevv((stderr, "inflate:         length %u\n", c->len));
+	 c->mode = DIST;
     case DIST:          /* i: get distance next */
-      j = c->sub.code.need;
-      NEEDBITS(j)
-      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
-      DUMPBITS(t->bits)
-      e = (uInt)(t->exop);
-      if (e & 16)               /* distance */
-      {
-        c->sub.copy.get = e & 15;
-        c->sub.copy.dist = t->base;
-        c->mode = DISTEXT;
-        break;
-      }
-      if ((e & 64) == 0)        /* next table */
-      {
-        c->sub.code.need = e;
-        c->sub.code.tree = t + t->base;
-        break;
-      }
-      c->mode = BADCODE;        /* invalid code */
-      z->msg = (char*)"invalid distance code";
-      r = Z_DATA_ERROR;
-      LEAVE
+	 j = c->sub.code.need;
+	 NEEDBITS(j)
+	 t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+	 DUMPBITS(t->bits)
+	 e = (uInt)(t->exop);
+	 if (e & 16)               /* distance */
+	 {
+	   c->sub.copy.get = e & 15;
+	   c->sub.copy.dist = t->base;
+	   c->mode = DISTEXT;
+	   break;
+	 }
+	 if ((e & 64) == 0)        /* next table */
+	 {
+	   c->sub.code.need = e;
+	   c->sub.code.tree = t + t->base;
+	   break;
+	 }
+	 c->mode = BADCODE;        /* invalid code */
+	 z->msg = (char*)"invalid distance code";
+	 r = Z_DATA_ERROR;
+	 LEAVE
     case DISTEXT:       /* i: getting distance extra */
-      j = c->sub.copy.get;
-      NEEDBITS(j)
-      c->sub.copy.dist += (uInt)b & inflate_mask[j];
-      DUMPBITS(j)
-      Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
-      c->mode = COPY;
+	 j = c->sub.copy.get;
+	 NEEDBITS(j)
+	 c->sub.copy.dist += (uInt)b & inflate_mask[j];
+	 DUMPBITS(j)
+	 Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
+	 c->mode = COPY;
     case COPY:          /* o: copying bytes in window, waiting for space */
-      f = q - c->sub.copy.dist;
-      while (f < s->window)             /* modulo window size-"while" instead */
-        f += s->end - s->window;        /* of "if" handles invalid distances */
-      while (c->len)
-      {
-        NEEDOUT
-        OUTBYTE(*f++)
-        if (f == s->end)
-          f = s->window;
-        c->len--;
-      }
-      c->mode = START;
-      break;
+	 csf = (unsigned long)q - c->sub.copy.dist;
+	 while (csf < (unsigned long)s->window)             /* modulo window size-"while" instead */
+	   csf += (unsigned long)(s->end - s->window);        /* of "if" handles invalid distances */
+	 while (c->len)
+	 {
+	   NEEDOUT
+	   OUTBYTE(*(Bytef *)csf++)
+	   if (csf == (unsigned long)s->end)
+		csf = (unsigned long)s->window;
+	   c->len--;
+	 }
+	 c->mode = START;
+	 break;
     case LIT:           /* o: got literal, waiting for output space */
-      NEEDOUT
-      OUTBYTE(c->sub.lit)
-      c->mode = START;
-      break;
+	 NEEDOUT
+	 OUTBYTE(c->sub.lit)
+	 c->mode = START;
+	 break;
     case WASH:          /* o: got eob, possibly more output */
-      if (k > 7)        /* return unused byte, if any */
-      {
+	 if (k > 7)        /* return unused byte, if any */
+	 {
         Assert(k < 16, "inflate_codes grabbed too many bytes")
         k -= 8;
         n++;
diff --git a/src/utilfuns/zlib/inffast.c b/src/utilfuns/zlib/inffast.c
index aa7f1d4..a7ebc64 100644
--- a/src/utilfuns/zlib/inffast.c
+++ b/src/utilfuns/zlib/inffast.c
@@ -44,7 +44,7 @@ z_streamp z;
   uInt md;              /* mask for distance tree */
   uInt c;               /* bytes to copy */
   uInt d;               /* distance back to copy from */
-  Bytef *r;             /* copy source pointer */
+  unsigned long csp;             /* copy source pointer */
 
   /* load input, output, bit values */
   LOAD
@@ -59,107 +59,107 @@ z_streamp z;
     GRABBITS(20)                /* max bits for literal/length code */
     if ((e = (t = tl + ((uInt)b & ml))->exop) == 0)
     {
-      DUMPBITS(t->bits)
-      Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
-                "inflate:         * literal '%c'\n" :
-                "inflate:         * literal 0x%02x\n", t->base));
-      *q++ = (Byte)t->base;
-      m--;
-      continue;
+	 DUMPBITS(t->bits)
+	 Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+			 "inflate:         * literal '%c'\n" :
+			 "inflate:         * literal 0x%02x\n", t->base));
+	 *q++ = (Byte)t->base;
+	 m--;
+	 continue;
     }
     do {
-      DUMPBITS(t->bits)
-      if (e & 16)
-      {
-        /* get extra bits for length */
-        e &= 15;
-        c = t->base + ((uInt)b & inflate_mask[e]);
-        DUMPBITS(e)
-        Tracevv((stderr, "inflate:         * length %u\n", c));
+	 DUMPBITS(t->bits)
+	 if (e & 16)
+	 {
+	   /* get extra bits for length */
+	   e &= 15;
+	   c = t->base + ((uInt)b & inflate_mask[e]);
+	   DUMPBITS(e)
+	   Tracevv((stderr, "inflate:         * length %u\n", c));
 
-        /* decode distance base of block to copy */
-        GRABBITS(15);           /* max bits for distance code */
-        e = (t = td + ((uInt)b & md))->exop;
-        do {
-          DUMPBITS(t->bits)
-          if (e & 16)
-          {
-            /* get extra bits to add to distance base */
-            e &= 15;
-            GRABBITS(e)         /* get extra bits (up to 13) */
-            d = t->base + ((uInt)b & inflate_mask[e]);
-            DUMPBITS(e)
-            Tracevv((stderr, "inflate:         * distance %u\n", d));
+	   /* decode distance base of block to copy */
+	   GRABBITS(15);           /* max bits for distance code */
+	   e = (t = td + ((uInt)b & md))->exop;
+	   do {
+		DUMPBITS(t->bits)
+		if (e & 16)
+		{
+		  /* get extra bits to add to distance base */
+		  e &= 15;
+		  GRABBITS(e)         /* get extra bits (up to 13) */
+		  d = t->base + ((uInt)b & inflate_mask[e]);
+		  DUMPBITS(e)
+		  Tracevv((stderr, "inflate:         * distance %u\n", d));
 
-            /* do the copy */
-            m -= c;
-            r = q - d;
-            if (r < s->window)                  /* wrap if needed */
-            {
-              do {
-                r += s->end - s->window;        /* force pointer in window */
-              } while (r < s->window);          /* covers invalid distances */
-              e = s->end - r;
-              if (c > e)
-              {
-                c -= e;                         /* wrapped copy */
-                do {
-                    *q++ = *r++;
-                } while (--e);
-                r = s->window;
-                do {
-                    *q++ = *r++;
-                } while (--c);
-              }
-              else                              /* normal copy */
-              {
-                *q++ = *r++;  c--;
-                *q++ = *r++;  c--;
-                do {
-                    *q++ = *r++;
-                } while (--c);
-              }
-            }
-            else                                /* normal copy */
-            {
-              *q++ = *r++;  c--;
-              *q++ = *r++;  c--;
-              do {
-                *q++ = *r++;
-              } while (--c);
-            }
-            break;
-          }
-          else if ((e & 64) == 0)
-          {
-            t += t->base;
-            e = (t += ((uInt)b & inflate_mask[e]))->exop;
-          }
-          else
-          {
-            z->msg = (char*)"invalid distance code";
-            UNGRAB
-            UPDATE
-            return Z_DATA_ERROR;
-          }
-        } while (1);
-        break;
-      }
-      if ((e & 64) == 0)
-      {
-        t += t->base;
-        if ((e = (t += ((uInt)b & inflate_mask[e]))->exop) == 0)
-        {
-          DUMPBITS(t->bits)
-          Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
-                    "inflate:         * literal '%c'\n" :
-                    "inflate:         * literal 0x%02x\n", t->base));
-          *q++ = (Byte)t->base;
-          m--;
-          break;
-        }
-      }
-      else if (e & 32)
+		  /* do the copy */
+		  m -= c;
+		  csp = (unsigned long)q - d;
+		  if (csp < (unsigned long)s->window)                  /* wrap if needed */
+		  {
+		    do {
+			 csp += (unsigned long)(s->end - s->window);        /* force pointer in window */
+		    } while (csp < (unsigned long)s->window);          /* covers invalid distances */
+		    e = (unsigned long)s->end - csp;
+		    if (c > e)
+		    {
+			 c -= e;                         /* wrapped copy */
+			 do {
+				*q++ = *(Bytef *)csp++;
+			 } while (--e);
+			 csp = s->window;
+			 do {
+				*q++ = *(Bytef *)csp++;
+			 } while (--c);
+		    }
+		    else                              /* normal copy */
+		    {
+			 *q++ = *(Bytef *)csp++;  c--;
+			 *q++ = *(Bytef *)csp++;  c--;
+			 do {
+				*q++ = *(Bytef *)csp++;
+			 } while (--c);
+		    }
+		  }
+		  else                                /* normal copy */
+		  {
+		    *q++ = *(Bytef *)csp++;  c--;
+		    *q++ = *(Bytef *)csp++;  c--;
+		    do {
+			 *q++ = *(Bytef *)csp++;
+		    } while (--c);
+		  }
+		  break;
+		}
+		else if ((e & 64) == 0)
+		{
+		  t += t->base;
+		  e = (t += ((uInt)b & inflate_mask[e]))->exop;
+		}
+		else
+		{
+		  z->msg = (char*)"invalid distance code";
+		  UNGRAB
+		  UPDATE
+		  return Z_DATA_ERROR;
+		}
+	   } while (1);
+	   break;
+	 }
+	 if ((e & 64) == 0)
+	 {
+	   t += t->base;
+	   if ((e = (t += ((uInt)b & inflate_mask[e]))->exop) == 0)
+	   {
+		DUMPBITS(t->bits)
+		Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+				"inflate:         * literal '%c'\n" :
+				"inflate:         * literal 0x%02x\n", t->base));
+		*q++ = (Byte)t->base;
+		m--;
+		break;
+	   }
+	 }
+	 else if (e & 32)
       {
         Tracevv((stderr, "inflate:         * end of block\n"));
         UNGRAB