function zip_deflate_fast()

in themes/docsy/static/js/deflate.js [559:635]

• 40 lines of code
• 12 McCabe index (conditional complexity)

    function zip_deflate_fast() {
        while (zip_lookahead != 0 && zip_qhead == null) {
            var flush; // set if current block must be flushed

            /* 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.
                * At this point we have always match_length < MIN_MATCH
                */
            if (zip_hash_head != zip_NIL &&
                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;
            }
            if (zip_match_length >= zip_MIN_MATCH) {
                //	    check_match(strstart, match_start, match_length);

                flush = zip_ct_tally(zip_strstart - zip_match_start,
                    zip_match_length - zip_MIN_MATCH);
                zip_lookahead -= zip_match_length;

                /* Insert new strings in the hash table only if the match length
                    * is not too large. This saves time but degrades compression.
                    */
                if (zip_match_length <= zip_max_lazy_match) {
                    zip_match_length--; // string at strstart already in hash table
                    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 be emitted as literals.
                            */
                    } while (--zip_match_length != 0);
                    zip_strstart++;
                } else {
                    zip_strstart += zip_match_length;
                    zip_match_length = 0;
                    zip_ins_h = zip_window[zip_strstart] & 0xff;
                    //		UPDATE_HASH(ins_h, window[strstart + 1]);
                    zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[zip_strstart + 1] & 0xff)) & zip_HASH_MASK;

                    //#if MIN_MATCH != 3
                    //		Call UPDATE_HASH() MIN_MATCH-3 more times
                    //#endif

                }
            } else {
                /* No match, output a literal byte */
                flush = zip_ct_tally(0, zip_window[zip_strstart] & 0xff);
                zip_lookahead--;
                zip_strstart++;
            }
            if (flush) {
                zip_flush_block(0);
                zip_block_start = zip_strstart;
            }

            /* 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();
        }
    }