Coverage Report

Created: 2025-07-12 06:15

/src/zlib-ng/deflate_fast.c
Line
Count
Source (jump to first uncovered line)
1
/* deflate_fast.c -- compress data using the fast strategy of deflation algorithm
2
 *
3
 * Copyright (C) 1995-2024 Jean-loup Gailly and Mark Adler
4
 * For conditions of distribution and use, see copyright notice in zlib.h
5
 */
6
7
#include "zbuild.h"
8
#include "deflate.h"
9
#include "deflate_p.h"
10
#include "functable.h"
11
12
/* ===========================================================================
13
 * Compress as much as possible from the input stream, return the current
14
 * block state.
15
 * This function does not perform lazy evaluation of matches and inserts
16
 * new strings in the dictionary only for unmatched strings or for short
17
 * matches. It is used only for the fast compression options.
18
 */
19
0
Z_INTERNAL block_state deflate_fast(deflate_state *s, int flush) {
20
0
    Pos hash_head;        /* head of the hash chain */
21
0
    int bflush = 0;       /* set if current block must be flushed */
22
0
    int64_t dist;
23
0
    uint32_t match_len = 0;
24
25
0
    for (;;) {
26
        /* Make sure that we always have enough lookahead, except
27
         * at the end of the input file. We need STD_MAX_MATCH bytes
28
         * for the next match, plus WANT_MIN_MATCH bytes to insert the
29
         * string following the next match.
30
         */
31
0
        if (s->lookahead < MIN_LOOKAHEAD) {
32
0
            PREFIX(fill_window)(s);
33
0
            if (UNLIKELY(s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH)) {
34
0
                return need_more;
35
0
            }
36
0
            if (UNLIKELY(s->lookahead == 0))
37
0
                break; /* flush the current block */
38
0
        }
39
40
        /* Insert the string window[strstart .. strstart+2] in the
41
         * dictionary, and set hash_head to the head of the hash chain:
42
         */
43
0
        if (s->lookahead >= WANT_MIN_MATCH) {
44
0
            hash_head = quick_insert_string(s, s->strstart);
45
0
            dist = (int64_t)s->strstart - hash_head;
46
47
            /* Find the longest match, discarding those <= prev_length.
48
             * At this point we have always match length < WANT_MIN_MATCH
49
             */
50
0
            if (dist <= MAX_DIST(s) && dist > 0 && hash_head != 0) {
51
                /* To simplify the code, we prevent matches with the string
52
                 * of window index 0 (in particular we have to avoid a match
53
                 * of the string with itself at the start of the input file).
54
                 */
55
0
                match_len = FUNCTABLE_CALL(longest_match)(s, hash_head);
56
                /* longest_match() sets match_start */
57
0
            }
58
0
        }
59
60
0
        if (match_len >= WANT_MIN_MATCH) {
61
0
            Assert(s->strstart <= UINT16_MAX, "strstart should fit in uint16_t");
62
0
            Assert(s->match_start <= UINT16_MAX, "match_start should fit in uint16_t");
63
0
            check_match(s, (Pos)s->strstart, (Pos)s->match_start, match_len);
64
65
0
            bflush = zng_tr_tally_dist(s, s->strstart - s->match_start, match_len - STD_MIN_MATCH);
66
67
0
            s->lookahead -= match_len;
68
69
            /* Insert new strings in the hash table only if the match length
70
             * is not too large. This saves time but degrades compression.
71
             */
72
0
            if (match_len <= s->max_insert_length && s->lookahead >= WANT_MIN_MATCH) {
73
0
                match_len--; /* string at strstart already in table */
74
0
                s->strstart++;
75
76
0
                insert_string(s, s->strstart, match_len);
77
0
                s->strstart += match_len;
78
0
            } else {
79
0
                s->strstart += match_len;
80
0
                quick_insert_string(s, s->strstart + 2 - STD_MIN_MATCH);
81
82
                /* If lookahead < STD_MIN_MATCH, ins_h is garbage, but it does not
83
                 * matter since it will be recomputed at next deflate call.
84
                 */
85
0
            }
86
0
            match_len = 0;
87
0
        } else {
88
            /* No match, output a literal byte */
89
0
            bflush = zng_tr_tally_lit(s, s->window[s->strstart]);
90
0
            s->lookahead--;
91
0
            s->strstart++;
92
0
        }
93
0
        if (UNLIKELY(bflush))
94
0
            FLUSH_BLOCK(s, 0);
95
0
    }
96
0
    s->insert = s->strstart < (STD_MIN_MATCH - 1) ? s->strstart : (STD_MIN_MATCH - 1);
97
0
    if (UNLIKELY(flush == Z_FINISH)) {
98
0
        FLUSH_BLOCK(s, 1);
99
0
        return finish_done;
100
0
    }
101
0
    if (UNLIKELY(s->sym_next))
102
0
        FLUSH_BLOCK(s, 0);
103
0
    return block_done;
104
0
}