function zip_deflate_better()

in themes/docsy/static/js/deflate.js [637:732]

• 51 lines of code
• 17 McCabe index (conditional complexity)

    function zip_deflate_better() {
        /* Process the input block. */
        while (zip_lookahead != 0 && zip_qhead == null) {
            /* Insert the string window[strstart .. strstart+2] in the
                * dictionary, and set hash_head to the head of the hash chain:
                */
            zip_INSERT_STRING();

            /* Find the longest match, discarding those <= prev_length.
                */
            zip_prev_length = zip_match_length;
            zip_prev_match = zip_match_start;
            zip_match_length = zip_MIN_MATCH - 1;

            if (zip_hash_head != zip_NIL &&
                zip_prev_length < zip_max_lazy_match &&
                zip_strstart - zip_hash_head <= zip_MAX_DIST) {
                /* To simplify the code, we prevent matches with the string
                    * of window index 0 (in particular we have to avoid a match
                    * of the string with itself at the start of the input file).
                    */
                zip_match_length = zip_longest_match(zip_hash_head);
                /* longest_match() sets match_start */
                if (zip_match_length > zip_lookahead)
                    zip_match_length = zip_lookahead;

                /* Ignore a length 3 match if it is too distant: */
                if (zip_match_length == zip_MIN_MATCH &&
                    zip_strstart - zip_match_start > zip_TOO_FAR) {
                    /* If prev_match is also MIN_MATCH, match_start is garbage
                        * but we will ignore the current match anyway.
                        */
                    zip_match_length--;
                }
            }
            /* If there was a match at the previous step and the current
                * match is not better, output the previous match:
                */
            if (zip_prev_length >= zip_MIN_MATCH &&
                zip_match_length <= zip_prev_length) {
                var flush; // set if current block must be flushed

                //	    check_match(strstart - 1, prev_match, prev_length);
                flush = zip_ct_tally(zip_strstart - 1 - zip_prev_match,
                    zip_prev_length - zip_MIN_MATCH);

                /* Insert in hash table all strings up to the end of the match.
                    * strstart-1 and strstart are already inserted.
                    */
                zip_lookahead -= zip_prev_length - 1;
                zip_prev_length -= 2;
                do {
                    zip_strstart++;
                    zip_INSERT_STRING();
                    /* strstart never exceeds WSIZE-MAX_MATCH, so there are
                        * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
                        * these bytes are garbage, but it does not matter since the
                        * next lookahead bytes will always be emitted as literals.
                        */
                } while (--zip_prev_length != 0);
                zip_match_available = 0;
                zip_match_length = zip_MIN_MATCH - 1;
                zip_strstart++;
                if (flush) {
                    zip_flush_block(0);
                    zip_block_start = zip_strstart;
                }
            } else if (zip_match_available != 0) {
                /* If there was no match at the previous position, output a
                    * single literal. If there was a match but the current match
                    * is longer, truncate the previous match to a single literal.
                    */
                if (zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff)) {
                    zip_flush_block(0);
                    zip_block_start = zip_strstart;
                }
                zip_strstart++;
                zip_lookahead--;
            } else {
                /* There is no previous match to compare with, wait for
                    * the next step to decide.
                    */
                zip_match_available = 1;
                zip_strstart++;
                zip_lookahead--;
            }

            /* Make sure that we always have enough lookahead, except
                * at the end of the input file. We need MAX_MATCH bytes
                * for the next match, plus MIN_MATCH bytes to insert the
                * string following the next match.
                */
            while (zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
                zip_fill_window();
        }
    }