Function longest_match

extlibs/minizip/src/deflate.c:1343–1492

For 80x86 and 680x0, an optimized version will be provided in match.asm or * match.S. The code will be functionally equivalent. */

(s, cur_match)

 * match.S. The code will be functionally equivalent.
 */
local uInt longest_match(s, cur_match)
deflate_state* s;

IPos cur_match; /* current match */
{
    unsigned chain_length = s->max_chain_length;/* max hash chain length */
    register Bytef* scan = s->window + s->strstart; /* current string */
    register Bytef* match; /* matched string */
    register int len; /* length of current match */
    int best_len = (int)s->prev_length; /* best match length so far */
    int nice_match = s->nice_match; /* stop if match long enough */
    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
                     s->strstart - (IPos)MAX_DIST(s) : NIL;
    /* Stop when cur_match becomes <= limit. To simplify the code,
     * we prevent matches with the string of window index 0.
     */
    Posf* prev = s->prev;
    uInt wmask = s->w_mask;

#ifdef UNALIGNED_OK
    /* Compare two bytes at a time. Note: this is not always beneficial.
     * Try with and without -DUNALIGNED_OK to check.
     */
    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
    register ush scan_start = *(ushf*)scan;
    register ush scan_end   = *(ushf*)(scan+best_len-1);
#else
    register Bytef* strend = s->window + s->strstart + MAX_MATCH;
    register Byte scan_end1 = scan[best_len - 1];
    register Byte scan_end = scan[best_len];
#endif

    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
     * It is easy to get rid of this optimization if necessary.
     */
    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");

    /* Do not waste too much time if we already have a good match: */
    if (s->prev_length >= s->good_match)
    {
        chain_length >>= 2;
    }
    /* Do not look for matches beyond the end of the input. This is necessary
     * to make deflate deterministic.
     */
    if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;

    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");

    do
    {
        Assert(cur_match < s->strstart, "no future");
        match = s->window + cur_match;

        /* Skip to next match if the match length cannot increase
         * or if the match length is less than 2.  Note that the checks below
         * for insufficient lookahead only occur occasionally for performance
         * reasons.  Therefore uninitialized memory will be accessed, and