static ucl_bool ptr_check(void)
{
ucl_bool r = 1;
int i;
char _wrkmem[10 * sizeof(ucl_byte *) + sizeof(ucl_align_t)];
ucl_byte *wrkmem;
ucl_bytepp dict;
unsigned char x[4 * sizeof(ucl_align_t)];
long d;
ucl_align_t a;
for (i = 0; i < (int) sizeof(x); i++)
x[i] = UCL_BYTE(i);
wrkmem = (ucl_byte *) UCL_PTR_ALIGN_UP(_wrkmem,sizeof(ucl_align_t));
/* Expect a compiler warning on architectures that
* do not allow unaligned access. */
dict = (ucl_bytepp) wrkmem;
d = (long) ((const ucl_bytep) dict - (const ucl_bytep) _wrkmem);
r &= __ucl_assert(d >= 0);
r &= __ucl_assert(d < (long) sizeof(ucl_align_t));
memset(&a,0xff,sizeof(a));
r &= __ucl_assert(a.a_ushort == USHRT_MAX);
r &= __ucl_assert(a.a_uint == UINT_MAX);
r &= __ucl_assert(a.a_ulong == ULONG_MAX);
r &= __ucl_assert(a.a_ucl_uint == UCL_UINT_MAX);
/* sanity check of the memory model */
if (r == 1)
{
for (i = 0; i < 8; i++)
r &= __ucl_assert((const ucl_voidp) (&dict[i]) == (const ucl_voidp) (&wrkmem[i * sizeof(ucl_byte *)]));
}
/* check BZERO8_PTR and that NULL == 0 */
memset(&a,0,sizeof(a));
r &= __ucl_assert(a.a_charp == NULL);
r &= __ucl_assert(a.a_ucl_bytep == NULL);
r &= __ucl_assert(NULL == 0);
if (r == 1)
{
for (i = 0; i < 10; i++)
dict[i] = wrkmem;
BZERO8_PTR(dict+1,sizeof(dict[0]),8);
r &= __ucl_assert(dict[0] == wrkmem);
for (i = 1; i < 9; i++)
r &= __ucl_assert(dict[i] == NULL);
r &= __ucl_assert(dict[9] == wrkmem);
}
/* check that the pointer constructs work as expected */
if (r == 1)
{
unsigned k = 1;
const unsigned n = (unsigned) sizeof(ucl_uint32);
ucl_byte *p0;
ucl_byte *p1;
k += __ucl_align_gap(&x[k],n);
p0 = (ucl_bytep) &x[k];
#if defined(PTR_LINEAR)
r &= __ucl_assert((PTR_LINEAR(p0) & (n-1)) == 0);
#else
r &= __ucl_assert(n == 4);
r &= __ucl_assert(PTR_ALIGNED_4(p0));
#endif
r &= __ucl_assert(k >= 1);
p1 = (ucl_bytep) &x[1];
r &= __ucl_assert(PTR_GE(p0,p1));
r &= __ucl_assert(k < 1+n);
p1 = (ucl_bytep) &x[1+n];
r &= __ucl_assert(PTR_LT(p0,p1));
/* now check that aligned memory access doesn't core dump */
if (r == 1)
{
/* Expect 2 compiler warnings on architectures that
* do not allow unaligned access. */
ucl_uint32 v0 = * (ucl_uint32 *) &x[k];
ucl_uint32 v1 = * (ucl_uint32 *) &x[k+n];
r &= __ucl_assert(v0 > 0);
r &= __ucl_assert(v1 > 0);
}
}
return r;
}
static int
do_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
const lzo_bytep ip;
#if defined(__LZO_HASH_INCREMENTAL)
lzo_xint dv;
#endif
lzo_bytep op;
const lzo_bytep m_pos;
const lzo_bytep const ip_end = in+in_len - DVAL_LEN - MIN_MATCH_LONG;
const lzo_bytep const in_end = in+in_len - DVAL_LEN;
const lzo_bytep ii;
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
#if !defined(NDEBUG)
const lzo_bytep m_pos_sav;
#endif
op = out;
ip = in;
ii = ip; /* point to start of literal run */
if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1)
goto the_end;
/* init dictionary */
#if (LZO_DETERMINISTIC)
BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
#endif
DVAL_FIRST(dv,ip);
UPDATE_D(dict,0,dv,ip,in);
ip++;
DVAL_NEXT(dv,ip);
do {
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
lzo_uint dindex;
DINDEX1(dindex,ip);
GINDEX(m_pos,m_off,dict,dindex,in);
if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET))
goto literal;
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
goto match;
DINDEX2(dindex,ip);
GINDEX(m_pos,m_off,dict,dindex,in);
if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET))
goto literal;
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
goto match;
goto literal;
literal:
UPDATE_I(dict,0,dindex,ip,in);
if (++ip >= ip_end)
break;
continue;
match:
UPDATE_I(dict,0,dindex,ip,in);
#if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
m_pos_sav = m_pos;
#endif
m_pos += 3;
{
/* we have found a match (of at least length 3) */
#if !defined(NDEBUG) && !(LZO_DICT_USE_PTR)
assert((m_pos_sav = ip - m_off) == (m_pos - 3));
#endif
/* 1) store the current literal run */
if (pd(ip,ii) > 0)
{
lzo_uint t = pd(ip,ii);
#if 1
/* OPTIMIZED: inline the copying of a short run */
if (t < R0MIN)
{
*op++ = LZO_BYTE(t);
MEMCPY_DS(op, ii, t);
}
else
#endif
op = store_run(op,ii,t);
}
/* 2a) compute match len */
ii = ip; /* point to start of current match */
/* we already matched MIN_MATCH bytes,
* m_pos also already advanced MIN_MATCH bytes */
ip += MIN_MATCH;
assert(m_pos < ip);
/* try to match another MIN_MATCH_LONG - MIN_MATCH bytes
* to see if we get a long match */
#define PS *m_pos++ != *ip++
#if (MIN_MATCH_LONG - MIN_MATCH == 2) /* MBITS == 2 */
if (PS || PS)
#elif (MIN_MATCH_LONG - MIN_MATCH == 6) /* MBITS == 3 */
if (PS || PS || PS || PS || PS || PS)
#elif (MIN_MATCH_LONG - MIN_MATCH == 14) /* MBITS == 4 */
if (PS || PS || PS || PS || PS || PS || PS ||
PS || PS || PS || PS || PS || PS || PS)
#elif (MIN_MATCH_LONG - MIN_MATCH == 30) /* MBITS == 5 */
if (PS || PS || PS || PS || PS || PS || PS || PS ||
PS || PS || PS || PS || PS || PS || PS || PS ||
PS || PS || PS || PS || PS || PS || PS || PS ||
PS || PS || PS || PS || PS || PS)
#else
# error "MBITS not yet implemented"
#endif
{
lzo_uint m_len;
/* 2b) code a short match */
assert(pd(ip,m_pos) == m_off);
--ip; /* ran one too far, point back to non-match */
m_len = pd(ip, ii);
assert(m_len >= MIN_MATCH_SHORT);
assert(m_len <= MAX_MATCH_SHORT);
assert(m_off > 0);
assert(m_off <= MAX_OFFSET);
assert(ii-m_off == m_pos_sav);
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
--m_off;
/* code short match len + low offset bits */
*op++ = LZO_BYTE(((m_len - THRESHOLD) << OBITS) |
(m_off & OMASK));
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> OBITS);
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
#define SI /* nothing */
#define DI ++ii; DVAL_NEXT(dv,ii); UPDATE_D(dict,0,dv,ii,in);
#define XI assert(ii < ip); ii = ip; DVAL_FIRST(dv,(ip));
#if (CLEVEL == 9) || (CLEVEL >= 7 && MBITS <= 4) || (CLEVEL >= 5 && MBITS <= 3)
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
++ii;
do {
DVAL_NEXT(dv,ii);
UPDATE_D(dict,0,dv,ii,in);
} while (++ii < ip);
DVAL_NEXT(dv,ii);
assert(ii == ip);
DVAL_ASSERT(dv,ip);
#elif (CLEVEL >= 3)
SI DI DI XI
#elif (CLEVEL >= 2)
SI DI XI
#else
XI
#endif
}
else
{
/* we've found a long match - see how far we can still go */
const lzo_bytep end;
lzo_uint m_len;
assert(ip <= in_end);
assert(ii == ip - MIN_MATCH_LONG);
if (pd(in_end,ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG))
end = in_end;
else
{
end = ip + (MAX_MATCH_LONG - MIN_MATCH_LONG);
assert(end < in_end);
}
while (ip < end && *m_pos == *ip)
m_pos++, ip++;
assert(ip <= in_end);
/* 2b) code the long match */
m_len = pd(ip, ii);
assert(m_len >= MIN_MATCH_LONG);
assert(m_len <= MAX_MATCH_LONG);
assert(m_off > 0);
assert(m_off <= MAX_OFFSET);
assert(ii-m_off == m_pos_sav);
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
assert(pd(ip,m_pos) == m_off);
--m_off;
/* code long match flag + low offset bits */
*op++ = LZO_BYTE(((MSIZE - 1) << OBITS) | (m_off & OMASK));
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> OBITS);
/* code match len */
*op++ = LZO_BYTE(m_len - MIN_MATCH_LONG);
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
#if (CLEVEL == 9)
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
/* This is not recommended because it is slow. */
++ii;
do {
DVAL_NEXT(dv,ii);
UPDATE_D(dict,0,dv,ii,in);
} while (++ii < ip);
DVAL_NEXT(dv,ii);
assert(ii == ip);
DVAL_ASSERT(dv,ip);
#elif (CLEVEL >= 8)
SI DI DI DI DI DI DI DI DI XI
#elif (CLEVEL >= 7)
SI DI DI DI DI DI DI DI XI
#elif (CLEVEL >= 6)
SI DI DI DI DI DI DI XI
#elif (CLEVEL >= 5)
SI DI DI DI DI XI
#elif (CLEVEL >= 4)
SI DI DI DI XI
#elif (CLEVEL >= 3)
SI DI DI XI
#elif (CLEVEL >= 2)
SI DI XI
#else
XI
#endif
}
/* ii now points to the start of next literal run */
assert(ii == ip);
}
