athena/extern/lzo/src/lzo1b_sm.ch

/* lzo1b_sm.ch -- implementation of the LZO1B compression algorithm

   This file is part of the LZO real-time data compression library.

   Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
   All Rights Reserved.

   The LZO library is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.

   The LZO library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with the LZO library; see the file COPYING.
   If not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

   Markus F.X.J. Oberhumer
   <markus@oberhumer.com>
   http://www.oberhumer.com/opensource/lzo/
 */


/* WARNING: this file should *not* be used by applications. It is
   part of the implementation of the library and is subject
   to change.
 */



/***********************************************************************
// search for a match
************************************************************************/

#if (DD_BITS == 0)

/* search ip in the dictionary */
DINDEX1(dindex, ip);
GINDEX(m_pos, m_off, dict, dindex, in);

if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET))
    goto literal;

#if 1

if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
    goto try_match;

DINDEX2(dindex, ip);
#endif
GINDEX(m_pos, m_off, dict, dindex, in);

if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET))
    goto literal;

if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
    goto try_match;

goto literal;


#else /* (DD_BITS == 0) */



/* search ip in the deepened dictionary */
{
    lzo_dict_p d = &dict [ DINDEX(dv, ip) ];
    const lzo_bytep ip_sav;
    unsigned j = DD_SIZE;
    lzo_uint x_len;
    LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, x_off, 0);

    DVAL_ASSERT(dv, ip);

    ip_sav = ip;
    m_len = 0;

    do
    {
#if !defined(NDEBUG)
        const lzo_bytep z_pos = NULL;
#endif
#if (LZO_DICT_USE_PTR)
        m_pos = *d;
        assert((z_pos = m_pos) == *d);
#if (LZO_DETERMINISTIC)
        assert(m_pos == NULL || m_pos >= in);
        assert(m_pos == NULL || m_pos < ip);
#endif
#else
        x_off = *d;
#endif
        assert(ip == ip_sav);

        if (LZO_CHECK_MPOS(m_pos, x_off, in, ip, MAX_OFFSET))
#if (CLEVEL == 9)
            *d = DENTRY(ip, in);

#else
            ((void)(0));
#endif
        else if (m_pos[m_len] != ip[m_len])
            ((void)(0));
        else if (*m_pos++ == *ip++ && *m_pos++ == *ip++ && *m_pos++ == *ip++)
        {
#if !(LZO_DICT_USE_PTR)
            assert((z_pos = ip - 3 - x_off) == (m_pos - 3));
#endif

            /* a match */
            if (MATCH_M2)
            {
                x_len = pd((ip - 1), ip_sav);

                if (x_len > m_len)
                {
                    m_len = x_len;
                    m_off = x_off;
                    assert((m_pos_sav = z_pos) != NULL);
                }

#if (CLEVEL == 9)
                /* try to find a closer match */
                else if (x_len == m_len && x_off < m_off)
                {
                    m_off = x_off;
                    assert((m_pos_sav = z_pos) != NULL);
                }

#endif
            }
            else
            {
                assert((ip - ip_sav) == M2_MAX_LEN + 1);
#if (CLEVEL == 9)
#if defined(MATCH_IP_END)
                {
                    const lzo_bytep end;
                    end = MATCH_IP_END;

                    while (ip < end  &&  *m_pos == *ip)
                        m_pos++, ip++;

                    assert(ip <= in_end);
                    x_len = pd(ip, ip_sav);
                }

                if (x_len > m_len)
                {
                    m_len = x_len;
                    m_off = x_off;
                    assert((m_pos_sav = z_pos) != NULL);

                    if (ip >= MATCH_IP_END)
                    {
                        ip = ip_sav;
#if 0
                        /* not needed - we are at the end */
                        d -= DD_SIZE - j;
                        assert(d == &dict [ DINDEX(dv, ip) ]);
                        UPDATE_P(d, drun, ip, in);
#endif
                        goto match;
                    }
                }
                else if (x_len == m_len && x_off < m_off)
                {
                    m_off = x_off;
                    assert((m_pos_sav = z_pos) != NULL);
                }

#else

                /* try to find a closer match */
                if (m_len < M2_MAX_LEN + 1 || x_off < m_off)
                {
                    m_len = M2_MAX_LEN + 1;
                    m_off = x_off;
                    assert((m_pos_sav = z_pos) != NULL);
                }

#endif
#else
                /* don't search for a longer/closer match */
                m_len = M2_MAX_LEN + 1;
                m_off = x_off;
                assert((m_pos_sav = z_pos) != NULL);
                ip = ip_sav;
                d -= DD_SIZE - j;
                assert(d == &dict [ DINDEX(dv, ip) ]);
                UPDATE_P(d, drun, ip, in);
                goto match;
#endif
            }

            ip = ip_sav;
        }
        else
            ip = ip_sav;

        d++;
    }
    while (--j > 0);

    assert(ip == ip_sav);

    d -= DD_SIZE;
    assert(d == &dict [ DINDEX(dv, ip) ]);
    UPDATE_P(d, drun, ip, in);
}

#endif /* (DD_BITS == 0) */


/* vim:set ts=4 sw=4 et: */