#include <limits.h>
#include <stddef.h>
#include "minilzo.h"
#include <string.h>
#include <assert.h>

Data Structures
struct	lzo_memops_TU2_struct

struct	lzo_memops_TU4_struct

struct	lzo_memops_TU8_struct

union	lzo_config_check_union

Macros
#define	__LZO_IN_MINILZO 1

#define	__LZO_CONF_H 1

#define	__LZO_NOEXPORT1 /empty/

#define	__LZO_NOEXPORT2 /empty/

#define	LZO_PUBLIC_DECL(r)

#define	LZO_PUBLIC_IMPL(r)

#define	LZO_LOCAL_DECL(r)

#define	LZO_LOCAL_IMPL(r)

#define	LZO_STATIC_DECL(r)

#define	LZO_STATIC_IMPL(r)

#define	HAVE_STRING_H 1

#define	HAVE_MEMCMP 1

#define	HAVE_MEMCPY 1

#define	HAVE_MEMMOVE 1

#define	HAVE_MEMSET 1

#define	lzo_memcmp(a, b, c)

#define	lzo_memcpy(a, b, c)

#define	lzo_memmove(a, b, c)

#define	lzo_memset(a, b, c)

#define	NDEBUG 1

#define	BOUNDS_CHECKING_OFF_DURING(stmt)

#define	BOUNDS_CHECKING_OFF_IN_EXPR(expr)

#define	LZO_BYTE(x)

#define	LZO_MAX(a, b)

#define	LZO_MIN(a, b)

#define	LZO_MAX3(a, b, c)

#define	LZO_MIN3(a, b, c)

#define	lzo_sizeof(type)

#define	LZO_HIGH(array)

#define	LZO_SIZE(bits)

#define	LZO_MASK(bits)

#define	LZO_USIZE(bits)

#define	LZO_UMASK(bits)

#define	DMUL(a, b)

#define	__LZO_FUNC_H 1

#define	lzo_memops_TU0p void __LZO_MMODEL *

#define	lzo_memops_TU1p unsigned char __LZO_MMODEL *

#define	lzo_memops_TU2p lzo_memops_TU2 *

#define	lzo_memops_TU4p lzo_memops_TU4 __LZO_MMODEL *

#define	lzo_memops_TU8p lzo_memops_TU8 __LZO_MMODEL *

#define	lzo_memops_set_TU1p volatile lzo_memops_TU1p

#define	lzo_memops_move_TU1p lzo_memops_TU1p

#define	LZO_MEMOPS_SET1(dd, cc)

#define	LZO_MEMOPS_SET2(dd, cc)

#define	LZO_MEMOPS_SET3(dd, cc)

#define	LZO_MEMOPS_SET4(dd, cc)

#define	LZO_MEMOPS_MOVE1(dd, ss)

#define	LZO_MEMOPS_MOVE2(dd, ss)

#define	LZO_MEMOPS_MOVE3(dd, ss)

#define	LZO_MEMOPS_MOVE4(dd, ss)

#define	LZO_MEMOPS_MOVE8(dd, ss)

#define	LZO_MEMOPS_COPY1(dd, ss)

#define	LZO_MEMOPS_COPY2(dd, ss)

#define	LZO_MEMOPS_COPY4(dd, ss)

#define	LZO_MEMOPS_COPY8(dd, ss)

#define	LZO_MEMOPS_COPYN(dd, ss, nn)

#define	LZO_MEMOPS_GET_LE16(ss)

#define	LZO_MEMOPS_GET_LE32(ss)

#define	LZO_MEMOPS_GET_NE16(ss)

#define	LZO_MEMOPS_GET_NE32(ss)

#define	LZO_MEMOPS_PUT_LE16(dd, vv)

#define	LZO_MEMOPS_PUT_LE32(dd, vv)

#define	LZO_MEMOPS_PUT_NE16(dd, vv)

#define	LZO_MEMOPS_PUT_NE32(dd, vv)

#define	UA_SET1 LZO_MEMOPS_SET1

#define	UA_SET2 LZO_MEMOPS_SET2

#define	UA_SET3 LZO_MEMOPS_SET3

#define	UA_SET4 LZO_MEMOPS_SET4

#define	UA_MOVE1 LZO_MEMOPS_MOVE1

#define	UA_MOVE2 LZO_MEMOPS_MOVE2

#define	UA_MOVE3 LZO_MEMOPS_MOVE3

#define	UA_MOVE4 LZO_MEMOPS_MOVE4

#define	UA_MOVE8 LZO_MEMOPS_MOVE8

#define	UA_COPY1 LZO_MEMOPS_COPY1

#define	UA_COPY2 LZO_MEMOPS_COPY2

#define	UA_COPY3 LZO_MEMOPS_COPY3

#define	UA_COPY4 LZO_MEMOPS_COPY4

#define	UA_COPY8 LZO_MEMOPS_COPY8

#define	UA_COPYN LZO_MEMOPS_COPYN

#define	UA_COPYN_X LZO_MEMOPS_COPYN

#define	UA_GET_LE16 LZO_MEMOPS_GET_LE16

#define	UA_GET_LE32 LZO_MEMOPS_GET_LE32

#define	UA_GET_NE16 LZO_MEMOPS_GET_NE16

#define	UA_GET_NE32 LZO_MEMOPS_GET_NE32

#define	UA_PUT_LE16 LZO_MEMOPS_PUT_LE16

#define	UA_PUT_LE32 LZO_MEMOPS_PUT_LE32

#define	UA_PUT_NE16 LZO_MEMOPS_PUT_NE16

#define	UA_PUT_NE32 LZO_MEMOPS_PUT_NE32

#define	MEMCPY8_DS(dest, src, len)

#define	BZERO8_PTR(s, l, n)

#define	MEMCPY_DS(dest, src, len)

#define	__LZO_PTR_H 1

#define	PTR(a)

#define	PTR_LINEAR(a)

#define	PTR_ALIGNED_4(a)

#define	PTR_ALIGNED_8(a)

#define	PTR_ALIGNED2_4(a, b)

#define	PTR_ALIGNED2_8(a, b)

#define	PTR_LT(a, b)

#define	PTR_GE(a, b)

#define	PTR_DIFF(a, b)

#define	pd(a, b)

#define	LZO_DETERMINISTIC 1

#define	LZO_DICT_USE_PTR 1

#define	lzo_dict_t const lzo_bytep

#define	lzo_dict_p lzo_dict_t *

#define	LZO_BASE 65521u

#define	LZO_NMAX 5552

#define	LZO_DO1(buf, i)

#define	LZO_DO2(buf, i)

#define	LZO_DO4(buf, i)

#define	LZO_DO8(buf, i)

#define	LZO_DO16(buf, i)

#define	lzo_hsize_t lzo_uint

#define	lzo_hvoid_p lzo_voidp

#define	lzo_hbyte_p lzo_bytep

#define	LZOLIB_PUBLIC(r, f)

#define	lzo_hmemcmp lzo_memcmp

#define	lzo_hmemcpy lzo_memcpy

#define	lzo_hmemmove lzo_memmove

#define	lzo_hmemset lzo_memset

#define	__LZOLIB_HMEMCPY_CH_INCLUDED 1

#define	LZO1X 1

#define	LZO_EOF_CODE 1

#define	M2_MAX_OFFSET 0x0800

#define	LZO_DICT_USE_PTR 0

#define	lzo_dict_t lzo_uint16_t

#define	LZO_NEED_DICT_H 1

#define	D_BITS 14

#define	D_INDEX1(d, p)

#define	D_INDEX2(d, p)

#define	DINDEX(dv, p)

#define	__LZO_CONFIG1X_H 1

#define	M1_MAX_OFFSET 0x0400

#define	M3_MAX_OFFSET 0x4000

#define	M4_MAX_OFFSET 0xbfff

#define	MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET)

#define	M1_MIN_LEN 2

#define	M1_MAX_LEN 2

#define	M2_MIN_LEN 3

#define	M2_MAX_LEN 8

#define	M3_MIN_LEN 3

#define	M3_MAX_LEN 33

#define	M4_MIN_LEN 3

#define	M4_MAX_LEN 9

#define	M1_MARKER 0

#define	M2_MARKER 64

#define	M3_MARKER 32

#define	M4_MARKER 16

#define	MIN_LOOKAHEAD (M2_MAX_LEN + 1)

#define	LZO_HASH LZO_HASH_LZO_INCREMENTAL_B

#define	DL_MIN_LEN M2_MIN_LEN

#define	__LZO_DICT_H 1

#define	D_SIZE LZO_SIZE(D_BITS)

#define	D_MASK LZO_MASK(D_BITS)

#define	D_HIGH ((D_MASK >> 1) + 1)

#define	DD_BITS 0

#define	DD_SIZE LZO_SIZE(DD_BITS)

#define	DD_MASK LZO_MASK(DD_BITS)

#define	DL_BITS (D_BITS - DD_BITS)

#define	DL_SIZE LZO_SIZE(DL_BITS)

#define	DL_MASK LZO_MASK(DL_BITS)

#define	DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN)

#define	LZO_HASH_GZIP 1

#define	LZO_HASH_GZIP_INCREMENTAL 2

#define	LZO_HASH_LZO_INCREMENTAL_A 3

#define	LZO_HASH_LZO_INCREMENTAL_B 4

#define	_DV2_A(p, shift1, shift2)

#define	_DV2_B(p, shift1, shift2)

#define	_DV3_B(p, shift1, shift2, shift3)

#define	_DV_A(p, shift)

#define	_DV_B(p, shift)

#define	DA2(p, s1, s2)

#define	DS2(p, s1, s2)

#define	DX2(p, s1, s2)

#define	DA3(p, s1, s2, s3)

#define	DS3(p, s1, s2, s3)

#define	DX3(p, s1, s2, s3)

#define	DMS(v, s)

#define	DM(v)

#define	__LZO_HASH_INCREMENTAL 1

#define	DVAL_FIRST(dv, p)

#define	DVAL_NEXT(dv, p)

#define	_DINDEX(dv, p)

#define	DVAL_LOOKAHEAD DL_MIN_LEN

#define	DINDEX1 D_INDEX1

#define	DINDEX2 D_INDEX2

#define	DVAL_ASSERT(dv, p)

#define	DENTRY(p, in)

#define	GINDEX(m_pos, m_off, dict, dindex, in)

#define	UPDATE_D(dict, drun, dv, p, in)

#define	UPDATE_I(dict, drun, index, p, in)

#define	UPDATE_P(ptr, drun, p, in)

#define	LZO_CHECK_MPOS_DET(m_pos, m_off, in, ip, max_offset)

#define	LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, max_offset)

#define	LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET

#define	LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)

#define	DO_COMPRESS lzo1x_1_compress

#define	do_compress LZO_PP_ECONCAT2(DO_COMPRESS,_core)

#define	DO_DECOMPRESS lzo1x_decompress

#define	TEST_LB(m_pos)

#define	TEST_LBO(m_pos, o)

#define	TEST_IP 1

#define	TEST_OP 1

#define	TEST_IP_AND_TEST_OP 1

#define	NEED_IP(x)

#define	TEST_IV(x)

#define	NEED_OP(x)

#define	TEST_OV(x)

#define	LZO_TEST_OVERRUN 1

#define	DO_DECOMPRESS lzo1x_decompress_safe

#define	LZO_TEST_OVERRUN_INPUT 2

#define	LZO_TEST_OVERRUN_OUTPUT 2

#define	LZO_TEST_OVERRUN_LOOKBEHIND 1

#define	TEST_IP (ip < ip_end)

#define	NEED_IP(x)

#define	TEST_IV(x)

#define	TEST_OP (op <= op_end)

#define	NEED_OP(x)

#define	TEST_OV(x)

#define	TEST_LB(m_pos)

#define	TEST_LBO(m_pos, o)

#define	HAVE_TEST_IP 1

#define	TEST_OP 1

#define	TEST_IP_AND_TEST_OP TEST_IP

#define	HAVE_NEED_IP 1

#define	HAVE_NEED_OP 1

#define	HAVE_ANY_IP 1

#define	HAVE_ANY_OP 1

Functions
__lzo_static_forceinline unsigned	lzo_bitops_ctlz32_func (lzo_uint32_t v)

__lzo_static_forceinline unsigned	lzo_bitops_cttz32_func (lzo_uint32_t v)

	lzo_unused_funcs_impl (void, lzo_bitops_unused_funcs)

	LZO_COMPILE_TIME_ASSERT_HEADER (sizeof(*(lzo_memops_TU1p) 0)==1)

__lzo_static_forceinline lzo_uint32_t	lzo_memops_get_le32 (const lzo_voidp ss)

__lzo_static_forceinline lzo_uint16_t	lzo_memops_get_ne16 (const lzo_voidp ss)

__lzo_static_forceinline lzo_uint32_t	lzo_memops_get_ne32 (const lzo_voidp ss)

__lzo_static_forceinline void	lzo_memops_put_le16 (lzo_voidp dd, lzo_uint16_t vv)

__lzo_static_forceinline void	lzo_memops_put_le32 (lzo_voidp dd, lzo_uint32_t vv)

__lzo_static_forceinline void	lzo_memops_put_ne16 (lzo_voidp dd, lzo_uint16_t vv)

__lzo_static_forceinline void	lzo_memops_put_ne32 (lzo_voidp dd, lzo_uint32_t vv)

	lzo_unused_funcs_impl (void, lzo_memops_unused_funcs)

	LZO_EXTERN (const lzo_bytep)

	__lzo_ptr_linear (const lzo_voidp ptr)

	__lzo_align_gap (const lzo_voidp ptr, lzo_uint size)

	lzo_copyright (void)

	lzo_version (void)

	lzo_version_string (void)

	lzo_version_date (void)

	_lzo_version_string (void)

	_lzo_version_date (void)

	lzo_adler32 (lzo_uint32_t adler, const lzo_bytep buf, lzo_uint len)

	LZOLIB_PUBLIC (int, lzo_hmemcmp) const

	LZOLIB_PUBLIC (lzo_hvoid_p, lzo_hmemcpy)

	LZOLIB_PUBLIC (lzo_hvoid_p, lzo_hmemmove)

	LZOLIB_PUBLIC (lzo_hvoid_p, lzo_hmemset)

	_lzo_config_check (void)

	__lzo_init_v2 (unsigned v, int s1, int s2, int s3, int s4, int s5, int s6, int s7, int s8, int s9)

	DO_COMPRESS (const lzo_bytep in, lzo_uint in_len, lzo_bytep out, lzo_uintp out_len, lzo_voidp wrkmem)

	DO_DECOMPRESS (const lzo_bytep in, lzo_uint in_len, lzo_bytep out, lzo_uintp out_len, lzo_voidp wrkmem)

Variables
struct lzo_memops_TU2_struct	__lzo_may_alias

	lzo_full_align_t

Macro Definition Documentation

◆ __LZO_CONF_H

#define __LZO_CONF_H 1

◆ __LZO_CONFIG1X_H

#define __LZO_CONFIG1X_H 1

◆ __LZO_DICT_H

#define __LZO_DICT_H 1

◆ __LZO_FUNC_H

#define __LZO_FUNC_H 1

◆ __LZO_HASH_INCREMENTAL

#define __LZO_HASH_INCREMENTAL 1

◆ __LZO_IN_MINILZO

#define __LZO_IN_MINILZO 1

◆ __LZO_NOEXPORT1

#define __LZO_NOEXPORT1 /*empty*/

◆ __LZO_NOEXPORT2

#define __LZO_NOEXPORT2 /*empty*/

◆ __LZO_PTR_H

#define __LZO_PTR_H 1

◆ __LZOLIB_HMEMCPY_CH_INCLUDED

#define __LZOLIB_HMEMCPY_CH_INCLUDED 1

◆ _DINDEX

#define _DINDEX	(		dv,
			p )

Value:

((DMUL(0x9f5f,dv)) >> 5)

DMUL

#define DMUL(a, b)

Definition minilzo.c:3540

◆ _DV2_A

#define _DV2_A	(	p,
		shift1,
		shift2 )

Value:

(((( (lzo_xint)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2])

lzo_xint

#define lzo_xint

Definition lzoconf.h:132

◆ _DV2_B

#define _DV2_B	(	p,
		shift1,
		shift2 )

Value:

(((( (lzo_xint)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0])

◆ _DV3_B

#define _DV3_B	(	p,
		shift1,
		shift2,
		shift3 )

Value:

((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0])

_DV2_B

#define _DV2_B(p, shift1, shift2)

Definition minilzo.c:4757

◆ _DV_A

#define _DV_A	(		p,
			shift )

Value:

_DV2_A(p,shift,shift)

_DV2_A

#define _DV2_A(p, shift1, shift2)

Definition minilzo.c:4755

◆ _DV_B

#define _DV_B	(		p,
			shift )

Value:

_DV2_B(p,shift,shift)

◆ BOUNDS_CHECKING_OFF_DURING

#define BOUNDS_CHECKING_OFF_DURING ( stmt )

Value:

stmt

◆ BOUNDS_CHECKING_OFF_IN_EXPR

#define BOUNDS_CHECKING_OFF_IN_EXPR ( expr )

Value:

(expr)

◆ BZERO8_PTR

#define BZERO8_PTR	(	s,
		l,
		n )

Value:

lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n))

lzo_voidp

#define lzo_voidp

lzo_uint

unsigned long lzo_uint

Definition lzoconf.h:116

lzo_memset

#define lzo_memset(a, b, c)

Definition minilzo.c:3468

◆ D_BITS

#define D_BITS 14

◆ D_HIGH

#define D_HIGH ((D_MASK >> 1) + 1)

◆ D_INDEX1

#define D_INDEX1	(		d,
			p )

Value:

d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)

DM

#define DM(v)

Definition minilzo.c:4781

DX3

#define DX3(p, s1, s2, s3)

Definition minilzo.c:4779

d

#define d(i)

Definition sha256.c:44

◆ D_INDEX2

#define D_INDEX2	(		d,
			p )

Value:

d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)

D_HIGH

#define D_HIGH

Definition minilzo.c:4703

D_MASK

#define D_MASK

Definition minilzo.c:4698

◆ D_MASK

#define D_MASK LZO_MASK(D_BITS)

◆ D_SIZE

#define D_SIZE LZO_SIZE(D_BITS)

◆ DA2

#define DA2	(	p,
		s1,
		s2 )

Value:

(((((lzo_xint)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0])

s1

#define s1(x)

Definition Sha256.c:142

◆ DA3

#define DA3	(	p,
		s1,
		s2,
		s3 )

Value:

((DA2((p)+1,s2,s3) << (s1)) + (p)[0])

DA2

#define DA2(p, s1, s2)

Definition minilzo.c:4771

◆ DD_BITS

#define DD_BITS 0

◆ DD_MASK

#define DD_MASK LZO_MASK(DD_BITS)

◆ DD_SIZE

#define DD_SIZE LZO_SIZE(DD_BITS)

◆ DENTRY

#define DENTRY	(		p,
			in )

Value:

((lzo_dict_t) pd(p, in))

lzo_dict_t

#define lzo_dict_t

Definition minilzo.c:4163

pd

#define pd(a, b)

◆ DINDEX

#define DINDEX	(		dv,
			p )

Value:

DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))

D_BITS

#define D_BITS

Definition minilzo.c:4621

◆ DINDEX1

#define DINDEX1 D_INDEX1

◆ DINDEX2

#define DINDEX2 D_INDEX2

◆ DL_BITS

#define DL_BITS (D_BITS - DD_BITS)

◆ DL_MASK

#define DL_MASK LZO_MASK(DL_BITS)

◆ DL_MIN_LEN

#define DL_MIN_LEN M2_MIN_LEN

◆ DL_SHIFT

#define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN)

◆ DL_SIZE

#define DL_SIZE LZO_SIZE(DL_BITS)

◆ DM

#define DM ( v )

Value:

DMS(v,0)

DMS

#define DMS(v, s)

Definition minilzo.c:4780

◆ DMS

#define DMS	(		v,
			s )

Value:

((lzo_uint) (((v) & (D_MASK >> (s))) << (s)))

lzo_uint

#define lzo_uint

Definition lz5.h:31

◆ DMUL

#define DMUL	(		a,
			b )

Value:

((lzo_xint) ((a) * (b)))

b

#define b(i)

Definition sha256.c:42

a

#define a(i)

Definition sha256.c:41

◆ DO_COMPRESS

#define DO_COMPRESS lzo1x_1_compress

◆ do_compress

#define do_compress LZO_PP_ECONCAT2(DO_COMPRESS,_core)

◆ DO_DECOMPRESS [1/2]

#define DO_DECOMPRESS lzo1x_decompress

◆ DO_DECOMPRESS [2/2]

#define DO_DECOMPRESS lzo1x_decompress_safe

◆ DS2

#define DS2	(	p,
		s1,
		s2 )

Value:

(((((lzo_xint)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0])

◆ DS3

#define DS3	(	p,
		s1,
		s2,
		s3 )

Value:

((DS2((p)+1,s2,s3) << (s1)) - (p)[0])

DS2

#define DS2(p, s1, s2)

Definition minilzo.c:4773

◆ DVAL_ASSERT

#define DVAL_ASSERT	(		dv,
			p )

Value:

((void) 0)

◆ DVAL_FIRST

#define DVAL_FIRST	(		dv,
			p )

Value:

dv = _DV_B((p),5)

_DV_B

#define _DV_B(p, shift)

Definition minilzo.c:4770

◆ DVAL_LOOKAHEAD

#define DVAL_LOOKAHEAD DL_MIN_LEN

◆ DVAL_NEXT

#define DVAL_NEXT	(		dv,
			p )

Value:

dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_xint)(p[2]) << (2*5)))

◆ DX2

#define DX2	(	p,
		s1,
		s2 )

Value:

(((((lzo_xint)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0])

◆ DX3

#define DX3	(	p,
		s1,
		s2,
		s3 )

Value:

((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0])

DX2

#define DX2(p, s1, s2)

Definition minilzo.c:4775

◆ GINDEX

#define GINDEX	(	m_pos,
		m_off,
		dict,
		dindex,
		in )

Value:

m_off = dict[dindex]

dict

const void * dict

Definition zbuff.h:76

◆ HAVE_ANY_IP

#define HAVE_ANY_IP 1

◆ HAVE_ANY_OP

#define HAVE_ANY_OP 1

◆ HAVE_MEMCMP

#define HAVE_MEMCMP 1

◆ HAVE_MEMCPY

#define HAVE_MEMCPY 1

◆ HAVE_MEMMOVE

#define HAVE_MEMMOVE 1

◆ HAVE_MEMSET

#define HAVE_MEMSET 1

◆ HAVE_NEED_IP

#define HAVE_NEED_IP 1

◆ HAVE_NEED_OP

#define HAVE_NEED_OP 1

◆ HAVE_STRING_H

#define HAVE_STRING_H 1

◆ HAVE_TEST_IP

#define HAVE_TEST_IP 1

◆ LZO1X

#define LZO1X 1

◆ LZO_BASE

#define LZO_BASE 65521u

◆ LZO_BYTE

#define LZO_BYTE ( x )

Value:

((unsigned char) (x))

◆ LZO_CHECK_MPOS

#define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET

◆ LZO_CHECK_MPOS_DET

#define LZO_CHECK_MPOS_DET	(	m_pos,
		m_off,
		in,
		ip,
		max_offset )

Value:

        (m_off == 0 || \
         ((m_off = pd(ip, in) - m_off) > max_offset) || \
         (m_pos = (ip) - (m_off), 0) )

◆ LZO_CHECK_MPOS_NON_DET

#define LZO_CHECK_MPOS_NON_DET	(	m_pos,
		m_off,
		in,
		ip,
		max_offset )

Value:

        (pd(ip, in) <= m_off || \
         ((m_off = pd(ip, in) - m_off) > max_offset) || \
         (m_pos = (ip) - (m_off), 0) )

◆ LZO_DETERMINISTIC [1/2]

#define LZO_DETERMINISTIC 1

◆ LZO_DETERMINISTIC [2/2]

#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)

◆ lzo_dict_p

#define lzo_dict_p lzo_dict_t *

◆ lzo_dict_t [1/2]

#define lzo_dict_t const lzo_bytep

◆ lzo_dict_t [2/2]

#define lzo_dict_t lzo_uint16_t

◆ LZO_DICT_USE_PTR [1/2]

#define LZO_DICT_USE_PTR 1

◆ LZO_DICT_USE_PTR [2/2]

#define LZO_DICT_USE_PTR 0

◆ LZO_DO1

#define LZO_DO1	(		buf,
			i )

Value:

s1 += buf[i]; s2 += s1

buf

char buf[N_BUF]

Definition spewG.c:36

i

lzma_index ** i

Definition index.h:629

◆ LZO_DO16

#define LZO_DO16	(		buf,
			i )

Value:

LZO_DO8(buf,i); LZO_DO8(buf,i+8)

LZO_DO8

#define LZO_DO8(buf, i)

Definition minilzo.c:4276

◆ LZO_DO2

#define LZO_DO2	(		buf,
			i )

Value:

LZO_DO1(buf,i); LZO_DO1(buf,i+1)

LZO_DO1

#define LZO_DO1(buf, i)

Definition minilzo.c:4273

◆ LZO_DO4

#define LZO_DO4	(		buf,
			i )

Value:

LZO_DO2(buf,i); LZO_DO2(buf,i+2)

LZO_DO2

#define LZO_DO2(buf, i)

Definition minilzo.c:4274

◆ LZO_DO8

#define LZO_DO8	(		buf,
			i )

Value:

LZO_DO4(buf,i); LZO_DO4(buf,i+4)

LZO_DO4

#define LZO_DO4(buf, i)

Definition minilzo.c:4275

◆ LZO_EOF_CODE

#define LZO_EOF_CODE 1

◆ LZO_HASH

#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B

◆ LZO_HASH_GZIP

#define LZO_HASH_GZIP 1

◆ LZO_HASH_GZIP_INCREMENTAL

#define LZO_HASH_GZIP_INCREMENTAL 2

◆ LZO_HASH_LZO_INCREMENTAL_A

#define LZO_HASH_LZO_INCREMENTAL_A 3

◆ LZO_HASH_LZO_INCREMENTAL_B

#define LZO_HASH_LZO_INCREMENTAL_B 4

◆ lzo_hbyte_p

#define lzo_hbyte_p lzo_bytep

◆ LZO_HIGH

#define LZO_HIGH ( array )

Value:

((lzo_uint) (sizeof(array)/sizeof(*(array))))

◆ lzo_hmemcmp

#define lzo_hmemcmp lzo_memcmp

◆ lzo_hmemcpy

#define lzo_hmemcpy lzo_memcpy

◆ lzo_hmemmove

#define lzo_hmemmove lzo_memmove

◆ lzo_hmemset

#define lzo_hmemset lzo_memset

◆ lzo_hsize_t

#define lzo_hsize_t lzo_uint

◆ lzo_hvoid_p

#define lzo_hvoid_p lzo_voidp

◆ LZO_LOCAL_DECL

#define LZO_LOCAL_DECL ( r )

Value:

__LZO_EXTERN_C LZO_LOCAL_IMPL(r)

__LZO_EXTERN_C

#define __LZO_EXTERN_C

LZO_LOCAL_IMPL

#define LZO_LOCAL_IMPL(r)

Definition minilzo.c:3377

◆ LZO_LOCAL_IMPL

#define LZO_LOCAL_IMPL ( r )

Value:

__LZO_NOEXPORT1 r __LZO_NOEXPORT2 __LZO_CDECL

__LZO_CDECL

#define __LZO_CDECL

__LZO_NOEXPORT1

#define __LZO_NOEXPORT1

Definition minilzo.c:3361

__LZO_NOEXPORT2

#define __LZO_NOEXPORT2

Definition minilzo.c:3364

◆ LZO_MASK

#define LZO_MASK ( bits )

Value:

(LZO_SIZE(bits) - 1)

LZO_SIZE

#define LZO_SIZE(bits)

Definition minilzo.c:3529

◆ LZO_MAX

#define LZO_MAX	(		a,
			b )

Value:

((a) >= (b) ? (a) : (b))

◆ LZO_MAX3

#define LZO_MAX3	(	a,
		b,
		c )

Value:

((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c))

LZO_MAX

#define LZO_MAX(a, b)

Definition minilzo.c:3520

c

#define c(i)

Definition sha256.c:43

◆ lzo_memcmp

#define lzo_memcmp	(	a,
		b,
		c )

Value:

memcmp(a,b,c)

◆ lzo_memcpy

#define lzo_memcpy	(	a,
		b,
		c )

Value:

memcpy(a,b,c)

◆ lzo_memmove

#define lzo_memmove	(	a,
		b,
		c )

Value:

memmove(a,b,c)

◆ LZO_MEMOPS_COPY1

#define LZO_MEMOPS_COPY1	(		dd,
			ss )

Value:

LZO_MEMOPS_MOVE1(dd,ss)

LZO_MEMOPS_MOVE1

#define LZO_MEMOPS_MOVE1(dd, ss)

Definition minilzo.c:3746

◆ LZO_MEMOPS_COPY2

#define LZO_MEMOPS_COPY2	(		dd,
			ss )

Value:

LZO_MEMOPS_MOVE2(dd,ss)

LZO_MEMOPS_MOVE2

#define LZO_MEMOPS_MOVE2(dd, ss)

Definition minilzo.c:3752

◆ LZO_MEMOPS_COPY4

#define LZO_MEMOPS_COPY4	(		dd,
			ss )

Value:

LZO_MEMOPS_MOVE4(dd,ss)

LZO_MEMOPS_MOVE4

#define LZO_MEMOPS_MOVE4(dd, ss)

Definition minilzo.c:3764

◆ LZO_MEMOPS_COPY8

#define LZO_MEMOPS_COPY8	(		dd,
			ss )

Value:

LZO_BLOCK_BEGIN LZO_MEMOPS_COPY4(dd,ss); LZO_MEMOPS_COPY4((lzo_memops_TU1p)(lzo_memops_TU0p)(dd)+4,(const lzo_memops_TU1p)(const lzo_memops_TU0p)(ss)+4); LZO_BLOCK_END

LZO_BLOCK_BEGIN

#define LZO_BLOCK_BEGIN

Definition lzodefs.h:1448

LZO_BLOCK_END

#define LZO_BLOCK_END

Definition lzodefs.h:1449

lzo_memops_TU0p

#define lzo_memops_TU0p

Definition minilzo.c:3670

lzo_memops_TU1p

#define lzo_memops_TU1p

Definition minilzo.c:3673

LZO_MEMOPS_COPY4

#define LZO_MEMOPS_COPY4(dd, ss)

◆ LZO_MEMOPS_COPYN

#define LZO_MEMOPS_COPYN	(	dd,
		ss,
		nn )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_TU1p d__n = (lzo_memops_TU1p) (lzo_memops_TU0p) (dd); \
    const lzo_memops_TU1p s__n = (const lzo_memops_TU1p) (const lzo_memops_TU0p) (ss); \
    lzo_uint n__n = (nn); \
    while ((void)0, n__n >= 8) { LZO_MEMOPS_COPY8(d__n, s__n); d__n += 8; s__n += 8; n__n -= 8; } \
    if ((void)0, n__n >= 4) { LZO_MEMOPS_COPY4(d__n, s__n); d__n += 4; s__n += 4; n__n -= 4; } \
    if ((void)0, n__n > 0) do { *d__n++ = *s__n++; } while (--n__n > 0); \
    LZO_BLOCK_END

◆ LZO_MEMOPS_GET_LE16

#define LZO_MEMOPS_GET_LE16 ( ss )

Value:

lzo_memops_get_le16(ss)

◆ LZO_MEMOPS_GET_LE32

#define LZO_MEMOPS_GET_LE32 ( ss )

Value:

lzo_memops_get_le32(ss)

lzo_memops_get_le32

__lzo_static_forceinline lzo_uint32_t lzo_memops_get_le32(const lzo_voidp ss)

Definition minilzo.c:3855

◆ LZO_MEMOPS_GET_NE16

#define LZO_MEMOPS_GET_NE16 ( ss )

Value:

lzo_memops_get_ne16(ss)

lzo_memops_get_ne16

__lzo_static_forceinline lzo_uint16_t lzo_memops_get_ne16(const lzo_voidp ss)

Definition minilzo.c:3881

◆ LZO_MEMOPS_GET_NE32

#define LZO_MEMOPS_GET_NE32 ( ss )

Value:

lzo_memops_get_ne32(ss)

lzo_memops_get_ne32

__lzo_static_forceinline lzo_uint32_t lzo_memops_get_ne32(const lzo_voidp ss)

Definition minilzo.c:3894

◆ LZO_MEMOPS_MOVE1

#define LZO_MEMOPS_MOVE1	(		dd,
			ss )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_move_TU1p d__1 = (lzo_memops_move_TU1p) (lzo_memops_TU0p) (dd); \
    const lzo_memops_move_TU1p s__1 = (const lzo_memops_move_TU1p) (const lzo_memops_TU0p) (ss); \
    d__1[0] = s__1[0]; \
    LZO_BLOCK_END

◆ LZO_MEMOPS_MOVE2

#define LZO_MEMOPS_MOVE2	(		dd,
			ss )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_move_TU1p d__2 = (lzo_memops_move_TU1p) (lzo_memops_TU0p) (dd); \
    const lzo_memops_move_TU1p s__2 = (const lzo_memops_move_TU1p) (const lzo_memops_TU0p) (ss); \
    d__2[0] = s__2[0]; d__2[1] = s__2[1]; \
    LZO_BLOCK_END

◆ LZO_MEMOPS_MOVE3

#define LZO_MEMOPS_MOVE3	(		dd,
			ss )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_move_TU1p d__3 = (lzo_memops_move_TU1p) (lzo_memops_TU0p) (dd); \
    const lzo_memops_move_TU1p s__3 = (const lzo_memops_move_TU1p) (const lzo_memops_TU0p) (ss); \
    d__3[0] = s__3[0]; d__3[1] = s__3[1]; d__3[2] = s__3[2]; \
    LZO_BLOCK_END

◆ LZO_MEMOPS_MOVE4

#define LZO_MEMOPS_MOVE4	(		dd,
			ss )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_move_TU1p d__4 = (lzo_memops_move_TU1p) (lzo_memops_TU0p) (dd); \
    const lzo_memops_move_TU1p s__4 = (const lzo_memops_move_TU1p) (const lzo_memops_TU0p) (ss); \
    d__4[0] = s__4[0]; d__4[1] = s__4[1]; d__4[2] = s__4[2]; d__4[3] = s__4[3]; \
    LZO_BLOCK_END

◆ LZO_MEMOPS_MOVE8

#define LZO_MEMOPS_MOVE8	(		dd,
			ss )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_move_TU1p d__8 = (lzo_memops_move_TU1p) (lzo_memops_TU0p) (dd); \
    const lzo_memops_move_TU1p s__8 = (const lzo_memops_move_TU1p) (const lzo_memops_TU0p) (ss); \
    d__8[0] = s__8[0]; d__8[1] = s__8[1]; d__8[2] = s__8[2]; d__8[3] = s__8[3]; \
    d__8[4] = s__8[4]; d__8[5] = s__8[5]; d__8[6] = s__8[6]; d__8[7] = s__8[7]; \
    LZO_BLOCK_END

◆ lzo_memops_move_TU1p

#define lzo_memops_move_TU1p lzo_memops_TU1p

◆ LZO_MEMOPS_PUT_LE16

#define LZO_MEMOPS_PUT_LE16	(		dd,
			vv )

Value:

lzo_memops_put_le16(dd,vv)

lzo_memops_put_le16

__lzo_static_forceinline void lzo_memops_put_le16(lzo_voidp dd, lzo_uint16_t vv)

Definition minilzo.c:3912

◆ LZO_MEMOPS_PUT_LE32

#define LZO_MEMOPS_PUT_LE32	(		dd,
			vv )

Value:

lzo_memops_put_le32(dd,vv)

lzo_memops_put_le32

__lzo_static_forceinline void lzo_memops_put_le32(lzo_voidp dd, lzo_uint32_t vv)

Definition minilzo.c:3932

◆ LZO_MEMOPS_PUT_NE16

#define LZO_MEMOPS_PUT_NE16	(		dd,
			vv )

Value:

lzo_memops_put_ne16(dd,vv)

lzo_memops_put_ne16

__lzo_static_forceinline void lzo_memops_put_ne16(lzo_voidp dd, lzo_uint16_t vv)

Definition minilzo.c:3954

◆ LZO_MEMOPS_PUT_NE32

#define LZO_MEMOPS_PUT_NE32	(		dd,
			vv )

Value:

lzo_memops_put_ne32(dd,vv)

lzo_memops_put_ne32

__lzo_static_forceinline void lzo_memops_put_ne32(lzo_voidp dd, lzo_uint32_t vv)

Definition minilzo.c:3964

◆ LZO_MEMOPS_SET1

#define LZO_MEMOPS_SET1	(		dd,
			cc )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_set_TU1p d__1 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \
    d__1[0] = LZO_BYTE(cc); \
    LZO_BLOCK_END

◆ LZO_MEMOPS_SET2

#define LZO_MEMOPS_SET2	(		dd,
			cc )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_set_TU1p d__2 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \
    d__2[0] = LZO_BYTE(cc); d__2[1] = LZO_BYTE(cc); \
    LZO_BLOCK_END

◆ LZO_MEMOPS_SET3

#define LZO_MEMOPS_SET3	(		dd,
			cc )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_set_TU1p d__3 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \
    d__3[0] = LZO_BYTE(cc); d__3[1] = LZO_BYTE(cc); d__3[2] = LZO_BYTE(cc); \
    LZO_BLOCK_END

◆ LZO_MEMOPS_SET4

#define LZO_MEMOPS_SET4	(		dd,
			cc )

Value:

    LZO_BLOCK_BEGIN \
    lzo_memops_set_TU1p d__4 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \
    d__4[0] = LZO_BYTE(cc); d__4[1] = LZO_BYTE(cc); d__4[2] = LZO_BYTE(cc); d__4[3] = LZO_BYTE(cc); \
    LZO_BLOCK_END

◆ lzo_memops_set_TU1p

#define lzo_memops_set_TU1p volatile lzo_memops_TU1p

◆ lzo_memops_TU0p

#define lzo_memops_TU0p void __LZO_MMODEL *

◆ lzo_memops_TU1p

#define lzo_memops_TU1p unsigned char __LZO_MMODEL *

◆ lzo_memops_TU2p

#define lzo_memops_TU2p lzo_memops_TU2 *

◆ lzo_memops_TU4p

#define lzo_memops_TU4p lzo_memops_TU4 __LZO_MMODEL *

◆ lzo_memops_TU8p

#define lzo_memops_TU8p lzo_memops_TU8 __LZO_MMODEL *

◆ lzo_memset

#define lzo_memset	(	a,
		b,
		c )

Value:

memset(a,b,c)

◆ LZO_MIN

#define LZO_MIN	(		a,
			b )

Value:

((a) <= (b) ? (a) : (b))

◆ LZO_MIN3

#define LZO_MIN3	(	a,
		b,
		c )

Value:

((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c))

LZO_MIN

#define LZO_MIN(a, b)

Definition minilzo.c:3521

◆ LZO_NEED_DICT_H

#define LZO_NEED_DICT_H 1

◆ LZO_NMAX

#define LZO_NMAX 5552

◆ LZO_PUBLIC_DECL

#define LZO_PUBLIC_DECL ( r )

Value:

LZO_EXTERN(r)

LZO_EXTERN

#define LZO_EXTERN(r)

◆ LZO_PUBLIC_IMPL

#define LZO_PUBLIC_IMPL ( r )

Value:

LZO_PUBLIC(r)

LZO_PUBLIC

#define LZO_PUBLIC(r)

◆ LZO_SIZE

#define LZO_SIZE ( bits )

Value:

(1u << (bits))

◆ lzo_sizeof

#define lzo_sizeof ( type )

Value:

((lzo_uint) (sizeof(type)))

◆ LZO_STATIC_DECL

#define LZO_STATIC_DECL ( r )

Value:

LZO_PRIVATE(r)

LZO_PRIVATE

#define LZO_PRIVATE(r)

◆ LZO_STATIC_IMPL

#define LZO_STATIC_IMPL ( r )

Value:

LZO_PRIVATE(r)

◆ LZO_TEST_OVERRUN

#define LZO_TEST_OVERRUN 1

◆ LZO_TEST_OVERRUN_INPUT

#define LZO_TEST_OVERRUN_INPUT 2

◆ LZO_TEST_OVERRUN_LOOKBEHIND

#define LZO_TEST_OVERRUN_LOOKBEHIND 1

◆ LZO_TEST_OVERRUN_OUTPUT

#define LZO_TEST_OVERRUN_OUTPUT 2

◆ LZO_UMASK

#define LZO_UMASK ( bits )

Value:

(LZO_USIZE(bits) - 1)

LZO_USIZE

#define LZO_USIZE(bits)

Definition minilzo.c:3532

◆ LZO_USIZE

#define LZO_USIZE ( bits )

Value:

((lzo_uint) 1 << (bits))

◆ LZOLIB_PUBLIC

#define LZOLIB_PUBLIC	(		r,
			f )

Value:

LZO_PUBLIC(r) f

f

#define f(i)

Definition sha256.c:46

◆ M1_MARKER

#define M1_MARKER 0

◆ M1_MAX_LEN

#define M1_MAX_LEN 2

◆ M1_MAX_OFFSET

#define M1_MAX_OFFSET 0x0400

◆ M1_MIN_LEN

#define M1_MIN_LEN 2

◆ M2_MARKER

#define M2_MARKER 64

◆ M2_MAX_LEN

#define M2_MAX_LEN 8

◆ M2_MAX_OFFSET

#define M2_MAX_OFFSET 0x0800

◆ M2_MIN_LEN

#define M2_MIN_LEN 3

◆ M3_MARKER

#define M3_MARKER 32

◆ M3_MAX_LEN

#define M3_MAX_LEN 33

◆ M3_MAX_OFFSET

#define M3_MAX_OFFSET 0x4000

◆ M3_MIN_LEN

#define M3_MIN_LEN 3

◆ M4_MARKER

#define M4_MARKER 16

◆ M4_MAX_LEN

#define M4_MAX_LEN 9

◆ M4_MAX_OFFSET

#define M4_MAX_OFFSET 0xbfff

◆ M4_MIN_LEN

#define M4_MIN_LEN 3

◆ MEMCPY8_DS

#define MEMCPY8_DS	(	dest,
		src,
		len )

Value:

lzo_memcpy(dest,src,len); dest += len; src += len

src

const char * src

Definition lz4.h:866

dest

char * dest

Definition lz4.h:806

lzo_memcpy

#define lzo_memcpy(a, b, c)

Definition minilzo.c:3454

len

static uint32_t const uint8_t uint32_t len

Definition memcmplen.h:44

◆ MEMCPY_DS

#define MEMCPY_DS	(	dest,
		src,
		len )

Value:

do *dest++ = *src++; while (--len > 0)

◆ MIN_LOOKAHEAD

#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)

◆ MX_MAX_OFFSET

#define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET)

◆ NDEBUG

#define NDEBUG 1

◆ NEED_IP [1/2]

#define NEED_IP ( x )

Value:

((void) 0)

◆ NEED_IP [2/2]

#define NEED_IP ( x )

Value:

if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun

◆ NEED_OP [1/2]

#define NEED_OP ( x )

Value:

((void) 0)

◆ NEED_OP [2/2]

#define NEED_OP ( x )

Value:

if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun

op

#define op

◆ pd

#define pd	(		a,
			b )

Value:

((lzo_uint) ((a)-(b)))

◆ PTR

#define PTR ( a )

Value:

((lzo_uintptr_t) (a))

lzo_uintptr_t

#define lzo_uintptr_t

Definition lzodefs.h:3078

◆ PTR_ALIGNED2_4

#define PTR_ALIGNED2_4	(		a,
			b )

Value:

(((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0)

PTR_LINEAR

#define PTR_LINEAR(a)

◆ PTR_ALIGNED2_8

#define PTR_ALIGNED2_8	(		a,
			b )

Value:

(((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0)

◆ PTR_ALIGNED_4

#define PTR_ALIGNED_4 ( a )

Value:

((PTR_LINEAR(a) & 3) == 0)

◆ PTR_ALIGNED_8

#define PTR_ALIGNED_8 ( a )

Value:

((PTR_LINEAR(a) & 7) == 0)

◆ PTR_DIFF

#define PTR_DIFF	(		a,
			b )

Value:

(PTR(a) - PTR(b))

PTR

#define PTR(a)

◆ PTR_GE

#define PTR_GE	(		a,
			b )

Value:

(PTR(a) >= PTR(b))

◆ PTR_LINEAR

#define PTR_LINEAR ( a )

Value:

PTR(a)

◆ PTR_LT

#define PTR_LT	(		a,
			b )

Value:

(PTR(a) < PTR(b))

◆ TEST_IP [1/2]

#define TEST_IP 1

◆ TEST_IP [2/2]

#define TEST_IP (ip < ip_end)

◆ TEST_IP_AND_TEST_OP [1/2]

#define TEST_IP_AND_TEST_OP 1

◆ TEST_IP_AND_TEST_OP [2/2]

#define TEST_IP_AND_TEST_OP TEST_IP

◆ TEST_IV [1/2]

#define TEST_IV ( x )

Value:

((void) 0)

◆ TEST_IV [2/2]

#define TEST_IV ( x )

Value:

if ((x) > (lzo_uint)0 - (511)) goto input_overrun

◆ TEST_LB [1/2]

#define TEST_LB ( m_pos )

Value:

((void) 0)

◆ TEST_LB [2/2]

#define TEST_LB ( m_pos )

Value:

if (PTR_LT(m_pos,out) || PTR_GE(m_pos,op)) goto lookbehind_overrun

PTR_GE

#define PTR_GE(a, b)

PTR_LT

#define PTR_LT(a, b)

◆ TEST_LBO [1/2]

#define TEST_LBO	(		m_pos,
			o )

Value:

((void) 0)

◆ TEST_LBO [2/2]

#define TEST_LBO	(		m_pos,
			o )

Value:

if (PTR_LT(m_pos,out) || PTR_GE(m_pos,op-(o))) goto lookbehind_overrun

◆ TEST_OP [1/3]

#define TEST_OP 1

◆ TEST_OP [2/3]

#define TEST_OP (op <= op_end)

◆ TEST_OP [3/3]

#define TEST_OP 1

◆ TEST_OV [1/2]

#define TEST_OV ( x )

Value:

((void) 0)

◆ TEST_OV [2/2]

#define TEST_OV ( x )

Value:

if ((x) > (lzo_uint)0 - (511)) goto output_overrun

◆ UA_COPY1

#define UA_COPY1 LZO_MEMOPS_COPY1

◆ UA_COPY2

#define UA_COPY2 LZO_MEMOPS_COPY2

◆ UA_COPY3

#define UA_COPY3 LZO_MEMOPS_COPY3

◆ UA_COPY4

#define UA_COPY4 LZO_MEMOPS_COPY4

◆ UA_COPY8

#define UA_COPY8 LZO_MEMOPS_COPY8

◆ UA_COPYN

#define UA_COPYN LZO_MEMOPS_COPYN

◆ UA_COPYN_X

#define UA_COPYN_X LZO_MEMOPS_COPYN

◆ UA_GET_LE16

#define UA_GET_LE16 LZO_MEMOPS_GET_LE16

◆ UA_GET_LE32

#define UA_GET_LE32 LZO_MEMOPS_GET_LE32

◆ UA_GET_NE16

#define UA_GET_NE16 LZO_MEMOPS_GET_NE16

◆ UA_GET_NE32

#define UA_GET_NE32 LZO_MEMOPS_GET_NE32

◆ UA_MOVE1

#define UA_MOVE1 LZO_MEMOPS_MOVE1

◆ UA_MOVE2

#define UA_MOVE2 LZO_MEMOPS_MOVE2

◆ UA_MOVE3

#define UA_MOVE3 LZO_MEMOPS_MOVE3

◆ UA_MOVE4

#define UA_MOVE4 LZO_MEMOPS_MOVE4

◆ UA_MOVE8

#define UA_MOVE8 LZO_MEMOPS_MOVE8

◆ UA_PUT_LE16

#define UA_PUT_LE16 LZO_MEMOPS_PUT_LE16

◆ UA_PUT_LE32

#define UA_PUT_LE32 LZO_MEMOPS_PUT_LE32

◆ UA_PUT_NE16

#define UA_PUT_NE16 LZO_MEMOPS_PUT_NE16

◆ UA_PUT_NE32

#define UA_PUT_NE32 LZO_MEMOPS_PUT_NE32

◆ UA_SET1

#define UA_SET1 LZO_MEMOPS_SET1

◆ UA_SET2

#define UA_SET2 LZO_MEMOPS_SET2

◆ UA_SET3

#define UA_SET3 LZO_MEMOPS_SET3

◆ UA_SET4

#define UA_SET4 LZO_MEMOPS_SET4

◆ UPDATE_D

#define UPDATE_D	(	dict,
		drun,
		dv,
		p,
		in )

Value:

dict[ DINDEX(dv,p) ] = DENTRY(p,in)

DINDEX

#define DINDEX(dv, p)

Definition minilzo.c:4626

DENTRY

#define DENTRY(p, in)

Definition minilzo.c:4851

◆ UPDATE_I

#define UPDATE_I	(	dict,
		drun,
		index,
		p,
		in )

Value:

dict[index] = DENTRY(p,in)

◆ UPDATE_P

#define UPDATE_P	(	ptr,
		drun,
		p,
		in )

Value:

(ptr)[0] = DENTRY(p,in)

Function Documentation

◆ __lzo_align_gap()

__lzo_align_gap	(	const lzo_voidp	ptr,
		lzo_uint	size )

◆ __lzo_init_v2()

__lzo_init_v2	(	unsigned	v,
		int	s1,
		int	s2,
		int	s3,
		int	s4,
		int	s5,
		int	s6,
		int	s7,
		int	s8,
		int	s9 )

◆ __lzo_ptr_linear()

__lzo_ptr_linear ( const lzo_voidp ptr )

◆ _lzo_config_check()

_lzo_config_check ( void )

◆ _lzo_version_date()

_lzo_version_date ( void )

◆ _lzo_version_string()

_lzo_version_string ( void )

◆ DO_COMPRESS()

DO_COMPRESS	(	const lzo_bytep	in,
		lzo_uint	in_len,
		lzo_bytep	out,
		lzo_uintp	out_len,
		lzo_voidp	wrkmem )

◆ DO_DECOMPRESS()

DO_DECOMPRESS	(	const lzo_bytep	in,
		lzo_uint	in_len,
		lzo_bytep	out,
		lzo_uintp	out_len,
		lzo_voidp	wrkmem )

◆ lzo_adler32()

lzo_adler32	(	lzo_uint32_t	adler,
		const lzo_bytep	buf,
		lzo_uint	len )

◆ lzo_bitops_ctlz32_func()

__lzo_static_forceinline unsigned lzo_bitops_ctlz32_func ( lzo_uint32_t v )

◆ lzo_bitops_cttz32_func()

__lzo_static_forceinline unsigned lzo_bitops_cttz32_func ( lzo_uint32_t v )

◆ LZO_COMPILE_TIME_ASSERT_HEADER()

LZO_COMPILE_TIME_ASSERT_HEADER ( sizeof(*(lzo_memops_TU1p) 0) = =1 )

◆ lzo_copyright()

lzo_copyright ( void )

◆ LZO_EXTERN()

LZO_EXTERN ( const lzo_bytep )

◆ lzo_memops_get_le32()

__lzo_static_forceinline lzo_uint32_t lzo_memops_get_le32 ( const lzo_voidp ss )

◆ lzo_memops_get_ne16()

__lzo_static_forceinline lzo_uint16_t lzo_memops_get_ne16 ( const lzo_voidp ss )

◆ lzo_memops_get_ne32()

__lzo_static_forceinline lzo_uint32_t lzo_memops_get_ne32 ( const lzo_voidp ss )

◆ lzo_memops_put_le16()

__lzo_static_forceinline void lzo_memops_put_le16	(	lzo_voidp	dd,
		lzo_uint16_t	vv )

◆ lzo_memops_put_le32()

__lzo_static_forceinline void lzo_memops_put_le32	(	lzo_voidp	dd,
		lzo_uint32_t	vv )

◆ lzo_memops_put_ne16()

__lzo_static_forceinline void lzo_memops_put_ne16	(	lzo_voidp	dd,
		lzo_uint16_t	vv )

◆ lzo_memops_put_ne32()

__lzo_static_forceinline void lzo_memops_put_ne32	(	lzo_voidp	dd,
		lzo_uint32_t	vv )

◆ lzo_unused_funcs_impl() [1/2]

lzo_unused_funcs_impl	(	void	,
		lzo_bitops_unused_funcs	)

◆ lzo_unused_funcs_impl() [2/2]

lzo_unused_funcs_impl	(	void	,
		lzo_memops_unused_funcs	)

◆ lzo_version()

lzo_version ( void )

◆ lzo_version_date()

lzo_version_date ( void )

◆ lzo_version_string()

lzo_version_string ( void )

◆ LZOLIB_PUBLIC() [1/4]

LZOLIB_PUBLIC	(	int	,
		lzo_hmemcmp	) const

◆ LZOLIB_PUBLIC() [2/4]

LZOLIB_PUBLIC	(	lzo_hvoid_p	,
		lzo_hmemcpy	)

◆ LZOLIB_PUBLIC() [3/4]

LZOLIB_PUBLIC	(	lzo_hvoid_p	,
		lzo_hmemmove	)

◆ LZOLIB_PUBLIC() [4/4]

LZOLIB_PUBLIC	(	lzo_hvoid_p	,
		lzo_hmemset	)

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ __LZO_CONF_H

◆ __LZO_CONFIG1X_H

◆ __LZO_DICT_H

◆ __LZO_FUNC_H

◆ __LZO_HASH_INCREMENTAL

◆ __LZO_IN_MINILZO

◆ __LZO_NOEXPORT1

◆ __LZO_NOEXPORT2

◆ __LZO_PTR_H

◆ __LZOLIB_HMEMCPY_CH_INCLUDED

◆ _DINDEX

◆ _DV2_A

◆ _DV2_B

◆ _DV3_B

◆ _DV_A

◆ _DV_B

◆ BOUNDS_CHECKING_OFF_DURING

◆ BOUNDS_CHECKING_OFF_IN_EXPR

◆ BZERO8_PTR

◆ D_BITS

◆ D_HIGH

◆ D_INDEX1

◆ D_INDEX2

◆ D_MASK

◆ D_SIZE

◆ DA2

◆ DA3

◆ DD_BITS

◆ DD_MASK

◆ DD_SIZE

◆ DENTRY

◆ DINDEX

◆ DINDEX1

◆ DINDEX2

◆ DL_BITS

◆ DL_MASK

◆ DL_MIN_LEN

◆ DL_SHIFT

◆ DL_SIZE

◆ DM

◆ DMS

◆ DMUL

◆ DO_COMPRESS

◆ do_compress

◆ DO_DECOMPRESS [1/2]

◆ DO_DECOMPRESS [2/2]

◆ DS2

◆ DS3

◆ DVAL_ASSERT

◆ DVAL_FIRST

◆ DVAL_LOOKAHEAD

◆ DVAL_NEXT

◆ DX2

◆ DX3

◆ GINDEX

◆ HAVE_ANY_IP

◆ HAVE_ANY_OP

◆ HAVE_MEMCMP

◆ HAVE_MEMCPY

◆ HAVE_MEMMOVE

◆ HAVE_MEMSET

◆ HAVE_NEED_IP

◆ HAVE_NEED_OP

◆ HAVE_STRING_H

◆ HAVE_TEST_IP

◆ LZO1X

◆ LZO_BASE

◆ LZO_BYTE

◆ LZO_CHECK_MPOS

◆ LZO_CHECK_MPOS_DET

◆ LZO_CHECK_MPOS_NON_DET

◆ LZO_DETERMINISTIC [1/2]

◆ LZO_DETERMINISTIC [2/2]

◆ lzo_dict_p

◆ lzo_dict_t [1/2]