| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| #include "lzo1_d.ch" |
| |
| |
| |
| |
| |
| |
| LZO_PUBLIC(int) |
| DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, |
| lzo_bytep out, lzo_uintp out_len, |
| lzo_voidp wrkmem ) |
| { |
| register lzo_bytep op; |
| register const lzo_bytep ip; |
| register lzo_uint t; |
| register const lzo_bytep m_pos; |
| |
| const lzo_bytep const ip_end = in + in_len; |
| #if defined(HAVE_ANY_OP) |
| lzo_bytep const op_end = out + *out_len; |
| #endif |
| |
| LZO_UNUSED(wrkmem); |
| |
| op = out; |
| ip = in; |
| |
| while (TEST_IP && TEST_OP) |
| { |
| t = *ip++; |
| |
| if (t < R0MIN) |
| { |
| if (t == 0) |
| { |
| NEED_IP(1); |
| t = *ip++; |
| if (t >= R0FAST - R0MIN) |
| { |
| t -= R0FAST - R0MIN; |
| if (t == 0) |
| t = R0FAST; |
| else |
| { |
| #if 0 |
| t = 256u << ((unsigned) t); |
| #else |
| |
| lzo_uint tt = 256; |
| do tt <<= 1; while (--t > 0); |
| t = tt; |
| #endif |
| } |
| |
| NEED_IP(t); NEED_OP(t); |
| #if 1 && defined(LZO_UNALIGNED_OK_4) |
| do { |
| * (lzo_uint32p) (op+0) = * (const lzo_uint32p) (ip+0); |
| * (lzo_uint32p) (op+4) = * (const lzo_uint32p) (ip+4); |
| op += 8; ip += 8; |
| t -= 8; |
| } while (t > 0); |
| #else |
| MEMCPY8_DS(op,ip,t); |
| #endif |
| continue; |
| } |
| t += R0MIN; |
| } |
| |
| NEED_IP(t); NEED_OP(t); |
| |
| #if 1 && defined(LZO_UNALIGNED_OK_4) |
| if (t >= 4) |
| { |
| do { |
| * (lzo_uint32p) op = * (const lzo_uint32p) ip; |
| op += 4; ip += 4; t -= 4; |
| } while (t >= 4); |
| if (t > 0) do *op++ = *ip++; while (--t > 0); |
| } |
| else |
| #endif |
| { |
| #if (M3O_BITS < 7) |
| literal1: |
| #endif |
| do *op++ = *ip++; while (--t > 0); |
| } |
| |
| #if (M3O_BITS == 7) |
| literal2: |
| #endif |
| |
| |
| while (TEST_IP && TEST_OP) |
| { |
| t = *ip++; |
| if (t >= R0MIN) |
| goto match; |
| |
| NEED_IP(2); NEED_OP(M2_MIN_LEN + 1); |
| |
| |
| assert((t & M2O_MASK) == t); |
| m_pos = op - M2_MIN_OFFSET; |
| m_pos -= t | (((lzo_uint) *ip++) << M2O_BITS); |
| assert(m_pos >= out); assert(m_pos < op); |
| TEST_LB(m_pos); |
| COPY_M2; |
| *op++ = *ip++; |
| } |
| |
| #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) |
| break; |
| #endif |
| } |
| |
| match: |
| |
| if (t >= M2_MARKER) |
| { |
| |
| NEED_IP(1); |
| m_pos = op - M2_MIN_OFFSET; |
| m_pos -= (t & M2O_MASK) | (((lzo_uint) *ip++) << M2O_BITS); |
| assert(m_pos >= out); assert(m_pos < op); |
| TEST_LB(m_pos); |
| |
| |
| t = (t >> M2O_BITS) - 1; |
| NEED_OP(t + M2_MIN_LEN - 1); |
| COPY_M2X; |
| MEMCPY_DS(op,m_pos,t); |
| } |
| else |
| { |
| |
| t &= M3L_MASK; |
| if (t == 0) |
| { |
| NEED_IP(1); |
| while (*ip == 0) |
| { |
| t += 255; |
| ip++; |
| NEED_IP(1); |
| } |
| t += (M4_MIN_LEN - M3_MIN_LEN) + *ip++; |
| } |
| |
| |
| NEED_IP(2); |
| m_pos = op - (M3_MIN_OFFSET - M3_EOF_OFFSET); |
| m_pos -= *ip++ & M3O_MASK; |
| m_pos -= (lzo_uint)(*ip++) << M3O_BITS; |
| #if defined(LZO_EOF_CODE) |
| if (m_pos == op) |
| goto eof_found; |
| #endif |
| |
| |
| assert(m_pos >= out); assert(m_pos < op); |
| TEST_LB(m_pos); NEED_OP(t + M3_MIN_LEN - 1); |
| #if defined(LZO_UNALIGNED_OK_4) |
| if (t >= 2 * 4 - (M3_MIN_LEN - 1) && (op - m_pos) >= 4) |
| { |
| * (lzo_uint32p) op = * (const lzo_uint32p) m_pos; |
| op += 4; m_pos += 4; t -= 4 - (M3_MIN_LEN - 1); |
| do { |
| * (lzo_uint32p) op = * (const lzo_uint32p) m_pos; |
| op += 4; m_pos += 4; t -= 4; |
| } while (t >= 4); |
| if (t > 0) do *op++ = *m_pos++; while (--t > 0); |
| } |
| else |
| #endif |
| { |
| COPY_M3X; |
| MEMCPY_DS(op,m_pos,t); |
| } |
| |
| |
| #if (M3O_BITS < 7) |
| t = ip[-2] >> M3O_BITS; |
| if (t) |
| { |
| NEED_IP(t); NEED_OP(t); |
| goto literal1; |
| } |
| #elif (M3O_BITS == 7) |
| |
| if (ip[-2] & (1 << M3O_BITS)) |
| { |
| NEED_IP(1); NEED_OP(1); |
| *op++ = *ip++; |
| goto literal2; |
| } |
| #endif |
| } |
| } |
| |
| |
| #if defined(LZO_EOF_CODE) |
| #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) |
| |
| *out_len = pd(op, out); |
| return LZO_E_EOF_NOT_FOUND; |
| #endif |
| |
| eof_found: |
| assert(t == 1); |
| #endif |
| *out_len = pd(op, out); |
| return (ip == ip_end ? LZO_E_OK : |
| (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); |
| |
| |
| #if defined(HAVE_NEED_IP) |
| input_overrun: |
| *out_len = pd(op, out); |
| return LZO_E_INPUT_OVERRUN; |
| #endif |
| |
| #if defined(HAVE_NEED_OP) |
| output_overrun: |
| *out_len = pd(op, out); |
| return LZO_E_OUTPUT_OVERRUN; |
| #endif |
| |
| #if defined(LZO_TEST_OVERRUN_LOOKBEHIND) |
| lookbehind_overrun: |
| *out_len = pd(op, out); |
| return LZO_E_LOOKBEHIND_OVERRUN; |
| #endif |
| } |
| |
| |
| |
| |
| |
| |