inflatelib.c

VXWORKS源代码

*/ 

static voidp falloc
    (
    voidp	q,	/* opaque pointer */
    uInt	n,      /* number of items */
    uInt	s       /* size of item */
    )
    {
    *(int *)q -= n;
    return (voidp)(fixed_mem + *(int *)q);
    }

/******************************************************************************
*
* inflate_trees_fixed - do something
*/ 

static int inflate_trees_fixed
    (
    uInt *	bl,	/* literal desired/actual bit depth */
    uInt *	bd,     /* distance desired/actual bit depth */
    inflate_huft ** tl, /* literal/length tree result */
    inflate_huft ** td  /* distance tree result */
    )
    {
    /* build fixed tables if not already (multiple overlapped executions ok) */
    if (!fixed_built)
	{
	int k;              /* temporary variable */
	unsigned *c = (unsigned *)zcalloc (0, 288, sizeof (unsigned));
			    /* length list for huft_build */
	z_stream z;         /* for falloc function */
	int f = FIXEDH;     /* number of hufts left in fixed_mem */

	/* set up fake z_stream for memory routines */
	z.zalloc = falloc;
	z.zfree = Z_NULL;
	z.opaque = (voidp)&f;

	/* literal table */
	for (k = 0; k < 144; k++)
	    c[k] = 8;
	for (; k < 256; k++)
	    c[k] = 9;
	for (; k < 280; k++)
	    c[k] = 7;
        for (; k < 288; k++)
	    c[k] = 8;
	fixed_bl = 7;
	huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z);

	/* distance table */
	for (k = 0; k < 30; k++)
#if	CPU_FAMILY==MC680X0
	    ((volatile unsigned *)c)[k] = 5;
#else
	    c[k] = 5;
#endif
	fixed_bd = 5;
	huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z);

	/* done */
	fixed_built = 1;
	zcfree (0, c);
	}

    *bl = fixed_bl;
    *bd = fixed_bd;
    *tl = fixed_tl;
    *td = fixed_td;
    return Z_OK;
    }

/******************************************************************************
*
* inflate_trees_free - frees inflate trees
*
* Free the malloc'ed tables built by huft_build(), which makes a linked
* list of the tables it made, with the links in a dummy first entry of
* each table.
*/ 

static int inflate_trees_free
    (
    inflate_huft *	t,	/* table to free */
    z_streamp		z       /* for zfree function */
    )
    {
    register inflate_huft *p, *q, *r;

    /* Reverse linked list */
    p = Z_NULL;
    q = t;
    while (q != Z_NULL)
	{
	r = (q - 1)->next;
	(q - 1)->next = p;
	p = q;
	q = r;
	}

    /* Go through linked list, freeing from the malloced (t[-1]) address. */
    while (p != Z_NULL)
	{
	q = (--p)->next;
	ZFREE(z,p);
	p = q;
	} 

    return Z_OK;
    }

/******************************************************************************
*
* inflate_flush - flushes inflate
*
* copy as much as possible from the sliding window to the output area
*/ 

static int inflate_flush
    (
    inflate_blocks_statef * s,
    z_streamp		z,
    int 		r
    )
    {
    uInt n;
    Byte *p;
    Byte *q;

    /* local copies of source and destination pointers */
    p = z->next_out;
    q = s->read;

    /* compute number of bytes to copy as far as end of window */
    n = (uInt)((q <= s->write ? s->write : s->end) - q);
    if (n > z->avail_out)
	n = z->avail_out;
    if (n && r == Z_BUF_ERROR)
	r = Z_OK;

    /* update counters */
    z->avail_out -= n;
    z->total_out += n;

    /* update check information */
    if (s->checkfn != Z_NULL)
	z->adler = s->check = (*s->checkfn)(s->check, q, n);

    /* copy as far as end of window */
    memcpy(p, q, n);
    p += n;
    q += n;

    /* see if more to copy at beginning of window */
    if (q == s->end)
	{
	/* wrap pointers */
	q = s->window;
	if (s->write == s->end)
	    s->write = s->window;

	/* compute bytes to copy */
	n = (uInt)(s->write - q);
	if (n > z->avail_out)
	    n = z->avail_out;
	if (n && r == Z_BUF_ERROR)
	    r = Z_OK;

	/* update counters */
	z->avail_out -= n;
	z->total_out += n;

	/* update check information */
	if (s->checkfn != Z_NULL)
	    z->adler = s->check = (*s->checkfn)(s->check, q, n);

	/* copy */
	memcpy(p, q, n);
	p += n;
	q += n;
	}

    /* update pointers */
    z->next_out = p;
    s->read = q;

    /* done */
    return r;
    }

/******************************************************************************
*
* inflate_fast - inflate fast
*
* 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.
*/ 

static int inflate_fast
    (
    uInt	bl,
    uInt	bd,
    inflate_huft * tl,
    inflate_huft * td,
    inflate_blocks_statef * s,
    z_streamp	z
    )
    {
    inflate_huft *t;	/* temporary pointer */
    uInt 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 */
  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)
    {
      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));

        /* 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;
            if ((uInt)(q - s->window) >= d)     /* offset before dest */
            {                                   /*  just copy */
              r = q - d;
              *q++ = *r++;  c--;        /* minimum count is three, */
              *q++ = *r++;  c--;        /*  so unroll loop a little */
            }
            else                        /* else offset after destination */
            {
              e = d - (uInt)(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);
            break;
          }
          else if ((e & 64) == 0)
            e = (t = t->next + ((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)
      {
        if ((e = (t = t->next + ((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
        UPDATE
        return Z_STREAM_END;
      }
      else
      {
        z->msg = (char*)"invalid literal/length code";
        UNGRAB
        UPDATE
        return Z_DATA_ERROR;
      }
    } while (1);
  } while (m >= 258 && n >= 10);

  /* not enough input or output--restore pointers and return */
  UNGRAB
  UPDATE
  return Z_OK;
}

/******************************************************************************
*
* inflate_codes_new - inflate codes new
*
* NOMANUAL
*/ 

static inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z)
uInt bl, bd;
inflate_huft *tl;
inflate_huft *td; /* need separate declaration for Borland C++ */
z_streamp z;
{
  inflate_codes_statef *c;

  if ((c = (inflate_codes_statef *)
       ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)
  {
    c->mode = START;
    c->lbits = (Byte)bl;
    c->dbits = (Byte)bd;
    c->ltree = tl;
    c->dtree = td;
    Tracev((stderr, "inflate:       codes new\n"));
  }
  return c;
}

/******************************************************************************
*
* inflate_codes - inflate codes
*
*/ 

static int inflate_codes(s, z, r)
inflate_blocks_statef *s;
z_streamp z;
int r;
{
  uInt j;               /* temporary storage */
  inflate_huft *t;      /* temporary pointer */
  uInt 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 */
  Byte *f;             /* pointer to copy strings from */
  inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */

  /* copy input/output information to locals (UPDATE macro restores) */
  LOAD

  /* process input and output based on current state */
  while (1) switch (c->mode)
  {             /* 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;
        }
      }
#endif /* !SLOW */
      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;