metin-server/m2dev-client-src
3
0
Fork 1
Code Issues 1 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity

client almost builds

Browse Source
This commit is contained in:
d1str4ught
2025-08-19 00:20:40 +02:00
parent 4be475f111
commit be56f3f31a
1090 changed files with 126610 additions and 14032 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
vendor/lzo-2.10/src/compr1b.h vendored Normal file
View File

@@ -0,0 +1,68 @@
/* compr1b.h --
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define LZO_NEED_DICT_H 1
#include "config1b.h"
#if !defined(COMPRESS_ID)
#define COMPRESS_ID LZO_PP_ECONCAT2(DD_BITS,CLEVEL)
#endif
#include "lzo1b_c.ch"
/***********************************************************************
//
************************************************************************/
#define LZO_COMPRESS \
LZO_PP_ECONCAT3(lzo1b_,COMPRESS_ID,_compress)
#define LZO_COMPRESS_FUNC \
LZO_PP_ECONCAT3(_lzo1b_,COMPRESS_ID,_compress_func)
/***********************************************************************
//
************************************************************************/
const lzo_compress_t LZO_COMPRESS_FUNC = do_compress;
LZO_PUBLIC(int)
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return _lzo1b_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
}
/* vim:set ts=4 sw=4 et: */

68
vendor/lzo-2.10/src/compr1c.h vendored Normal file
View File

@@ -0,0 +1,68 @@
/* compr1c.h --
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define LZO_NEED_DICT_H 1
#include "config1c.h"
#if !defined(COMPRESS_ID)
#define COMPRESS_ID LZO_PP_ECONCAT2(DD_BITS,CLEVEL)
#endif
#include "lzo1b_c.ch"
/***********************************************************************
//
************************************************************************/
#define LZO_COMPRESS \
LZO_PP_ECONCAT3(lzo1c_,COMPRESS_ID,_compress)
#define LZO_COMPRESS_FUNC \
LZO_PP_ECONCAT3(_lzo1c_,COMPRESS_ID,_compress_func)
/***********************************************************************
//
************************************************************************/
const lzo_compress_t LZO_COMPRESS_FUNC = do_compress;
LZO_PUBLIC(int)
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return _lzo1c_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
}
/* vim:set ts=4 sw=4 et: */

46
vendor/lzo-2.10/src/config1.h vendored Normal file
View File

@@ -0,0 +1,46 @@
/* config1.h -- configuration for the LZO1 algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1_H
#define __LZO_CONFIG1_H 1
#include "lzo_conf.h"
#include <lzo/lzo1.h>
#define LZO_NO_R1 1
#include "config1a.h"
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

182
vendor/lzo-2.10/src/config1a.h vendored Normal file
View File

@@ -0,0 +1,182 @@
/* config1a.h -- configuration for the LZO1A algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1A_H
#define __LZO_CONFIG1A_H 1
#include "lzo_conf.h"
#include <lzo/lzo1a.h>
#undef LZO_COLLECT_STATS /* no support for stats here */
/***********************************************************************
// algorithm configuration
************************************************************************/
/* run bits (4 - 5) - the compressor and the decompressor
* must use the same value. */
#if !defined(RBITS)
# define RBITS 5
#endif
/* dictionary depth (0 - 6) - this only affects the compressor.
* 0 is fastest, 6 is best compression ratio */
#if !defined(DDBITS)
# define DDBITS 0
#endif
/* compression level (1 - 9) - this only affects the compressor.
* 1 is fastest, 9 is best compression ratio */
#if !defined(CLEVEL)
# define CLEVEL 1 /* fastest by default */
#endif
/* check configuration */
#if (RBITS < 4 || RBITS > 5)
# error "invalid RBITS"
#endif
#if (DDBITS < 0 || DDBITS > 6)
# error "invalid DDBITS"
#endif
#if (CLEVEL < 1 || CLEVEL > 9)
# error "invalid CLEVEL"
#endif
/***********************************************************************
// internal configuration
************************************************************************/
/* add a special code so that the decompressor can detect the
* end of the compressed data block (overhead is 3 bytes per block) */
#undef LZO_EOF_CODE
/***********************************************************************
// algorithm internal configuration
************************************************************************/
/* choose the hashing strategy */
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
/* config */
#define R_BITS RBITS
#define DD_BITS DDBITS
#ifndef D_BITS
#define D_BITS 16
#endif
/***********************************************************************
// optimization and debugging
************************************************************************/
/* Collect statistics */
#if 0 && !defined(LZO_COLLECT_STATS)
# define LZO_COLLECT_STATS 1
#endif
/***********************************************************************
//
************************************************************************/
#define M3O_BITS M2O_BITS
#define M3L_BITS CHAR_BIT
#define M3_MAX_LEN (M3_MIN_LEN + LZO_SIZE(M3L_BITS) - 1)
#define _MAX_OFFSET _M2_MAX_OFFSET
#define LZO_NO_M3 1
#include "lzo1b_de.h"
#include "stats1b.h"
#include "lzo1b_cc.h"
/***********************************************************************
// check for total LZO1/LZO1A compatibility
************************************************************************/
#undef M2_MARKER
#define M2_MARKER (1 << M2O_BITS)
#if (R_BITS != 5)
# error
#endif
#if (M2O_BITS != 5)
# error
#endif
#if (M3O_BITS != 5)
# error
#endif
#if (M2_MIN_LEN != 3)
# error
#endif
#if (M2_MAX_LEN != 8)
# error
#endif
#if (M3_MIN_LEN != 9)
# error
#endif
#if (M3_MAX_LEN != 264)
# error
#endif
#if (_M2_MAX_OFFSET != (1u << 13))
# error
#endif
#if (_M2_MAX_OFFSET != _M3_MAX_OFFSET)
# error
#endif
#if (_M2_MAX_OFFSET != _MAX_OFFSET)
# error
#endif
#if (R0MIN != 32)
# error
#endif
#if (R0MAX != 287)
# error
#endif
#if (R0FAST != 280)
# error
#endif
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

126
vendor/lzo-2.10/src/config1b.h vendored Normal file
View File

@@ -0,0 +1,126 @@
/* config1b.h -- configuration for the LZO1B algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1B_H
#define __LZO_CONFIG1B_H 1
#include "lzo_conf.h"
#include <lzo/lzo1b.h>
/***********************************************************************
// algorithm configuration
************************************************************************/
/* run bits (4 - 5) - the compressor and the decompressor
* must use the same value. */
#if !defined(RBITS)
# define RBITS 5
#endif
/* dictionary depth (0 - 6) - this only affects the compressor.
* 0 is fastest, 6 is best compression ratio */
#if !defined(DDBITS)
# define DDBITS 0
#endif
/* compression level (1 - 9) - this only affects the compressor.
* 1 is fastest, 9 is best compression ratio */
#if !defined(CLEVEL)
# define CLEVEL 1 /* fastest by default */
#endif
/* check configuration */
#if (RBITS < 4 || RBITS > 5)
# error "invalid RBITS"
#endif
#if (DDBITS < 0 || DDBITS > 6)
# error "invalid DDBITS"
#endif
#if (CLEVEL < 1 || CLEVEL > 9)
# error "invalid CLEVEL"
#endif
/***********************************************************************
// internal configuration
************************************************************************/
/* add a special code so that the decompressor can detect the
* end of the compressed data block (overhead is 3 bytes per block) */
#define LZO_EOF_CODE 1
/***********************************************************************
// algorithm internal configuration
************************************************************************/
/* choose the hashing strategy */
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
/* config */
#define R_BITS RBITS
#define DD_BITS DDBITS
#ifndef D_BITS
#define D_BITS 14
#endif
/***********************************************************************
// optimization and debugging
************************************************************************/
/* Collect statistics */
#if 0 && !defined(LZO_COLLECT_STATS)
# define LZO_COLLECT_STATS 1
#endif
/***********************************************************************
//
************************************************************************/
#include "lzo1b_de.h"
#include "stats1b.h"
#include "lzo1b_cc.h"
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

131
vendor/lzo-2.10/src/config1c.h vendored Normal file
View File

@@ -0,0 +1,131 @@
/* config1c.h -- configuration for the LZO1C algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1C_H
#define __LZO_CONFIG1C_H 1
#include "lzo_conf.h"
#include <lzo/lzo1c.h>
/***********************************************************************
// algorithm configuration
************************************************************************/
/* run bits (4 - 5) - the compressor and the decompressor
* must use the same value. */
#if !defined(RBITS)
# define RBITS 5
#endif
/* dictionary depth (0 - 6) - this only affects the compressor.
* 0 is fastest, 6 is best compression ratio */
#if !defined(DDBITS)
# define DDBITS 0
#endif
/* compression level (1 - 9) - this only affects the compressor.
* 1 is fastest, 9 is best compression ratio */
#if !defined(CLEVEL)
# define CLEVEL 1 /* fastest by default */
#endif
/* check configuration */
#if (RBITS < 4 || RBITS > 5)
# error "invalid RBITS"
#endif
#if (DDBITS < 0 || DDBITS > 6)
# error "invalid DDBITS"
#endif
#if (CLEVEL < 1 || CLEVEL > 9)
# error "invalid CLEVEL"
#endif
/***********************************************************************
// internal configuration
************************************************************************/
/* add a special code so that the decompressor can detect the
* end of the compressed data block (overhead is 3 bytes per block) */
#define LZO_EOF_CODE 1
/***********************************************************************
// algorithm internal configuration
************************************************************************/
/* choose the hashing strategy */
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
/* config */
#define R_BITS RBITS
#define DD_BITS DDBITS
#ifndef D_BITS
#define D_BITS 14
#endif
/***********************************************************************
// optimization and debugging
************************************************************************/
/* Collect statistics */
#if 0 && !defined(LZO_COLLECT_STATS)
# define LZO_COLLECT_STATS 1
#endif
/***********************************************************************
//
************************************************************************/
/* good parameters when using a blocksize of 8kB */
#define M3O_BITS 6
#undef LZO_DETERMINISTIC
#include "lzo1b_de.h"
#include "stats1c.h"
#include "lzo1c_cc.h"
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

83
vendor/lzo-2.10/src/config1f.h vendored Normal file
View File

@@ -0,0 +1,83 @@
/* config1f.h -- configuration for the LZO1F algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1F_H
#define __LZO_CONFIG1F_H 1
#include "lzo_conf.h"
#include <lzo/lzo1f.h>
/***********************************************************************
//
************************************************************************/
#define LZO_EOF_CODE 1
#undef LZO_DETERMINISTIC
#define M2_MAX_OFFSET 0x0800
#define M3_MAX_OFFSET 0x3fff
#define M2_MIN_LEN 3
#define M2_MAX_LEN 8
#define M3_MIN_LEN 3
#define M3_MAX_LEN 33
#define M3_MARKER 224
/***********************************************************************
//
************************************************************************/
#ifndef MIN_LOOKAHEAD
#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
#endif
#if defined(LZO_NEED_DICT_H)
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
#define DL_MIN_LEN M2_MIN_LEN
#include "lzo_dict.h"
#endif
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

106
vendor/lzo-2.10/src/config1x.h vendored Normal file
View File

@@ -0,0 +1,106 @@
/* config1x.h -- configuration for the LZO1X algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1X_H
#define __LZO_CONFIG1X_H 1
#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z)
# define LZO1X 1
#endif
#include "lzo_conf.h"
#if !defined(__LZO_IN_MINILZO)
#include <lzo/lzo1x.h>
#endif
/***********************************************************************
//
************************************************************************/
#ifndef LZO_EOF_CODE
#define LZO_EOF_CODE 1
#endif
#undef LZO_DETERMINISTIC
#define M1_MAX_OFFSET 0x0400
#ifndef M2_MAX_OFFSET
#define M2_MAX_OFFSET 0x0800
#endif
#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
#ifndef M2_MAX_LEN
#define M2_MAX_LEN 8
#endif
#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
/***********************************************************************
//
************************************************************************/
#ifndef MIN_LOOKAHEAD
#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
#endif
#if defined(LZO_NEED_DICT_H)
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B
#endif
#define DL_MIN_LEN M2_MIN_LEN
#include "lzo_dict.h"
#endif
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

52
vendor/lzo-2.10/src/config1y.h vendored Normal file
View File

@@ -0,0 +1,52 @@
/* config1y.h -- configuration for the LZO1Y algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1Y_H
#define __LZO_CONFIG1Y_H 1
#if !defined(LZO1Y)
# define LZO1Y 1
#endif
#include "lzo_conf.h"
#include <lzo/lzo1y.h>
#define M2_MAX_LEN 14
#define M2_MAX_OFFSET 0x0400
#include "config1x.h"
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

51
vendor/lzo-2.10/src/config1z.h vendored Normal file
View File

@@ -0,0 +1,51 @@
/* config1z.h -- configuration for the LZO1Z algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG1Z_H
#define __LZO_CONFIG1Z_H 1
#if !defined(LZO1Z)
# define LZO1Z 1
#endif
#include "lzo_conf.h"
#include <lzo/lzo1z.h>
#define M2_MAX_OFFSET 0x0700
#include "config1x.h"
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

141
vendor/lzo-2.10/src/config2a.h vendored Normal file
View File

@@ -0,0 +1,141 @@
/* config2a.h -- configuration for the LZO2A algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONFIG2A_H
#define __LZO_CONFIG2A_H 1
#include "lzo_conf.h"
#include <lzo/lzo2a.h>
/***********************************************************************
// algorithm configuration
************************************************************************/
/* dictionary depth (0 - 6) - this only affects the compressor.
* 0 is fastest, 6 is best compression ratio */
#if !defined(DDBITS)
# define DDBITS 0
#endif
/* compression level (1 - 9) - this only affects the compressor.
* 1 is fastest, 9 is best compression ratio */
#if !defined(CLEVEL)
# define CLEVEL 1 /* fastest by default */
#endif
/* check configuration */
#if (DDBITS < 0 || DDBITS > 6)
# error "invalid DDBITS"
#endif
#if (CLEVEL < 1 || CLEVEL > 9)
# error "invalid CLEVEL"
#endif
/***********************************************************************
// internal configuration
************************************************************************/
#if 1
#define SWD_N 8191 /* size of ring buffer */
#else
#define SWD_N 16383 /* size of ring buffer */
#endif
#define M1_MIN_LEN 2
#define M1_MAX_LEN 5
#define M2_MIN_LEN 3
#define M3_MIN_LEN 3
/* add a special code so that the decompressor can detect the
* end of the compressed data block (overhead is 3 bytes per block) */
#define LZO_EOF_CODE 1
#undef LZO_DETERMINISTIC
/***********************************************************************
// algorithm internal configuration
************************************************************************/
/* choose the hashing strategy */
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
/* config */
#define DD_BITS DDBITS
#ifndef D_BITS
#define D_BITS 14
#endif
/***********************************************************************
// optimization and debugging
************************************************************************/
/* Collect statistics */
#if 0 && !defined(LZO_COLLECT_STATS)
# define LZO_COLLECT_STATS 1
#endif
/***********************************************************************
//
************************************************************************/
/* get bits */
#define _NEEDBITS \
{ _NEEDBYTE; b |= ((lzo_uint32_t) _NEXTBYTE) << k; k += 8; assert(k <= 32); }
#define NEEDBITS(j) { assert((j) < 8); if (k < (j)) _NEEDBITS }
/* set bits */
#define SETBITS(j,x) { b |= ((lzo_uint32_t)(x)) << k; k += (j); assert(k <= 32); }
/* access bits */
#define MASKBITS(j) (b & ((((lzo_uint32_t)1 << (j)) - 1)))
/* drop bits */
#define DUMPBITS(j) { assert(k >= j); b >>= (j); k -= (j); }
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

621
vendor/lzo-2.10/src/lzo1.c vendored Normal file
View File

@@ -0,0 +1,621 @@
/* lzo1.c -- implementation of the LZO1 algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#include <lzo/lzo1.h>
/***********************************************************************
// The next two defines can be changed to customize LZO1.
// The default version is LZO1-5/1.
************************************************************************/
/* run bits (3 - 5) - the compressor and the decompressor
* must use the same value. */
#if !defined(RBITS)
# define RBITS 5
#endif
/* compression level (1 - 9) - this only affects the compressor.
* 1 is fastest, 9 is best compression ratio */
#if !defined(CLEVEL)
# define CLEVEL 1 /* fastest by default */
#endif
/* check configuration */
#if (RBITS < 3 || RBITS > 5)
# error "invalid RBITS"
#endif
#if (CLEVEL < 1 || CLEVEL > 9)
# error "invalid CLEVEL"
#endif
/***********************************************************************
// You should not have to change anything below this line.
************************************************************************/
/*
Format of the marker byte
76543210
--------
00000000 a long run (a 'R0' run) - there are short and long R0 runs
000rrrrr a short run with len r
mmmooooo a short match (len = 2+m, o = offset low bits)
111ooooo a long match (o = offset low bits)
*/
#define RSIZE (1 << RBITS)
#define RMASK (RSIZE - 1)
#define OBITS RBITS /* offset and run-length use same bits */
#define OSIZE (1 << OBITS)
#define OMASK (OSIZE - 1)
#define MBITS (8 - OBITS)
#define MSIZE (1 << MBITS)
#define MMASK (MSIZE - 1)
/* sanity checks */
#if (OBITS < 3 || OBITS > 5)
# error "invalid OBITS"
#endif
#if (MBITS < 3 || MBITS > 5)
# error "invalid MBITS"
#endif
/***********************************************************************
// some macros to improve readability
************************************************************************/
/* Minimum len of a match */
#define MIN_MATCH 3
#define THRESHOLD (MIN_MATCH - 1)
/* Minimum len of match coded in 2 bytes */
#define MIN_MATCH_SHORT MIN_MATCH
/* Maximum len of match coded in 2 bytes */
#define MAX_MATCH_SHORT (THRESHOLD + (MSIZE - 2))
/* MSIZE - 2: 0 is used to indicate runs,
* MSIZE-1 is used to indicate a long match */
/* Minimum len of match coded in 3 bytes */
#define MIN_MATCH_LONG (MAX_MATCH_SHORT + 1)
/* Maximum len of match coded in 3 bytes */
#define MAX_MATCH_LONG (MIN_MATCH_LONG + 255)
/* Maximum offset of a match */
#define MAX_OFFSET (1 << (8 + OBITS))
/*
RBITS | MBITS MIN THR. MSIZE MAXS MINL MAXL MAXO R0MAX R0FAST
======+===============================================================
3 | 5 3 2 32 32 33 288 2048 263 256
4 | 4 3 2 16 16 17 272 4096 271 264
5 | 3 3 2 8 8 9 264 8192 287 280
*/
/***********************************************************************
// internal configuration
// all of these affect compression only
************************************************************************/
/* choose the hashing strategy */
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,5,5)) >> 5)
#define D_INDEX2(d,p) d = d ^ D_MASK
#define DBITS (8 + RBITS)
#include "lzo_dict.h"
#define DVAL_LEN DVAL_LOOKAHEAD
/***********************************************************************
// get algorithm info, return memory required for compression
************************************************************************/
LZO_EXTERN(lzo_uint) lzo1_info ( int *rbits, int *clevel );
LZO_PUBLIC(lzo_uint)
lzo1_info ( int *rbits, int *clevel )
{
if (rbits)
*rbits = RBITS;
if (clevel)
*clevel = CLEVEL;
return D_SIZE * lzo_sizeof(lzo_bytep);
}
/***********************************************************************
// decode a R0 literal run (a long run)
************************************************************************/
#define R0MIN (RSIZE) /* Minimum len of R0 run of literals */
#define R0MAX (R0MIN + 255) /* Maximum len of R0 run of literals */
#define R0FAST (R0MAX & ~7u) /* R0MAX aligned to 8 byte boundary */
#if (R0MAX - R0FAST != 7) || ((R0FAST & 7) != 0)
# error "something went wrong"
#endif
/* 7 special codes from R0FAST+1 .. R0MAX
* these codes mean long R0 runs with lengths
* 512, 1024, 2048, 4096, 8192, 16384, 32768 */
/***********************************************************************
// LZO1 decompress a block of data.
//
// Could be easily translated into assembly code.
************************************************************************/
LZO_PUBLIC(int)
lzo1_decompress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
lzo_bytep op;
const lzo_bytep ip;
const lzo_bytep const ip_end = in + in_len;
lzo_uint t;
LZO_UNUSED(wrkmem);
op = out;
ip = in;
while (ip < ip_end)
{
t = *ip++; /* get marker */
if (t < R0MIN) /* a literal run */
{
if (t == 0) /* a R0 literal run */
{
t = *ip++;
if (t >= R0FAST - R0MIN) /* a long R0 run */
{
t -= R0FAST - R0MIN;
if (t == 0)
t = R0FAST;
else
{
#if 0
t = 256u << ((unsigned) t);
#else
/* help the optimizer */
lzo_uint tt = 256;
do tt <<= 1; while (--t > 0);
t = tt;
#endif
}
MEMCPY8_DS(op,ip,t);
continue;
}
t += R0MIN;
}
MEMCPY_DS(op,ip,t);
}
else /* a match */
{
lzo_uint tt;
/* get match offset */
const lzo_bytep m_pos = op - 1;
m_pos -= (lzo_uint)(t & OMASK) | (((lzo_uint) *ip++) << OBITS);
/* get match len */
if (t >= ((MSIZE - 1) << OBITS)) /* all m-bits set */
tt = (MIN_MATCH_LONG - THRESHOLD) + *ip++; /* a long match */
else
tt = t >> OBITS; /* a short match */
assert(m_pos >= out);
assert(m_pos < op);
/* a half unrolled loop */
*op++ = *m_pos++;
*op++ = *m_pos++;
MEMCPY_DS(op,m_pos,tt);
}
}
*out_len = pd(op, out);
/* the next line is the only check in the decompressor ! */
return (ip == ip_end ? LZO_E_OK :
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
}
/***********************************************************************
// code a literal run
************************************************************************/
static
#if LZO_ARCH_AVR
__lzo_noinline
#endif
lzo_bytep
store_run(lzo_bytep op, const lzo_bytep ii, lzo_uint r_len)
{
assert(r_len > 0);
/* code a long R0 run */
if (r_len >= 512)
{
unsigned r_bits = 7; /* 256 << 7 == 32768 */
do {
while (r_len >= (256u << r_bits))
{
r_len -= (256u << r_bits);
*op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
MEMCPY8_DS(op, ii, (256u << r_bits));
}
} while (--r_bits > 0);
}
while (r_len >= R0FAST)
{
r_len -= R0FAST;
*op++ = 0; *op++ = R0FAST - R0MIN;
MEMCPY8_DS(op, ii, R0FAST);
}
if (r_len >= R0MIN)
{
/* code a short R0 run */
*op++ = 0; *op++ = LZO_BYTE(r_len - R0MIN);
MEMCPY_DS(op, ii, r_len);
}
else if (r_len > 0)
{
/* code a 'normal' run */
*op++ = LZO_BYTE(r_len);
MEMCPY_DS(op, ii, r_len);
}
assert(r_len == 0);
return op;
}
/***********************************************************************
// LZO1 compress a block of data.
//
// Could be translated into assembly code without too much effort.
//
// I apologize for the spaghetti code, but it really helps the optimizer.
************************************************************************/
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);
}
} while (ip < ip_end);
the_end:
assert(ip <= in_end);
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
/* return -1 if op == out to indicate that we
* couldn't compress and didn't copy anything.
*/
if (op == out)
{
*out_len = 0;
return LZO_E_NOT_COMPRESSIBLE;
}
#endif
/* store the final literal run */
if (pd(in_end+DVAL_LEN,ii) > 0)
op = store_run(op,ii,pd(in_end+DVAL_LEN,ii));
*out_len = pd(op, out);
return 0; /* compression went ok */
}
/***********************************************************************
// compress public entry point.
************************************************************************/
LZO_PUBLIC(int)
lzo1_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
int r = LZO_E_OK;
/* don't try to compress a block that's too short */
if (in_len == 0)
*out_len = 0;
else if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1)
{
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
r = LZO_E_NOT_COMPRESSIBLE;
#else
*out_len = pd(store_run(out,in,in_len), out);
#endif
}
else
r = do_compress(in,in_len,out,out_len,wrkmem);
return r;
}
/* vim:set ts=4 sw=4 et: */

116
vendor/lzo-2.10/src/lzo1_99.c vendored Normal file
View File

@@ -0,0 +1,116 @@
/* lzo1_99.c -- implementation of the LZO1-99 algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 99
#define DDBITS 3
#define CLEVEL 9
/***********************************************************************
//
************************************************************************/
#define LZO_NEED_DICT_H 1
#include "config1.h"
/***********************************************************************
// compression internal entry point.
************************************************************************/
static int
_lzo1_do_compress ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_compress_t func )
{
int r;
/* don't try to compress a block that's too short */
if (in_len == 0)
{
*out_len = 0;
r = LZO_E_OK;
}
else if (in_len <= MIN_LOOKAHEAD + 1)
{
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
*out_len = 0;
r = LZO_E_NOT_COMPRESSIBLE;
#else
*out_len = pd(STORE_RUN(out,in,in_len), out);
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
#endif
}
else
r = func(in,in_len,out,out_len,wrkmem);
return r;
}
/***********************************************************************
//
************************************************************************/
#if !defined(COMPRESS_ID)
#define COMPRESS_ID _LZO_ECONCAT2(DD_BITS,CLEVEL)
#endif
#define LZO_CODE_MATCH_INCLUDE_FILE "lzo1_cm.ch"
#include "lzo1b_c.ch"
/***********************************************************************
//
************************************************************************/
#define LZO_COMPRESS \
LZO_PP_ECONCAT3(lzo1_,COMPRESS_ID,_compress)
#define LZO_COMPRESS_FUNC \
LZO_PP_ECONCAT3(_lzo1_,COMPRESS_ID,_compress_func)
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return _lzo1_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
}
/* vim:set ts=4 sw=4 et: */

38
vendor/lzo-2.10/src/lzo1_cm.ch vendored Normal file
View File

@@ -0,0 +1,38 @@
/* lzo1_cm.ch -- implementation of the LZO1 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#include "lzo1a_cm.ch"
/* vim:set ts=4 sw=4 et: */

156
vendor/lzo-2.10/src/lzo1_d.ch vendored Normal file
View File

@@ -0,0 +1,156 @@
/* lzo1_d.ch -- common decompression stuff
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#if defined(LZO_TEST_OVERRUN)
# if !defined(LZO_TEST_OVERRUN_INPUT)
# define LZO_TEST_OVERRUN_INPUT 2
# endif
# if !defined(LZO_TEST_OVERRUN_OUTPUT)
# define LZO_TEST_OVERRUN_OUTPUT 2
# endif
# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND)
# define LZO_TEST_OVERRUN_LOOKBEHIND 1
# endif
#endif
/***********************************************************************
// Overrun detection is internally handled by these macros:
//
// TEST_IP test input overrun at loop begin
// NEED_IP test input overrun at every input byte
//
// TEST_OP test output overrun at loop begin
// NEED_OP test output overrun at every output byte
//
// TEST_LB test match position
//
// The fastest decompressor results when testing for no overruns
// and using LZO_EOF_CODE.
************************************************************************/
#undef TEST_IP
#undef TEST_OP
#undef TEST_IP_AND_TEST_OP
#undef TEST_LB
#undef TEST_LBO
#undef NEED_IP
#undef NEED_OP
#undef TEST_IV
#undef TEST_OV
#undef HAVE_TEST_IP
#undef HAVE_TEST_OP
#undef HAVE_NEED_IP
#undef HAVE_NEED_OP
#undef HAVE_ANY_IP
#undef HAVE_ANY_OP
#if defined(LZO_TEST_OVERRUN_INPUT)
# if (LZO_TEST_OVERRUN_INPUT >= 1)
# define TEST_IP (ip < ip_end)
# endif
# if (LZO_TEST_OVERRUN_INPUT >= 2)
# define NEED_IP(x) \
if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
# define TEST_IV(x) if ((x) > (lzo_uint)0 - (511)) goto input_overrun
# endif
#endif
#if defined(LZO_TEST_OVERRUN_OUTPUT)
# if (LZO_TEST_OVERRUN_OUTPUT >= 1)
# define TEST_OP (op <= op_end)
# endif
# if (LZO_TEST_OVERRUN_OUTPUT >= 2)
# undef TEST_OP /* don't need both of the tests here */
# define NEED_OP(x) \
if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
# define TEST_OV(x) if ((x) > (lzo_uint)0 - (511)) goto output_overrun
# endif
#endif
#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
# define TEST_LB(m_pos) if (PTR_LT(m_pos,out) || PTR_GE(m_pos,op)) goto lookbehind_overrun
# define TEST_LBO(m_pos,o) if (PTR_LT(m_pos,out) || PTR_GE(m_pos,op-(o))) goto lookbehind_overrun
#else
# define TEST_LB(m_pos) ((void) 0)
# define TEST_LBO(m_pos,o) ((void) 0)
#endif
#if !defined(LZO_EOF_CODE) && !defined(TEST_IP)
/* if we have no EOF code, we have to test for the end of the input */
# define TEST_IP (ip < ip_end)
#endif
#if defined(TEST_IP)
# define HAVE_TEST_IP 1
#else
# define TEST_IP 1
#endif
#if defined(TEST_OP)
# define HAVE_TEST_OP 1
#else
# define TEST_OP 1
#endif
#if defined(HAVE_TEST_IP) && defined(HAVE_TEST_OP)
# define TEST_IP_AND_TEST_OP (TEST_IP && TEST_OP)
#elif defined(HAVE_TEST_IP)
# define TEST_IP_AND_TEST_OP TEST_IP
#elif defined(HAVE_TEST_OP)
# define TEST_IP_AND_TEST_OP TEST_OP
#else
# define TEST_IP_AND_TEST_OP 1
#endif
#if defined(NEED_IP)
# define HAVE_NEED_IP 1
#else
# define NEED_IP(x) ((void) 0)
# define TEST_IV(x) ((void) 0)
#endif
#if defined(NEED_OP)
# define HAVE_NEED_OP 1
#else
# define NEED_OP(x) ((void) 0)
# define TEST_OV(x) ((void) 0)
#endif
#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP)
# define HAVE_ANY_IP 1
#endif
#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP)
# define HAVE_ANY_OP 1
#endif
/* vim:set ts=4 sw=4 et: */

643
vendor/lzo-2.10/src/lzo1a.c vendored Normal file
View File

@@ -0,0 +1,643 @@
/* lzo1a.c -- implementation of the LZO1A algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#include <lzo/lzo1a.h>
/***********************************************************************
// The next two defines can be changed to customize LZO1A.
// The default version is LZO1A-5/1.
************************************************************************/
/* run bits (3 - 5) - the compressor and the decompressor
* must use the same value. */
#if !defined(RBITS)
# define RBITS 5
#endif
/* compression level (1 - 9) - this only affects the compressor.
* 1 is fastest, 9 is best compression ratio
*/
#if !defined(CLEVEL)
# define CLEVEL 1 /* fastest by default */
#endif
/* Collect statistics */
#if 0 && !defined(LZO_COLLECT_STATS)
# define LZO_COLLECT_STATS 1
#endif
/***********************************************************************
// You should not have to change anything below this line.
************************************************************************/
/* check configuration */
#if (RBITS < 3 || RBITS > 5)
# error "invalid RBITS"
#endif
#if (CLEVEL < 1 || CLEVEL > 9)
# error "invalid CLEVEL"
#endif
/***********************************************************************
// internal configuration
// all of these affect compression only
************************************************************************/
/* choose the hashing strategy */
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,5,5)) >> 5)
#define D_INDEX2(d,p) d = d ^ D_MASK
#include "lzo1a_de.h"
#include "stats1a.h"
/* check other constants */
#if (LBITS < 5 || LBITS > 8)
# error "invalid LBITS"
#endif
#if (LZO_COLLECT_STATS)
static lzo1a_stats_t lzo_statistics;
lzo1a_stats_t *lzo1a_stats = &lzo_statistics;
# define lzo_stats lzo1a_stats
#endif
/***********************************************************************
// get algorithm info, return memory required for compression
************************************************************************/
LZO_EXTERN(lzo_uint) lzo1a_info ( int *rbits, int *clevel );
LZO_PUBLIC(lzo_uint)
lzo1a_info ( int *rbits, int *clevel )
{
if (rbits)
*rbits = RBITS;
if (clevel)
*clevel = CLEVEL;
return D_SIZE * lzo_sizeof(lzo_bytep);
}
/***********************************************************************
// LZO1A decompress a block of data.
//
// Could be easily translated into assembly code.
************************************************************************/
LZO_PUBLIC(int)
lzo1a_decompress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
lzo_bytep op;
const lzo_bytep ip;
lzo_uint t;
const lzo_bytep m_pos;
const lzo_bytep const ip_end = in + in_len;
LZO_UNUSED(wrkmem);
op = out;
ip = in;
while (ip < ip_end)
{
t = *ip++; /* get marker */
LZO_STATS(lzo_stats->marker[t]++);
if (t == 0) /* a R0 literal run */
{
t = *ip++;
if (t >= R0FAST - R0MIN) /* a long R0 run */
{
t -= R0FAST - R0MIN;
if (t == 0)
t = R0FAST;
else
{
#if 0
t = 256u << ((unsigned) t);
#else
/* help the optimizer */
lzo_uint tt = 256;
do tt <<= 1; while (--t > 0);
t = tt;
#endif
}
MEMCPY8_DS(op,ip,t);
continue;
}
t += R0MIN;
goto literal;
}
else if (t < R0MIN) /* a short literal run */
{
literal:
MEMCPY_DS(op,ip,t);
/* after a literal a match must follow */
while (ip < ip_end)
{
t = *ip++; /* get R1 marker */
if (t >= R0MIN)
goto match;
/* R1 match - a context sensitive 3 byte match + 1 byte literal */
assert((t & OMASK) == t);
m_pos = op - MIN_OFFSET;
m_pos -= t | (((lzo_uint) *ip++) << OBITS);
assert(m_pos >= out); assert(m_pos < op);
*op++ = m_pos[0];
*op++ = m_pos[1];
*op++ = m_pos[2];
*op++ = *ip++;
}
}
else /* a match */
{
match:
/* get match offset */
m_pos = op - MIN_OFFSET;
m_pos -= (t & OMASK) | (((lzo_uint) *ip++) << OBITS);
assert(m_pos >= out); assert(m_pos < op);
/* get match len */
if (t < ((MSIZE - 1) << OBITS)) /* a short match */
{
t >>= OBITS;
*op++ = *m_pos++;
*op++ = *m_pos++;
MEMCPY_DS(op,m_pos,t);
}
else /* a long match */
{
#if (LBITS < 8)
t = (MIN_MATCH_LONG - THRESHOLD) + ((lzo_uint)(*ip++) & LMASK);
#else
t = (MIN_MATCH_LONG - THRESHOLD) + (lzo_uint)(*ip++);
#endif
*op++ = *m_pos++;
*op++ = *m_pos++;
MEMCPY_DS(op,m_pos,t);
#if (LBITS < 8)
/* a very short literal following a long match */
t = ip[-1] >> LBITS;
if (t) do
*op++ = *ip++;
while (--t);
#endif
}
}
}
*out_len = pd(op, out);
/* the next line is the only check in the decompressor */
return (ip == ip_end ? LZO_E_OK :
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
}
/***********************************************************************
// LZO1A compress a block of data.
//
// I apologize for the spaghetti code, but it really helps the optimizer.
************************************************************************/
#include "lzo1a_cr.ch"
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
const lzo_bytep m_pos;
lzo_bytep op;
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;
const lzo_bytep r1 = ip_end; /* pointer for R1 match (none yet) */
#if (LBITS < 8)
const lzo_bytep im = ip_end; /* pointer to last match start */
#endif
#if !defined(NDEBUG)
const lzo_bytep m_pos_sav;
#endif
op = out;
ip = in;
ii = ip; /* point to start of current literal run */
/* 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_NON_DET(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_NON_DET(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)
assert(m_pos == NULL || m_pos >= in);
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
assert(m_pos >= in);
assert(ip < ip_end);
/* 1) store the current literal run */
if (pd(ip,ii) > 0)
{
lzo_uint t = pd(ip,ii);
if (ip - r1 == MIN_MATCH + 1)
{
/* Code a context sensitive R1 match.
* This is tricky and somewhat difficult to explain:
* multiplex a literal run of length 1 into the previous
* short match of length MIN_MATCH.
* The key idea is:
* - after a short run a match MUST follow
* - therefore the value m = 000 in the mmmooooo marker is free
* - use 000ooooo to indicate a MIN_MATCH match (this
* is already coded) plus a 1 byte literal
*/
assert(t == 1);
/* modify marker byte */
assert((op[-2] >> OBITS) == (MIN_MATCH - THRESHOLD));
op[-2] &= OMASK;
assert((op[-2] >> OBITS) == 0);
/* copy 1 literal */
*op++ = *ii;
LZO_STATS(lzo_stats->r1_matches++);
r1 = ip; /* set new R1 pointer */
}
else if (t < R0MIN)
{
/* inline the copying of a short run */
#if (LBITS < 8)
if (t < (1 << (8-LBITS)) && ii - im >= MIN_MATCH_LONG)
{
/* Code a very short literal run into the
* previous long match length byte.
*/
LZO_STATS(lzo_stats->lit_runs_after_long_match++);
LZO_STATS(lzo_stats->lit_run_after_long_match[t]++);
assert(ii - im <= MAX_MATCH_LONG);
assert((op[-1] >> LBITS) == 0);
op[-1] = LZO_BYTE(op[-1] | (t << LBITS));
MEMCPY_DS(op, ii, t);
}
else
#endif
{
LZO_STATS(lzo_stats->lit_runs++);
LZO_STATS(lzo_stats->lit_run[t]++);
*op++ = LZO_BYTE(t);
MEMCPY_DS(op, ii, t);
r1 = ip; /* set new R1 pointer */
}
}
else if (t < R0FAST)
{
/* inline the copying of a short R0 run */
LZO_STATS(lzo_stats->r0short_runs++);
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
MEMCPY_DS(op, ii, t);
r1 = ip; /* set new R1 pointer */
}
else
op = store_run(op,ii,t);
}
#if (LBITS < 8)
im = ip;
#endif
/* 2) 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
{
/* we've found a short match */
lzo_uint m_len;
/* 2a) compute match parameters */
assert(ip-m_pos == (int)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 >= MIN_OFFSET);
assert(m_off <= MAX_OFFSET);
assert(ii-m_off == m_pos_sav);
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
m_off -= MIN_OFFSET;
/* 2b) code a short match */
/* 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);
#if (LZO_COLLECT_STATS)
lzo_stats->short_matches++;
lzo_stats->short_match[m_len]++;
if (m_off < OSIZE)
lzo_stats->short_match_offset_osize[m_len]++;
if (m_off < 256)
lzo_stats->short_match_offset_256[m_len]++;
if (m_off < 1024)
lzo_stats->short_match_offset_1024[m_len]++;
#endif
/* 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);
/* 2a) compute match parameters */
m_len = pd(ip, ii);
assert(m_len >= MIN_MATCH_LONG);
assert(m_len <= MAX_MATCH_LONG);
assert(m_off >= MIN_OFFSET);
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 -= MIN_OFFSET;
/* 2b) code the long match */
/* 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);
#if (LZO_COLLECT_STATS)
lzo_stats->long_matches++;
lzo_stats->long_match[m_len]++;
#endif
/* 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 the next literal run */
assert(ii == ip);
}
} while (ip < ip_end);
assert(ip <= in_end);
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
/* return -1 if op == out to indicate that we
* couldn't compress and didn't copy anything.
*/
if (op == out)
{
*out_len = 0;
return LZO_E_NOT_COMPRESSIBLE;
}
#endif
/* store the final literal run */
if (pd(in_end+DVAL_LEN,ii) > 0)
op = store_run(op,ii,pd(in_end+DVAL_LEN,ii));
*out_len = pd(op, out);
return 0; /* compression went ok */
}
/***********************************************************************
// LZO1A compress public entry point.
************************************************************************/
LZO_PUBLIC(int)
lzo1a_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
int r = LZO_E_OK;
#if (LZO_COLLECT_STATS)
lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
lzo_stats->rbits = RBITS;
lzo_stats->clevel = CLEVEL;
lzo_stats->dbits = DBITS;
lzo_stats->lbits = LBITS;
lzo_stats->min_match_short = MIN_MATCH_SHORT;
lzo_stats->max_match_short = MAX_MATCH_SHORT;
lzo_stats->min_match_long = MIN_MATCH_LONG;
lzo_stats->max_match_long = MAX_MATCH_LONG;
lzo_stats->min_offset = MIN_OFFSET;
lzo_stats->max_offset = MAX_OFFSET;
lzo_stats->r0min = R0MIN;
lzo_stats->r0fast = R0FAST;
lzo_stats->r0max = R0MAX;
lzo_stats->in_len = in_len;
#endif
/* don't try to compress a block that's too short */
if (in_len == 0)
*out_len = 0;
else if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1)
{
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
r = LZO_E_NOT_COMPRESSIBLE;
#else
*out_len = pd(store_run(out,in,in_len), out);
#endif
}
else
r = do_compress(in,in_len,out,out_len,wrkmem);
#if (LZO_COLLECT_STATS)
lzo_stats->short_matches -= lzo_stats->r1_matches;
lzo_stats->short_match[MIN_MATCH] -= lzo_stats->r1_matches;
lzo_stats->out_len = *out_len;
#endif
return r;
}
/* vim:set ts=4 sw=4 et: */

116
vendor/lzo-2.10/src/lzo1a_99.c vendored Normal file
View File

@@ -0,0 +1,116 @@
/* lzo1a_99.c -- implementation of the LZO1A-99 algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 99
#define DDBITS 3
#define CLEVEL 9
/***********************************************************************
//
************************************************************************/
#define LZO_NEED_DICT_H 1
#include "config1a.h"
/***********************************************************************
// compression internal entry point.
************************************************************************/
static int
_lzo1a_do_compress ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_compress_t func )
{
int r;
/* don't try to compress a block that's too short */
if (in_len == 0)
{
*out_len = 0;
r = LZO_E_OK;
}
else if (in_len <= MIN_LOOKAHEAD + 1)
{
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
*out_len = 0;
r = LZO_E_NOT_COMPRESSIBLE;
#else
*out_len = pd(STORE_RUN(out,in,in_len), out);
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
#endif
}
else
r = func(in,in_len,out,out_len,wrkmem);
return r;
}
/***********************************************************************
//
************************************************************************/
#if !defined(COMPRESS_ID)
#define COMPRESS_ID _LZO_ECONCAT2(DD_BITS,CLEVEL)
#endif
#define LZO_CODE_MATCH_INCLUDE_FILE "lzo1a_cm.ch"
#include "lzo1b_c.ch"
/***********************************************************************
//
************************************************************************/
#define LZO_COMPRESS \
LZO_PP_ECONCAT3(lzo1a_,COMPRESS_ID,_compress)
#define LZO_COMPRESS_FUNC \
LZO_PP_ECONCAT3(_lzo1a_,COMPRESS_ID,_compress_func)
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return _lzo1a_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
}
/* vim:set ts=4 sw=4 et: */

228
vendor/lzo-2.10/src/lzo1a_cm.ch vendored Normal file
View File

@@ -0,0 +1,228 @@
/* lzo1a_cm.ch -- implementation of the LZO1A compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
/***********************************************************************
// code the match in LZO1 compatible format
************************************************************************/
#define THRESHOLD (M2_MIN_LEN - 1)
#define MSIZE LZO_SIZE(M2L_BITS)
/***********************************************************************
//
************************************************************************/
#if (DD_BITS == 0)
/* we already matched M2_MIN_LEN bytes,
* m_pos also already advanced M2_MIN_LEN bytes */
ip += M2_MIN_LEN;
assert(m_pos < ip);
/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
* to see if we get more than a M2 match */
#define M2_OR_M3 (MATCH_M2)
#else /* (DD_BITS == 0) */
/* we already matched m_len bytes */
assert(m_len >= M2_MIN_LEN);
ip += m_len;
assert(ip <= in_end);
#define M2_OR_M3 (m_len <= M2_MAX_LEN)
#endif /* (DD_BITS == 0) */
if (M2_OR_M3)
{
/* we've found a short match */
assert(ip <= in_end);
/* 2a) compute match parameters */
#if (DD_BITS == 0)
assert(pd(ip,m_pos) == m_off);
--ip; /* ran one too far, point back to non-match */
m_len = ip - ii;
#endif
assert(m_len >= M2_MIN_LEN);
assert(m_len <= M2_MAX_LEN);
assert(m_off >= M2_MIN_OFFSET);
assert(m_off <= M2_MAX_OFFSET);
assert(ii-m_off == m_pos_sav);
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
/* 2b) code the match */
m_off -= M2_MIN_OFFSET;
/* code short match len + low offset bits */
*op++ = LZO_BYTE(((m_len - THRESHOLD) << M2O_BITS) |
(m_off & M2O_MASK));
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M2O_BITS);
if (ip >= ip_end)
{
ii = ip;
break;
}
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
#if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3)
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
++ii;
do {
DVAL_NEXT(dv,ii);
#if 0
UPDATE_D(dict,drun,dv,ii,in);
#else
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
#endif
MI
} 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;
assert(ip <= in_end);
assert(ii == ip - (M2_MAX_LEN + 1));
assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0);
#if (DD_BITS > 0)
assert(m_len == (lzo_uint)(ip-ii));
m_pos = ip - m_off;
assert(m_pos == m_pos_sav + m_len);
#endif
if (pd(in_end,ip) <= (M3_MAX_LEN - M3_MIN_LEN))
end = in_end;
else
{
end = ip + (M3_MAX_LEN - M3_MIN_LEN);
assert(end < in_end);
}
while (ip < end && *m_pos == *ip)
{ m_pos++; ip++; }
assert(ip <= in_end);
/* 2a) compute match parameters */
m_len = pd(ip, ii);
assert(m_len >= M3_MIN_LEN);
assert(m_len <= M3_MAX_LEN);
assert(m_off >= M3_MIN_OFFSET);
assert(m_off <= M3_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);
/* 2b) code the match */
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
/* code long match flag + low offset bits */
*op++ = LZO_BYTE(((MSIZE - 1) << M3O_BITS) | (m_off & M3O_MASK));
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M3O_BITS);
/* code match len */
*op++ = LZO_BYTE(m_len - M3_MIN_LEN);
if (ip >= ip_end)
{
ii = ip;
break;
}
/* 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 can be slow. */
++ii;
do {
DVAL_NEXT(dv,ii);
#if 0
UPDATE_D(dict,drun,dv,ii,in);
#else
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
#endif
MI
} 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 the next literal run */
assert(ii == ip);
/* vim:set ts=4 sw=4 et: */

114
vendor/lzo-2.10/src/lzo1a_cr.ch vendored Normal file
View File

@@ -0,0 +1,114 @@
/* lzo1a_cr.ch -- literal run handling for the the LZO1A algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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 LZO package and is subject
to change.
*/
#ifndef __LZO1A_CR_H
#define __LZO1A_CR_H 1
/***********************************************************************
// code a literal run
************************************************************************/
static lzo_bytep
store_run(lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
{
lzo_bytep op;
const lzo_bytep ip;
lzo_uint t;
op = oo;
ip = ii;
assert(r_len > 0);
/* code a long R0 run */
if (r_len >= 512)
{
unsigned r_bits = 6; /* 256 << 6 == 16384 */
lzo_uint tt = 32768u;
while (r_len >= (t = tt))
{
r_len -= t;
*op++ = 0; *op++ = (R0MAX - R0MIN);
MEMCPY8_DS(op, ip, t);
LZO_STATS(lzo_stats->r0long_runs++);
}
tt >>= 1;
do {
if (r_len >= (t = tt))
{
r_len -= t;
*op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
MEMCPY8_DS(op, ip, t);
LZO_STATS(lzo_stats->r0long_runs++);
}
tt >>= 1;
} while (--r_bits > 0);
}
assert(r_len < 512);
while (r_len >= (t = R0FAST))
{
r_len -= t;
*op++ = 0; *op++ = (R0FAST - R0MIN);
MEMCPY8_DS(op, ip, t);
LZO_STATS(lzo_stats->r0fast_runs++);
}
t = r_len;
if (t >= R0MIN)
{
/* code a short R0 run */
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
MEMCPY_DS(op, ip, t);
LZO_STATS(lzo_stats->r0short_runs++);
}
else if (t > 0)
{
/* code a short literal run */
LZO_STATS(lzo_stats->lit_runs++);
LZO_STATS(lzo_stats->lit_run[t]++);
*op++ = LZO_BYTE(t);
MEMCPY_DS(op, ip, t);
}
return op;
}
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

144
vendor/lzo-2.10/src/lzo1a_de.h vendored Normal file
View File

@@ -0,0 +1,144 @@
/* lzo1a_de.h -- definitions for the the LZO1A algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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 LZO package and is subject
to change.
*/
#ifndef __LZO_DEFS_H
#define __LZO_DEFS_H 1
#ifdef __cplusplus
extern "C" {
#endif
/***********************************************************************
//
************************************************************************/
/*
Format of the marker byte
76543210
--------
00000000 a long literal run ('R0' run) - there are short and long R0 runs
000rrrrr a short literal run with len r
mmmooooo a short match (len = 2+m, o = offset low bits)
111ooooo a long match (o = offset low bits)
*/
#define RSIZE (1 << RBITS)
#define RMASK (RSIZE - 1)
#define MBITS (8 - OBITS)
#define MSIZE (1 << MBITS)
#define MMASK (MSIZE - 1)
#define OBITS RBITS /* offset and run-length use same bits */
#define OSIZE (1 << OBITS)
#define OMASK (OSIZE - 1)
/* additional bits for coding the length in a long match */
#define LBITS 8
#define LSIZE (1 << LBITS)
#define LMASK (LSIZE - 1)
/***********************************************************************
// some macros to improve readability
************************************************************************/
/* Minimum len of a match */
#define MIN_MATCH 3
#define THRESHOLD (MIN_MATCH - 1)
/* Min-/Maximum len of a match coded in 2 bytes */
#define MIN_MATCH_SHORT (MIN_MATCH)
#define MAX_MATCH_SHORT (MIN_MATCH_SHORT + (MSIZE - 2) - 1)
/* why (MSIZE - 2) ? because 0 is used to mark runs,
* and MSIZE-1 is used to mark a long match */
/* Min-/Maximum len of a match coded in 3 bytes */
#define MIN_MATCH_LONG (MAX_MATCH_SHORT + 1)
#define MAX_MATCH_LONG (MIN_MATCH_LONG + LSIZE - 1)
/* Min-/Maximum offset of a match */
#define MIN_OFFSET 1
#define MAX_OFFSET (1 << (CHAR_BIT + OBITS))
/* R0 literal run (a long run) */
#define R0MIN (RSIZE) /* Minimum len of R0 run of literals */
#define R0MAX (R0MIN + 255) /* Maximum len of R0 run of literals */
#define R0FAST (R0MAX & ~7) /* R0MAX aligned to 8 byte boundary */
#if (R0MAX - R0FAST != 7) || ((R0FAST & 7) != 0)
# error "something went wrong"
#endif
/* 7 special codes from R0FAST+1 .. R0MAX
* these codes mean long R0 runs with lengths
* 512, 1024, 2048, 4096, 8192, 16384, 32768 */
/*
RBITS | MBITS MIN THR. MSIZE MAXS MINL MAXL MAXO R0MAX R0FAST
======+===============================================================
3 | 5 3 2 32 32 33 288 2048 263 256
4 | 4 3 2 16 16 17 272 4096 271 264
5 | 3 3 2 8 8 9 264 8192 287 280
*/
/***********************************************************************
//
************************************************************************/
#define DBITS 13
#include "lzo_dict.h"
#define DVAL_LEN DVAL_LOOKAHEAD
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_1.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_1.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 1
#define DDBITS 0
#define CLEVEL 1
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_2.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_2.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 2
#define DDBITS 0
#define CLEVEL 2
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_3.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_3.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 3
#define DDBITS 0
#define CLEVEL 3
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_4.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_4.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 4
#define DDBITS 1
#define CLEVEL 2
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_5.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_5.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 5
#define DDBITS 1
#define CLEVEL 3
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_6.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_6.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 6
#define DDBITS 1
#define CLEVEL 5
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_7.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_7.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 7
#define DDBITS 2
#define CLEVEL 3
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_8.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_8.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 8
#define DDBITS 2
#define CLEVEL 8
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1b_9.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1b_9.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 9
#define DDBITS 2
#define CLEVEL 9
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

38
vendor/lzo-2.10/src/lzo1b_99.c vendored Normal file
View File

@@ -0,0 +1,38 @@
/* lzo1b_99.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 99
#define DDBITS 3
#define CLEVEL 9
#define D_BITS 16
#define MATCH_IP_END in_end
#include "compr1b.h"
/* vim:set ts=4 sw=4 et: */

350
vendor/lzo-2.10/src/lzo1b_9x.c vendored Normal file
View File

@@ -0,0 +1,350 @@
/* lzo1b_9x.c -- implementation of the LZO1B-999 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1b.h"
/***********************************************************************
//
************************************************************************/
#define SWD_N 0xffffL /* size of ring buffer */
#define SWD_THRESHOLD 2 /* lower limit for match length */
#define SWD_F 2048 /* upper limit for match length */
#define LZO1B 1
#define LZO_COMPRESS_T lzo1b_999_t
#define lzo_swd_t lzo1b_999_swd_t
#include "lzo_mchw.ch"
/***********************************************************************
//
************************************************************************/
static lzo_bytep
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
{
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
{
assert(m_len >= M2_MIN_LEN);
assert(m_off >= M2_MIN_OFFSET);
m_off -= M2_MIN_OFFSET;
/* code match len + low offset bits */
*op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) |
(m_off & M2O_MASK));
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M2O_BITS);
c->m2_m++;
}
else
{
assert(m_len >= M3_MIN_LEN);
assert(m_off <= M3_MAX_OFFSET);
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
/* code match len */
if (m_len <= M3_MAX_LEN)
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
else
{
assert(m_len >= M4_MIN_LEN);
/* code M4 match len flag */
*op++ = M4_MARKER;
/* code match len */
m_len -= M4_MIN_LEN - 1;
while (m_len > 255)
{
m_len -= 255;
*op++ = 0;
}
assert(m_len > 0);
*op++ = LZO_BYTE(m_len);
}
/* code low offset bits */
*op++ = LZO_BYTE(m_off & M3O_MASK);
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M3O_BITS);
c->r1_m_len = 0;
c->m3_m++;
}
return op;
}
/***********************************************************************
// this is a public function, but there is no prototype in a header file
************************************************************************/
LZO_EXTERN(int)
lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain );
LZO_PUBLIC(int)
lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain )
{
lzo_bytep op;
const lzo_bytep ii;
lzo_uint lit;
lzo_uint m_len, m_off;
LZO_COMPRESS_T cc;
LZO_COMPRESS_T * const c = &cc;
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
int r;
/* sanity check */
LZO_COMPILE_TIME_ASSERT(LZO1B_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
c->init = 0;
c->ip = c->in = in;
c->in_end = in + in_len;
c->cb = cb;
c->r1_r = c->m3_r = c->m2_m = c->m3_m = 0;
op = out;
ii = c->ip; /* point to start of literal run */
lit = 0;
c->r1_m_len = 0;
r = init_match(c,swd,NULL,0,0);
if (r != 0)
return r;
if (max_chain > 0)
swd->max_chain = max_chain;
r = find_match(c,swd,0,0);
if (r != 0)
return r;
while (c->look > 0)
{
int lazy_match_min_gain = -1;
lzo_uint ahead = 0;
m_len = c->m_len;
m_off = c->m_off;
#if 0
printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look,
m_len, m_off);
#endif
assert(c->ip - c->look >= in);
if (lit == 0)
ii = c->ip - c->look;
assert(ii + lit == c->ip - c->look);
assert(swd->b_char == *(c->ip - c->look));
if ((m_len < M2_MIN_LEN) ||
(m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET))
{
m_len = 0;
}
else
{
assert(c->ip - c->look - m_off >= in);
assert(c->ip - c->look - m_off + m_len < c->ip);
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
if (lit > 0)
{
/* we have a current literal run: do not try a lazy match,
if the literal could be coded into a r1 match */
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
lazy_match_min_gain = -1;
else
lazy_match_min_gain = 1;
#if (M2_MIN_LEN == 2)
if (m_len == 2)
{
/* don't code a match of len 2 if we have to
code a literal run. Code a literal instead. */
m_len = 0;
}
#endif
#if (M2_MIN_LEN == M3_MIN_LEN)
if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET)
{
/* don't code a M3 match of len 3 if we have to
code a literal run. Code a literal instead. */
m_len = 0;
}
#endif
}
else
{
/* no current literal run: only try a lazy match,
if the literal could be coded into a r1 match */
if (c->r1_m_len == M2_MIN_LEN)
lazy_match_min_gain = 0;
else
lazy_match_min_gain = -1;
}
}
/* try a lazy match */
if (m_len == 0)
lazy_match_min_gain = -1;
if (lazy_match_min_gain >= 0 && c->look > m_len)
{
assert(m_len > 0);
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
assert(c->look > 0);
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
c->m_off > M2_MAX_OFFSET)
lazy_match_min_gain += 1;
if (c->m_len >= m_len + lazy_match_min_gain)
{
c->lazy++;
#if !defined(NDEBUG)
m_len = c->m_len;
m_off = c->m_off;
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
#endif
lit++;
assert(ii + lit == c->ip - c->look);
continue;
}
else
{
ahead = 1;
assert(ii + lit + 1 == c->ip - c->look);
}
assert(m_len > 0);
}
assert(ii + lit + ahead == c->ip - c->look);
if (m_len == 0)
{
/* a literal */
lit++;
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
}
else
{
/* 1 - store run */
if (lit > 0)
{
/* code current literal run */
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
{
/* Code a context sensitive R1 match. */
assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS));
op[-2] &= M2O_MASK;
assert((op[-2] >> M2O_BITS) == 0);
/* copy 1 literal */
*op++ = *ii++;
assert(ii + ahead == c->ip - c->look);
c->r1_r++;
}
else
{
op = STORE_RUN(op,ii,lit);
}
if (lit < R0FAST)
c->r1_m_len = m_len;
else
c->r1_m_len = 0;
lit = 0;
}
else
c->r1_m_len = 0;
/* 2 - code match */
op = code_match(c,op,m_len,m_off);
r = find_match(c,swd,m_len,1+ahead);
assert(r == 0); LZO_UNUSED(r);
}
c->codesize = pd(op, out);
}
/* store final run */
if (lit > 0)
op = STORE_RUN(op,ii,lit);
#if defined(LZO_EOF_CODE)
*op++ = M3_MARKER | 1;
*op++ = 0;
*op++ = 0;
#endif
c->codesize = pd(op, out);
assert(c->textsize == in_len);
*out_len = pd(op, out);
if (c->cb && c->cb->nprogress)
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
#if 0
printf("%ld %ld -> %ld: %ld %ld %ld %ld %ld\n",
(long) c->textsize, (long)in_len, (long) c->codesize,
c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy);
#endif
return LZO_E_OK;
}
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
lzo1b_999_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return lzo1b_999_compress_callback(in,in_len,out,out_len,wrkmem,
(lzo_callback_p) 0, 0);
}
/* vim:set ts=4 sw=4 et: */

262
vendor/lzo-2.10/src/lzo1b_c.ch vendored Normal file
View File

@@ -0,0 +1,262 @@
/* lzo1b_c.ch -- implementation of the LZO1B compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
/***********************************************************************
//
************************************************************************/
#if !defined(LZO_HAVE_R1) && !defined(LZO_NO_R1)
# define LZO_HAVE_R1 1
#endif
#if !defined(LZO_HAVE_M3) && !defined(LZO_NO_M3)
# if (M3O_BITS < 8)
# define LZO_HAVE_M3 1
# endif
#endif
#define MI /*empty*/
#define SI MI
#if (DD_BITS > 0)
#define DI ++ii; DVAL_NEXT(dv,ii); UPDATE_D(dict,drun,dv,ii,in); MI
#define XI assert(ii < ip); ii = ip; DVAL_FIRST(dv,(ip));
#else
#define DI ++ii; DINDEX1(dindex,ii); UPDATE_I(dict,0,dindex,ii,in); MI
#define XI assert(ii < ip); ii = ip;
#endif
/***********************************************************************
// compress a block of data.
//
// I really apologize for this spaghetti code.
************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
LZO_PRIVATE(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 (DD_BITS > 0)
#if defined(__LZO_HASH_INCREMENTAL)
lzo_xint dv;
#endif
unsigned drun = 0;
#endif
lzo_bytep op;
const lzo_bytep const in_end = in + in_len;
const lzo_bytep const ip_end = in + in_len - MIN_LOOKAHEAD;
const lzo_bytep ii;
#if defined(LZO_HAVE_R1)
const lzo_bytep r1 = ip_end; /* pointer for R1 match (none yet) */
#endif
#if defined(LZO_HAVE_M3)
lzo_bytep m3 = out + 1; /* pointer after last m3/m4 match */
#endif
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
#if (LZO_COLLECT_STATS)
lzo_stats->r_bits = R_BITS;
lzo_stats->m3o_bits = M3O_BITS;
lzo_stats->dd_bits = DD_BITS;
lzo_stats->clevel = CLEVEL;
lzo_stats->d_bits = D_BITS;
lzo_stats->min_lookahead = MIN_LOOKAHEAD;
lzo_stats->max_lookbehind = MAX_LOOKBEHIND;
lzo_stats->compress_id = LZO_PP_MACRO_EXPAND(COMPRESS_ID);
#endif
/* init dictionary */
#if (LZO_DETERMINISTIC)
BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
#endif
op = out;
ip = in;
ii = ip; /* point to start of current literal run */
#if (DD_BITS > 0)
DVAL_FIRST(dv,ip);
UPDATE_D(dict,drun,dv,ip,in);
ip++;
DVAL_NEXT(dv,ip);
#else
ip++;
#endif
assert(ip < ip_end);
for (;;)
{
const lzo_bytep m_pos;
#if !defined(NDEBUG)
const lzo_bytep m_pos_sav = NULL;
#endif
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
#if (DD_BITS == 0)
lzo_uint dindex;
#endif
lzo_uint m_len;
/***********************************************************************
// search for a match
************************************************************************/
#if !defined(LZO_SEARCH_MATCH_INCLUDE_FILE)
# define LZO_SEARCH_MATCH_INCLUDE_FILE "lzo1b_sm.ch"
#endif
#include LZO_SEARCH_MATCH_INCLUDE_FILE
#if !defined(LZO_TEST_MATCH_INCLUDE_FILE)
# define LZO_TEST_MATCH_INCLUDE_FILE "lzo1b_tm.ch"
#endif
#include LZO_TEST_MATCH_INCLUDE_FILE
/***********************************************************************
// found a literal
************************************************************************/
/* a literal */
literal:
#if (DD_BITS == 0)
UPDATE_I(dict,0,dindex,ip,in);
#endif
if (++ip >= ip_end)
break;
#if (DD_BITS > 0)
DVAL_NEXT(dv,ip);
#endif
continue;
/***********************************************************************
// found a match
************************************************************************/
match:
#if (DD_BITS == 0)
UPDATE_I(dict,0,dindex,ip,in);
#endif
/* we have found a match of at least M2_MIN_LEN */
#if !defined(LZO_CODE_RUN_INCLUDE_FILE)
# define LZO_CODE_RUN_INCLUDE_FILE "lzo1b_cr.ch"
#endif
#include LZO_CODE_RUN_INCLUDE_FILE
/* ii now points to the start of the current match */
assert(ii == ip);
/***********************************************************************
// code the match
************************************************************************/
#if !defined(LZO_CODE_MATCH_INCLUDE_FILE)
# define LZO_CODE_MATCH_INCLUDE_FILE "lzo1b_cm.ch"
#endif
#include LZO_CODE_MATCH_INCLUDE_FILE
/* ii now points to the start of the next literal run */
assert(ii == ip);
}
/***********************************************************************
// end of block
************************************************************************/
assert(ip <= in_end);
#if (LZO_COLLECT_STATS)
{
lzo_uint i;
const lzo_bytep p;
for (i = 0; i < D_SIZE; i++)
{
p = dict[i];
if (BOUNDS_CHECKING_OFF_IN_EXPR(p == NULL || p < in || p > in_end))
lzo_stats->unused_dict_entries++;
}
lzo_stats->unused_dict_entries_percent =
100.0 * lzo_stats->unused_dict_entries / D_SIZE;
}
#endif
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
/* return if op == out to indicate that we
* couldn't compress and didn't copy anything.
*/
if (op == out)
{
*out_len = 0;
return LZO_E_NOT_COMPRESSIBLE;
}
#endif
/* store the final literal run */
if (pd(in_end,ii) > 0)
{
lzo_uint t = pd(in_end,ii);
op = STORE_RUN(op,ii,t);
}
*out_len = pd(op, out);
return LZO_E_OK; /* compression went ok */
}
#ifdef __cplusplus
} /* extern "C" */
#endif
/* vim:set ts=4 sw=4 et: */

153
vendor/lzo-2.10/src/lzo1b_cc.c vendored Normal file
View File

@@ -0,0 +1,153 @@
/* lzo1b_cc.c -- LZO1B compression internal entry point
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define LZO_NEED_DICT_H 1
#include "config1b.h"
/***********************************************************************
// compression internal entry point.
************************************************************************/
LZO_LOCAL_IMPL(int)
_lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_compress_t func )
{
int r;
#if defined(LZO_TEST_COMPRESS_OVERRUN)
lzo_uint avail_out = *out_len;
#endif
#if (LZO_COLLECT_STATS)
_lzo1b_stats_init(lzo_stats);
lzo_stats->in_len = in_len;
#endif
/* don't try to compress a block that's too short */
if (in_len == 0)
{
*out_len = 0;
r = LZO_E_OK;
}
else if (in_len <= MIN_LOOKAHEAD + 1)
{
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
*out_len = 0;
r = LZO_E_NOT_COMPRESSIBLE;
#else
*out_len = pd(STORE_RUN(out,in,in_len), out);
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
#endif
}
else
r = func(in,in_len,out,out_len,wrkmem);
#if defined(LZO_EOF_CODE)
#if defined(LZO_TEST_COMPRESS_OVERRUN)
if (r == LZO_E_OK && avail_out - *out_len < 3)
r = LZO_E_COMPRESS_OVERRUN;
#endif
if (r == LZO_E_OK)
{
lzo_bytep op = out + *out_len;
op[0] = M3_MARKER | 1;
op[1] = 0;
op[2] = 0;
*out_len += 3;
}
#endif
#if (LZO_COLLECT_STATS)
lzo_stats->out_len = *out_len;
lzo_stats->match_bytes =
1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches +
3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches;
_lzo1b_stats_calc(lzo_stats);
#endif
return r;
}
/***********************************************************************
// note: this is not thread safe, but as it is used for finetuning only
// we don't care
************************************************************************/
#undef lzo_stats
/* lzo_stats_t is still defined */
#if (LZO_COLLECT_STATS)
static lzo_stats_t lzo_statistics;
lzo_stats_t * const lzo1b_stats = &lzo_statistics;
void _lzo1b_stats_init(lzo_stats_t *lzo_stats)
{
lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
}
void _lzo1b_stats_calc(lzo_stats_t *lzo_stats)
{
lzo_stats->matches =
lzo_stats->m1_matches + lzo_stats->m2_matches +
lzo_stats->m3_matches + lzo_stats->m4_matches;
lzo_stats->literal_overhead = lzo_stats->lit_runs +
2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs +
lzo_stats->r0long_runs);
lzo_stats->literal_bytes = lzo_stats->literals +
lzo_stats->literal_overhead;
#if 0
assert(lzo_stats->match_bytes + lzo_stats->literal_bytes ==
lzo_stats->out_len);
#endif
lzo_stats->m2_matches -= lzo_stats->r1_matches;
lzo_stats->m2_match[M2_MIN_LEN] -= lzo_stats->r1_matches;
if (lzo_stats->literals > 0)
lzo_stats->literal_overhead_percent =
100.0 * lzo_stats->literal_overhead / lzo_stats->literals;
}
#endif
/* vim:set ts=4 sw=4 et: */

77
vendor/lzo-2.10/src/lzo1b_cc.h vendored Normal file
View File

@@ -0,0 +1,77 @@
/* lzo1b_cc.h -- definitions for the the LZO1B compression driver
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO1B_CC_H
#define __LZO1B_CC_H 1
/***********************************************************************
//
************************************************************************/
extern const lzo_compress_t _lzo1b_1_compress_func;
extern const lzo_compress_t _lzo1b_2_compress_func;
extern const lzo_compress_t _lzo1b_3_compress_func;
extern const lzo_compress_t _lzo1b_4_compress_func;
extern const lzo_compress_t _lzo1b_5_compress_func;
extern const lzo_compress_t _lzo1b_6_compress_func;
extern const lzo_compress_t _lzo1b_7_compress_func;
extern const lzo_compress_t _lzo1b_8_compress_func;
extern const lzo_compress_t _lzo1b_9_compress_func;
extern const lzo_compress_t _lzo1b_99_compress_func;
/***********************************************************************
//
************************************************************************/
LZO_LOCAL_DECL(lzo_bytep )
_lzo1b_store_run ( lzo_bytep const oo, const lzo_bytep const ii,
lzo_uint r_len);
#define STORE_RUN _lzo1b_store_run
LZO_LOCAL_DECL(int)
_lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_compress_t func );
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

280
vendor/lzo-2.10/src/lzo1b_cm.ch vendored Normal file
View File

@@ -0,0 +1,280 @@
/* lzo1b_cm.ch -- implementation of the LZO1B compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
/***********************************************************************
// code the match
************************************************************************/
#if (DD_BITS == 0)
/* we already matched M2_MIN_LEN bytes,
* m_pos also already advanced M2_MIN_LEN bytes */
ip += M2_MIN_LEN;
assert(m_pos < ip);
/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
* to see if we get more than a M2 match */
#define M2_OR_M3 (MATCH_M2)
#else /* (DD_BITS == 0) */
/* we already matched m_len bytes */
assert(m_len >= M2_MIN_LEN);
ip += m_len;
assert(ip <= in_end);
#define M2_OR_M3 (m_len <= M2_MAX_LEN)
#endif /* (DD_BITS == 0) */
if (M2_OR_M3)
{
/* we've found a M2 or M3 match */
assert(ip <= in_end);
/* 2a) compute match parameters */
#if (DD_BITS == 0)
assert(pd(ip,m_pos) == m_off);
--ip; /* ran one too far, point back to non-match */
m_len = pd(ip, ii);
#endif
/* 2a2) verify match parameters */
assert(m_len >= M2_MIN_LEN);
assert(m_len <= M2_MAX_LEN);
assert(m_len <= M3_MAX_LEN);
assert(m_off >= M2_MIN_OFFSET);
assert(m_off >= M3_MIN_OFFSET);
assert(m_off <= M3_MAX_OFFSET);
assert(ii-m_off == m_pos_sav);
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
/* 2b) code the match */
#if (_M2_MAX_OFFSET != _M3_MAX_OFFSET)
if (m_off <= M2_MAX_OFFSET)
{
#else
assert(m_off <= M2_MAX_OFFSET);
#endif
m_off -= M2_MIN_OFFSET;
/* code match len + low offset bits */
*op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) |
(m_off & M2O_MASK));
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M2O_BITS);
LZO_STATS(lzo_stats->m2_matches++);
LZO_STATS(lzo_stats->m2_match[m_len]++);
#if (_M2_MAX_OFFSET != _M3_MAX_OFFSET)
}
else
{
#if defined(LZO_HAVE_R1)
#if (M3_MIN_LEN == M2_MIN_LEN)
r1 = ip_end; /* invalidate R1 pointer */
#endif
#endif
assert(m_len >= M3_MIN_LEN);
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
/* code match len */
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
/* code low offset bits */
*op++ = LZO_BYTE(m_off & M3O_MASK);
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M3O_BITS);
LZO_STATS(lzo_stats->m3_matches++);
LZO_STATS(lzo_stats->m3_match[m_len]++);
#if defined(LZO_HAVE_M3)
m3 = op; /* set M3 pointer */
#endif
}
#endif /* (_M2_MAX_OFFSET != _M3_MAX_OFFSET) */
if (ip >= ip_end)
{
ii = ip;
break;
}
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
#if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3)
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
++ii;
do {
DVAL_NEXT(dv,ii);
#if 0
UPDATE_D(dict,drun,dv,ii,in);
#else
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
#endif
MI
} 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 M3 or M4 match - see how far we can still go */
assert(ip <= in_end);
assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0);
/* 2a) compute match parameters */
#if !defined(MATCH_IP_END)
assert(ii == ip - (M2_MAX_LEN + 1));
#if (DD_BITS > 0)
assert(m_len == (lzo_uint)(ip-ii));
m_pos = ip - m_off;
assert(m_pos == m_pos_sav + m_len);
#endif
{
const lzo_bytep end;
end = in_end;
while (ip < end && *m_pos == *ip)
{ m_pos++; ip++; }
assert(ip <= in_end);
m_len = pd(ip, ii);
}
assert(pd(ip,m_pos) == m_off);
#endif
/* 2a2) verify match parameters */
assert(m_len >= M3_MIN_LEN);
assert(m_off >= M3_MIN_OFFSET);
assert(m_off >= M4_MIN_OFFSET);
assert(m_off <= M3_MAX_OFFSET);
assert(m_off <= M4_MAX_OFFSET);
assert(ii-m_off == m_pos_sav);
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
/* 2b) code the match */
if (m_len <= M3_MAX_LEN)
{
/* code match len */
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
LZO_STATS(lzo_stats->m3_matches++);
LZO_STATS(lzo_stats->m3_match[m_len]++);
}
else
{
assert(m_len >= M4_MIN_LEN);
/* code M4 match len flag */
*op++ = M4_MARKER;
/* code match len */
m_len -= M4_MIN_LEN - 1;
while (m_len > 255)
{
m_len -= 255;
*op++ = 0;
}
assert(m_len > 0);
*op++ = LZO_BYTE(m_len);
LZO_STATS(lzo_stats->m4_matches++);
}
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
/* code low offset bits */
*op++ = LZO_BYTE(m_off & M3O_MASK);
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M3O_BITS);
#if defined(LZO_HAVE_M3)
m3 = op; /* set M3 pointer */
#endif
if (ip >= ip_end)
{
ii = ip;
break;
}
/* 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 can be slow. */
++ii;
do {
DVAL_NEXT(dv,ii);
#if 0
UPDATE_D(dict,drun,dv,ii,in);
#else
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
#endif
MI
} 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 the next literal run */
assert(ii == ip);
/* vim:set ts=4 sw=4 et: */

112
vendor/lzo-2.10/src/lzo1b_cr.ch vendored Normal file
View File

@@ -0,0 +1,112 @@
/* lzo1b_cr.ch -- implementation of the LZO1B compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
/***********************************************************************
// store the current literal run
************************************************************************/
assert(ip < ip_end);
if (pd(ip,ii) > 0)
{
lzo_uint t = pd(ip,ii);
#if defined(LZO_HAVE_R1)
if (ip == r1)
{
/* Code a context sensitive R1 match. */
LZO_STATS(lzo_stats->literals += t);
LZO_STATS(lzo_stats->r1_matches++);
assert(t == 1);
/* modify marker byte */
assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS));
op[-2] &= M2O_MASK;
assert((op[-2] >> M2O_BITS) == 0);
/* copy 1 literal */
*op++ = *ii++;
r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */
}
else
#endif
if (t < R0MIN)
{
/* inline the copying of a short run */
LZO_STATS(lzo_stats->literals += t);
LZO_STATS(lzo_stats->lit_runs++);
LZO_STATS(lzo_stats->lit_run[t]++);
#if defined(LZO_HAVE_M3)
if (t < LZO_SIZE(8-M3O_BITS) && op == m3)
{
/* Code a very short literal run into the low offset bits
* of the previous M3/M4 match.
*/
LZO_STATS(lzo_stats->lit_runs_after_m3_match++);
LZO_STATS(lzo_stats->lit_run_after_m3_match[t]++);
assert((m3[-2] >> M3O_BITS) == 0);
m3[-2] = LZO_BYTE(m3[-2] | (t << M3O_BITS));
}
else
#endif
{
*op++ = LZO_BYTE(t);
}
MEMCPY_DS(op, ii, t);
#if defined(LZO_HAVE_R1)
r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */
#endif
}
else if (t < R0FAST)
{
/* inline the copying of a short R0 run */
LZO_STATS(lzo_stats->literals += t);
LZO_STATS(lzo_stats->r0short_runs++);
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
MEMCPY_DS(op, ii, t);
#if defined(LZO_HAVE_R1)
r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */
#endif
}
else
{
op = STORE_RUN(op,ii,t);
ii = ip;
}
}
/* ii now points to the start of the current match */
assert(ii == ip);
/* vim:set ts=4 sw=4 et: */

268
vendor/lzo-2.10/src/lzo1b_d.ch vendored Normal file
View File

@@ -0,0 +1,268 @@
/* lzo1b_d.ch -- implementation of the LZO1B decompression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo1_d.ch"
/***********************************************************************
// decompress a block of data.
************************************************************************/
LZO_PUBLIC(int)
DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
lzo_bytep op;
const lzo_bytep ip;
lzo_uint t;
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_AND_TEST_OP)
{
t = *ip++; /* get marker */
if (t < R0MIN) /* a literal run */
{
if (t == 0) /* a R0 literal run */
{
NEED_IP(1);
t = *ip++;
if (t >= R0FAST - R0MIN) /* a long R0 run */
{
t -= R0FAST - R0MIN;
if (t == 0)
t = R0FAST;
else
{
#if 0
t = 256u << ((unsigned) t);
#else
/* help the optimizer */
lzo_uint tt = 256;
do tt <<= 1; while (--t > 0);
t = tt;
#endif
}
NEED_IP(t); NEED_OP(t);
#if 1 && (LZO_OPT_UNALIGNED32)
do {
UA_COPY4(op+0, ip+0);
UA_COPY4(op+4, ip+4);
op += 8; ip += 8;
t -= 8;
} while (t > 0);
#else
MEMCPY8_DS(op,ip,t);
#endif
continue;
}
t += R0MIN; /* a short R0 run */
}
NEED_IP(t); NEED_OP(t);
/* copy literal run */
#if 1 && (LZO_OPT_UNALIGNED32)
if (t >= 4)
{
do {
UA_COPY4(op, 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
/* after a literal a match must follow */
while (TEST_IP_AND_TEST_OP)
{
t = *ip++; /* get R1 marker */
if (t >= R0MIN)
goto match;
NEED_IP(2); NEED_OP(M2_MIN_LEN + 1);
/* R1 match - a M2_MIN_LEN match + 1 byte literal */
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) /* a M2 match */
{
/* get match offset */
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);
/* get match len */
t = (t >> M2O_BITS) - 1;
NEED_OP(t + M2_MIN_LEN - 1);
COPY_M2X;
MEMCPY_DS(op,m_pos,t);
}
else /* a M3 or M4 match */
{
/* get match len */
t &= M3L_MASK;
if (t == 0) /* a M4 match */
{
NEED_IP(1);
while (*ip == 0)
{
t += 255;
ip++;
TEST_OV(t);
NEED_IP(1);
}
t += (M4_MIN_LEN - M3_MIN_LEN) + *ip++;
}
/* get match offset */
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
/* copy match */
assert(m_pos >= out); assert(m_pos < op);
TEST_LB(m_pos); NEED_OP(t + M3_MIN_LEN - 1);
#if (LZO_OPT_UNALIGNED32)
if (t >= 2 * 4 - (M3_MIN_LEN - 1) && (op - m_pos) >= 4)
{
UA_COPY4(op, m_pos);
op += 4; m_pos += 4; t -= 4 - (M3_MIN_LEN - 1);
do {
UA_COPY4(op, 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)
/* optimized version */
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)
/* no EOF code was found */
*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
}
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1b_d1.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1b_d1.c -- LZO1B decompression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1b.h"
#undef LZO_TEST_OVERRUN
#define DO_DECOMPRESS lzo1b_decompress
#include "lzo1b_d.ch"
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1b_d2.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1b_d2.c -- LZO1B decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1b.h"
#define LZO_TEST_OVERRUN 1
#define DO_DECOMPRESS lzo1b_decompress_safe
#include "lzo1b_d.ch"
/* vim:set ts=4 sw=4 et: */

330
vendor/lzo-2.10/src/lzo1b_de.h vendored Normal file
View File

@@ -0,0 +1,330 @@
/* lzo1b_de.h -- definitions for the the LZO1B/LZO1C algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_DEFS_H
#define __LZO_DEFS_H 1
#ifdef __cplusplus
extern "C" {
#endif
/***********************************************************************
//
************************************************************************/
/*
Format of the marker byte
76543210
--------
00000000 R0 - a long literal run ('R0' run)
000rrrrr R - a short literal run with len r
00100000 M4 - a very long match
001mmmmm M3 - a long match (len = m+M3_MIN_LEN)
mmmooooo M2 - a short match (len = m+M2_MIN_LEN, o = offset low bits)
M1 is not used !
*/
#ifndef R_BITS
#define R_BITS (5)
#endif
#ifndef M1L_BITS
#define M1L_BITS (0)
#endif
#ifndef M2L_BITS
#define M2L_BITS (CHAR_BIT - M2O_BITS)
#endif
#ifndef M3L_BITS
#define M3L_BITS (R_BITS)
#endif
#ifndef M4L_BITS
#define M4L_BITS (CHAR_BIT)
#endif
#ifndef M1O_BITS
#define M1O_BITS (6)
#endif
#ifndef M2O_BITS
#define M2O_BITS (R_BITS)
#endif
#ifndef M3O_BITS
#define M3O_BITS (CHAR_BIT)
#endif
#ifndef M4O_BITS
#define M4O_BITS (M3O_BITS) /* must be the same */
#endif
#ifndef M1X_BITS
#define M1X_BITS (M1O_BITS)
#endif
#ifndef M2X_BITS
#define M2X_BITS (M2O_BITS + CHAR_BIT)
#endif
#ifndef M3X_BITS
#define M3X_BITS (M3O_BITS + CHAR_BIT)
#endif
#ifndef M4X_BITS
#define M4X_BITS M3X_BITS
#endif
#define __MIN_OFFSET(bits) 1
#define __MAX_OFFSET(bits) LZO_SIZE(bits)
#define M1_MIN_OFFSET __MIN_OFFSET(M1X_BITS)
#define M2_MIN_OFFSET __MIN_OFFSET(M2X_BITS)
#define M3_MIN_OFFSET __MIN_OFFSET(M3X_BITS)
#define M4_MIN_OFFSET M3_MIN_OFFSET
#if defined(LZO_EOF_CODE) && !defined(M3_EOF_OFFSET)
#define M3_EOF_OFFSET 1
#else
#define M3_EOF_OFFSET 0
#endif
#ifndef _M1_MAX_OFFSET
#define _M1_MAX_OFFSET __MAX_OFFSET(M1X_BITS)
#endif
#ifndef _M2_MAX_OFFSET
#define _M2_MAX_OFFSET __MAX_OFFSET(M2X_BITS)
#endif
#ifndef _M3_MAX_OFFSET
#define _M3_MAX_OFFSET (__MAX_OFFSET(M3X_BITS) - M3_EOF_OFFSET)
#endif
#ifndef _M4_MAX_OFFSET
#define _M4_MAX_OFFSET _M3_MAX_OFFSET
#endif
#ifndef _MAX_OFFSET
#define _MAX_OFFSET _M4_MAX_OFFSET
#endif
#if (M3_EOF_OFFSET > 0) && (_M2_MAX_OFFSET == _M3_MAX_OFFSET + M3_EOF_OFFSET)
# undef _M2_MAX_OFFSET
# define _M2_MAX_OFFSET _M3_MAX_OFFSET
#endif
#if (_M2_MAX_OFFSET > _M3_MAX_OFFSET)
# error
#endif
#define M1_MAX_OFFSET ((lzo_uint) _M1_MAX_OFFSET)
#define M2_MAX_OFFSET ((lzo_uint) _M2_MAX_OFFSET)
#define M3_MAX_OFFSET ((lzo_uint) _M3_MAX_OFFSET)
#define M4_MAX_OFFSET ((lzo_uint) _M4_MAX_OFFSET)
#define MAX_OFFSET ((lzo_uint) _MAX_OFFSET)
#ifndef M1_MIN_LEN
#define M1_MIN_LEN (2)
#endif
#ifndef M2_MIN_LEN
#define M2_MIN_LEN (3)
#endif
#ifndef M3_MIN_LEN
#if (M3X_BITS == M2X_BITS)
#define M3_MIN_LEN (M2_MAX_LEN + 1)
#else
#define M3_MIN_LEN (4)
#endif
#endif
#ifndef M4_MIN_LEN
#define M4_MIN_LEN (M3_MAX_LEN + 1)
#endif
#ifndef M1_MAX_LEN
#define M1_MAX_LEN (M1_MIN_LEN + LZO_SIZE(M1L_BITS) - 1)
#endif
#ifndef M2_MAX_LEN
#define M2_MAX_LEN (M2_MIN_LEN + LZO_SIZE(M2L_BITS) - 3)
#endif
#ifndef M3_MAX_LEN
#define M3_MAX_LEN (M3_MIN_LEN + LZO_SIZE(M3L_BITS) - 2)
#endif
#ifndef M4_MAX_LEN
#define M4_MAX_LEN (ULONG_MAX)
#endif
#define M1O_MASK LZO_MASK(M1O_BITS)
#define M1L_MASK LZO_MASK(M1L_BITS)
#define M2O_MASK LZO_MASK(M2O_BITS)
#define M2L_MASK LZO_MASK(M2L_BITS)
#define M3O_MASK LZO_MASK(M3O_BITS)
#define M3L_MASK LZO_MASK(M3L_BITS)
#define M4O_MASK LZO_MASK(M4O_BITS)
#define M4L_MASK LZO_MASK(M4L_BITS)
#define M1_MARKER (1 << M1O_BITS)
#define M2_MARKER (2 << M2O_BITS)
#define M3_MARKER (1 << M3L_BITS)
#define M4_MARKER M3_MARKER
/***********************************************************************
// R0 literal run (a long run)
************************************************************************/
#ifndef R0MIN
#define R0MIN (LZO_SIZE(R_BITS)) /* Minimum len of R0 run of literals */
#endif
#define R0MAX (R0MIN + 256 - 1) /* Maximum len of R0 run of literals */
#if (R0MAX - (R0MAX & ~7u) >= 7)
#define R0FAST (R0MAX & ~7u) /* R0MAX aligned to 8 byte boundary */
#else
#define R0FAST (R0MAX & ~15u) /* R0MAX aligned to 8 byte boundary */
#endif
#if (R0MAX - R0FAST < 7) || ((R0FAST & 7) != 0)
# error "something went wrong"
#endif
#if (R0FAST * 2 < 512)
# error "R0FAST is not big enough"
#endif
/* 7 special codes from R0FAST+1 .. R0MAX
* these codes mean long R0 runs with lengths
* 512, 1024, 2048, 4096, 8192, 16384, 32768
*/
/***********************************************************************
// matching
************************************************************************/
#define PS *m_pos++ != *ip++
/* We already matched M2_MIN_LEN bytes.
* Try to match another M2_MAX_LEN - M2_MIN_LEN bytes. */
#if (M2_MAX_LEN - M2_MIN_LEN == 4)
# define MATCH_M2X (PS || PS || PS || PS)
#elif (M2_MAX_LEN - M2_MIN_LEN == 5)
# define MATCH_M2X (PS || PS || PS || PS || PS)
#elif (M2_MAX_LEN - M2_MIN_LEN == 6)
# define MATCH_M2X (PS || PS || PS || PS || PS || PS)
#elif (M2_MAX_LEN - M2_MIN_LEN == 7)
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS)
#elif (M2_MAX_LEN - M2_MIN_LEN == 13)
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS || PS || \
PS || PS || PS || PS || PS)
#elif (M2_MAX_LEN - M2_MIN_LEN == 14)
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS || PS || \
PS || PS || PS || PS || PS || PS)
#elif (M2_MAX_LEN - M2_MIN_LEN == 16)
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS || PS || \
PS || PS || PS || PS || PS || PS || PS || PS)
#elif (M2_MAX_LEN - M2_MIN_LEN == 29)
# define MATCH_M2X (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 "MATCH_M2X not yet implemented"
#endif
/* We already matched M2_MIN_LEN bytes.
* Try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
* to see if we get more than a M2 match */
#define MATCH_M2 (MATCH_M2X || PS)
/***********************************************************************
// copying
************************************************************************/
#define _CP *op++ = *m_pos++
#if (M2_MIN_LEN == 2)
# define COPY_M2X _CP
#elif (M2_MIN_LEN == 3)
# define COPY_M2X _CP; _CP
#elif (M2_MIN_LEN == 4)
# define COPY_M2X _CP; _CP; _CP
#else
# error "COPY_M2X not yet implemented"
#endif
#if (M3_MIN_LEN == 3)
# define COPY_M3X _CP; _CP
#elif (M3_MIN_LEN == 4)
# define COPY_M3X _CP; _CP; _CP
#elif (M3_MIN_LEN == 9)
# define COPY_M3X _CP; _CP; _CP; _CP; _CP; _CP; _CP; _CP
#else
# error "COPY_M3X not yet implemented"
#endif
#define COPY_M2 COPY_M2X; *op++ = *m_pos++
#define COPY_M3 COPY_M3X; *op++ = *m_pos++
/***********************************************************************
//
************************************************************************/
#if defined(LZO_NEED_DICT_H)
#define DL_MIN_LEN M2_MIN_LEN
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
#include "lzo_dict.h"
#ifndef MIN_LOOKAHEAD
#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
#endif
#ifndef MAX_LOOKBEHIND
#define MAX_LOOKBEHIND (MAX_OFFSET)
#endif
#endif /* defined(LZO_NEED_DICT_H) */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

102
vendor/lzo-2.10/src/lzo1b_r.ch vendored Normal file
View File

@@ -0,0 +1,102 @@
/* lzo1b_r.ch -- literal run handling for the the LZO1B/LZO1C algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
/***********************************************************************
// store a literal run (internal)
************************************************************************/
LZO_LOCAL_IMPL(lzo_bytep )
STORE_RUN ( lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
{
lzo_bytep op;
const lzo_bytep ip;
lzo_uint t;
LZO_STATS(lzo_stats->literals += r_len);
op = oo;
ip = ii;
assert(r_len > 0);
/* code a long R0 run */
if (r_len >= 512)
{
unsigned r_bits = 6; /* 256 << 6 == 16384 */
lzo_uint tt = 32768u;
while (r_len >= (t = tt))
{
r_len -= t;
*op++ = 0; *op++ = (R0FAST - R0MIN) + 7;
MEMCPY8_DS(op, ip, t);
LZO_STATS(lzo_stats->r0long_runs++);
}
tt >>= 1;
do {
if (r_len >= (t = tt))
{
r_len -= t;
*op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
MEMCPY8_DS(op, ip, t);
LZO_STATS(lzo_stats->r0long_runs++);
}
tt >>= 1;
} while (--r_bits > 0);
}
assert(r_len < 512);
while (r_len >= (t = R0FAST))
{
r_len -= t;
*op++ = 0; *op++ = (R0FAST - R0MIN);
MEMCPY8_DS(op, ip, t);
LZO_STATS(lzo_stats->r0fast_runs++);
}
t = r_len;
if (t >= R0MIN)
{
/* code a short R0 run */
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
MEMCPY_DS(op, ip, t);
LZO_STATS(lzo_stats->r0short_runs++);
}
else if (t > 0)
{
/* code a short literal run */
LZO_STATS(lzo_stats->lit_runs++);
LZO_STATS(lzo_stats->lit_run[t]++);
*op++ = LZO_BYTE(t);
MEMCPY_DS(op, ip, t);
}
return op;
}
/* vim:set ts=4 sw=4 et: */

33
vendor/lzo-2.10/src/lzo1b_rr.c vendored Normal file
View File

@@ -0,0 +1,33 @@
/* lzo1b_rr.c -- literal run handling
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1b.h"
#include "lzo1b_r.ch"
/* vim:set ts=4 sw=4 et: */

196
vendor/lzo-2.10/src/lzo1b_sm.ch vendored Normal file
View File

@@ -0,0 +1,196 @@
/* lzo1b_sm.ch -- implementation of the LZO1B compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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: */

84
vendor/lzo-2.10/src/lzo1b_tm.ch vendored Normal file
View File

@@ -0,0 +1,84 @@
/* lzo1b_tm.ch -- implementation of the LZO1B compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
/***********************************************************************
// test for a potential match
************************************************************************/
#if (DD_BITS == 0)
try_match:
#if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
#if (LZO_DETERMINISTIC)
assert(m_pos == NULL || m_pos >= in);
assert(m_pos == NULL || m_pos < ip);
#endif
m_pos_sav = m_pos;
#endif
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
{
m_pos += 3;
goto match;
}
#else /* (DD_BITS == 0) */
/* test potential match */
if (m_len > M2_MIN_LEN)
goto match;
if (m_len == M2_MIN_LEN)
{
#if (_MAX_OFFSET == _M2_MAX_OFFSET)
goto match;
#else
if (m_off <= M2_MAX_OFFSET)
goto match;
#if 0 && (M3_MIN_LEN == M2_MIN_LEN)
if (ip == ii)
goto match;
#endif
#endif
}
goto literal;
#endif /* (DD_BITS == 0) */
/* vim:set ts=4 sw=4 et: */

82
vendor/lzo-2.10/src/lzo1b_xx.c vendored Normal file
View File

@@ -0,0 +1,82 @@
/* lzo1b_xx.c -- LZO1B compression public entry point
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1b.h"
/***********************************************************************
//
************************************************************************/
static const lzo_compress_t * const c_funcs [9] =
{
&_lzo1b_1_compress_func,
&_lzo1b_2_compress_func,
&_lzo1b_3_compress_func,
&_lzo1b_4_compress_func,
&_lzo1b_5_compress_func,
&_lzo1b_6_compress_func,
&_lzo1b_7_compress_func,
&_lzo1b_8_compress_func,
&_lzo1b_9_compress_func
};
static lzo_compress_t lzo1b_get_compress_func(int clevel)
{
const lzo_compress_t *f;
if (clevel < LZO1B_BEST_SPEED || clevel > LZO1B_BEST_COMPRESSION)
{
if (clevel == LZO1B_DEFAULT_COMPRESSION)
clevel = LZO1B_BEST_SPEED;
else
return (lzo_compress_t) 0;
}
f = c_funcs[clevel-1];
assert(f && *f);
return *f;
}
LZO_PUBLIC(int)
lzo1b_compress ( const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem,
int clevel )
{
lzo_compress_t f;
f = lzo1b_get_compress_func(clevel);
if (!f)
return LZO_E_ERROR;
return _lzo1b_do_compress(src,src_len,dst,dst_len,wrkmem,f);
}
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_1.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_1.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 1
#define DDBITS 0
#define CLEVEL 1
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_2.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_2.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 2
#define DDBITS 0
#define CLEVEL 2
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_3.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_3.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 3
#define DDBITS 0
#define CLEVEL 3
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_4.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_4.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 4
#define DDBITS 1
#define CLEVEL 2
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_5.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_5.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 5
#define DDBITS 1
#define CLEVEL 3
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_6.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_6.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 6
#define DDBITS 1
#define CLEVEL 5
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_7.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_7.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 7
#define DDBITS 2
#define CLEVEL 3
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_8.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_8.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 8
#define DDBITS 2
#define CLEVEL 8
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1c_9.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1c_9.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 9
#define DDBITS 2
#define CLEVEL 9
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

38
vendor/lzo-2.10/src/lzo1c_99.c vendored Normal file
View File

@@ -0,0 +1,38 @@
/* lzo1c_99.c -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define COMPRESS_ID 99
#define DDBITS 3
#define CLEVEL 9
#define D_BITS 16
#define MATCH_IP_END in_end
#include "compr1c.h"
/* vim:set ts=4 sw=4 et: */

364
vendor/lzo-2.10/src/lzo1c_9x.c vendored Normal file
View File

@@ -0,0 +1,364 @@
/* lzo1c_9x.c -- implementation of the LZO1C-999 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1c.h"
/***********************************************************************
//
************************************************************************/
#define SWD_N 16383 /* size of ring buffer */
#define SWD_THRESHOLD 2 /* lower limit for match length */
#define SWD_F 2048 /* upper limit for match length */
#define LZO1C 1
#define LZO_COMPRESS_T lzo1c_999_t
#define lzo_swd_t lzo1c_999_swd_t
#include "lzo_mchw.ch"
/***********************************************************************
//
************************************************************************/
static lzo_bytep
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
{
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
{
assert(m_len >= M2_MIN_LEN);
assert(m_off >= M2_MIN_OFFSET);
m_off -= M2_MIN_OFFSET;
/* code match len + low offset bits */
*op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) |
(m_off & M2O_MASK));
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M2O_BITS);
c->m2_m++;
}
else
{
assert(m_len >= M3_MIN_LEN);
assert(m_off <= M3_MAX_OFFSET);
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
/* code match len */
if (m_len <= M3_MAX_LEN)
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
else
{
assert(m_len >= M4_MIN_LEN);
/* code M4 match len flag */
*op++ = M4_MARKER;
/* code match len */
m_len -= M4_MIN_LEN - 1;
while (m_len > 255)
{
m_len -= 255;
*op++ = 0;
}
assert(m_len > 0);
*op++ = LZO_BYTE(m_len);
}
/* code low offset bits */
*op++ = LZO_BYTE(m_off & M3O_MASK);
/* code high offset bits */
*op++ = LZO_BYTE(m_off >> M3O_BITS);
c->r1_m_len = 0;
c->m3 = op;
c->m3_m++;
}
return op;
}
/***********************************************************************
// this is a public function, but there is no prototype in a header file
************************************************************************/
LZO_EXTERN(int)
lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain );
LZO_PUBLIC(int)
lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain )
{
lzo_bytep op;
const lzo_bytep ii;
lzo_uint lit;
lzo_uint m_len, m_off;
LZO_COMPRESS_T cc;
LZO_COMPRESS_T * const c = &cc;
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
int r;
/* sanity check */
LZO_COMPILE_TIME_ASSERT(LZO1C_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
c->init = 0;
c->ip = c->in = in;
c->in_end = in + in_len;
c->cb = cb;
c->r1_r = c->m3_r = c->m2_m = c->m3_m = 0;
op = out;
ii = c->ip; /* point to start of literal run */
lit = 0;
c->r1_m_len = 0;
c->m3 = out + 1; /* pointer after last m3/m4 match */
r = init_match(c,swd,NULL,0,0);
if (r != 0)
return r;
if (max_chain > 0)
swd->max_chain = max_chain;
r = find_match(c,swd,0,0);
if (r != 0)
return r;
while (c->look > 0)
{
int lazy_match_min_gain = -1;
lzo_uint ahead = 0;
m_len = c->m_len;
m_off = c->m_off;
#if 0
printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look,
m_len, m_off);
#endif
assert(c->ip - c->look >= in);
if (lit == 0)
ii = c->ip - c->look;
assert(ii + lit == c->ip - c->look);
assert(swd->b_char == *(c->ip - c->look));
if ((m_len < M2_MIN_LEN) ||
(m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET))
{
m_len = 0;
}
else
{
assert(c->ip - c->look - m_off >= in);
assert(c->ip - c->look - m_off + m_len < c->ip);
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
if (lit > 0)
{
/* we have a current literal run: do not try a lazy match,
if the literal could be coded into a r1 or m3 match */
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
lazy_match_min_gain = -1;
else if (lit == 3 && op == c->m3)
lazy_match_min_gain = -1;
else if (lit < 3 && op == c->m3)
lazy_match_min_gain = 0;
else
lazy_match_min_gain = 1;
#if (M2_MIN_LEN == 2)
if (m_len == 2)
{
/* don't code a match of len 2 if we have to
code a literal run. Code a literal instead. */
m_len = 0;
}
#endif
#if (M2_MIN_LEN == M3_MIN_LEN)
if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET)
{
/* don't code a M3 match of len 3 if we have to
code a literal run. Code a literal instead. */
m_len = 0;
}
#endif
}
else
{
/* no current literal run: only try a lazy match,
if the literal could be coded into a r1 or m3 match */
if (c->r1_m_len == M2_MIN_LEN || op == c->m3)
lazy_match_min_gain = 0;
else
lazy_match_min_gain = -1;
}
}
/* try a lazy match */
if (m_len == 0)
lazy_match_min_gain = -1;
if (lazy_match_min_gain >= 0 && c->look > m_len)
{
assert(m_len > 0);
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
assert(c->look > 0);
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
c->m_off > M2_MAX_OFFSET)
lazy_match_min_gain += 1;
if (c->m_len >= m_len + lazy_match_min_gain)
{
c->lazy++;
#if !defined(NDEBUG)
m_len = c->m_len;
m_off = c->m_off;
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
#endif
lit++;
assert(ii + lit == c->ip - c->look);
continue;
}
else
{
ahead = 1;
assert(ii + lit + 1 == c->ip - c->look);
}
assert(m_len > 0);
}
assert(ii + lit + ahead == c->ip - c->look);
if (m_len == 0)
{
/* a literal */
lit++;
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
}
else
{
/* 1 - store run */
if (lit > 0)
{
/* code current literal run */
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
{
/* Code a context sensitive R1 match. */
assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS));
op[-2] &= M2O_MASK;
assert((op[-2] >> M2O_BITS) == 0);
/* copy 1 literal */
*op++ = *ii++;
assert(ii + ahead == c->ip - c->look);
c->r1_r++;
}
else if (lit < 4 && op == c->m3)
{
assert((c->m3[-2] >> M3O_BITS) == 0);
c->m3[-2] = LZO_BYTE(c->m3[-2] | (lit << M3O_BITS));
MEMCPY_DS(op, ii, lit);
assert(ii + ahead == c->ip - c->look);
c->m3_r++;
}
else
{
op = STORE_RUN(op,ii,lit);
}
if (lit < R0FAST)
c->r1_m_len = m_len;
else
c->r1_m_len = 0;
lit = 0;
}
else
c->r1_m_len = 0;
/* 2 - code match */
op = code_match(c,op,m_len,m_off);
r = find_match(c,swd,m_len,1+ahead);
assert(r == 0); LZO_UNUSED(r);
}
c->codesize = pd(op, out);
}
/* store final run */
if (lit > 0)
op = STORE_RUN(op,ii,lit);
#if defined(LZO_EOF_CODE)
*op++ = M3_MARKER | 1;
*op++ = 0;
*op++ = 0;
#endif
c->codesize = pd(op, out);
assert(c->textsize == in_len);
*out_len = pd(op, out);
if (c->cb && c->cb->nprogress)
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
#if 0
printf("%ld %ld -> %ld: %ld %ld %ld %ld %ld\n",
(long) c->textsize, (long)in_len, (long) c->codesize,
c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy);
#endif
return LZO_E_OK;
}
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
lzo1c_999_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return lzo1c_999_compress_callback(in,in_len,out,out_len,wrkmem,
(lzo_callback_p) 0, 0);
}
/* vim:set ts=4 sw=4 et: */

153
vendor/lzo-2.10/src/lzo1c_cc.c vendored Normal file
View File

@@ -0,0 +1,153 @@
/* lzo1c_cc.c -- LZO1C compression internal entry point
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define LZO_NEED_DICT_H 1
#include "config1c.h"
/***********************************************************************
// compression internal entry point.
************************************************************************/
LZO_LOCAL_IMPL(int)
_lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_compress_t func )
{
int r;
#if defined(LZO_TEST_COMPRESS_OVERRUN)
lzo_uint avail_out = *out_len;
#endif
#if (LZO_COLLECT_STATS)
_lzo1c_stats_init(lzo_stats);
lzo_stats->in_len = in_len;
#endif
/* don't try to compress a block that's too short */
if (in_len == 0)
{
*out_len = 0;
r = LZO_E_OK;
}
else if (in_len <= MIN_LOOKAHEAD + 1)
{
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
*out_len = 0;
r = LZO_E_NOT_COMPRESSIBLE;
#else
*out_len = pd(STORE_RUN(out,in,in_len), out);
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
#endif
}
else
r = func(in,in_len,out,out_len,wrkmem);
#if defined(LZO_EOF_CODE)
#if defined(LZO_TEST_COMPRESS_OVERRUN)
if (r == LZO_E_OK && avail_out - *out_len < 3)
r = LZO_E_COMPRESS_OVERRUN;
#endif
if (r == LZO_E_OK)
{
lzo_bytep op = out + *out_len;
op[0] = M3_MARKER | 1;
op[1] = 0;
op[2] = 0;
*out_len += 3;
}
#endif
#if (LZO_COLLECT_STATS)
lzo_stats->out_len = *out_len;
lzo_stats->match_bytes =
1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches +
3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches;
_lzo1c_stats_calc(lzo_stats);
#endif
return r;
}
/***********************************************************************
// note: this is not thread safe, but as it is used for finetuning only
// we don't care
************************************************************************/
#undef lzo_stats
/* lzo_stats_t is still defined */
#if (LZO_COLLECT_STATS)
static lzo_stats_t lzo_statistics;
lzo_stats_t * const lzo1c_stats = &lzo_statistics;
void _lzo1c_stats_init(lzo_stats_t *lzo_stats)
{
lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
}
void _lzo1c_stats_calc(lzo_stats_t *lzo_stats)
{
lzo_stats->matches =
lzo_stats->m1_matches + lzo_stats->m2_matches +
lzo_stats->m3_matches + lzo_stats->m4_matches;
lzo_stats->literal_overhead = lzo_stats->lit_runs +
2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs +
lzo_stats->r0long_runs);
lzo_stats->literal_bytes = lzo_stats->literals +
lzo_stats->literal_overhead;
#if 0
assert(lzo_stats->match_bytes + lzo_stats->literal_bytes ==
lzo_stats->out_len);
#endif
lzo_stats->m2_matches -= lzo_stats->r1_matches;
lzo_stats->m2_match[M2_MIN_LEN] -= lzo_stats->r1_matches;
if (lzo_stats->literals > 0)
lzo_stats->literal_overhead_percent =
100.0 * lzo_stats->literal_overhead / lzo_stats->literals;
}
#endif
/* vim:set ts=4 sw=4 et: */

77
vendor/lzo-2.10/src/lzo1c_cc.h vendored Normal file
View File

@@ -0,0 +1,77 @@
/* lzo1c_cc.h -- definitions for the the LZO1C compression driver
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO1C_CC_H
#define __LZO1C_CC_H 1
/***********************************************************************
//
************************************************************************/
extern const lzo_compress_t _lzo1c_1_compress_func;
extern const lzo_compress_t _lzo1c_2_compress_func;
extern const lzo_compress_t _lzo1c_3_compress_func;
extern const lzo_compress_t _lzo1c_4_compress_func;
extern const lzo_compress_t _lzo1c_5_compress_func;
extern const lzo_compress_t _lzo1c_6_compress_func;
extern const lzo_compress_t _lzo1c_7_compress_func;
extern const lzo_compress_t _lzo1c_8_compress_func;
extern const lzo_compress_t _lzo1c_9_compress_func;
extern const lzo_compress_t _lzo1c_99_compress_func;
/***********************************************************************
//
************************************************************************/
LZO_LOCAL_DECL(lzo_bytep )
_lzo1c_store_run ( lzo_bytep const oo, const lzo_bytep const ii,
lzo_uint r_len);
#define STORE_RUN _lzo1c_store_run
LZO_LOCAL_DECL(int)
_lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_compress_t func );
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1c_d1.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1c_d1.c -- LZO1C decompression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1c.h"
#undef LZO_TEST_OVERRUN
#define DO_DECOMPRESS lzo1c_decompress
#include "lzo1b_d.ch"
/* vim:set ts=4 sw=4 et: */

50
vendor/lzo-2.10/src/lzo1c_d2.c vendored Normal file
View File

@@ -0,0 +1,50 @@
/* lzo1c_d2.c -- LZO1C decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1c.h"
#define LZO_TEST_OVERRUN 1
#define DO_DECOMPRESS lzo1c_decompress_safe
#include "lzo1b_d.ch"
#if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
LZO_EXTERN(int) lzo1c_decompress_asm_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem);
LZO_PUBLIC(int) lzo1c_decompress_asm_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem)
{
return lzo1c_decompress_safe(src, src_len, dst, dst_len, wrkmem);
}
#endif
/* vim:set ts=4 sw=4 et: */

33
vendor/lzo-2.10/src/lzo1c_rr.c vendored Normal file
View File

@@ -0,0 +1,33 @@
/* lzo1c_rr.c -- literal run handling
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1c.h"
#include "lzo1b_r.ch"
/* vim:set ts=4 sw=4 et: */

82
vendor/lzo-2.10/src/lzo1c_xx.c vendored Normal file
View File

@@ -0,0 +1,82 @@
/* lzo1c_xx.c -- LZO1C compression public entry point
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1c.h"
/***********************************************************************
//
************************************************************************/
static const lzo_compress_t * const c_funcs [9] =
{
&_lzo1c_1_compress_func,
&_lzo1c_2_compress_func,
&_lzo1c_3_compress_func,
&_lzo1c_4_compress_func,
&_lzo1c_5_compress_func,
&_lzo1c_6_compress_func,
&_lzo1c_7_compress_func,
&_lzo1c_8_compress_func,
&_lzo1c_9_compress_func
};
static lzo_compress_t lzo1c_get_compress_func(int clevel)
{
const lzo_compress_t *f;
if (clevel < LZO1C_BEST_SPEED || clevel > LZO1C_BEST_COMPRESSION)
{
if (clevel == LZO1C_DEFAULT_COMPRESSION)
clevel = LZO1C_BEST_SPEED;
else
return (lzo_compress_t) 0;
}
f = c_funcs[clevel-1];
assert(f && *f);
return *f;
}
LZO_PUBLIC(int)
lzo1c_compress ( const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem,
int clevel )
{
lzo_compress_t f;
f = lzo1c_get_compress_func(clevel);
if (!f)
return LZO_E_ERROR;
return _lzo1c_do_compress(src,src_len,dst,dst_len,wrkmem,f);
}
/* vim:set ts=4 sw=4 et: */

301
vendor/lzo-2.10/src/lzo1f_1.c vendored Normal file
View File

@@ -0,0 +1,301 @@
/* lzo1f_1.c -- implementation of the LZO1F-1 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#include <lzo/lzo1f.h>
/***********************************************************************
//
************************************************************************/
#define M2_MAX_OFFSET 0x0800
#define M3_MAX_OFFSET 0x3fff
#define M3_MARKER 224
#ifndef LZO_HASH
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
#endif
#define D_BITS 14
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
#include "lzo_dict.h"
/***********************************************************************
// compress a block of data.
************************************************************************/
static __lzo_noinline
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;
lzo_bytep op;
const lzo_bytep const in_end = in + in_len;
const lzo_bytep const ip_end = in + in_len - 9;
const lzo_bytep ii;
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
op = out;
ip = in;
ii = ip;
ip++;
for (;;)
{
const lzo_bytep m_pos;
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
lzo_uint m_len;
lzo_uint dindex;
lzo_uint lit;
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;
try_match:
#if 0 && (LZO_OPT_UNALIGNED16)
if (UA_GET_NE16(m_pos) != UA_GET_NE16(ip))
#else
if (m_pos[0] != ip[0] || m_pos[1] != ip[1])
#endif
{
}
else
{
if (m_pos[2] == ip[2])
{
m_pos += 3;
#if 0
if (m_off <= M2_MAX_OFFSET)
goto match;
if (lit <= 3)
goto match;
if (lit == 3) /* better compression, but slower */
{
assert(op - 2 > out); op[-2] |= LZO_BYTE(3);
*op++ = *ii++; *op++ = *ii++; *op++ = *ii++;
goto code_match;
}
if (*m_pos == ip[3])
#endif
goto match;
}
}
/* a literal */
literal:
UPDATE_I(dict,0,dindex,ip,in);
if (++ip >= ip_end)
break;
continue;
/* a match */
match:
UPDATE_I(dict,0,dindex,ip,in);
/* store current literal run */
lit = pd(ip,ii);
if (lit > 0)
{
lzo_uint t = lit;
if (t < 4 && op > out)
op[-2] = LZO_BYTE(op[-2] | t);
else if (t <= 31)
*op++ = LZO_BYTE(t);
else
{
lzo_uint tt = t - 31;
*op++ = 0;
while (tt > 255)
{
tt -= 255;
UA_SET1(op, 0);
op++;
}
assert(tt > 0);
*op++ = LZO_BYTE(tt);
}
do *op++ = *ii++; while (--t > 0);
}
assert(ii == ip);
/* code the match */
ip += 3;
if (*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++ ||
*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++)
{
--ip;
m_len = pd(ip, ii);
assert(m_len >= 3); assert(m_len <= 8);
if (m_off <= M2_MAX_OFFSET)
{
m_off -= 1;
*op++ = LZO_BYTE(((m_len - 2) << 5) | ((m_off & 7) << 2));
*op++ = LZO_BYTE(m_off >> 3);
}
else if (m_len == 3 && m_off <= 2*M2_MAX_OFFSET && lit > 0)
{
m_off -= 1;
/* m_off -= M2_MAX_OFFSET; */
*op++ = LZO_BYTE(((m_off & 7) << 2));
*op++ = LZO_BYTE(m_off >> 3);
}
else
{
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
*op++ = LZO_BYTE((m_off & 63) << 2);
*op++ = LZO_BYTE(m_off >> 6);
}
}
else
{
{
const lzo_bytep end;
end = in_end;
while (ip < end && *m_pos == *ip)
{ m_pos++; ip++; }
m_len = pd(ip, ii);
}
assert(m_len >= 3);
if (m_len <= 33)
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
else
{
m_len -= 33;
*op++ = M3_MARKER | 0;
while (m_len > 255)
{
m_len -= 255;
UA_SET1(op, 0);
op++;
}
assert(m_len > 0);
*op++ = LZO_BYTE(m_len);
}
*op++ = LZO_BYTE((m_off & 63) << 2);
*op++ = LZO_BYTE(m_off >> 6);
}
ii = ip;
if (ip >= ip_end)
break;
}
/* store final literal run */
if (pd(in_end,ii) > 0)
{
lzo_uint t = pd(in_end,ii);
if (t < 4 && op > out)
op[-2] = LZO_BYTE(op[-2] | t);
else if (t <= 31)
*op++ = LZO_BYTE(t);
else
{
lzo_uint tt = t - 31;
*op++ = 0;
while (tt > 255)
{
tt -= 255;
UA_SET1(op, 0);
op++;
}
assert(tt > 0);
*op++ = LZO_BYTE(tt);
}
UA_COPYN(op, ii, t);
op += t;
}
*out_len = pd(op, out);
return LZO_E_OK;
}
/***********************************************************************
// public entry point
************************************************************************/
LZO_PUBLIC(int)
lzo1f_1_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
lzo_bytep op = out;
int r = LZO_E_OK;
if (in_len == 0)
*out_len = 0;
else if (in_len <= 10)
{
*op++ = LZO_BYTE(in_len);
do *op++ = *in++; while (--in_len > 0);
*out_len = pd(op, out);
}
else
r = do_compress(in,in_len,out,out_len,wrkmem);
if (r == LZO_E_OK)
{
op = out + *out_len;
op[0] = M3_MARKER | 1;
op[1] = 0;
op[2] = 0;
*out_len += 3;
}
return r;
}
/* vim:set ts=4 sw=4 et: */

330
vendor/lzo-2.10/src/lzo1f_9x.c vendored Normal file
View File

@@ -0,0 +1,330 @@
/* lzo1f_9x.c -- implementation of the LZO1F-999 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1f.h"
/***********************************************************************
//
************************************************************************/
#define SWD_N 16383 /* size of ring buffer */
#define SWD_THRESHOLD 2 /* lower limit for match length */
#define SWD_F 2048 /* upper limit for match length */
#define LZO1F 1
#define LZO_COMPRESS_T lzo1f_999_t
#define lzo_swd_t lzo1f_999_swd_t
#include "lzo_mchw.ch"
/***********************************************************************
//
************************************************************************/
static lzo_bytep
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
{
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
{
m_off -= 1;
*op++ = LZO_BYTE(((m_len - 2) << 5) | ((m_off & 7) << 2));
*op++ = LZO_BYTE(m_off >> 3);
c->m2_m++;
}
else if (m_len == M2_MIN_LEN && m_off <= 2 * M2_MAX_OFFSET &&
c->r1_lit > 0)
{
assert(m_off > M2_MAX_OFFSET);
m_off -= 1 + M2_MAX_OFFSET;
*op++ = LZO_BYTE(((m_off & 7) << 2));
*op++ = LZO_BYTE(m_off >> 3);
c->r1_r++;
}
else
{
if (m_len <= M3_MAX_LEN)
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
else
{
m_len -= M3_MAX_LEN;
*op++ = M3_MARKER | 0;
while (m_len > 255)
{
m_len -= 255;
*op++ = 0;
}
assert(m_len > 0);
*op++ = LZO_BYTE(m_len);
}
*op++ = LZO_BYTE((m_off & 63) << 2);
*op++ = LZO_BYTE(m_off >> 6);
c->m3_m++;
}
return op;
}
static lzo_bytep
STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out )
{
if (t < 4 && op > out)
op[-2] = LZO_BYTE(op[-2] | t);
else if (t <= 31)
*op++ = LZO_BYTE(t);
else
{
lzo_uint tt = t - 31;
*op++ = 0;
while (tt > 255)
{
tt -= 255;
*op++ = 0;
}
assert(tt > 0);
*op++ = LZO_BYTE(tt);
}
do *op++ = *ii++; while (--t > 0);
return op;
}
/***********************************************************************
// this is a public function, but there is no prototype in a header file
************************************************************************/
LZO_EXTERN(int)
lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain );
LZO_PUBLIC(int)
lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain )
{
lzo_bytep op;
const lzo_bytep ii;
lzo_uint lit;
lzo_uint m_len, m_off;
LZO_COMPRESS_T cc;
LZO_COMPRESS_T * const c = &cc;
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
int r;
/* sanity check */
LZO_COMPILE_TIME_ASSERT(LZO1F_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
c->init = 0;
c->ip = c->in = in;
c->in_end = in + in_len;
c->cb = cb;
c->r1_r = c->m2_m = c->m3_m = 0;
op = out;
ii = c->ip; /* point to start of literal run */
lit = 0;
c->r1_lit = c->r1_m_len = 0;
r = init_match(c,swd,NULL,0,0);
if (r != 0)
return r;
if (max_chain > 0)
swd->max_chain = max_chain;
r = find_match(c,swd,0,0);
if (r != 0)
return r;
while (c->look > 0)
{
int lazy_match_min_gain = -1;
lzo_uint ahead = 0;
m_len = c->m_len;
m_off = c->m_off;
assert(c->ip - c->look >= in);
if (lit == 0)
ii = c->ip - c->look;
assert(ii + lit == c->ip - c->look);
assert(swd->b_char == *(c->ip - c->look));
if ((m_len < M2_MIN_LEN) ||
(m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET))
{
m_len = 0;
}
else
{
assert(c->ip - c->look - m_off >= in);
assert(c->ip - c->look - m_off + m_len < c->ip);
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
if (lit < 3)
lazy_match_min_gain = 1;
else if (lit == 3)
lazy_match_min_gain = 3;
else if (lit == 31)
lazy_match_min_gain = 3;
else
lazy_match_min_gain = 1;
}
/* try a lazy match */
if (m_len > 0 && lazy_match_min_gain >= 0 && c->look > m_len)
{
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
assert(c->look > 0);
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
c->m_off > M2_MAX_OFFSET)
{
lazy_match_min_gain += 1;
}
else if (c->m_len <= M2_MAX_LEN &&
c->m_off <= M2_MAX_OFFSET &&
m_off > M2_MAX_OFFSET)
{
if (lazy_match_min_gain > 0)
lazy_match_min_gain -= 1;
}
else if (m_len == M2_MIN_LEN && c->m_len == M2_MIN_LEN &&
c->m_off <= 2 * M2_MAX_OFFSET &&
m_off > M2_MAX_OFFSET)
{
if (lazy_match_min_gain > 0)
lazy_match_min_gain -= 1;
}
if (c->m_len >= m_len + lazy_match_min_gain)
{
c->lazy++;
#if !defined(NDEBUG)
m_len = c->m_len;
m_off = c->m_off;
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
#endif
lit++;
assert(ii + lit == c->ip - c->look);
continue;
}
else
{
ahead = 1;
assert(ii + lit + 1 == c->ip - c->look);
}
assert(m_len > 0);
}
assert(ii + lit + ahead == c->ip - c->look);
if (m_len == 0)
{
/* a literal */
lit++;
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
}
else
{
/* 1 - store run */
if (lit > 0)
{
op = STORE_RUN(op,ii,lit,out);
c->r1_m_len = m_len;
c->r1_lit = lit;
lit = 0;
}
else
c->r1_lit = c->r1_m_len = 0;
/* 2 - code match */
op = code_match(c,op,m_len,m_off);
r = find_match(c,swd,m_len,1+ahead);
assert(r == 0); LZO_UNUSED(r);
}
c->codesize = pd(op, out);
}
/* store final run */
if (lit > 0)
op = STORE_RUN(op,ii,lit,out);
#if defined(LZO_EOF_CODE)
*op++ = M3_MARKER | 1;
*op++ = 0;
*op++ = 0;
#endif
c->codesize = pd(op, out);
assert(c->textsize == in_len);
*out_len = pd(op, out);
if (c->cb && c->cb->nprogress)
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
#if 0
printf("%ld %ld -> %ld: %ld %ld %ld %ld\n",
(long) c->textsize, (long)in_len, (long) c->codesize,
c->r1_r, c->m2_m, c->m3_m, c->lazy);
#endif
return LZO_E_OK;
}
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
lzo1f_999_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return lzo1f_999_compress_callback(in,in_len,out,out_len,wrkmem,
(lzo_callback_p) 0, 0);
}
/* vim:set ts=4 sw=4 et: */

210
vendor/lzo-2.10/src/lzo1f_d.ch vendored Normal file
View File

@@ -0,0 +1,210 @@
/* lzo1f_d.ch -- implementation of the LZO1F decompression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo1_d.ch"
/***********************************************************************
// decompress a block of data.
************************************************************************/
LZO_PUBLIC(int)
DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
lzo_bytep op;
const lzo_bytep ip;
lzo_uint t;
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);
*out_len = 0;
op = out;
ip = in;
while (TEST_IP_AND_TEST_OP)
{
t = *ip++;
if (t > 31)
goto match;
/* a literal run */
if (t == 0)
{
NEED_IP(1);
while (*ip == 0)
{
t += 255;
ip++;
TEST_IV(t);
NEED_IP(1);
}
t += 31 + *ip++;
}
/* copy literals */
assert(t > 0); NEED_OP(t); NEED_IP(t+1);
#if (LZO_OPT_UNALIGNED32)
if (t >= 4)
{
do {
UA_COPY4(op, ip);
op += 4; ip += 4; t -= 4;
} while (t >= 4);
if (t > 0) do *op++ = *ip++; while (--t > 0);
}
else
#endif
do *op++ = *ip++; while (--t > 0);
t = *ip++;
while (TEST_IP_AND_TEST_OP)
{
/* handle matches */
if (t < 32)
{
m_pos = op - 1 - 0x800;
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
TEST_LB(m_pos); NEED_OP(3);
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
}
else
{
match:
if (t < M3_MARKER)
{
m_pos = op - 1;
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
t >>= 5;
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
goto copy_match;
}
else
{
t &= 31;
if (t == 0)
{
NEED_IP(1);
while (*ip == 0)
{
t += 255;
ip++;
TEST_OV(t);
NEED_IP(1);
}
t += 31 + *ip++;
}
NEED_IP(2);
m_pos = op;
#if (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
m_pos -= UA_GET_LE16(ip) >> 2;
ip += 2;
#else
m_pos -= *ip++ >> 2;
m_pos -= *ip++ << 6;
#endif
if (m_pos == op)
goto eof_found;
}
/* copy match */
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
#if (LZO_OPT_UNALIGNED32)
if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
{
UA_COPY4(op, m_pos);
op += 4; m_pos += 4; t -= 4 - (3 - 1);
do {
UA_COPY4(op, 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_match:
*op++ = *m_pos++; *op++ = *m_pos++;
do *op++ = *m_pos++; while (--t > 0);
}
}
t = ip[-2] & 3;
if (t == 0)
break;
/* copy literals */
assert(t > 0); NEED_OP(t); NEED_IP(t+1);
do *op++ = *ip++; while (--t > 0);
t = *ip++;
}
}
#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
/* no EOF code was found */
*out_len = pd(op, out);
return LZO_E_EOF_NOT_FOUND;
#endif
eof_found:
assert(t == 1);
*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
}
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1f_d1.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1f_d1.c -- LZO1F decompression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1f.h"
#undef LZO_TEST_OVERRUN
#define DO_DECOMPRESS lzo1f_decompress
#include "lzo1f_d.ch"
/* vim:set ts=4 sw=4 et: */

50
vendor/lzo-2.10/src/lzo1f_d2.c vendored Normal file
View File

@@ -0,0 +1,50 @@
/* lzo1f_d2.c -- LZO1F decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1f.h"
#define LZO_TEST_OVERRUN 1
#define DO_DECOMPRESS lzo1f_decompress_safe
#include "lzo1f_d.ch"
#if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
LZO_EXTERN(int) lzo1f_decompress_asm_fast_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem);
LZO_PUBLIC(int) lzo1f_decompress_asm_fast_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem)
{
return lzo1f_decompress_safe(src, src_len, dst, dst_len, wrkmem);
}
#endif
/* vim:set ts=4 sw=4 et: */

57
vendor/lzo-2.10/src/lzo1x_1.c vendored Normal file
View File

@@ -0,0 +1,57 @@
/* lzo1x_1.c -- LZO1X-1 compression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#if 1 && defined(UA_GET_LE32)
#undef LZO_DICT_USE_PTR
#define LZO_DICT_USE_PTR 0
#undef lzo_dict_t
#define lzo_dict_t lzo_uint16_t
#endif
#define LZO_NEED_DICT_H 1
#ifndef D_BITS
#define D_BITS 14
#endif
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
#if 1
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
#else
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
#endif
#include "config1x.h"
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
#ifndef DO_COMPRESS
#define DO_COMPRESS lzo1x_1_compress
#endif
#include "lzo1x_c.ch"
/* vim:set ts=4 sw=4 et: */

57
vendor/lzo-2.10/src/lzo1x_1k.c vendored Normal file
View File

@@ -0,0 +1,57 @@
/* lzo1x_1k.c -- LZO1X-1(11) compression (needs only 8kB work memory)
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#if 1 && defined(UA_GET_LE32)
#undef LZO_DICT_USE_PTR
#define LZO_DICT_USE_PTR 0
#undef lzo_dict_t
#define lzo_dict_t lzo_uint16_t
#endif
#define LZO_NEED_DICT_H 1
#ifndef D_BITS
#define D_BITS 11
#endif
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,3,5)) >> 5)
#define D_INDEX2(d,p) d = d ^ D_MASK
#if 1
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
#else
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
#endif
#include "config1x.h"
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
#ifndef DO_COMPRESS
#define DO_COMPRESS lzo1x_1_11_compress
#endif
#include "lzo1x_c.ch"
/* vim:set ts=4 sw=4 et: */

57
vendor/lzo-2.10/src/lzo1x_1l.c vendored Normal file
View File

@@ -0,0 +1,57 @@
/* lzo1x_1l.c -- LZO1X-1(12) compression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#if 1 && defined(UA_GET_LE32)
#undef LZO_DICT_USE_PTR
#define LZO_DICT_USE_PTR 0
#undef lzo_dict_t
#define lzo_dict_t lzo_uint16_t
#endif
#define LZO_NEED_DICT_H 1
#ifndef D_BITS
#define D_BITS 12
#endif
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,4,5)) >> 5)
#define D_INDEX2(d,p) d = d ^ D_MASK
#if 1
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
#else
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
#endif
#include "config1x.h"
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
#ifndef DO_COMPRESS
#define DO_COMPRESS lzo1x_1_12_compress
#endif
#include "lzo1x_c.ch"
/* vim:set ts=4 sw=4 et: */

58
vendor/lzo-2.10/src/lzo1x_1o.c vendored Normal file
View File

@@ -0,0 +1,58 @@
/* lzo1x_1o.c -- LZO1X-1(15) compression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#if 1 && defined(UA_GET_LE32)
#undef LZO_DICT_USE_PTR
#define LZO_DICT_USE_PTR 0
#undef lzo_dict_t
#define lzo_dict_t lzo_uint16_t
#define D_BITS 13
#endif
#define LZO_NEED_DICT_H 1
#ifndef D_BITS
#define D_BITS 15
#endif
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
#if 1
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
#else
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
#endif
#include "config1x.h"
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
#ifndef DO_COMPRESS
#define DO_COMPRESS lzo1x_1_15_compress
#endif
#include "lzo1x_c.ch"
/* vim:set ts=4 sw=4 et: */

867
vendor/lzo-2.10/src/lzo1x_9x.c vendored Normal file
View File

@@ -0,0 +1,867 @@
/* lzo1x_9x.c -- implementation of the LZO1X-999 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z)
# define LZO1X 1
#endif
#if defined(LZO1X)
# include "config1x.h"
#elif defined(LZO1Y)
# include "config1y.h"
#elif defined(LZO1Z)
# include "config1z.h"
#else
# error
#endif
/***********************************************************************
//
************************************************************************/
#define SWD_N M4_MAX_OFFSET /* size of ring buffer */
#define SWD_THRESHOLD 1 /* lower limit for match length */
#define SWD_F 2048 /* upper limit for match length */
#define SWD_BEST_OFF (LZO_MAX3( M2_MAX_LEN, M3_MAX_LEN, M4_MAX_LEN ) + 1)
#if defined(LZO1X)
# define LZO_COMPRESS_T lzo1x_999_t
# define lzo_swd_t lzo1x_999_swd_t
#elif defined(LZO1Y)
# define LZO_COMPRESS_T lzo1y_999_t
# define lzo_swd_t lzo1y_999_swd_t
# define lzo1x_999_compress_internal lzo1y_999_compress_internal
# define lzo1x_999_compress_dict lzo1y_999_compress_dict
# define lzo1x_999_compress_level lzo1y_999_compress_level
# define lzo1x_999_compress lzo1y_999_compress
#elif defined(LZO1Z)
# define LZO_COMPRESS_T lzo1z_999_t
# define lzo_swd_t lzo1z_999_swd_t
# define lzo1x_999_compress_internal lzo1z_999_compress_internal
# define lzo1x_999_compress_dict lzo1z_999_compress_dict
# define lzo1x_999_compress_level lzo1z_999_compress_level
# define lzo1x_999_compress lzo1z_999_compress
#else
# error
#endif
#if 0
# define HEAD3(b,p) \
((((((lzo_xint)b[p]<<3)^b[p+1])<<3)^b[p+2]) & (SWD_HSIZE-1))
#endif
#if 0 && (LZO_OPT_UNALIGNED32) && (LZO_ABI_LITTLE_ENDIAN)
# define HEAD3(b,p) \
(((* (lzo_uint32_tp) &b[p]) ^ ((* (lzo_uint32_tp) &b[p])>>10)) & (SWD_HSIZE-1))
#endif
#include "lzo_mchw.ch"
/* this is a public functions, but there is no prototype in a header file */
LZO_EXTERN(int)
lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
const lzo_bytep dict, lzo_uint dict_len,
lzo_callback_p cb,
int try_lazy_parm,
lzo_uint good_length,
lzo_uint max_lazy,
lzo_uint nice_length,
lzo_uint max_chain,
lzo_uint32_t flags );
/***********************************************************************
//
************************************************************************/
static lzo_bytep
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
{
lzo_uint x_len = m_len;
lzo_uint x_off = m_off;
c->match_bytes += m_len;
#if 0
/*
static lzo_uint last_m_len = 0, last_m_off = 0;
static lzo_uint prev_m_off[4];
static unsigned prev_m_off_ptr = 0;
unsigned i;
//if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
if (m_len >= 3 && m_len <= M2_MAX_LEN)
{
//if (m_len == last_m_len && m_off == last_m_off)
//printf("last_m_len + last_m_off\n");
//else
if (m_off == last_m_off)
printf("last_m_off\n");
else
{
for (i = 0; i < 4; i++)
if (m_off == prev_m_off[i])
printf("prev_m_off %u: %5ld\n",i,(long)m_off);
}
}
last_m_len = m_len;
last_m_off = prev_m_off[prev_m_off_ptr] = m_off;
prev_m_off_ptr = (prev_m_off_ptr + 1) & 3;
*/
#endif
assert(op > c->out);
if (m_len == 2)
{
assert(m_off <= M1_MAX_OFFSET);
assert(c->r1_lit > 0); assert(c->r1_lit < 4);
m_off -= 1;
#if defined(LZO1Z)
*op++ = LZO_BYTE(M1_MARKER | (m_off >> 6));
*op++ = LZO_BYTE(m_off << 2);
#else
*op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2));
*op++ = LZO_BYTE(m_off >> 2);
#endif
c->m1a_m++;
}
#if defined(LZO1Z)
else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off))
#else
else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
#endif
{
assert(m_len >= 3);
#if defined(LZO1X)
m_off -= 1;
*op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2));
*op++ = LZO_BYTE(m_off >> 3);
assert(op[-2] >= M2_MARKER);
#elif defined(LZO1Y)
m_off -= 1;
*op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2));
*op++ = LZO_BYTE(m_off >> 2);
assert(op[-2] >= M2_MARKER);
#elif defined(LZO1Z)
if (m_off == c->last_m_off)
*op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6));
else
{
m_off -= 1;
*op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6));
*op++ = LZO_BYTE(m_off << 2);
}
#endif
c->m2_m++;
}
else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && c->r1_lit >= 4)
{
assert(m_len == 3);
assert(m_off > M2_MAX_OFFSET);
m_off -= 1 + M2_MAX_OFFSET;
#if defined(LZO1Z)
*op++ = LZO_BYTE(M1_MARKER | (m_off >> 6));
*op++ = LZO_BYTE(m_off << 2);
#else
*op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2));
*op++ = LZO_BYTE(m_off >> 2);
#endif
c->m1b_m++;
}
else if (m_off <= M3_MAX_OFFSET)
{
assert(m_len >= 3);
m_off -= 1;
if (m_len <= M3_MAX_LEN)
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
else
{
m_len -= M3_MAX_LEN;
*op++ = M3_MARKER | 0;
while (m_len > 255)
{
m_len -= 255;
*op++ = 0;
}
assert(m_len > 0);
*op++ = LZO_BYTE(m_len);
}
#if defined(LZO1Z)
*op++ = LZO_BYTE(m_off >> 6);
*op++ = LZO_BYTE(m_off << 2);
#else
*op++ = LZO_BYTE(m_off << 2);
*op++ = LZO_BYTE(m_off >> 6);
#endif
c->m3_m++;
}
else
{
lzo_uint k;
assert(m_len >= 3);
assert(m_off > 0x4000); assert(m_off <= 0xbfff);
m_off -= 0x4000;
k = (m_off & 0x4000) >> 11;
if (m_len <= M4_MAX_LEN)
*op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2));
else
{
m_len -= M4_MAX_LEN;
*op++ = LZO_BYTE(M4_MARKER | k | 0);
while (m_len > 255)
{
m_len -= 255;
*op++ = 0;
}
assert(m_len > 0);
*op++ = LZO_BYTE(m_len);
}
#if defined(LZO1Z)
*op++ = LZO_BYTE(m_off >> 6);
*op++ = LZO_BYTE(m_off << 2);
#else
*op++ = LZO_BYTE(m_off << 2);
*op++ = LZO_BYTE(m_off >> 6);
#endif
c->m4_m++;
}
c->last_m_len = x_len;
c->last_m_off = x_off;
return op;
}
static lzo_bytep
STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t )
{
c->lit_bytes += t;
if (op == c->out && t <= 238)
{
*op++ = LZO_BYTE(17 + t);
}
else if (t <= 3)
{
#if defined(LZO1Z)
op[-1] = LZO_BYTE(op[-1] | t);
#else
op[-2] = LZO_BYTE(op[-2] | t);
#endif
c->lit1_r++;
}
else if (t <= 18)
{
*op++ = LZO_BYTE(t - 3);
c->lit2_r++;
}
else
{
lzo_uint tt = t - 18;
*op++ = 0;
while (tt > 255)
{
tt -= 255;
*op++ = 0;
}
assert(tt > 0);
*op++ = LZO_BYTE(tt);
c->lit3_r++;
}
do *op++ = *ii++; while (--t > 0);
return op;
}
static lzo_bytep
code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii,
lzo_uint lit, lzo_uint m_len )
{
if (lit > 0)
{
assert(m_len >= 2);
op = STORE_RUN(c,op,ii,lit);
c->r1_m_len = m_len;
c->r1_lit = lit;
}
else
{
assert(m_len >= 3);
c->r1_m_len = 0;
c->r1_lit = 0;
}
return op;
}
/***********************************************************************
//
************************************************************************/
static lzo_uint
len_of_coded_match ( lzo_uint m_len, lzo_uint m_off, lzo_uint lit )
{
lzo_uint n = 4;
if (m_len < 2)
return 0;
if (m_len == 2)
return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0;
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
return 2;
if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4)
return 2;
if (m_off <= M3_MAX_OFFSET)
{
if (m_len <= M3_MAX_LEN)
return 3;
m_len -= M3_MAX_LEN;
while (m_len > 255)
{
m_len -= 255;
n++;
}
return n;
}
if (m_off <= M4_MAX_OFFSET)
{
if (m_len <= M4_MAX_LEN)
return 3;
m_len -= M4_MAX_LEN;
while (m_len > 255)
{
m_len -= 255;
n++;
}
return n;
}
return 0;
}
static lzo_uint
min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, lzo_uint l3)
{
lzo_uint lazy_match_min_gain;
assert (ahead >= 1);
lazy_match_min_gain = ahead;
#if 0
if (l3)
lit2 -= ahead;
#endif
if (lit1 <= 3)
lazy_match_min_gain += (lit2 <= 3) ? 0 : 2;
else if (lit1 <= 18)
lazy_match_min_gain += (lit2 <= 18) ? 0 : 1;
lazy_match_min_gain += (l2 - l1) * 2;
if (l3)
lazy_match_min_gain -= (ahead - l3) * 2;
if ((lzo_int) lazy_match_min_gain < 0)
lazy_match_min_gain = 0;
#if 0
if (l1 == 2)
if (lazy_match_min_gain == 0)
lazy_match_min_gain = 1;
#endif
return lazy_match_min_gain;
}
/***********************************************************************
//
************************************************************************/
#if !defined(NDEBUG)
static
void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off )
{
const LZO_COMPRESS_T *c = swd->c;
lzo_uint d_off;
assert(m_len >= 2);
if (m_off <= (lzo_uint) (c->bp - c->in))
{
assert(c->bp - m_off + m_len < c->ip);
assert(lzo_memcmp(c->bp, c->bp - m_off, m_len) == 0);
}
else
{
assert(swd->dict != NULL);
d_off = m_off - (lzo_uint) (c->bp - c->in);
assert(d_off <= swd->dict_len);
if (m_len > d_off)
{
assert(lzo_memcmp(c->bp, swd->dict_end - d_off, d_off) == 0);
assert(c->in + m_len - d_off < c->ip);
assert(lzo_memcmp(c->bp + d_off, c->in, m_len - d_off) == 0);
}
else
{
assert(lzo_memcmp(c->bp, swd->dict_end - d_off, m_len) == 0);
}
}
}
#else
# define assert_match(a,b,c) ((void)0)
#endif
#if defined(SWD_BEST_OFF)
static void
better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off )
{
#if defined(LZO1Z)
const LZO_COMPRESS_T *c = swd->c;
#endif
if (*m_len <= M2_MIN_LEN)
return;
#if defined(LZO1Z)
if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN)
return;
#if 1
if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off)
{
*m_len = *m_len - 1;
*m_off = swd->best_off[*m_len];
return;
}
#endif
#endif
if (*m_off <= M2_MAX_OFFSET)
return;
#if 1
/* M3/M4 -> M2 */
if (*m_off > M2_MAX_OFFSET &&
*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET)
{
*m_len = *m_len - 1;
*m_off = swd->best_off[*m_len];
return;
}
#endif
#if 1
/* M4 -> M2 */
if (*m_off > M3_MAX_OFFSET &&
*m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 &&
swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET)
{
*m_len = *m_len - 2;
*m_off = swd->best_off[*m_len];
return;
}
#endif
#if 1
/* M4 -> M3 */
if (*m_off > M3_MAX_OFFSET &&
*m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 &&
swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET)
{
*m_len = *m_len - 1;
*m_off = swd->best_off[*m_len];
}
#endif
}
#endif
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
const lzo_bytep dict, lzo_uint dict_len,
lzo_callback_p cb,
int try_lazy_parm,
lzo_uint good_length,
lzo_uint max_lazy,
lzo_uint nice_length,
lzo_uint max_chain,
lzo_uint32_t flags )
{
lzo_bytep op;
const lzo_bytep ii;
lzo_uint lit;
lzo_uint m_len, m_off;
LZO_COMPRESS_T cc;
LZO_COMPRESS_T * const c = &cc;
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
lzo_uint try_lazy;
int r;
/* sanity check */
#if defined(LZO1X)
LZO_COMPILE_TIME_ASSERT(LZO1X_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
#elif defined(LZO1Y)
LZO_COMPILE_TIME_ASSERT(LZO1Y_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
#elif defined(LZO1Z)
LZO_COMPILE_TIME_ASSERT(LZO1Z_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
#else
# error
#endif
/* setup parameter defaults */
/* number of lazy match tries */
try_lazy = (lzo_uint) try_lazy_parm;
if (try_lazy_parm < 0)
try_lazy = 1;
/* reduce lazy match search if we already have a match with this length */
if (good_length == 0)
good_length = 32;
/* do not try a lazy match if we already have a match with this length */
if (max_lazy == 0)
max_lazy = 32;
/* stop searching for longer matches than this one */
if (nice_length == 0)
nice_length = 0;
/* don't search more positions than this */
if (max_chain == 0)
max_chain = SWD_MAX_CHAIN;
c->init = 0;
c->ip = c->in = in;
c->in_end = in + in_len;
c->out = out;
c->cb = cb;
c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0;
c->lit1_r = c->lit2_r = c->lit3_r = 0;
op = out;
ii = c->ip; /* point to start of literal run */
lit = 0;
c->r1_lit = c->r1_m_len = 0;
r = init_match(c,swd,dict,dict_len,flags);
if (r != 0)
return r;
if (max_chain > 0)
swd->max_chain = max_chain;
if (nice_length > 0)
swd->nice_length = nice_length;
r = find_match(c,swd,0,0);
if (r != 0)
return r;
while (c->look > 0)
{
lzo_uint ahead;
lzo_uint max_ahead;
lzo_uint l1, l2, l3;
c->codesize = pd(op, out);
m_len = c->m_len;
m_off = c->m_off;
assert(c->bp == c->ip - c->look);
assert(c->bp >= in);
if (lit == 0)
ii = c->bp;
assert(ii + lit == c->bp);
assert(swd->b_char == *(c->bp));
if ( m_len < 2 ||
(m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) ||
#if 1
/* Do not accept this match for compressed-data compatibility
* with LZO v1.01 and before
* [ might be a problem for decompress() and optimize() ]
*/
(m_len == 2 && op == out) ||
#endif
(op == out && lit == 0))
{
/* a literal */
m_len = 0;
}
else if (m_len == M2_MIN_LEN)
{
/* compression ratio improves if we code a literal in some cases */
if (m_off > MX_MAX_OFFSET && lit >= 4)
m_len = 0;
}
if (m_len == 0)
{
/* a literal */
lit++;
swd->max_chain = max_chain;
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
continue;
}
/* a match */
#if defined(SWD_BEST_OFF)
if (swd->use_best_off)
better_match(swd,&m_len,&m_off);
#endif
assert_match(swd,m_len,m_off);
/* shall we try a lazy match ? */
ahead = 0;
if (try_lazy == 0 || m_len >= max_lazy)
{
/* no */
l1 = 0;
max_ahead = 0;
}
else
{
/* yes, try a lazy match */
l1 = len_of_coded_match(m_len,m_off,lit);
assert(l1 > 0);
#if 1
max_ahead = LZO_MIN(try_lazy, l1 - 1);
#else
max_ahead = LZO_MIN3(try_lazy, l1, m_len - 1);
#endif
}
while (ahead < max_ahead && c->look > m_len)
{
lzo_uint lazy_match_min_gain;
if (m_len >= good_length)
swd->max_chain = max_chain >> 2;
else
swd->max_chain = max_chain;
r = find_match(c,swd,1,0);
ahead++;
assert(r == 0); LZO_UNUSED(r);
assert(c->look > 0);
assert(ii + lit + ahead == c->bp);
#if defined(LZO1Z)
if (m_off == c->last_m_off && c->m_off != c->last_m_off)
if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN)
c->m_len = 0;
#endif
if (c->m_len < m_len)
continue;
#if 1
if (c->m_len == m_len && c->m_off >= m_off)
continue;
#endif
#if defined(SWD_BEST_OFF)
if (swd->use_best_off)
better_match(swd,&c->m_len,&c->m_off);
#endif
l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead);
if (l2 == 0)
continue;
#if 0
if (c->m_len == m_len && l2 >= l1)
continue;
#endif
#if 1
/* compressed-data compatibility [see above] */
l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit);
#else
l3 = len_of_coded_match(ahead,m_off,lit);
#endif
lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3);
if (c->m_len >= m_len + lazy_match_min_gain)
{
c->lazy++;
assert_match(swd,c->m_len,c->m_off);
if (l3)
{
/* code previous run */
op = code_run(c,op,ii,lit,ahead);
lit = 0;
/* code shortened match */
op = code_match(c,op,ahead,m_off);
}
else
{
lit += ahead;
assert(ii + lit == c->bp);
}
goto lazy_match_done;
}
}
assert(ii + lit + ahead == c->bp);
/* 1 - code run */
op = code_run(c,op,ii,lit,m_len);
lit = 0;
/* 2 - code match */
op = code_match(c,op,m_len,m_off);
swd->max_chain = max_chain;
r = find_match(c,swd,m_len,1+ahead);
assert(r == 0); LZO_UNUSED(r);
lazy_match_done: ;
}
/* store final run */
if (lit > 0)
op = STORE_RUN(c,op,ii,lit);
#if defined(LZO_EOF_CODE)
*op++ = M4_MARKER | 1;
*op++ = 0;
*op++ = 0;
#endif
c->codesize = pd(op, out);
assert(c->textsize == in_len);
*out_len = pd(op, out);
if (c->cb && c->cb->nprogress)
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
#if 0
printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n",
(long) c->textsize, (long) in_len, (long) c->codesize,
c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m,
c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy);
#endif
assert(c->lit_bytes + c->match_bytes == in_len);
return LZO_E_OK;
}
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
lzo1x_999_compress_level ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
const lzo_bytep dict, lzo_uint dict_len,
lzo_callback_p cb,
int compression_level )
{
static const struct
{
int try_lazy_parm;
lzo_uint good_length;
lzo_uint max_lazy;
lzo_uint nice_length;
lzo_uint max_chain;
lzo_uint32_t flags;
} c[9] = {
/* faster compression */
{ 0, 0, 0, 8, 4, 0 },
{ 0, 0, 0, 16, 8, 0 },
{ 0, 0, 0, 32, 16, 0 },
{ 1, 4, 4, 16, 16, 0 },
{ 1, 8, 16, 32, 32, 0 },
{ 1, 8, 16, 128, 128, 0 },
{ 2, 8, 32, 128, 256, 0 },
{ 2, 32, 128, SWD_F, 2048, 1 },
{ 2, SWD_F, SWD_F, SWD_F, 4096, 1 }
/* max. compression */
};
if (compression_level < 1 || compression_level > 9)
return LZO_E_ERROR;
compression_level -= 1;
return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem,
dict, dict_len, cb,
c[compression_level].try_lazy_parm,
c[compression_level].good_length,
c[compression_level].max_lazy,
#if 0
c[compression_level].nice_length,
#else
0,
#endif
c[compression_level].max_chain,
c[compression_level].flags);
}
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
lzo1x_999_compress_dict ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
const lzo_bytep dict, lzo_uint dict_len )
{
return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
dict, dict_len, 0, 8);
}
LZO_PUBLIC(int)
lzo1x_999_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
NULL, 0, (lzo_callback_p) 0, 8);
}
/* vim:set ts=4 sw=4 et: */

403
vendor/lzo-2.10/src/lzo1x_c.ch vendored Normal file
View File

@@ -0,0 +1,403 @@
/* lzo1x_c.ch -- implementation of the LZO1[XY]-1 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#if 1 && defined(DO_COMPRESS) && !defined(do_compress)
/* choose a unique name to better help PGO optimizations */
# define do_compress LZO_PP_ECONCAT2(DO_COMPRESS,_core)
#endif
/***********************************************************************
// compress a block of data.
************************************************************************/
static __lzo_noinline lzo_uint
do_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_uint ti, lzo_voidp wrkmem)
{
const lzo_bytep ip;
lzo_bytep op;
const lzo_bytep const in_end = in + in_len;
const lzo_bytep const ip_end = in + in_len - 20;
const lzo_bytep ii;
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
op = out;
ip = in;
ii = ip;
ip += ti < 4 ? 4 - ti : 0;
for (;;)
{
const lzo_bytep m_pos;
#if !(LZO_DETERMINISTIC)
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
lzo_uint m_len;
lzo_uint dindex;
next:
if __lzo_unlikely(ip >= ip_end)
break;
DINDEX1(dindex,ip);
GINDEX(m_pos,m_off,dict,dindex,in);
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_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,M4_MAX_OFFSET))
goto literal;
if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
goto try_match;
goto literal;
try_match:
#if (LZO_OPT_UNALIGNED32)
if (UA_GET_NE32(m_pos) != UA_GET_NE32(ip))
#else
if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3])
#endif
{
/* a literal */
literal:
UPDATE_I(dict,0,dindex,ip,in);
ip += 1 + ((ip - ii) >> 5);
continue;
}
/*match:*/
UPDATE_I(dict,0,dindex,ip,in);
#else
lzo_uint m_off;
lzo_uint m_len;
{
lzo_uint32_t dv;
lzo_uint dindex;
literal:
ip += 1 + ((ip - ii) >> 5);
next:
if __lzo_unlikely(ip >= ip_end)
break;
dv = UA_GET_LE32(ip);
dindex = DINDEX(dv,ip);
GINDEX(m_off,m_pos,in+dict,dindex,in);
UPDATE_I(dict,0,dindex,ip,in);
if __lzo_unlikely(dv != UA_GET_LE32(m_pos))
goto literal;
}
#endif
/* a match */
ii -= ti; ti = 0;
{
lzo_uint t = pd(ip,ii);
if (t != 0)
{
if (t <= 3)
{
op[-2] = LZO_BYTE(op[-2] | t);
#if (LZO_OPT_UNALIGNED32)
UA_COPY4(op, ii);
op += t;
#else
{ do *op++ = *ii++; while (--t > 0); }
#endif
}
#if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64)
else if (t <= 16)
{
*op++ = LZO_BYTE(t - 3);
UA_COPY8(op, ii);
UA_COPY8(op+8, ii+8);
op += t;
}
#endif
else
{
if (t <= 18)
*op++ = LZO_BYTE(t - 3);
else
{
lzo_uint tt = t - 18;
*op++ = 0;
while __lzo_unlikely(tt > 255)
{
tt -= 255;
UA_SET1(op, 0);
op++;
}
assert(tt > 0);
*op++ = LZO_BYTE(tt);
}
#if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64)
do {
UA_COPY8(op, ii);
UA_COPY8(op+8, ii+8);
op += 16; ii += 16; t -= 16;
} while (t >= 16); if (t > 0)
#endif
{ do *op++ = *ii++; while (--t > 0); }
}
}
}
m_len = 4;
{
#if (LZO_OPT_UNALIGNED64)
lzo_uint64_t v;
v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len);
if __lzo_unlikely(v == 0) {
do {
m_len += 8;
v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len);
if __lzo_unlikely(ip + m_len >= ip_end)
goto m_len_done;
} while (v == 0);
}
#if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz64)
m_len += lzo_bitops_ctlz64(v) / CHAR_BIT;
#elif (LZO_ABI_BIG_ENDIAN)
if ((v >> (64 - CHAR_BIT)) == 0) do {
v <<= CHAR_BIT;
m_len += 1;
} while ((v >> (64 - CHAR_BIT)) == 0);
#elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz64)
m_len += lzo_bitops_cttz64(v) / CHAR_BIT;
#elif (LZO_ABI_LITTLE_ENDIAN)
if ((v & UCHAR_MAX) == 0) do {
v >>= CHAR_BIT;
m_len += 1;
} while ((v & UCHAR_MAX) == 0);
#else
if (ip[m_len] == m_pos[m_len]) do {
m_len += 1;
} while (ip[m_len] == m_pos[m_len]);
#endif
#elif (LZO_OPT_UNALIGNED32)
lzo_uint32_t v;
v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
if __lzo_unlikely(v == 0) {
do {
m_len += 4;
v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
if (v != 0)
break;
m_len += 4;
v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
if __lzo_unlikely(ip + m_len >= ip_end)
goto m_len_done;
} while (v == 0);
}
#if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz32)
m_len += lzo_bitops_ctlz32(v) / CHAR_BIT;
#elif (LZO_ABI_BIG_ENDIAN)
if ((v >> (32 - CHAR_BIT)) == 0) do {
v <<= CHAR_BIT;
m_len += 1;
} while ((v >> (32 - CHAR_BIT)) == 0);
#elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz32)
m_len += lzo_bitops_cttz32(v) / CHAR_BIT;
#elif (LZO_ABI_LITTLE_ENDIAN)
if ((v & UCHAR_MAX) == 0) do {
v >>= CHAR_BIT;
m_len += 1;
} while ((v & UCHAR_MAX) == 0);
#else
if (ip[m_len] == m_pos[m_len]) do {
m_len += 1;
} while (ip[m_len] == m_pos[m_len]);
#endif
#else
if __lzo_unlikely(ip[m_len] == m_pos[m_len]) {
do {
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if __lzo_unlikely(ip + m_len >= ip_end)
goto m_len_done;
} while (ip[m_len] == m_pos[m_len]);
}
#endif
}
m_len_done:
m_off = pd(ip,m_pos);
ip += m_len;
ii = ip;
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
{
m_off -= 1;
#if defined(LZO1X)
*op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2));
*op++ = LZO_BYTE(m_off >> 3);
#elif defined(LZO1Y)
*op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2));
*op++ = LZO_BYTE(m_off >> 2);
#endif
}
else if (m_off <= M3_MAX_OFFSET)
{
m_off -= 1;
if (m_len <= M3_MAX_LEN)
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
else
{
m_len -= M3_MAX_LEN;
*op++ = M3_MARKER | 0;
while __lzo_unlikely(m_len > 255)
{
m_len -= 255;
UA_SET1(op, 0);
op++;
}
*op++ = LZO_BYTE(m_len);
}
*op++ = LZO_BYTE(m_off << 2);
*op++ = LZO_BYTE(m_off >> 6);
}
else
{
m_off -= 0x4000;
if (m_len <= M4_MAX_LEN)
*op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2));
else
{
m_len -= M4_MAX_LEN;
*op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8));
while __lzo_unlikely(m_len > 255)
{
m_len -= 255;
UA_SET1(op, 0);
op++;
}
*op++ = LZO_BYTE(m_len);
}
*op++ = LZO_BYTE(m_off << 2);
*op++ = LZO_BYTE(m_off >> 6);
}
goto next;
}
*out_len = pd(op, out);
return pd(in_end,ii-ti);
}
/***********************************************************************
// public entry point
************************************************************************/
LZO_PUBLIC(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 = in;
lzo_bytep op = out;
lzo_uint l = in_len;
lzo_uint t = 0;
while (l > 20)
{
lzo_uint ll = l;
lzo_uintptr_t ll_end;
#if 0 || (LZO_DETERMINISTIC)
ll = LZO_MIN(ll, 49152);
#endif
ll_end = (lzo_uintptr_t)ip + ll;
if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll)
break;
#if (LZO_DETERMINISTIC)
lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t));
#endif
t = do_compress(ip,ll,op,out_len,t,wrkmem);
ip += ll;
op += *out_len;
l -= ll;
}
t += l;
if (t > 0)
{
const lzo_bytep ii = in + in_len - t;
if (op == out && t <= 238)
*op++ = LZO_BYTE(17 + t);
else if (t <= 3)
op[-2] = LZO_BYTE(op[-2] | t);
else if (t <= 18)
*op++ = LZO_BYTE(t - 3);
else
{
lzo_uint tt = t - 18;
*op++ = 0;
while (tt > 255)
{
tt -= 255;
UA_SET1(op, 0);
op++;
}
assert(tt > 0);
*op++ = LZO_BYTE(tt);
}
UA_COPYN(op, ii, t);
op += t;
}
*op++ = M4_MARKER | 1;
*op++ = 0;
*op++ = 0;
*out_len = pd(op, out);
return LZO_E_OK;
}
/* vim:set ts=4 sw=4 et: */

475
vendor/lzo-2.10/src/lzo1x_d.ch vendored Normal file
View File

@@ -0,0 +1,475 @@
/* lzo1x_d.ch -- implementation of the LZO1X decompression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo1_d.ch"
/***********************************************************************
// decompress a block of data.
************************************************************************/
#if defined(DO_DECOMPRESS)
LZO_PUBLIC(int)
DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
#endif
{
lzo_bytep op;
const lzo_bytep ip;
lzo_uint t;
#if defined(COPY_DICT)
lzo_uint m_off;
const lzo_bytep dict_end;
#else
const lzo_bytep m_pos;
#endif
const lzo_bytep const ip_end = in + in_len;
#if defined(HAVE_ANY_OP)
lzo_bytep const op_end = out + *out_len;
#endif
#if defined(LZO1Z)
lzo_uint last_m_off = 0;
#endif
LZO_UNUSED(wrkmem);
#if defined(COPY_DICT)
if (dict)
{
if (dict_len > M4_MAX_OFFSET)
{
dict += dict_len - M4_MAX_OFFSET;
dict_len = M4_MAX_OFFSET;
}
dict_end = dict + dict_len;
}
else
{
dict_len = 0;
dict_end = NULL;
}
#endif /* COPY_DICT */
*out_len = 0;
op = out;
ip = in;
NEED_IP(1);
if (*ip > 17)
{
t = *ip++ - 17;
if (t < 4)
goto match_next;
assert(t > 0); NEED_OP(t); NEED_IP(t+3);
do *op++ = *ip++; while (--t > 0);
goto first_literal_run;
}
for (;;)
{
NEED_IP(3);
t = *ip++;
if (t >= 16)
goto match;
/* a literal run */
if (t == 0)
{
while (*ip == 0)
{
t += 255;
ip++;
TEST_IV(t);
NEED_IP(1);
}
t += 15 + *ip++;
}
/* copy literals */
assert(t > 0); NEED_OP(t+3); NEED_IP(t+6);
#if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32)
t += 3;
if (t >= 8) do
{
UA_COPY8(op,ip);
op += 8; ip += 8; t -= 8;
} while (t >= 8);
if (t >= 4)
{
UA_COPY4(op,ip);
op += 4; ip += 4; t -= 4;
}
if (t > 0)
{
*op++ = *ip++;
if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
}
#elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4)
#if !(LZO_OPT_UNALIGNED32)
if (PTR_ALIGNED2_4(op,ip))
{
#endif
UA_COPY4(op,ip);
op += 4; ip += 4;
if (--t > 0)
{
if (t >= 4)
{
do {
UA_COPY4(op,ip);
op += 4; ip += 4; t -= 4;
} while (t >= 4);
if (t > 0) do *op++ = *ip++; while (--t > 0);
}
else
do *op++ = *ip++; while (--t > 0);
}
#if !(LZO_OPT_UNALIGNED32)
}
else
#endif
#endif
#if !(LZO_OPT_UNALIGNED32)
{
*op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
do *op++ = *ip++; while (--t > 0);
}
#endif
first_literal_run:
t = *ip++;
if (t >= 16)
goto match;
#if defined(COPY_DICT)
#if defined(LZO1Z)
m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
last_m_off = m_off;
#else
m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2);
#endif
NEED_OP(3);
t = 3; COPY_DICT(t,m_off)
#else /* !COPY_DICT */
#if defined(LZO1Z)
t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
m_pos = op - t;
last_m_off = t;
#else
m_pos = op - (1 + M2_MAX_OFFSET);
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
#endif
TEST_LB(m_pos); NEED_OP(3);
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
#endif /* COPY_DICT */
goto match_done;
/* handle matches */
for (;;) {
match:
if (t >= 64) /* a M2 match */
{
#if defined(COPY_DICT)
#if defined(LZO1X)
m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3);
t = (t >> 5) - 1;
#elif defined(LZO1Y)
m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2);
t = (t >> 4) - 3;
#elif defined(LZO1Z)
m_off = t & 0x1f;
if (m_off >= 0x1c)
m_off = last_m_off;
else
{
m_off = 1 + (m_off << 6) + (*ip++ >> 2);
last_m_off = m_off;
}
t = (t >> 5) - 1;
#endif
#else /* !COPY_DICT */
#if defined(LZO1X)
m_pos = op - 1;
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
t = (t >> 5) - 1;
#elif defined(LZO1Y)
m_pos = op - 1;
m_pos -= (t >> 2) & 3;
m_pos -= *ip++ << 2;
t = (t >> 4) - 3;
#elif defined(LZO1Z)
{
lzo_uint off = t & 0x1f;
m_pos = op;
if (off >= 0x1c)
{
assert(last_m_off > 0);
m_pos -= last_m_off;
}
else
{
off = 1 + (off << 6) + (*ip++ >> 2);
m_pos -= off;
last_m_off = off;
}
}
t = (t >> 5) - 1;
#endif
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
goto copy_match;
#endif /* COPY_DICT */
}
else if (t >= 32) /* a M3 match */
{
t &= 31;
if (t == 0)
{
while (*ip == 0)
{
t += 255;
ip++;
TEST_OV(t);
NEED_IP(1);
}
t += 31 + *ip++;
NEED_IP(2);
}
#if defined(COPY_DICT)
#if defined(LZO1Z)
m_off = 1 + (ip[0] << 6) + (ip[1] >> 2);
last_m_off = m_off;
#else
m_off = 1 + (ip[0] >> 2) + (ip[1] << 6);
#endif
#else /* !COPY_DICT */
#if defined(LZO1Z)
{
lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2);
m_pos = op - off;
last_m_off = off;
}
#elif (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
m_pos = op - 1;
m_pos -= UA_GET_LE16(ip) >> 2;
#else
m_pos = op - 1;
m_pos -= (ip[0] >> 2) + (ip[1] << 6);
#endif
#endif /* COPY_DICT */
ip += 2;
}
else if (t >= 16) /* a M4 match */
{
#if defined(COPY_DICT)
m_off = (t & 8) << 11;
#else /* !COPY_DICT */
m_pos = op;
m_pos -= (t & 8) << 11;
#endif /* COPY_DICT */
t &= 7;
if (t == 0)
{
while (*ip == 0)
{
t += 255;
ip++;
TEST_OV(t);
NEED_IP(1);
}
t += 7 + *ip++;
NEED_IP(2);
}
#if defined(COPY_DICT)
#if defined(LZO1Z)
m_off += (ip[0] << 6) + (ip[1] >> 2);
#else
m_off += (ip[0] >> 2) + (ip[1] << 6);
#endif
ip += 2;
if (m_off == 0)
goto eof_found;
m_off += 0x4000;
#if defined(LZO1Z)
last_m_off = m_off;
#endif
#else /* !COPY_DICT */
#if defined(LZO1Z)
m_pos -= (ip[0] << 6) + (ip[1] >> 2);
#elif (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
m_pos -= UA_GET_LE16(ip) >> 2;
#else
m_pos -= (ip[0] >> 2) + (ip[1] << 6);
#endif
ip += 2;
if (m_pos == op)
goto eof_found;
m_pos -= 0x4000;
#if defined(LZO1Z)
last_m_off = pd((const lzo_bytep)op, m_pos);
#endif
#endif /* COPY_DICT */
}
else /* a M1 match */
{
#if defined(COPY_DICT)
#if defined(LZO1Z)
m_off = 1 + (t << 6) + (*ip++ >> 2);
last_m_off = m_off;
#else
m_off = 1 + (t >> 2) + (*ip++ << 2);
#endif
NEED_OP(2);
t = 2; COPY_DICT(t,m_off)
#else /* !COPY_DICT */
#if defined(LZO1Z)
t = 1 + (t << 6) + (*ip++ >> 2);
m_pos = op - t;
last_m_off = t;
#else
m_pos = op - 1;
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
#endif
TEST_LB(m_pos); NEED_OP(2);
*op++ = *m_pos++; *op++ = *m_pos;
#endif /* COPY_DICT */
goto match_done;
}
/* copy match */
#if defined(COPY_DICT)
NEED_OP(t+3-1);
t += 3-1; COPY_DICT(t,m_off)
#else /* !COPY_DICT */
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
#if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32)
if (op - m_pos >= 8)
{
t += (3 - 1);
if (t >= 8) do
{
UA_COPY8(op,m_pos);
op += 8; m_pos += 8; t -= 8;
} while (t >= 8);
if (t >= 4)
{
UA_COPY4(op,m_pos);
op += 4; m_pos += 4; t -= 4;
}
if (t > 0)
{
*op++ = m_pos[0];
if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } }
}
}
else
#elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4)
#if !(LZO_OPT_UNALIGNED32)
if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos))
{
assert((op - m_pos) >= 4); /* both pointers are aligned */
#else
if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
{
#endif
UA_COPY4(op,m_pos);
op += 4; m_pos += 4; t -= 4 - (3 - 1);
do {
UA_COPY4(op,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_match:
*op++ = *m_pos++; *op++ = *m_pos++;
do *op++ = *m_pos++; while (--t > 0);
}
#endif /* COPY_DICT */
match_done:
#if defined(LZO1Z)
t = ip[-1] & 3;
#else
t = ip[-2] & 3;
#endif
if (t == 0)
break;
/* copy literals */
match_next:
assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+3);
#if 0
do *op++ = *ip++; while (--t > 0);
#else
*op++ = *ip++;
if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
#endif
t = *ip++;
}
}
eof_found:
*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
}
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1x_d1.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1x_d1.c -- LZO1X decompression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1x.h"
#undef LZO_TEST_OVERRUN
#define DO_DECOMPRESS lzo1x_decompress
#include "lzo1x_d.ch"
/* vim:set ts=4 sw=4 et: */

61
vendor/lzo-2.10/src/lzo1x_d2.c vendored Normal file
View File

@@ -0,0 +1,61 @@
/* lzo1x_d2.c -- LZO1X decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1x.h"
#define LZO_TEST_OVERRUN 1
#define DO_DECOMPRESS lzo1x_decompress_safe
#include "lzo1x_d.ch"
#if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
LZO_EXTERN(int) lzo1x_decompress_asm_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem);
LZO_PUBLIC(int) lzo1x_decompress_asm_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem)
{
return lzo1x_decompress_safe(src, src_len, dst, dst_len, wrkmem);
}
LZO_EXTERN(int) lzo1x_decompress_asm_fast_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem);
LZO_PUBLIC(int) lzo1x_decompress_asm_fast_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem)
{
return lzo1x_decompress_safe(src, src_len, dst, dst_len, wrkmem);
}
#endif
/* vim:set ts=4 sw=4 et: */

93
vendor/lzo-2.10/src/lzo1x_d3.c vendored Normal file
View File

@@ -0,0 +1,93 @@
/* lzo1x_d3.c -- LZO1X decompression with preset dictionary
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1x.h"
#define LZO_TEST_OVERRUN 1
#define SLOW_MEMCPY(a,b,l) { do *a++ = *b++; while (--l > 0); }
#define FAST_MEMCPY(a,b,l) { lzo_memcpy(a,b,l); a += l; }
#if 1 && defined(FAST_MEMCPY)
# define DICT_MEMMOVE(op,m_pos,m_len,m_off) \
if (m_off >= (m_len)) \
FAST_MEMCPY(op,m_pos,m_len) \
else \
SLOW_MEMCPY(op,m_pos,m_len)
#else
# define DICT_MEMMOVE(op,m_pos,m_len,m_off) \
SLOW_MEMCPY(op,m_pos,m_len)
#endif
#if !defined(FAST_MEMCPY)
# define FAST_MEMCPY SLOW_MEMCPY
#endif
#define COPY_DICT_DICT(m_len,m_off) \
{ \
const lzo_bytep m_pos; \
m_off -= pd(op, out); assert(m_off > 0); \
if (m_off > dict_len) goto lookbehind_overrun; \
m_pos = dict_end - m_off; \
if (m_len > m_off) \
{ \
m_len -= m_off; \
FAST_MEMCPY(op,m_pos,m_off) \
m_pos = out; \
SLOW_MEMCPY(op,m_pos,m_len) \
} \
else \
FAST_MEMCPY(op,m_pos,m_len) \
}
#define COPY_DICT(m_len,m_off) \
assert(m_len >= 2); assert(m_off > 0); assert(op > out); \
if (m_off <= pd(op, out)) \
{ \
const lzo_bytep m_pos = op - m_off; \
DICT_MEMMOVE(op,m_pos,m_len,m_off) \
} \
else \
COPY_DICT_DICT(m_len,m_off)
LZO_PUBLIC(int)
lzo1x_decompress_dict_safe ( const lzo_bytep in, lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem /* NOT USED */,
const lzo_bytep dict, lzo_uint dict_len)
#include "lzo1x_d.ch"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1x_o.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1x_o.c -- LZO1X compressed data optimizer
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1x.h"
#define DO_OPTIMIZE lzo1x_optimize
#include "lzo1x_oo.ch"
/* vim:set ts=4 sw=4 et: */

352
vendor/lzo-2.10/src/lzo1x_oo.ch vendored Normal file
View File

@@ -0,0 +1,352 @@
/* lzo1x_oo.ch -- LZO1X compressed data optimizer
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define TEST_IP (ip < ip_end)
#define TEST_OP (op <= op_end)
#define TEST_IP_AND_TEST_OP (TEST_IP && TEST_OP)
#define NO_LIT LZO_UINT_MAX
/***********************************************************************
//
************************************************************************/
static void copy2(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off)
{
assert(off > 0);
ip[0] = m_pos[0];
if (off == 1)
ip[1] = m_pos[0];
else
ip[1] = m_pos[1];
}
static void copy3(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off)
{
assert(off > 0);
ip[0] = m_pos[0];
if (off == 1)
{
ip[2] = ip[1] = m_pos[0];
}
else if (off == 2)
{
ip[1] = m_pos[1];
ip[2] = m_pos[0];
}
else
{
ip[1] = m_pos[1];
ip[2] = m_pos[2];
}
}
/***********************************************************************
// optimize a block of data.
************************************************************************/
LZO_PUBLIC(int)
DO_OPTIMIZE ( lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
lzo_bytep op;
lzo_bytep ip;
lzo_uint t;
lzo_bytep m_pos;
lzo_bytep const ip_end = in + in_len;
lzo_bytep const op_end = out + *out_len;
lzo_bytep litp = NULL;
lzo_uint lit = 0;
lzo_uint next_lit = NO_LIT;
lzo_uint nl;
unsigned long o_m1_a = 0, o_m1_b = 0, o_m2 = 0, o_m3_a = 0, o_m3_b = 0;
LZO_UNUSED(wrkmem);
*out_len = 0;
op = out;
ip = in;
assert(in_len >= 3);
if (*ip > 17)
{
t = *ip++ - 17;
if (t < 4)
goto match_next;
goto first_literal_run;
}
assert(*ip < 16 || (*ip == 17 && in_len == 3));
while (TEST_IP_AND_TEST_OP)
{
t = *ip++;
if (t >= 16)
goto match;
/* a literal run */
litp = ip - 1;
if (t == 0)
{
t = 15;
while (*ip == 0)
{ t += 255; ip++; }
t += *ip++;
}
lit = t + 3;
/* copy literals */
copy_literal_run:
*op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
first_literal_run:
do *op++ = *ip++; while (--t > 0);
t = *ip++;
if (t >= 16)
goto match;
#if defined(LZO1X)
m_pos = op - 1 - 0x800;
#elif defined(LZO1Y)
m_pos = op - 1 - 0x400;
#endif
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
lit = 0;
goto match_done;
/* handle matches */
do {
if (t < 16) /* a M1 match */
{
m_pos = op - 1;
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
if (litp == NULL)
goto copy_m1;
/* assert that there was a match just before */
assert(lit >= 1 && lit <= 3);
assert(litp == ip - 2 - lit - 2);
assert((lzo_uint)(*litp & 3) == lit);
nl = ip[-2] & 3;
/* test if a match follows */
if (nl == 0 && lit == 1 && ip[0] >= 16)
{
next_lit = nl;
/* adjust length of previous short run */
lit += 2;
*litp = LZO_BYTE((*litp & ~3) | lit);
/* copy over the 2 literals that replace the match */
copy2(ip-2,m_pos,pd(op,m_pos));
o_m1_a++;
}
/* test if a literal run follows */
else if (nl == 0 && ip[0] < 16 && ip[0] != 0 &&
(lit + 2 + ip[0] < 16))
{
t = *ip++;
/* remove short run */
*litp &= ~3;
/* copy over the 2 literals that replace the match */
copy2(ip-3+1,m_pos,pd(op,m_pos));
/* move literals 1 byte ahead */
litp += 2;
if (lit > 0)
lzo_memmove(litp+1,litp,lit);
/* insert new length of long literal run */
lit += 2 + t + 3; assert(lit <= 18);
*litp = LZO_BYTE(lit - 3);
o_m1_b++;
*op++ = *m_pos++; *op++ = *m_pos++;
goto copy_literal_run;
}
copy_m1:
*op++ = *m_pos++; *op++ = *m_pos++;
}
else
{
match:
if (t >= 64) /* a M2 match */
{
m_pos = op - 1;
#if defined(LZO1X)
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
t = (t >> 5) - 1;
#elif defined(LZO1Y)
m_pos -= (t >> 2) & 3;
m_pos -= *ip++ << 2;
t = (t >> 4) - 3;
#endif
if (litp == NULL)
goto copy_m;
nl = ip[-2] & 3;
/* test if in beetween two long literal runs */
if (t == 1 && lit > 3 && nl == 0 &&
ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16))
{
assert(*litp == lit - 3);
t = *ip++;
/* copy over the 3 literals that replace the match */
copy3(ip-1-2,m_pos,pd(op,m_pos));
/* set new length of previous literal run */
lit += 3 + t + 3; assert(lit <= 18);
*litp = LZO_BYTE(lit - 3);
o_m2++;
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
goto copy_literal_run;
}
}
else
{
if (t >= 32) /* a M3 match */
{
t &= 31;
if (t == 0)
{
t = 31;
while (*ip == 0)
{ t += 255; ip++; }
t += *ip++;
}
m_pos = op - 1;
m_pos -= *ip++ >> 2;
m_pos -= *ip++ << 6;
}
else /* a M4 match */
{
m_pos = op;
m_pos -= (t & 8) << 11;
t &= 7;
if (t == 0)
{
t = 7;
while (*ip == 0)
{ t += 255; ip++; }
t += *ip++;
}
m_pos -= *ip++ >> 2;
m_pos -= *ip++ << 6;
if (m_pos == op)
goto eof_found;
m_pos -= 0x4000;
}
if (litp == NULL)
goto copy_m;
nl = ip[-2] & 3;
/* test if in beetween two matches */
if (t == 1 && lit == 0 && nl == 0 && ip[0] >= 16)
{
assert(litp == ip - 3 - lit - 2);
assert((lzo_uint)(*litp & 3) == lit);
next_lit = nl;
/* make a previous short run */
lit += 3;
*litp = LZO_BYTE((*litp & ~3) | lit);
/* copy over the 3 literals that replace the match */
copy3(ip-3,m_pos,pd(op,m_pos));
o_m3_a++;
}
/* test if a literal run follows */
else if (t == 1 && lit <= 3 && nl == 0 &&
ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16))
{
assert(litp == ip - 3 - lit - 2);
assert((lzo_uint)(*litp & 3) == lit);
t = *ip++;
/* remove short run */
*litp &= ~3;
/* copy over the 3 literals that replace the match */
copy3(ip-4+1,m_pos,pd(op,m_pos));
/* move literals 1 byte ahead */
litp += 2;
if (lit > 0)
lzo_memmove(litp+1,litp,lit);
/* insert new length of long literal run */
lit += 3 + t + 3; assert(lit <= 18);
*litp = LZO_BYTE(lit - 3);
o_m3_b++;
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
goto copy_literal_run;
}
}
copy_m:
*op++ = *m_pos++; *op++ = *m_pos++;
do *op++ = *m_pos++; while (--t > 0);
}
match_done:
if (next_lit == NO_LIT)
{
t = ip[-2] & 3;
lit = t;
litp = ip - 2;
}
else
t = next_lit;
assert(t <= 3);
next_lit = NO_LIT;
if (t == 0)
break;
/* copy literals */
match_next:
do *op++ = *ip++; while (--t > 0);
t = *ip++;
} while (TEST_IP_AND_TEST_OP);
}
/* no EOF code was found */
*out_len = pd(op, out);
return LZO_E_EOF_NOT_FOUND;
eof_found:
assert(t == 1);
#if 0
printf("optimize: %5lu %5lu %5lu %5lu %5lu\n",
o_m1_a, o_m1_b, o_m2, o_m3_a, o_m3_b);
#endif
LZO_UNUSED(o_m1_a); LZO_UNUSED(o_m1_b); LZO_UNUSED(o_m2);
LZO_UNUSED(o_m3_a); LZO_UNUSED(o_m3_b);
*out_len = pd(op, out);
return (ip == ip_end ? LZO_E_OK :
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
}
/* vim:set ts=4 sw=4 et: */

57
vendor/lzo-2.10/src/lzo1y_1.c vendored Normal file
View File

@@ -0,0 +1,57 @@
/* lzo1y_1.c -- LZO1Y-1 compression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
#if 1 && defined(UA_GET_LE32)
#undef LZO_DICT_USE_PTR
#define LZO_DICT_USE_PTR 0
#undef lzo_dict_t
#define lzo_dict_t lzo_uint16_t
#endif
#define LZO_NEED_DICT_H 1
#ifndef D_BITS
#define D_BITS 14
#endif
#define D_INDEX1(d,p) d = DX3(p,5,5,6); d += d >> 5; d = DM(d)
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
#if 1
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
#else
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
#endif
#include "config1y.h"
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
#ifndef DO_COMPRESS
#define DO_COMPRESS lzo1y_1_compress
#endif
#include "lzo1x_c.ch"
/* vim:set ts=4 sw=4 et: */

32
vendor/lzo-2.10/src/lzo1y_9x.c vendored Normal file
View File

@@ -0,0 +1,32 @@
/* lzo1y_9x.c -- implementation of the LZO1Y-999 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define LZO1Y 1
#include "lzo1x_9x.c"
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1y_d1.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1y_d1.c -- LZO1Y decompression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1y.h"
#undef LZO_TEST_OVERRUN
#define DO_DECOMPRESS lzo1y_decompress
#include "lzo1x_d.ch"
/* vim:set ts=4 sw=4 et: */

61
vendor/lzo-2.10/src/lzo1y_d2.c vendored Normal file
View File

@@ -0,0 +1,61 @@
/* lzo1y_d2.c -- LZO1Y decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1y.h"
#define LZO_TEST_OVERRUN 1
#define DO_DECOMPRESS lzo1y_decompress_safe
#include "lzo1x_d.ch"
#if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
LZO_EXTERN(int) lzo1y_decompress_asm_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem);
LZO_PUBLIC(int) lzo1y_decompress_asm_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem)
{
return lzo1y_decompress_safe(src, src_len, dst, dst_len, wrkmem);
}
LZO_EXTERN(int) lzo1y_decompress_asm_fast_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem);
LZO_PUBLIC(int) lzo1y_decompress_asm_fast_safe
(const lzo_bytep src, lzo_uint src_len,
lzo_bytep dst, lzo_uintp dst_len,
lzo_voidp wrkmem)
{
return lzo1y_decompress_safe(src, src_len, dst, dst_len, wrkmem);
}
#endif
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1y_d3.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1y_d3.c -- LZO1Y decompression with preset dictionary
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1y.h"
#define lzo1x_decompress_dict_safe lzo1y_decompress_dict_safe
#include "lzo1x_d3.c"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1y_o.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1y_o.c -- LZO1Y compressed data optimizer
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1y.h"
#define DO_OPTIMIZE lzo1y_optimize
#include "lzo1x_oo.ch"
/* vim:set ts=4 sw=4 et: */

32
vendor/lzo-2.10/src/lzo1z_9x.c vendored Normal file
View File

@@ -0,0 +1,32 @@
/* lzo1z_9x.c -- implementation of the LZO1Z-999 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#define LZO1Z 1
#include "lzo1x_9x.c"
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1z_d1.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1z_d1.c -- LZO1Z decompression
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1z.h"
#undef LZO_TEST_OVERRUN
#define DO_DECOMPRESS lzo1z_decompress
#include "lzo1x_d.ch"
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo1z_d2.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo1z_d2.c -- LZO1Z decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1z.h"
#define LZO_TEST_OVERRUN 1
#define DO_DECOMPRESS lzo1z_decompress_safe
#include "lzo1x_d.ch"
/* vim:set ts=4 sw=4 et: */

35
vendor/lzo-2.10/src/lzo1z_d3.c vendored Normal file
View File

@@ -0,0 +1,35 @@
/* lzo1z_d3.c -- LZO1Z decompression with preset dictionary
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config1z.h"
#define lzo1x_decompress_dict_safe lzo1z_decompress_dict_safe
#include "lzo1x_d3.c"
/* vim:set ts=4 sw=4 et: */

346
vendor/lzo-2.10/src/lzo2a_9x.c vendored Normal file
View File

@@ -0,0 +1,346 @@
/* lzo2a_9x.c -- implementation of the LZO2A-999 compression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config2a.h"
/***********************************************************************
//
************************************************************************/
#define SWD_THRESHOLD 1 /* lower limit for match length */
#define SWD_F 2048 /* upper limit for match length */
#define LZO2A 1
#define LZO_COMPRESS_T lzo2a_999_t
#define lzo_swd_t lzo2a_999_swd_t
#include "lzo_mchw.ch"
#if (LZO_CC_BORLANDC && LZO_MM_FLAT)
# if ((__BORLANDC__) >= 0x0450 && (__BORLANDC__) < 0x0460)
/* avoid internal compiler error */
# pragma option -Od
# endif
#endif
/***********************************************************************
//
************************************************************************/
#define putbyte(x) *op++ = LZO_BYTE(x)
#define putbits(j,x) \
if (k == 0) bitp = op++; \
SETBITS(j,x); \
if (k >= 8) { *bitp = LZO_BYTE(MASKBITS(8)); DUMPBITS(8); \
if (k > 0) bitp = op++; }
#define putbit(x) putbits(1,x)
/***********************************************************************
// this is a public function, but there is no prototype in a header file
************************************************************************/
LZO_EXTERN(int)
lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain );
LZO_PUBLIC(int)
lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain )
{
lzo_bytep op;
lzo_bytep bitp = 0;
lzo_uint m_len, m_off;
LZO_COMPRESS_T cc;
LZO_COMPRESS_T * const c = &cc;
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
int r;
lzo_uint32_t b = 0; /* bit buffer */
unsigned k = 0; /* bits in bit buffer */
/* sanity check */
LZO_COMPILE_TIME_ASSERT(LZO2A_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
c->init = 0;
c->ip = c->in = in;
c->in_end = in + in_len;
c->cb = cb;
c->m1 = c->m2 = c->m3 = c->m4 = 0;
op = out;
r = init_match(c,swd,NULL,0,0);
if (r != 0)
return r;
if (max_chain > 0)
swd->max_chain = max_chain;
r = find_match(c,swd,0,0);
if (r != 0)
return r;
while (c->look > 0)
{
lzo_uint lazy_match_min_gain = 0;
#if (SWD_N >= 8192)
lzo_uint extra1 = 0;
#endif
lzo_uint extra2 = 0;
lzo_uint ahead = 0;
m_len = c->m_len;
m_off = c->m_off;
#if (SWD_N >= 8192)
if (m_off >= 8192)
{
if (m_len < M3_MIN_LEN)
m_len = 0;
else
lazy_match_min_gain = 1;
}
else
#endif
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
lazy_match_min_gain = 2;
#if (SWD_N >= 8192)
extra1 = 3;
#endif
extra2 = 2;
}
else if (m_len >= 10)
lazy_match_min_gain = 1;
else if (m_len >= 3)
{
lazy_match_min_gain = 1;
#if (SWD_N >= 8192)
extra1 = 1;
#endif
}
else
m_len = 0;
/* try a lazy match */
if (lazy_match_min_gain > 0 && c->look > m_len)
{
unsigned char lit = LZO_BYTE(swd->b_char);
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
assert(c->look > 0);
#if (SWD_N >= 8192)
if (m_off < 8192 && c->m_off >= 8192)
lazy_match_min_gain += extra1;
else
#endif
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
if (!(c->m_len >= M1_MIN_LEN &&
c->m_len <= M1_MAX_LEN && c->m_off <= 256))
lazy_match_min_gain += extra2;
}
if (c->m_len >= M1_MIN_LEN &&
c->m_len <= M1_MAX_LEN && c->m_off <= 256)
{
lazy_match_min_gain -= 1;
}
if ((lzo_int) lazy_match_min_gain < 1)
lazy_match_min_gain = 1;
if (c->m_len >= m_len + lazy_match_min_gain)
{
c->lazy++;
#if !defined(NDEBUG)
m_len = c->m_len;
m_off = c->m_off;
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
assert(m_len >= 3 || (m_len >= 2 && m_off <= 256));
#endif
/* code literal */
putbit(0);
putbyte(lit);
c->lit_bytes++;
continue;
}
else
ahead = 1;
assert(m_len > 0);
}
if (m_len == 0)
{
/* a literal */
putbit(0);
putbyte(swd->b_char);
c->lit_bytes++;
r = find_match(c,swd,1,0);
assert(r == 0); LZO_UNUSED(r);
}
else
{
assert(m_len >= M1_MIN_LEN);
assert(m_off > 0);
assert(m_off <= SWD_N);
/* 2 - code match */
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
putbit(1);
putbit(0);
putbits(2,m_len - M1_MIN_LEN);
putbyte(m_off - 1);
c->m1++;
}
#if (SWD_N >= 8192)
else if (m_off >= 8192)
{
unsigned len = m_len;
assert(m_len >= M3_MIN_LEN);
putbit(1);
putbit(1);
putbyte(m_off & 31);
putbyte(m_off >> 5);
putbit(1);
len -= M3_MIN_LEN - 1;
while (len > 255)
{
len -= 255;
putbyte(0);
}
putbyte(len);
c->m4++;
}
#endif
else
{
assert(m_len >= 3);
putbit(1);
putbit(1);
if (m_len <= 9)
{
putbyte(((m_len - 2) << 5) | (m_off & 31));
putbyte(m_off >> 5);
c->m2++;
}
else
{
lzo_uint len = m_len;
putbyte(m_off & 31);
putbyte(m_off >> 5);
#if (SWD_N >= 8192)
putbit(0);
#endif
len -= 10 - 1;
while (len > 255)
{
len -= 255;
putbyte(0);
}
putbyte(len);
c->m3++;
}
}
r = find_match(c,swd,m_len,1+ahead);
assert(r == 0); LZO_UNUSED(r);
}
c->codesize = pd(op, out);
}
#if defined(LZO_EOF_CODE)
/* code EOF code */
putbit(1);
putbit(1);
putbyte(1 << 5);
putbyte(0);
#endif
/* flush remaining bits */
assert(k < CHAR_BIT);
if (k > 0)
{
assert(b == MASKBITS(k));
assert(op - bitp > 1);
*bitp = LZO_BYTE(MASKBITS(k));
DUMPBITS(k);
assert(b == 0);
assert(k == 0);
}
assert(c->textsize == in_len);
c->codesize = pd(op, out);
*out_len = pd(op, out);
if (c->cb && c->cb->nprogress)
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
#if 0
printf("%ld -> %ld: %ld %ld %ld %ld %ld %ld\n",
(long) c->textsize, (long) c->codesize,
c->lit_bytes, c->m1, c->m2, c->m3, c->m4, c->lazy);
#endif
return LZO_E_OK;
}
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
lzo2a_999_compress ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
return lzo2a_999_compress_callback(in,in_len,out,out_len,wrkmem,
(lzo_callback_p) 0, 0);
}
/* vim:set ts=4 sw=4 et: */

174
vendor/lzo-2.10/src/lzo2a_d.ch vendored Normal file
View File

@@ -0,0 +1,174 @@
/* lzo2a_d.ch -- implementation of the LZO2A decompression algorithm
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo1_d.ch"
/***********************************************************************
// decompress a block of data.
************************************************************************/
#define _NEEDBYTE NEED_IP(1)
#define _NEXTBYTE (*ip++)
LZO_PUBLIC(int)
DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem )
{
lzo_bytep op;
const lzo_bytep ip;
const lzo_bytep m_pos;
lzo_uint t;
const lzo_bytep const ip_end = in + in_len;
#if defined(HAVE_ANY_OP)
lzo_bytep const op_end = out + *out_len;
#endif
lzo_uint32_t b = 0; /* bit buffer */
unsigned k = 0; /* bits in bit buffer */
LZO_UNUSED(wrkmem);
op = out;
ip = in;
while (TEST_IP_AND_TEST_OP)
{
NEEDBITS(1);
if (MASKBITS(1) == 0)
{
DUMPBITS(1);
/* a literal */
NEED_IP(1); NEED_OP(1);
*op++ = *ip++;
continue;
}
DUMPBITS(1);
NEEDBITS(1);
if (MASKBITS(1) == 0)
{
DUMPBITS(1);
/* a M1 match */
NEEDBITS(2);
t = M1_MIN_LEN + (lzo_uint) MASKBITS(2);
DUMPBITS(2);
NEED_IP(1); NEED_OP(t);
m_pos = op - 1 - *ip++;
assert(m_pos >= out); assert(m_pos < op);
TEST_LB(m_pos);
MEMCPY_DS(op,m_pos,t);
continue;
}
DUMPBITS(1);
NEED_IP(2);
t = *ip++;
m_pos = op;
m_pos -= (t & 31) | (((lzo_uint) *ip++) << 5);
t >>= 5;
if (t == 0)
{
#if (SWD_N >= 8192)
NEEDBITS(1);
t = MASKBITS(1);
DUMPBITS(1);
if (t == 0)
t = 10 - 1;
else
{
/* a M3 match */
m_pos -= 8192; /* t << 13 */
t = M3_MIN_LEN - 1;
}
#else
t = 10 - 1;
#endif
NEED_IP(1);
while (*ip == 0)
{
t += 255;
ip++;
TEST_OV(t);
NEED_IP(1);
}
t += *ip++;
}
else
{
#if defined(LZO_EOF_CODE)
if (m_pos == op)
goto eof_found;
#endif
t += 2;
}
assert(m_pos >= out); assert(m_pos < op);
TEST_LB(m_pos);
NEED_OP(t);
MEMCPY_DS(op,m_pos,t);
}
#if defined(LZO_EOF_CODE)
#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
/* no EOF code was found */
*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
}
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo2a_d1.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo2a_d1.c -- LZO2A decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config2a.h"
#undef LZO_TEST_OVERRUN
#define DO_DECOMPRESS lzo2a_decompress
#include "lzo2a_d.ch"
/* vim:set ts=4 sw=4 et: */

36
vendor/lzo-2.10/src/lzo2a_d2.c vendored Normal file
View File

@@ -0,0 +1,36 @@
/* lzo2a_d2.c -- LZO2A decompression with overrun testing
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "config2a.h"
#define LZO_TEST_OVERRUN 1
#define DO_DECOMPRESS lzo2a_decompress_safe
#include "lzo2a_d.ch"
/* vim:set ts=4 sw=4 et: */

436
vendor/lzo-2.10/src/lzo_conf.h vendored Normal file
View File

@@ -0,0 +1,436 @@
/* lzo_conf.h -- main internal configuration file for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_CONF_H
#define __LZO_CONF_H 1
#if !defined(__LZO_IN_MINILZO)
#if defined(LZO_CFG_FREESTANDING) && (LZO_CFG_FREESTANDING)
# define LZO_LIBC_FREESTANDING 1
# define LZO_OS_FREESTANDING 1
#endif
#if defined(LZO_CFG_EXTRA_CONFIG_HEADER)
# include LZO_CFG_EXTRA_CONFIG_HEADER
#endif
#if defined(__LZOCONF_H) || defined(__LZOCONF_H_INCLUDED)
# error "include this file first"
#endif
#if defined(LZO_CFG_BUILD_DLL) && (LZO_CFG_BUILD_DLL+0) && !defined(__LZO_EXPORT1) && !defined(__LZO_EXPORT2) && 0
/* idea: we could auto-define __LZO_EXPORT1 for DLL exports */
#ifndef __LZODEFS_H_INCLUDED
#if defined(LZO_HAVE_CONFIG_H)
# include <config.h>
#endif
#include <limits.h>
#include <stddef.h>
#include <lzo/lzodefs.h>
#endif
/* #define __LZO_EXPORT1 __attribute__((__visibility__("default"))) */
/* #define __LZO_EXPORT1 __declspec(dllexport) */
#endif
#include <lzo/lzoconf.h>
#if defined(LZO_CFG_EXTRA_CONFIG_HEADER2)
# include LZO_CFG_EXTRA_CONFIG_HEADER2
#endif
#endif /* !defined(__LZO_IN_MINILZO) */
#if !defined(__LZOCONF_H_INCLUDED) || (LZO_VERSION+0 != 0x20a0)
# error "version mismatch"
#endif
/***********************************************************************
// pragmas
************************************************************************/
#if (LZO_CC_MSC && (_MSC_VER >= 1000 && _MSC_VER < 1100))
/* disable bogus "unreachable code" warnings */
# pragma warning(disable: 4702)
#endif
#if (LZO_CC_MSC && (_MSC_VER >= 1000))
# pragma warning(disable: 4127 4701)
/* disable warnings about inlining */
# pragma warning(disable: 4514 4710 4711)
#endif
#if (LZO_CC_MSC && (_MSC_VER >= 1300))
/* disable '-Wall' warnings in system header files */
# pragma warning(disable: 4820)
#endif
#if (LZO_CC_MSC && (_MSC_VER >= 1800))
/* disable '-Wall' warnings in system header files */
# pragma warning(disable: 4746)
#endif
#if (LZO_CC_INTELC && (__INTEL_COMPILER >= 900))
/* disable pedantic warnings in system header files */
# pragma warning(disable: 1684)
#endif
#if (LZO_CC_SUNPROC)
#if !defined(__cplusplus)
# pragma error_messages(off,E_END_OF_LOOP_CODE_NOT_REACHED)
# pragma error_messages(off,E_LOOP_NOT_ENTERED_AT_TOP)
# pragma error_messages(off,E_STATEMENT_NOT_REACHED)
#endif
#endif
/***********************************************************************
// function types
************************************************************************/
#if !defined(__LZO_NOEXPORT1)
# define __LZO_NOEXPORT1 /*empty*/
#endif
#if !defined(__LZO_NOEXPORT2)
# define __LZO_NOEXPORT2 /*empty*/
#endif
#if 1
# define LZO_PUBLIC_DECL(r) LZO_EXTERN(r)
#endif
#if 1
# define LZO_PUBLIC_IMPL(r) LZO_PUBLIC(r)
#endif
#if !defined(LZO_LOCAL_DECL)
# define LZO_LOCAL_DECL(r) __LZO_EXTERN_C LZO_LOCAL_IMPL(r)
#endif
#if !defined(LZO_LOCAL_IMPL)
# define LZO_LOCAL_IMPL(r) __LZO_NOEXPORT1 r __LZO_NOEXPORT2 __LZO_CDECL
#endif
#if 1
# define LZO_STATIC_DECL(r) LZO_PRIVATE(r)
#endif
#if 1
# define LZO_STATIC_IMPL(r) LZO_PRIVATE(r)
#endif
/***********************************************************************
//
************************************************************************/
#if defined(__LZO_IN_MINILZO) || (LZO_CFG_FREESTANDING)
#elif 1
# include <string.h>
#else
# define LZO_WANT_ACC_INCD_H 1
#endif
#if defined(LZO_HAVE_CONFIG_H)
# define LZO_CFG_NO_CONFIG_HEADER 1
#endif
#include "lzo_supp.h"
/* Integral types */
#if 1 || defined(lzo_int8_t) || defined(lzo_uint8_t)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int8_t) == 1)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint8_t) == 1)
#endif
#if 1 || defined(lzo_int16_t) || defined(lzo_uint16_t)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16_t) == 2)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint16_t) == 2)
#endif
#if 1 || defined(lzo_int32_t) || defined(lzo_uint32_t)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32_t) == 4)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint32_t) == 4)
#endif
#if defined(lzo_int64_t) || defined(lzo_uint64_t)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64_t) == 8)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint64_t) == 8)
#endif
#if (LZO_CFG_FREESTANDING)
# undef HAVE_MEMCMP
# undef HAVE_MEMCPY
# undef HAVE_MEMMOVE
# undef HAVE_MEMSET
#endif
#if !(HAVE_MEMCMP)
# undef memcmp
# define memcmp(a,b,c) lzo_memcmp(a,b,c)
#else
# undef lzo_memcmp
# define lzo_memcmp(a,b,c) memcmp(a,b,c)
#endif
#if !(HAVE_MEMCPY)
# undef memcpy
# define memcpy(a,b,c) lzo_memcpy(a,b,c)
#else
# undef lzo_memcpy
# define lzo_memcpy(a,b,c) memcpy(a,b,c)
#endif
#if !(HAVE_MEMMOVE)
# undef memmove
# define memmove(a,b,c) lzo_memmove(a,b,c)
#else
# undef lzo_memmove
# define lzo_memmove(a,b,c) memmove(a,b,c)
#endif
#if !(HAVE_MEMSET)
# undef memset
# define memset(a,b,c) lzo_memset(a,b,c)
#else
# undef lzo_memset
# define lzo_memset(a,b,c) memset(a,b,c)
#endif
#undef NDEBUG
#if (LZO_CFG_FREESTANDING)
# undef LZO_DEBUG
# define NDEBUG 1
# undef assert
# define assert(e) ((void)0)
#else
# if !defined(LZO_DEBUG)
# define NDEBUG 1
# endif
# include <assert.h>
#endif
#if 0 && defined(__BOUNDS_CHECKING_ON)
# include <unchecked.h>
#else
# define BOUNDS_CHECKING_OFF_DURING(stmt) stmt
# define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr)
#endif
#if (LZO_CFG_PGO)
# undef __lzo_likely
# undef __lzo_unlikely
# define __lzo_likely(e) (e)
# define __lzo_unlikely(e) (e)
#endif
#undef _
#undef __
#undef ___
#undef ____
#undef _p0
#undef _p1
#undef _p2
#undef _p3
#undef _p4
#undef _s0
#undef _s1
#undef _s2
#undef _s3
#undef _s4
#undef _ww
/***********************************************************************
//
************************************************************************/
#if 1
# define LZO_BYTE(x) ((unsigned char) (x))
#else
# define LZO_BYTE(x) ((unsigned char) ((x) & 0xff))
#endif
#define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b))
#define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b))
#define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c))
#define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c))
#define lzo_sizeof(type) ((lzo_uint) (sizeof(type)))
#define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array))))
/* this always fits into 32 bits */
#define LZO_SIZE(bits) (1u << (bits))
#define LZO_MASK(bits) (LZO_SIZE(bits) - 1)
#define LZO_USIZE(bits) ((lzo_uint) 1 << (bits))
#define LZO_UMASK(bits) (LZO_USIZE(bits) - 1)
#if !defined(DMUL)
#if 0
/* 32*32 multiplies may be faster than 64*64 on some 64-bit machines,
* but then we need extra casts from unsigned<->size_t */
# define DMUL(a,b) ((lzo_xint) ((lzo_uint32_t)(a) * (lzo_uint32_t)(b)))
#else
# define DMUL(a,b) ((lzo_xint) ((a) * (b)))
#endif
#endif
/***********************************************************************
// compiler and architecture specific stuff
************************************************************************/
/* Some defines that indicate if memory can be accessed at unaligned
* memory addresses. You should also test that this is actually faster
* even if it is allowed by your system.
*/
#include "lzo_func.h"
#ifndef UA_SET1
#define UA_SET1 LZO_MEMOPS_SET1
#endif
#ifndef UA_SET2
#define UA_SET2 LZO_MEMOPS_SET2
#endif
#ifndef UA_SET3
#define UA_SET3 LZO_MEMOPS_SET3
#endif
#ifndef UA_SET4
#define UA_SET4 LZO_MEMOPS_SET4
#endif
#ifndef UA_MOVE1
#define UA_MOVE1 LZO_MEMOPS_MOVE1
#endif
#ifndef UA_MOVE2
#define UA_MOVE2 LZO_MEMOPS_MOVE2
#endif
#ifndef UA_MOVE3
#define UA_MOVE3 LZO_MEMOPS_MOVE3
#endif
#ifndef UA_MOVE4
#define UA_MOVE4 LZO_MEMOPS_MOVE4
#endif
#ifndef UA_MOVE8
#define UA_MOVE8 LZO_MEMOPS_MOVE8
#endif
#ifndef UA_COPY1
#define UA_COPY1 LZO_MEMOPS_COPY1
#endif
#ifndef UA_COPY2
#define UA_COPY2 LZO_MEMOPS_COPY2
#endif
#ifndef UA_COPY3
#define UA_COPY3 LZO_MEMOPS_COPY3
#endif
#ifndef UA_COPY4
#define UA_COPY4 LZO_MEMOPS_COPY4
#endif
#ifndef UA_COPY8
#define UA_COPY8 LZO_MEMOPS_COPY8
#endif
#ifndef UA_COPYN
#define UA_COPYN LZO_MEMOPS_COPYN
#endif
#ifndef UA_COPYN_X
#define UA_COPYN_X LZO_MEMOPS_COPYN
#endif
#ifndef UA_GET_LE16
#define UA_GET_LE16 LZO_MEMOPS_GET_LE16
#endif
#ifndef UA_GET_LE32
#define UA_GET_LE32 LZO_MEMOPS_GET_LE32
#endif
#ifdef LZO_MEMOPS_GET_LE64
#ifndef UA_GET_LE64
#define UA_GET_LE64 LZO_MEMOPS_GET_LE64
#endif
#endif
#ifndef UA_GET_NE16
#define UA_GET_NE16 LZO_MEMOPS_GET_NE16
#endif
#ifndef UA_GET_NE32
#define UA_GET_NE32 LZO_MEMOPS_GET_NE32
#endif
#ifdef LZO_MEMOPS_GET_NE64
#ifndef UA_GET_NE64
#define UA_GET_NE64 LZO_MEMOPS_GET_NE64
#endif
#endif
#ifndef UA_PUT_LE16
#define UA_PUT_LE16 LZO_MEMOPS_PUT_LE16
#endif
#ifndef UA_PUT_LE32
#define UA_PUT_LE32 LZO_MEMOPS_PUT_LE32
#endif
#ifndef UA_PUT_NE16
#define UA_PUT_NE16 LZO_MEMOPS_PUT_NE16
#endif
#ifndef UA_PUT_NE32
#define UA_PUT_NE32 LZO_MEMOPS_PUT_NE32
#endif
/* Fast memcpy that copies multiples of 8 byte chunks.
* len is the number of bytes.
* note: all parameters must be lvalues, len >= 8
* dest and src advance, len is undefined afterwards
*/
#define MEMCPY8_DS(dest,src,len) \
lzo_memcpy(dest,src,len); dest += len; src += len
#define BZERO8_PTR(s,l,n) \
lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n))
#define MEMCPY_DS(dest,src,len) \
do *dest++ = *src++; while (--len > 0)
/***********************************************************************
//
************************************************************************/
LZO_EXTERN(const lzo_bytep) lzo_copyright(void);
#include "lzo_ptr.h"
/* Generate compressed data in a deterministic way.
* This is fully portable, and compression can be faster as well.
* A reason NOT to be deterministic is when the block size is
* very small (e.g. 8kB) or the dictionary is big, because
* then the initialization of the dictionary becomes a relevant
* magnitude for compression speed.
*/
#ifndef LZO_DETERMINISTIC
#define LZO_DETERMINISTIC 1
#endif
#ifndef LZO_DICT_USE_PTR
#define LZO_DICT_USE_PTR 1
#endif
#if (LZO_DICT_USE_PTR)
# define lzo_dict_t const lzo_bytep
# define lzo_dict_p lzo_dict_t *
#else
# define lzo_dict_t lzo_uint
# define lzo_dict_p lzo_dict_t *
#endif
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

153
vendor/lzo-2.10/src/lzo_crc.c vendored Normal file
View File

@@ -0,0 +1,153 @@
/* lzo_crc.c -- crc checksum for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
/***********************************************************************
// crc32 checksum
// adapted from free code by Mark Adler <madler at alumni.caltech.edu>
// see http://www.zlib.org/
************************************************************************/
static const lzo_uint32_t lzo_crc32_table[256] = {
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
0x2d02ef8dL
};
LZO_PUBLIC(const lzo_uint32_tp)
lzo_get_crc32_table(void)
{
return lzo_crc32_table;
}
#if 1
#define LZO_DO1(buf,i) \
crc = table[((unsigned)crc ^ buf[i]) & 0xff] ^ (crc >> 8)
#else
#define LZO_DO1(buf,i) \
crc = table[(unsigned char)((unsigned char)crc ^ buf[i])] ^ (crc >> 8)
#endif
#define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1)
#define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2)
#define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4)
#define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8)
LZO_PUBLIC(lzo_uint32_t)
lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len)
{
lzo_uint32_t crc;
#undef table
#if 1
# define table lzo_crc32_table
#else
const lzo_uint32_t * table = lzo_crc32_table;
#endif
if (buf == NULL)
return 0;
crc = (c & LZO_UINT32_C(0xffffffff)) ^ LZO_UINT32_C(0xffffffff);
if (len >= 16) do
{
LZO_DO16(buf,0);
buf += 16;
len -= 16;
} while (len >= 16);
if (len != 0) do
{
LZO_DO1(buf,0);
buf += 1;
len -= 1;
} while (len > 0);
return crc ^ LZO_UINT32_C(0xffffffff);
#undef table
}
#undef LZO_DO1
#undef LZO_DO2
#undef LZO_DO4
#undef LZO_DO8
#undef LZO_DO16
/* vim:set ts=4 sw=4 et: */

307
vendor/lzo-2.10/src/lzo_dict.h vendored Normal file
View File

@@ -0,0 +1,307 @@
/* lzo_dict.h -- dictionary definitions for the the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_DICT_H
#define __LZO_DICT_H 1
#ifdef __cplusplus
extern "C" {
#endif
/***********************************************************************
// dictionary size
************************************************************************/
/* dictionary needed for compression */
#if !defined(D_BITS) && defined(DBITS)
# define D_BITS DBITS
#endif
#if !defined(D_BITS)
# error "D_BITS is not defined"
#endif
#if (D_BITS < 16)
# define D_SIZE LZO_SIZE(D_BITS)
# define D_MASK LZO_MASK(D_BITS)
#else
# define D_SIZE LZO_USIZE(D_BITS)
# define D_MASK LZO_UMASK(D_BITS)
#endif
#define D_HIGH ((D_MASK >> 1) + 1)
/* dictionary depth */
#if !defined(DD_BITS)
# define DD_BITS 0
#endif
#define DD_SIZE LZO_SIZE(DD_BITS)
#define DD_MASK LZO_MASK(DD_BITS)
/* dictionary length */
#if !defined(DL_BITS)
# define DL_BITS (D_BITS - DD_BITS)
#endif
#if (DL_BITS < 16)
# define DL_SIZE LZO_SIZE(DL_BITS)
# define DL_MASK LZO_MASK(DL_BITS)
#else
# define DL_SIZE LZO_USIZE(DL_BITS)
# define DL_MASK LZO_UMASK(DL_BITS)
#endif
#if (D_BITS != DL_BITS + DD_BITS)
# error "D_BITS does not match"
#endif
#if (D_BITS < 6 || D_BITS > 18)
# error "invalid D_BITS"
#endif
#if (DL_BITS < 6 || DL_BITS > 20)
# error "invalid DL_BITS"
#endif
#if (DD_BITS < 0 || DD_BITS > 6)
# error "invalid DD_BITS"
#endif
#if !defined(DL_MIN_LEN)
# define DL_MIN_LEN 3
#endif
#if !defined(DL_SHIFT)
# define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN)
#endif
/***********************************************************************
// dictionary access
************************************************************************/
#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
#if !defined(LZO_HASH)
# error "choose a hashing strategy"
#endif
#undef DM
#undef DX
#if (DL_MIN_LEN == 3)
# define _DV2_A(p,shift1,shift2) \
(((( (lzo_xint)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2])
# define _DV2_B(p,shift1,shift2) \
(((( (lzo_xint)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0])
# define _DV3_B(p,shift1,shift2,shift3) \
((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0])
#elif (DL_MIN_LEN == 2)
# define _DV2_A(p,shift1,shift2) \
(( (lzo_xint)(p[0]) << shift1) ^ p[1])
# define _DV2_B(p,shift1,shift2) \
(( (lzo_xint)(p[1]) << shift1) ^ p[2])
#else
# error "invalid DL_MIN_LEN"
#endif
#define _DV_A(p,shift) _DV2_A(p,shift,shift)
#define _DV_B(p,shift) _DV2_B(p,shift,shift)
#define DA2(p,s1,s2) \
(((((lzo_xint)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0])
#define DS2(p,s1,s2) \
(((((lzo_xint)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0])
#define DX2(p,s1,s2) \
(((((lzo_xint)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0])
#define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0])
#define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0])
#define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0])
#define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s)))
#define DM(v) DMS(v,0)
#if (LZO_HASH == LZO_HASH_GZIP)
/* hash function like in gzip/zlib (deflate) */
# define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT))
#elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL)
/* incremental hash like in gzip/zlib (deflate) */
# define __LZO_HASH_INCREMENTAL 1
# define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT)
# define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2])
# define _DINDEX(dv,p) (dv)
# define DVAL_LOOKAHEAD DL_MIN_LEN
#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A)
/* incremental LZO hash version A */
# define __LZO_HASH_INCREMENTAL 1
# define DVAL_FIRST(dv,p) dv = _DV_A((p),5)
# define DVAL_NEXT(dv,p) \
dv ^= (lzo_xint)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2])
# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5)
# define DVAL_LOOKAHEAD DL_MIN_LEN
#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B)
/* incremental LZO hash version B */
# define __LZO_HASH_INCREMENTAL 1
# define DVAL_FIRST(dv,p) dv = _DV_B((p),5)
# define DVAL_NEXT(dv,p) \
dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_xint)(p[2]) << (2*5)))
# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5)
# define DVAL_LOOKAHEAD DL_MIN_LEN
#else
# error "choose a hashing strategy"
#endif
#ifndef DINDEX
#define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS)
#endif
#if !defined(DINDEX1) && defined(D_INDEX1)
#define DINDEX1 D_INDEX1
#endif
#if !defined(DINDEX2) && defined(D_INDEX2)
#define DINDEX2 D_INDEX2
#endif
#if !defined(__LZO_HASH_INCREMENTAL)
# define DVAL_FIRST(dv,p) ((void) 0)
# define DVAL_NEXT(dv,p) ((void) 0)
# define DVAL_LOOKAHEAD 0
#endif
#if !defined(DVAL_ASSERT)
#if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG)
#if 1 && (LZO_CC_ARMCC_GNUC || LZO_CC_CLANG || (LZO_CC_GNUC >= 0x020700ul) || LZO_CC_INTELC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI)
static void __attribute__((__unused__))
#else
static void
#endif
DVAL_ASSERT(lzo_xint dv, const lzo_bytep p)
{
lzo_xint df;
DVAL_FIRST(df,(p));
assert(DINDEX(dv,p) == DINDEX(df,p));
}
#else
# define DVAL_ASSERT(dv,p) ((void) 0)
#endif
#endif
/***********************************************************************
// dictionary updating
************************************************************************/
#if (LZO_DICT_USE_PTR)
# define DENTRY(p,in) (p)
# define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex]
#else
# define DENTRY(p,in) ((lzo_dict_t) pd(p, in))
# define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex]
#endif
#if (DD_BITS == 0)
# define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in)
# define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in)
# define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in)
#else
# define UPDATE_D(dict,drun,dv,p,in) \
dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK
# define UPDATE_I(dict,drun,index,p,in) \
dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK
# define UPDATE_P(ptr,drun,p,in) \
(ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK
#endif
/***********************************************************************
// test for a match
************************************************************************/
#if (LZO_DICT_USE_PTR)
/* m_pos is either NULL or a valid pointer */
#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
(m_pos == NULL || (m_off = pd(ip, m_pos)) > max_offset)
/* m_pos may point anywhere... */
#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
(BOUNDS_CHECKING_OFF_IN_EXPR(( \
m_pos = ip - (lzo_uint) PTR_DIFF(ip,m_pos), \
PTR_LT(m_pos,in) || \
(m_off = (lzo_uint) PTR_DIFF(ip,m_pos)) == 0 || \
m_off > max_offset )))
#else
#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
(m_off == 0 || \
((m_off = pd(ip, in) - m_off) > max_offset) || \
(m_pos = (ip) - (m_off), 0) )
#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
(pd(ip, in) <= m_off || \
((m_off = pd(ip, in) - m_off) > max_offset) || \
(m_pos = (ip) - (m_off), 0) )
#endif
#if (LZO_DETERMINISTIC)
# define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET
#else
# define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET
#endif
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

50
vendor/lzo-2.10/src/lzo_dll.ch vendored Normal file
View File

@@ -0,0 +1,50 @@
/* lzo_dll.ch -- DLL initialization of the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
/***********************************************************************
// Windows 16 bit + Watcom C + DLL
************************************************************************/
#if (LZO_OS_WIN16 && LZO_CC_WATCOMC) && defined(__SW_BD)
/* don't pull in <windows.h> - we don't need it */
#if 0
BOOL FAR PASCAL LibMain ( HANDLE hInstance, WORD wDataSegment,
WORD wHeapSize, LPSTR lpszCmdLine )
#else
int __far __pascal LibMain ( int a, short b, short c, long d )
#endif
{
LZO_UNUSED(a); LZO_UNUSED(b); LZO_UNUSED(c); LZO_UNUSED(d);
return 1;
}
#endif
/* vim:set ts=4 sw=4 et: */

491
vendor/lzo-2.10/src/lzo_func.h vendored Normal file
View File

@@ -0,0 +1,491 @@
/* lzo_func.h -- functions
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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.
*/
#ifndef __LZO_FUNC_H
#define __LZO_FUNC_H 1
/***********************************************************************
// bitops
************************************************************************/
#if !defined(LZO_BITOPS_USE_ASM_BITSCAN) && !defined(LZO_BITOPS_USE_GNUC_BITSCAN) && !defined(LZO_BITOPS_USE_MSC_BITSCAN)
#if 1 && (LZO_ARCH_AMD64) && (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_ASM_SYNTAX_GNUC)
#define LZO_BITOPS_USE_ASM_BITSCAN 1
#elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || (LZO_CC_INTELC_GNUC && (__INTEL_COMPILER >= 1000)) || (LZO_CC_LLVM && (!defined(__llvm_tools_version__) || (__llvm_tools_version__+0 >= 0x010500ul))))
#define LZO_BITOPS_USE_GNUC_BITSCAN 1
#elif (LZO_OS_WIN32 || LZO_OS_WIN64) && ((LZO_CC_INTELC_MSC && (__INTEL_COMPILER >= 1010)) || (LZO_CC_MSC && (_MSC_VER >= 1400)))
#define LZO_BITOPS_USE_MSC_BITSCAN 1
#if (LZO_CC_MSC) && (LZO_ARCH_AMD64 || LZO_ARCH_I386)
#include <intrin.h>
#endif
#if (LZO_CC_MSC) && (LZO_ARCH_AMD64 || LZO_ARCH_I386)
#pragma intrinsic(_BitScanReverse)
#pragma intrinsic(_BitScanForward)
#endif
#if (LZO_CC_MSC) && (LZO_ARCH_AMD64)
#pragma intrinsic(_BitScanReverse64)
#pragma intrinsic(_BitScanForward64)
#endif
#endif
#endif
__lzo_static_forceinline unsigned lzo_bitops_ctlz32_func(lzo_uint32_t v)
{
#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386)
unsigned long r; (void) _BitScanReverse(&r, v); return (unsigned) r ^ 31;
#define lzo_bitops_ctlz32(v) lzo_bitops_ctlz32_func(v)
#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC)
lzo_uint32_t r;
__asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
return (unsigned) r ^ 31;
#define lzo_bitops_ctlz32(v) lzo_bitops_ctlz32_func(v)
#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT == 4)
unsigned r; r = (unsigned) __builtin_clz(v); return r;
#define lzo_bitops_ctlz32(v) ((unsigned) __builtin_clz(v))
#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8)
unsigned r; r = (unsigned) __builtin_clzl(v); return r ^ 32;
#define lzo_bitops_ctlz32(v) (((unsigned) __builtin_clzl(v)) ^ 32)
#else
LZO_UNUSED(v); return 0;
#endif
}
#if defined(lzo_uint64_t)
__lzo_static_forceinline unsigned lzo_bitops_ctlz64_func(lzo_uint64_t v)
{
#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64)
unsigned long r; (void) _BitScanReverse64(&r, v); return (unsigned) r ^ 63;
#define lzo_bitops_ctlz64(v) lzo_bitops_ctlz64_func(v)
#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC)
lzo_uint64_t r;
__asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
return (unsigned) r ^ 63;
#define lzo_bitops_ctlz64(v) lzo_bitops_ctlz64_func(v)
#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8)
unsigned r; r = (unsigned) __builtin_clzl(v); return r;
#define lzo_bitops_ctlz64(v) ((unsigned) __builtin_clzl(v))
#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG == 8) && (LZO_WORDSIZE >= 8)
unsigned r; r = (unsigned) __builtin_clzll(v); return r;
#define lzo_bitops_ctlz64(v) ((unsigned) __builtin_clzll(v))
#else
LZO_UNUSED(v); return 0;
#endif
}
#endif
__lzo_static_forceinline unsigned lzo_bitops_cttz32_func(lzo_uint32_t v)
{
#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386)
unsigned long r; (void) _BitScanForward(&r, v); return (unsigned) r;
#define lzo_bitops_cttz32(v) lzo_bitops_cttz32_func(v)
#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC)
lzo_uint32_t r;
__asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
return (unsigned) r;
#define lzo_bitops_cttz32(v) lzo_bitops_cttz32_func(v)
#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT >= 4)
unsigned r; r = (unsigned) __builtin_ctz(v); return r;
#define lzo_bitops_cttz32(v) ((unsigned) __builtin_ctz(v))
#else
LZO_UNUSED(v); return 0;
#endif
}
#if defined(lzo_uint64_t)
__lzo_static_forceinline unsigned lzo_bitops_cttz64_func(lzo_uint64_t v)
{
#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64)
unsigned long r; (void) _BitScanForward64(&r, v); return (unsigned) r;
#define lzo_bitops_cttz64(v) lzo_bitops_cttz64_func(v)
#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC)
lzo_uint64_t r;
__asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
return (unsigned) r;
#define lzo_bitops_cttz64(v) lzo_bitops_cttz64_func(v)
#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG >= 8) && (LZO_WORDSIZE >= 8)
unsigned r; r = (unsigned) __builtin_ctzl(v); return r;
#define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzl(v))
#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG >= 8) && (LZO_WORDSIZE >= 8)
unsigned r; r = (unsigned) __builtin_ctzll(v); return r;
#define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzll(v))
#else
LZO_UNUSED(v); return 0;
#endif
}
#endif
lzo_unused_funcs_impl(void, lzo_bitops_unused_funcs)(void)
{
LZO_UNUSED_FUNC(lzo_bitops_unused_funcs);
LZO_UNUSED_FUNC(lzo_bitops_ctlz32_func);
LZO_UNUSED_FUNC(lzo_bitops_cttz32_func);
#if defined(lzo_uint64_t)
LZO_UNUSED_FUNC(lzo_bitops_ctlz64_func);
LZO_UNUSED_FUNC(lzo_bitops_cttz64_func);
#endif
}
/***********************************************************************
// memops
************************************************************************/
#if defined(__lzo_alignof) && !(LZO_CFG_NO_UNALIGNED)
/* CBUG: disabled because of gcc bug 64516 */
#if !defined(lzo_memops_tcheck__) && 0
#define lzo_memops_tcheck__(t,a,b) ((void)0, sizeof(t) == (a) && __lzo_alignof(t) == (b))
#endif
#endif
#ifndef lzo_memops_TU0p
#define lzo_memops_TU0p void __LZO_MMODEL *
#endif
#ifndef lzo_memops_TU1p
#define lzo_memops_TU1p unsigned char __LZO_MMODEL *
#endif
#ifndef lzo_memops_TU2p
#if (LZO_OPT_UNALIGNED16)
typedef lzo_uint16_t __lzo_may_alias lzo_memops_TU2;
#define lzo_memops_TU2p volatile lzo_memops_TU2 *
#elif defined(__lzo_byte_struct)
__lzo_byte_struct(lzo_memops_TU2_struct,2)
typedef struct lzo_memops_TU2_struct lzo_memops_TU2;
#else
struct lzo_memops_TU2_struct { unsigned char a[2]; } __lzo_may_alias;
typedef struct lzo_memops_TU2_struct lzo_memops_TU2;
#endif
#ifndef lzo_memops_TU2p
#define lzo_memops_TU2p lzo_memops_TU2 *
#endif
#endif
#ifndef lzo_memops_TU4p
#if (LZO_OPT_UNALIGNED32)
typedef lzo_uint32_t __lzo_may_alias lzo_memops_TU4;
#define lzo_memops_TU4p volatile lzo_memops_TU4 __LZO_MMODEL *
#elif defined(__lzo_byte_struct)
__lzo_byte_struct(lzo_memops_TU4_struct,4)
typedef struct lzo_memops_TU4_struct lzo_memops_TU4;
#else
struct lzo_memops_TU4_struct { unsigned char a[4]; } __lzo_may_alias;
typedef struct lzo_memops_TU4_struct lzo_memops_TU4;
#endif
#ifndef lzo_memops_TU4p
#define lzo_memops_TU4p lzo_memops_TU4 __LZO_MMODEL *
#endif
#endif
#ifndef lzo_memops_TU8p
#if (LZO_OPT_UNALIGNED64)
typedef lzo_uint64_t __lzo_may_alias lzo_memops_TU8;
#define lzo_memops_TU8p volatile lzo_memops_TU8 __LZO_MMODEL *
#elif defined(__lzo_byte_struct)
__lzo_byte_struct(lzo_memops_TU8_struct,8)
typedef struct lzo_memops_TU8_struct lzo_memops_TU8;
#else
struct lzo_memops_TU8_struct { unsigned char a[8]; } __lzo_may_alias;
typedef struct lzo_memops_TU8_struct lzo_memops_TU8;
#endif
#ifndef lzo_memops_TU8p
#define lzo_memops_TU8p lzo_memops_TU8 __LZO_MMODEL *
#endif
#endif
#ifndef lzo_memops_set_TU1p
#define lzo_memops_set_TU1p volatile lzo_memops_TU1p
#endif
#ifndef lzo_memops_move_TU1p
#define lzo_memops_move_TU1p lzo_memops_TU1p
#endif
#define LZO_MEMOPS_SET1(dd,cc) \
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
#define LZO_MEMOPS_SET2(dd,cc) \
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
#define LZO_MEMOPS_SET3(dd,cc) \
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
#define LZO_MEMOPS_SET4(dd,cc) \
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
#define LZO_MEMOPS_MOVE1(dd,ss) \
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
#define LZO_MEMOPS_MOVE2(dd,ss) \
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
#define LZO_MEMOPS_MOVE3(dd,ss) \
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
#define LZO_MEMOPS_MOVE4(dd,ss) \
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
#define LZO_MEMOPS_MOVE8(dd,ss) \
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_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU1p)0)==1)
#define LZO_MEMOPS_COPY1(dd,ss) LZO_MEMOPS_MOVE1(dd,ss)
#if (LZO_OPT_UNALIGNED16)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2)
#define LZO_MEMOPS_COPY2(dd,ss) \
* (lzo_memops_TU2p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)
#elif defined(lzo_memops_tcheck__)
#define LZO_MEMOPS_COPY2(dd,ss) \
LZO_BLOCK_BEGIN if (lzo_memops_tcheck__(lzo_memops_TU2,2,1)) { \
* (lzo_memops_TU2p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss); \
} else { LZO_MEMOPS_MOVE2(dd,ss); } LZO_BLOCK_END
#else
#define LZO_MEMOPS_COPY2(dd,ss) LZO_MEMOPS_MOVE2(dd,ss)
#endif
#if (LZO_OPT_UNALIGNED32)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4)
#define LZO_MEMOPS_COPY4(dd,ss) \
* (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)
#elif defined(lzo_memops_tcheck__)
#define LZO_MEMOPS_COPY4(dd,ss) \
LZO_BLOCK_BEGIN if (lzo_memops_tcheck__(lzo_memops_TU4,4,1)) { \
* (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss); \
} else { LZO_MEMOPS_MOVE4(dd,ss); } LZO_BLOCK_END
#else
#define LZO_MEMOPS_COPY4(dd,ss) LZO_MEMOPS_MOVE4(dd,ss)
#endif
#if (LZO_WORDSIZE != 8)
#define LZO_MEMOPS_COPY8(dd,ss) \
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
#else
#if (LZO_OPT_UNALIGNED64)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0)==8)
#define LZO_MEMOPS_COPY8(dd,ss) \
* (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)
#elif (LZO_OPT_UNALIGNED32)
#define LZO_MEMOPS_COPY8(dd,ss) \
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
#elif defined(lzo_memops_tcheck__)
#define LZO_MEMOPS_COPY8(dd,ss) \
LZO_BLOCK_BEGIN if (lzo_memops_tcheck__(lzo_memops_TU8,8,1)) { \
* (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss); \
} else { LZO_MEMOPS_MOVE8(dd,ss); } LZO_BLOCK_END
#else
#define LZO_MEMOPS_COPY8(dd,ss) LZO_MEMOPS_MOVE8(dd,ss)
#endif
#endif
#define LZO_MEMOPS_COPYN(dd,ss,nn) \
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_static_forceinline lzo_uint16_t lzo_memops_get_le16(const lzo_voidp ss)
{
lzo_uint16_t v;
#if (LZO_ABI_LITTLE_ENDIAN)
LZO_MEMOPS_COPY2(&v, ss);
#elif (LZO_OPT_UNALIGNED16 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
const lzo_memops_TU2p s = (const lzo_memops_TU2p) ss;
unsigned long vv;
__asm__("lhbrx %0,0,%1" : "=r" (vv) : "r" (s), "m" (*s));
v = (lzo_uint16_t) vv;
#else
const lzo_memops_TU1p s = (const lzo_memops_TU1p) ss;
v = (lzo_uint16_t) (((lzo_uint16_t)s[0]) | ((lzo_uint16_t)s[1] << 8));
#endif
return v;
}
#if (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
#define LZO_MEMOPS_GET_LE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss))
#else
#define LZO_MEMOPS_GET_LE16(ss) lzo_memops_get_le16(ss)
#endif
__lzo_static_forceinline lzo_uint32_t lzo_memops_get_le32(const lzo_voidp ss)
{
lzo_uint32_t v;
#if (LZO_ABI_LITTLE_ENDIAN)
LZO_MEMOPS_COPY4(&v, ss);
#elif (LZO_OPT_UNALIGNED32 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
const lzo_memops_TU4p s = (const lzo_memops_TU4p) ss;
unsigned long vv;
__asm__("lwbrx %0,0,%1" : "=r" (vv) : "r" (s), "m" (*s));
v = (lzo_uint32_t) vv;
#else
const lzo_memops_TU1p s = (const lzo_memops_TU1p) ss;
v = (lzo_uint32_t) (((lzo_uint32_t)s[0]) | ((lzo_uint32_t)s[1] << 8) | ((lzo_uint32_t)s[2] << 16) | ((lzo_uint32_t)s[3] << 24));
#endif
return v;
}
#if (LZO_OPT_UNALIGNED32) && (LZO_ABI_LITTLE_ENDIAN)
#define LZO_MEMOPS_GET_LE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss))
#else
#define LZO_MEMOPS_GET_LE32(ss) lzo_memops_get_le32(ss)
#endif
#if (LZO_OPT_UNALIGNED64) && (LZO_ABI_LITTLE_ENDIAN)
#define LZO_MEMOPS_GET_LE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss))
#endif
__lzo_static_forceinline lzo_uint16_t lzo_memops_get_ne16(const lzo_voidp ss)
{
lzo_uint16_t v;
LZO_MEMOPS_COPY2(&v, ss);
return v;
}
#if (LZO_OPT_UNALIGNED16)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2)
#define LZO_MEMOPS_GET_NE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss))
#else
#define LZO_MEMOPS_GET_NE16(ss) lzo_memops_get_ne16(ss)
#endif
__lzo_static_forceinline lzo_uint32_t lzo_memops_get_ne32(const lzo_voidp ss)
{
lzo_uint32_t v;
LZO_MEMOPS_COPY4(&v, ss);
return v;
}
#if (LZO_OPT_UNALIGNED32)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4)
#define LZO_MEMOPS_GET_NE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss))
#else
#define LZO_MEMOPS_GET_NE32(ss) lzo_memops_get_ne32(ss)
#endif
#if (LZO_OPT_UNALIGNED64)
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0)==8)
#define LZO_MEMOPS_GET_NE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss))
#endif
__lzo_static_forceinline void lzo_memops_put_le16(lzo_voidp dd, lzo_uint16_t vv)
{
#if (LZO_ABI_LITTLE_ENDIAN)
LZO_MEMOPS_COPY2(dd, &vv);
#elif (LZO_OPT_UNALIGNED16 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
lzo_memops_TU2p d = (lzo_memops_TU2p) dd;
unsigned long v = vv;
__asm__("sthbrx %2,0,%1" : "=m" (*d) : "r" (d), "r" (v));
#else
lzo_memops_TU1p d = (lzo_memops_TU1p) dd;
d[0] = LZO_BYTE((vv ) & 0xff);
d[1] = LZO_BYTE((vv >> 8) & 0xff);
#endif
}
#if (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
#define LZO_MEMOPS_PUT_LE16(dd,vv) (* (lzo_memops_TU2p) (lzo_memops_TU0p) (dd) = (vv))
#else
#define LZO_MEMOPS_PUT_LE16(dd,vv) lzo_memops_put_le16(dd,vv)
#endif
__lzo_static_forceinline void lzo_memops_put_le32(lzo_voidp dd, lzo_uint32_t vv)
{
#if (LZO_ABI_LITTLE_ENDIAN)
LZO_MEMOPS_COPY4(dd, &vv);
#elif (LZO_OPT_UNALIGNED32 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
lzo_memops_TU4p d = (lzo_memops_TU4p) dd;
unsigned long v = vv;
__asm__("stwbrx %2,0,%1" : "=m" (*d) : "r" (d), "r" (v));
#else
lzo_memops_TU1p d = (lzo_memops_TU1p) dd;
d[0] = LZO_BYTE((vv ) & 0xff);
d[1] = LZO_BYTE((vv >> 8) & 0xff);
d[2] = LZO_BYTE((vv >> 16) & 0xff);
d[3] = LZO_BYTE((vv >> 24) & 0xff);
#endif
}
#if (LZO_OPT_UNALIGNED32) && (LZO_ABI_LITTLE_ENDIAN)
#define LZO_MEMOPS_PUT_LE32(dd,vv) (* (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = (vv))
#else
#define LZO_MEMOPS_PUT_LE32(dd,vv) lzo_memops_put_le32(dd,vv)
#endif
__lzo_static_forceinline void lzo_memops_put_ne16(lzo_voidp dd, lzo_uint16_t vv)
{
LZO_MEMOPS_COPY2(dd, &vv);
}
#if (LZO_OPT_UNALIGNED16)
#define LZO_MEMOPS_PUT_NE16(dd,vv) (* (lzo_memops_TU2p) (lzo_memops_TU0p) (dd) = (vv))
#else
#define LZO_MEMOPS_PUT_NE16(dd,vv) lzo_memops_put_ne16(dd,vv)
#endif
__lzo_static_forceinline void lzo_memops_put_ne32(lzo_voidp dd, lzo_uint32_t vv)
{
LZO_MEMOPS_COPY4(dd, &vv);
}
#if (LZO_OPT_UNALIGNED32)
#define LZO_MEMOPS_PUT_NE32(dd,vv) (* (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = (vv))
#else
#define LZO_MEMOPS_PUT_NE32(dd,vv) lzo_memops_put_ne32(dd,vv)
#endif
lzo_unused_funcs_impl(void, lzo_memops_unused_funcs)(void)
{
LZO_UNUSED_FUNC(lzo_memops_unused_funcs);
LZO_UNUSED_FUNC(lzo_memops_get_le16);
LZO_UNUSED_FUNC(lzo_memops_get_le32);
LZO_UNUSED_FUNC(lzo_memops_get_ne16);
LZO_UNUSED_FUNC(lzo_memops_get_ne32);
LZO_UNUSED_FUNC(lzo_memops_put_le16);
LZO_UNUSED_FUNC(lzo_memops_put_le32);
LZO_UNUSED_FUNC(lzo_memops_put_ne16);
LZO_UNUSED_FUNC(lzo_memops_put_ne32);
}
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

239
vendor/lzo-2.10/src/lzo_init.c vendored Normal file
View File

@@ -0,0 +1,239 @@
/* lzo_init.c -- initialization of the LZO library
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
#include "lzo_conf.h"
/***********************************************************************
// Runtime check of the assumptions about the size of builtin types,
// memory model, byte order and other low-level constructs.
//
// We are really paranoid here - LZO should either fail
// at startup or not at all.
//
// Because of inlining much of these functions evaluates to nothing.
//
// And while many of the tests seem highly obvious and redundant they are
// here to catch compiler/optimizer bugs. Yes, these do exist.
************************************************************************/
#if !defined(__LZO_IN_MINILZO)
#define LZO_WANT_ACC_CHK_CH 1
#undef LZOCHK_ASSERT
#include "lzo_supp.h"
LZOCHK_ASSERT((LZO_UINT32_C(1) << (int)(8*sizeof(LZO_UINT32_C(1))-1)) > 0)
LZOCHK_ASSERT_IS_SIGNED_T(lzo_int)
LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint)
#if !(__LZO_UINTPTR_T_IS_POINTER)
LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t)
#endif
LZOCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp))
LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_xint)
#endif
#undef LZOCHK_ASSERT
/***********************************************************************
//
************************************************************************/
union lzo_config_check_union {
lzo_uint a[2];
unsigned char b[2*LZO_MAX(8,sizeof(lzo_uint))];
#if defined(lzo_uint64_t)
lzo_uint64_t c[2];
#endif
};
#if 0
#define u2p(ptr,off) ((lzo_voidp) (((lzo_bytep)(lzo_voidp)(ptr)) + (off)))
#else
static __lzo_noinline lzo_voidp u2p(lzo_voidp ptr, lzo_uint off)
{
return (lzo_voidp) ((lzo_bytep) ptr + off);
}
#endif
LZO_PUBLIC(int)
_lzo_config_check(void)
{
#if (LZO_CC_CLANG && (LZO_CC_CLANG >= 0x030100ul && LZO_CC_CLANG < 0x030300ul))
# if 0
/* work around a clang 3.1 and clang 3.2 compiler bug; clang 3.3 and 3.4 work */
volatile
# endif
#endif
union lzo_config_check_union u;
lzo_voidp p;
unsigned r = 1;
u.a[0] = u.a[1] = 0;
p = u2p(&u, 0);
r &= ((* (lzo_bytep) p) == 0);
#if !(LZO_CFG_NO_CONFIG_CHECK)
#if (LZO_ABI_BIG_ENDIAN)
u.a[0] = u.a[1] = 0; u.b[sizeof(lzo_uint) - 1] = 128;
p = u2p(&u, 0);
r &= ((* (lzo_uintp) p) == 128);
#endif
#if (LZO_ABI_LITTLE_ENDIAN)
u.a[0] = u.a[1] = 0; u.b[0] = 128;
p = u2p(&u, 0);
r &= ((* (lzo_uintp) p) == 128);
#endif
u.a[0] = u.a[1] = 0;
u.b[0] = 1; u.b[3] = 2;
p = u2p(&u, 1);
r &= UA_GET_NE16(p) == 0;
r &= UA_GET_LE16(p) == 0;
u.b[1] = 128;
r &= UA_GET_LE16(p) == 128;
u.b[2] = 129;
r &= UA_GET_LE16(p) == LZO_UINT16_C(0x8180);
#if (LZO_ABI_BIG_ENDIAN)
r &= UA_GET_NE16(p) == LZO_UINT16_C(0x8081);
#endif
#if (LZO_ABI_LITTLE_ENDIAN)
r &= UA_GET_NE16(p) == LZO_UINT16_C(0x8180);
#endif
u.a[0] = u.a[1] = 0;
u.b[0] = 3; u.b[5] = 4;
p = u2p(&u, 1);
r &= UA_GET_NE32(p) == 0;
r &= UA_GET_LE32(p) == 0;
u.b[1] = 128;
r &= UA_GET_LE32(p) == 128;
u.b[2] = 129; u.b[3] = 130; u.b[4] = 131;
r &= UA_GET_LE32(p) == LZO_UINT32_C(0x83828180);
#if (LZO_ABI_BIG_ENDIAN)
r &= UA_GET_NE32(p) == LZO_UINT32_C(0x80818283);
#endif
#if (LZO_ABI_LITTLE_ENDIAN)
r &= UA_GET_NE32(p) == LZO_UINT32_C(0x83828180);
#endif
#if defined(UA_GET_NE64)
u.c[0] = u.c[1] = 0;
u.b[0] = 5; u.b[9] = 6;
p = u2p(&u, 1);
u.c[0] = u.c[1] = 0;
r &= UA_GET_NE64(p) == 0;
#if defined(UA_GET_LE64)
r &= UA_GET_LE64(p) == 0;
u.b[1] = 128;
r &= UA_GET_LE64(p) == 128;
#endif
#endif
#if defined(lzo_bitops_ctlz32)
{ unsigned i = 0; lzo_uint32_t v;
for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
r &= lzo_bitops_ctlz32(v) == 31 - i;
r &= lzo_bitops_ctlz32_func(v) == 31 - i;
}}
#endif
#if defined(lzo_bitops_ctlz64)
{ unsigned i = 0; lzo_uint64_t v;
for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
r &= lzo_bitops_ctlz64(v) == 63 - i;
r &= lzo_bitops_ctlz64_func(v) == 63 - i;
}}
#endif
#if defined(lzo_bitops_cttz32)
{ unsigned i = 0; lzo_uint32_t v;
for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
r &= lzo_bitops_cttz32(v) == i;
r &= lzo_bitops_cttz32_func(v) == i;
}}
#endif
#if defined(lzo_bitops_cttz64)
{ unsigned i = 0; lzo_uint64_t v;
for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
r &= lzo_bitops_cttz64(v) == i;
r &= lzo_bitops_cttz64_func(v) == i;
}}
#endif
#endif
LZO_UNUSED_FUNC(lzo_bitops_unused_funcs);
return r == 1 ? LZO_E_OK : LZO_E_ERROR;
}
/***********************************************************************
//
************************************************************************/
LZO_PUBLIC(int)
__lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5,
int s6, int s7, int s8, int s9)
{
int r;
#if defined(__LZO_IN_MINILZO)
#elif (LZO_CC_MSC && ((_MSC_VER) < 700))
#else
#define LZO_WANT_ACC_CHK_CH 1
#undef LZOCHK_ASSERT
#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr)
#include "lzo_supp.h"
#endif
#undef LZOCHK_ASSERT
if (v == 0)
return LZO_E_ERROR;
r = (s1 == -1 || s1 == (int) sizeof(short)) &&
(s2 == -1 || s2 == (int) sizeof(int)) &&
(s3 == -1 || s3 == (int) sizeof(long)) &&
(s4 == -1 || s4 == (int) sizeof(lzo_uint32_t)) &&
(s5 == -1 || s5 == (int) sizeof(lzo_uint)) &&
(s6 == -1 || s6 == (int) lzo_sizeof_dict_t) &&
(s7 == -1 || s7 == (int) sizeof(char *)) &&
(s8 == -1 || s8 == (int) sizeof(lzo_voidp)) &&
(s9 == -1 || s9 == (int) sizeof(lzo_callback_t));
if (!r)
return LZO_E_ERROR;
r = _lzo_config_check();
if (r != LZO_E_OK)
return r;
return r;
}
#if !defined(__LZO_IN_MINILZO)
#include "lzo_dll.ch"
#endif
/* vim:set ts=4 sw=4 et: */

222
vendor/lzo-2.10/src/lzo_mchw.ch vendored Normal file
View File

@@ -0,0 +1,222 @@
/* lzo_mchw.ch -- matching functions using a window
This file is part of the LZO real-time data compression library.
Copyright (C) 1996-2017 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/
*/
/***********************************************************************
//
************************************************************************/
typedef struct
{
unsigned init;
lzo_uint look; /* bytes in lookahead buffer */
lzo_uint m_len;
lzo_uint m_off;
lzo_uint last_m_len;
lzo_uint last_m_off;
const lzo_bytep bp;
const lzo_bytep ip;
const lzo_bytep in;
const lzo_bytep in_end;
lzo_bytep out;
lzo_callback_p cb;
lzo_uint textsize; /* text size counter */
lzo_uint codesize; /* code size counter */
lzo_uint printcount; /* counter for reporting progress every 1K bytes */
/* some stats */
lzo_uint lit_bytes;
lzo_uint match_bytes;
lzo_uint rep_bytes;
lzo_uint lazy;
#if defined(LZO1B)
lzo_uint r1_m_len;
/* some stats */
lzo_uint r1_r, m3_r, m2_m, m3_m;
#endif
#if defined(LZO1C)
lzo_uint r1_m_len;
lzo_bytep m3;
/* some stats */
lzo_uint r1_r, m3_r, m2_m, m3_m;
#endif
#if defined(LZO1F)
lzo_uint r1_lit;
lzo_uint r1_m_len;
/* some stats */
lzo_uint r1_r, m2_m, m3_m;
#endif
#if defined(LZO1X) || defined(LZO1Y) || defined(LZO1Z)
lzo_uint r1_lit;
lzo_uint r1_m_len;
/* some stats */
lzo_uint m1a_m, m1b_m, m2_m, m3_m, m4_m;
lzo_uint lit1_r, lit2_r, lit3_r;
#endif
#if defined(LZO2A)
/* some stats */
lzo_uint m1, m2, m3, m4;
#endif
}
LZO_COMPRESS_T;
#define getbyte(c) ((c).ip < (c).in_end ? *((c).ip)++ : (-1))
#include "lzo_swd.ch"
/***********************************************************************
//
************************************************************************/
static int
init_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
const lzo_bytep dict, lzo_uint dict_len,
lzo_uint32_t flags )
{
int r;
assert(!c->init);
c->init = 1;
s->c = c;
c->last_m_len = c->last_m_off = 0;
c->textsize = c->codesize = c->printcount = 0;
c->lit_bytes = c->match_bytes = c->rep_bytes = 0;
c->lazy = 0;
r = swd_init(s,dict,dict_len);
if (r != LZO_E_OK)
{
swd_exit(s);
return r;
}
s->use_best_off = (flags & 1) ? 1 : 0;
return LZO_E_OK;
}
/***********************************************************************
//
************************************************************************/
static int
find_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
lzo_uint this_len, lzo_uint skip )
{
assert(c->init);
if (skip > 0)
{
assert(this_len >= skip);
swd_accept(s, this_len - skip);
c->textsize += this_len - skip + 1;
}
else
{
assert(this_len <= 1);
c->textsize += this_len - skip;
}
s->m_len = SWD_THRESHOLD;
s->m_off = 0;
#ifdef SWD_BEST_OFF
if (s->use_best_off)
lzo_memset(s->best_pos,0,sizeof(s->best_pos));
#endif
swd_findbest(s);
c->m_len = s->m_len;
c->m_off = s->m_off;
swd_getbyte(s);
if (s->b_char < 0)
{
c->look = 0;
c->m_len = 0;
swd_exit(s);
}
else
{
c->look = s->look + 1;
}
c->bp = c->ip - c->look;
#if 0
/* brute force match search */
if (c->m_len > SWD_THRESHOLD && c->m_len + 1 <= c->look)
{
const lzo_bytep ip = c->bp;
const lzo_bytep m = c->bp - c->m_off;
const lzo_bytep in = c->in;
if (ip - in > s->swd_n)
in = ip - s->swd_n;
for (;;)
{
while (*in != *ip)
in++;
if (in == ip)
break;
if (in != m)
if (lzo_memcmp(in,ip,c->m_len+1) == 0)
printf("%p %p %p %5d\n",in,ip,m,c->m_len);
in++;
}
}
#endif
if (c->cb && c->cb->nprogress && c->textsize > c->printcount)
{
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
c->printcount += 1024;
}
return LZO_E_OK;
}
/* vim:set ts=4 sw=4 et: */

Some files were not shown because too many files have changed in this diff Show More