function zip_flush_block()

in themes/docsy/static/js/deflate.js [1378:1453]

• 36 lines of code
• 7 McCabe index (conditional complexity)

    function zip_flush_block(eof) { // true if this is the last block for a file
        var opt_lenb, static_lenb; // opt_len and static_len in bytes
        var max_blindex;	// index of last bit length code of non zero freq
        var stored_len;	// length of input block

        stored_len = zip_strstart - zip_block_start;
        zip_flag_buf[zip_last_flags] = zip_flags; // Save the flags for the last 8 items

        // Construct the literal and distance trees
        zip_build_tree(zip_l_desc);
        //    Tracev((stderr, "\nlit data: dyn %ld, stat %ld",
        //	    encoder->opt_len, encoder->static_len));

        zip_build_tree(zip_d_desc);
        //    Tracev((stderr, "\ndist data: dyn %ld, stat %ld",
        //	    encoder->opt_len, encoder->static_len));
        /* At this point, opt_len and static_len are the total bit lengths of
            * the compressed block data, excluding the tree representations.
            */

        /* Build the bit length tree for the above two trees, and get the index
            * in bl_order of the last bit length code to send.
            */
        max_blindex = zip_build_bl_tree();

        // Determine the best encoding. Compute first the block length in bytes
        opt_lenb = (zip_opt_len + 3 + 7) >> 3;
        static_lenb = (zip_static_len + 3 + 7) >> 3;

        //    Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
        //	   opt_lenb, encoder->opt_len,
        //	   static_lenb, encoder->static_len, stored_len,
        //	   encoder->last_lit, encoder->last_dist));

        if (static_lenb <= opt_lenb)
            opt_lenb = static_lenb;
        if (stored_len + 4 <= opt_lenb // 4: two words for the lengths
            && zip_block_start >= 0) {
            var i;

            /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
                * Otherwise we can't have processed more than WSIZE input bytes since
                * the last block flush, because compression would have been
                * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
                * transform a block into a stored block.
                */
            zip_send_bits((zip_STORED_BLOCK << 1) + eof, 3);  /* send block type */
            zip_bi_windup();		 /* align on byte boundary */
            zip_put_short(stored_len);
            zip_put_short(~stored_len);

            // copy block
            /*
                p = &window[block_start];
                for(i = 0; i < stored_len; i++)
            put_byte(p[i]);
            */
            for (i = 0; i < stored_len; i++)
                zip_put_byte(zip_window[zip_block_start + i]);

        } else if (static_lenb == opt_lenb) {
            zip_send_bits((zip_STATIC_TREES << 1) + eof, 3);
            zip_compress_block(zip_static_ltree, zip_static_dtree);
        } else {
            zip_send_bits((zip_DYN_TREES << 1) + eof, 3);
            zip_send_all_trees(zip_l_desc.max_code + 1,
                zip_d_desc.max_code + 1,
                max_blindex + 1);
            zip_compress_block(zip_dyn_ltree, zip_dyn_dtree);
        }

        zip_init_block();

        if (eof != 0)
            zip_bi_windup();
    }