jar.c

已经移植好的java虚拟机

	    if (out - distance < outStart) {
		ziperr("copy underflow");
		goto done_loop;
	    } else if (out + length > outEnd) {
		ziperr("Output overflow");
		goto done_loop;
	    } else {
		unsigned char *prev = out - distance;
		unsigned char *end  = out + length;
		while (out != end) {
#ifdef JAR_DEBUG_FILE		    
		    if (state->jarDebugBytes 
			&& state->jarDebugBytes[out - outStart] != *prev) {
			ziperr("Dragon copy error");
		    }
#endif
		    *out++ = *prev++;
		}
	    }
	}
    }

 done_loop:
    STORE_IN;
    STORE_OUT;

    if (!JAR_INFLATER_INSIDE_KVM && !fixedHuffman) { 
	freeBytes(lcodes);
	freeBytes(dcodes);
    }
    return noerror;
}


/*=========================================================================
 * FUNCTION:  decodeDynamicHuffmanTables
 * TYPE:      Huffman code Decoding
 * OVERVIEW:  Used by inflateHuffman() for decoding dynamic Huffman tables. 
 * INTERFACE:
 *   parameters: inflaterState: *state
 *               HuffmanCodeTable: **lcodesPtr
 *               HuffmanCodeTable: **dcodesPtr
 * 
 *   returns:    TRUE if successful in decoding or
 *               FALSE if an error occurs
 *=======================================================================*/

static bool_t
decodeDynamicHuffmanTables(inflaterState *state,
			   HuffmanCodeTable **lcodesPtr,
			   HuffmanCodeTable **dcodesPtr) {
    DECLARE_IN_VARIABLES

    HuffmanCodeTable *ccodes = NULL;
    HuffmanCodeTable *lcodes = NULL;
    HuffmanCodeTable *dcodes = NULL;

    int hlit, hdist, hclen;
    int i;
    unsigned int quickBits;
    unsigned char codelen[286 + 32];
    unsigned char *codePtr, *endCodePtr;

    LOAD_IN;

    /* 5 Bits: HLIT, # of Literal/Length codes - 257 (257 - 286) */
    /* 5 Bits: HDIST, # of Distance codes - 1        (1 - 32) */
    /* 4 Bits: HCLEN, # of Code Length codes - 4     (4 - 19) */
    NEEDBITS(14);
    hlit = 257 + NEXTBITS(5);
    DUMPBITS(5);
    hdist = 1 + NEXTBITS(5);
    DUMPBITS(5);
    hclen = 4 + NEXTBITS(4);
    DUMPBITS(4);

    /*
     * (HCLEN + 4) x 3 bits: code lengths for the code length
     *  alphabet given just above, in the order: 16, 17, 18,
     *  0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
     *
     *  These code lengths are interpreted as 3-bit integers
     *  (0-7); as above, a code length of 0 means the
     *  corresponding symbol (literal/length or distance code
     *  length) is not used.
     */
    memset(codelen, 0x0, 19);
    for (i=0; i<hclen; i++) {
	NEEDBITS(3);		/* 3, plus 7 below */
	if (inRemaining < 0) { 
	    goto error;
	}
	codelen[(int)ccode_idx[i]] = (unsigned char) NEXTBITS(3);
	DUMPBITS(3);
    }

    ccodes = makeCodeTable(state, codelen, 19, MAX_QUICK_CXD);
    if (ccodes == NULL) {
	goto error;
    }
    quickBits = ccodes->h.quickBits;

    /*
     * HLIT + 257 code lengths for the literal/length alphabet,
     * encoded using the code length Huffman code.
     *
     * HDIST + 1 code lengths for the distance alphabet,
     * encoded using the code length Huffman code.
     *
     * The code length repeat codes can cross from HLIT + 257 to the
     * HDIST + 1 code lengths.  In other words, all code lengths form
     * a single sequence of HLIT + HDIST + 258 values.
     */

    memset(codelen, 0x0, sizeof(codelen));
    for (   codePtr = codelen, endCodePtr = codePtr + hlit + hdist;
	    codePtr < endCodePtr; ) {
	int val;

	if (inRemaining < 0) { 
	    goto error;
	}

	NEEDBITS(MAX_BITS + 7);	/* 7 is max repeat bits below */
	GET_HUFFMAN_ENTRY(ccodes, quickBits, val, error);

	/*
	 *  0 - 15: Represent code lengths of 0 - 15
	 *      16: Copy the previous code length 3 - 6 times.
         *          3 + (2 bits of length)
	 *      17: Repeat a code length of 0 for 3 - 10 times.
	 *          3 + (3 bits of length)
	 *      18: Repeat a code length of 0 for 11 - 138 times
	 *          11 + (7 bits of length)
	 */
	if (val <= 15) {
	    *codePtr++ = val;
	} else if (val <= 18) {
	    unsigned repeat  = (val == 18) ? 11 : 3;
	    unsigned bits    = (val == 18) ? 7 : (val - 14);

	    repeat += NEXTBITS(bits); /* The NEEDBITS is above */
	    DUMPBITS(bits);

	    if (codePtr + repeat > endCodePtr) {
		ziperr("Bad repeat code");
	    }

	    if (val == 16) {
		if (codePtr == codelen) {
		    ziperr("Bad repeat code");
		    goto error;
		}
		memset(codePtr, codePtr[-1], repeat);
	    } else {
		/* The values have already been set to zero, above, so
		 * we don't have to do anything */
	    }
	    codePtr += repeat;
	} else {
	    ziperr("Bad code-length code");
	    goto error;
	}
    }


    lcodes = makeCodeTable(state, codelen, hlit, MAX_QUICK_LXL);
    if (lcodes == NULL) {
        goto error;
    }

    dcodes = makeCodeTable(state, codelen + hlit, hdist, MAX_QUICK_CXD);
    if (dcodes == NULL) {
        goto error;
    }

    *lcodesPtr = lcodes;
    *dcodesPtr = dcodes;
    STORE_IN;
    if (!JAR_INFLATER_INSIDE_KVM) { 
	freeBytes(ccodes);
    }
    return TRUE;

error:
    if (!JAR_INFLATER_INSIDE_KVM) { 
	freeBytes(ccodes);
	freeBytes(dcodes);
	freeBytes(lcodes);
    }
    return FALSE;
}


/*=========================================================================
 * FUNCTION:  makeCodeTable
 * TYPE:      Huffman code table creation
 * INTERFACE:
 *   parameters: inflaterState 
 *               code length 
 *               number of elements of the alphabet 
 *               maxQuickBits 
 *   returns:    Huffman code table created if successful or
 *               NULL if an error occurs
 *=======================================================================*/

HuffmanCodeTable * makeCodeTable(
	inflaterState *state,
        unsigned char *codelen,	/* Code lengths */
        unsigned numElems,      /* Number of elements of the alphabet */
        unsigned maxQuickBits)  /* If the length of a code is longer than
                                 * <maxQuickBits> number of bits, the code is
                                 * stored in the sequential lookup table
                                 * instead of the quick lookup array. */
{
    unsigned int bitLengthCount[MAX_BITS + 1];
    unsigned int codes[MAX_BITS + 1];
    unsigned bits, minCodeLen = 0, maxCodeLen = 0;
    const unsigned char *endCodeLen = codelen + numElems;
    unsigned int code, quickMask;
    unsigned char *p;

    HuffmanCodeTable * table;
    int mainTableLength, longTableLength, numLongTables;
    int tableSize;
    int j;

    unsigned short *nextLongTable;

    /* Count the number of codes for each code length */
    memset(bitLengthCount, 0, sizeof(bitLengthCount));
    for (p = codelen; p < endCodeLen; p++) { 
	bitLengthCount[*p]++;
    }

    if (bitLengthCount[0] == numElems) {
	ziperr("Bad code table -- empty");
        return NULL;
    }

    /* Find the minimum and maximum.  It's faster to do it in a separate
     * loop that goes 1..MAX_BITS, than in the above loop that looks at
     * every code element */
    code = minCodeLen = maxCodeLen = 0;
    for (bits = 1; bits <= MAX_BITS; bits++) {
	codes[bits] = code;
	if (bitLengthCount[bits] != 0) {
	    if (minCodeLen == 0) minCodeLen = bits;
	    maxCodeLen = bits;
	    code += bitLengthCount[bits] << (MAX_BITS - bits);
	}
    }

    if (INCLUDEDEBUGCODE) { 
	if (code != (1 << MAX_BITS)) {
	    code += (1 << (MAX_BITS - maxCodeLen));
	    if (code != (1 << MAX_BITS)) {
		ziperr("Unexpected bit codes");
	    }
	}
    }

    /* Calculate the size of the code table and allocate it. */
    if (maxCodeLen <= maxQuickBits) {
	/* We don't need any subtables.  We may even be able to get
	 * away with a table smaller than maxCodeLen 
	 */
	maxQuickBits = maxCodeLen;
	mainTableLength = (1 << maxCodeLen);
	numLongTables = longTableLength = 0;
    } else {
	mainTableLength = (1 << maxQuickBits);
	numLongTables = (1 << MAX_BITS) - codes[maxQuickBits + 1];
	numLongTables = numLongTables >> (MAX_BITS - maxQuickBits);
	longTableLength = 1 << (maxCodeLen - maxQuickBits);
    }
    ASSERT(mainTableLength == 1 << maxQuickBits);
    tableSize = sizeof(HuffmanCodeTableHeader) 
	      + (mainTableLength + numLongTables * longTableLength) *
		       sizeof(table->entries[0]);
    table = (HuffmanCodeTable*)mallocBytes(tableSize);
    nextLongTable = &table->entries[mainTableLength];
    MAKE_TEMPORARY_ROOT(table);

    memset(table, 0, tableSize);

    table->h.maxCodeLen   = maxCodeLen;
    table->h.quickBits    = maxQuickBits;

    quickMask = (1 << maxQuickBits) - 1;

    for (p = codelen; p < endCodeLen; p++) {
	unsigned short huff;
	bits = *p;
	if (bits == 0) {
	    continue;
	}
	/* Get the next code of the current length */
	code = codes[bits];
	codes[bits] += 1 << (MAX_BITS - bits);
	code = REVERSE_15BITS(code);
	huff = ((p - codelen) << 4) + bits;
	if (bits <= maxQuickBits) { 
	    unsigned stride = 1 << bits;
	    for (j = code; j < mainTableLength; j += stride) {
		table->entries[j] = huff;
	    } 
	} else {
	    unsigned short *thisLongTable;
	    unsigned stride = 1 << (bits - maxQuickBits);
	    unsigned int prefixCode = code & quickMask;
	    unsigned int suffixCode = code >> maxQuickBits;
	    if (table->entries[prefixCode] == 0) {
		/* This in the first long code with the indicated prefix. 
		 * Create a pointer to the subtable */
		long delta = (char *)nextLongTable - (char *)table;
		table->entries[prefixCode] = (unsigned short)(HUFFINFO_LONG_MASK | delta);
		thisLongTable = nextLongTable;
		nextLongTable += longTableLength;
	    } else {
		long delta = table->entries[prefixCode] & ~HUFFINFO_LONG_MASK;
		thisLongTable = (unsigned short *)((char *)table + delta);
	    }
	    for (j = suffixCode; j < longTableLength; j += stride) {
		thisLongTable[j] = huff;
	    }
	}
	if (INCLUDEDEBUGCODE && inflateVerbose > 0) {
	    putchar(' ');
	    
	    for (j = 15; j >= 0; j--) {
		char c = (j >= (signed)bits) ? ' '
		    : (code & (1 << j)) ? '1' : '0';
		putchar(c);
	    }
	    fprintf(stdout, 
		    "   Char = %02x, Code = %4x\n", (p - codelen), code);
	}

    }
    ASSERT(nextLongTable == &table->entries[mainTableLength + numLongTables * longTableLength]);

    return table;
}


#if INCLUDEDEBUGCODE

/*=========================================================================
 * FUNCTION:  ziperr 
 * TYPE:      zip error processing function
 * OVERVIEW:  Used by inflate() and other functions for zip error processing. 
 * INTERFACE:
 *   parameters: const char *message 
 *              
 *   returns:    nothing 
 *=======================================================================*/
static void
ziperr(const char *message) {
    fprintf(stderr, "Zip Error: %s\n", message);
}

#endif