Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
Libretro
beetle-pce-libretro
Commits
f9264bee
Commit
f9264bee
authored
Apr 09, 2021
by
Libretro-Admin
Browse files
Remove unnecessary files in dependencies
parent
9cac6293
Pipeline
#19648
passed with stages
in 2 minutes and 3 seconds
Changes
11
Pipelines
1
Expand all
Hide whitespace changes
Inline
Side-by-side
Makefile.common
View file @
f9264bee
...
...
@@ -38,18 +38,10 @@ LIBCHDR_SOURCES_C = \
ZLIB_INCFLAGS
=
-I
$(DEPS_DIR)
/zlib-1.2.11
ZLIB_SOURCES_C
=
\
$(DEPS_DIR)
/zlib-1.2.11/adler32.c
\
$(DEPS_DIR)
/zlib-1.2.11/compress.c
\
$(DEPS_DIR)
/zlib-1.2.11/crc32.c
\
$(DEPS_DIR)
/zlib-1.2.11/deflate.c
\
$(DEPS_DIR)
/zlib-1.2.11/gzclose.c
\
$(DEPS_DIR)
/zlib-1.2.11/gzlib.c
\
$(DEPS_DIR)
/zlib-1.2.11/gzread.c
\
$(DEPS_DIR)
/zlib-1.2.11/gzwrite.c
\
$(DEPS_DIR)
/zlib-1.2.11/inffast.c
\
$(DEPS_DIR)
/zlib-1.2.11/inflate.c
\
$(DEPS_DIR)
/zlib-1.2.11/inftrees.c
\
$(DEPS_DIR)
/zlib-1.2.11/trees.c
\
$(DEPS_DIR)
/zlib-1.2.11/uncompr.c
\
$(DEPS_DIR)
/zlib-1.2.11/zutil.c
ifneq
(,$(findstring msvc2003,$(platform)))
...
...
deps/zlib-1.2.11/compress.c
deleted
100644 → 0
View file @
9cac6293
/* compress.c -- compress a memory buffer
* Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#define ZLIB_INTERNAL
#include "zlib.h"
/* ===========================================================================
Compresses the source buffer into the destination buffer. The level
parameter has the same meaning as in deflateInit. sourceLen is the byte
length of the source buffer. Upon entry, destLen is the total size of the
destination buffer, which must be at least 0.1% larger than sourceLen plus
12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
Z_STREAM_ERROR if the level parameter is invalid.
*/
int
ZEXPORT
compress2
(
dest
,
destLen
,
source
,
sourceLen
,
level
)
Bytef
*
dest
;
uLongf
*
destLen
;
const
Bytef
*
source
;
uLong
sourceLen
;
int
level
;
{
z_stream
stream
;
int
err
;
const
uInt
max
=
(
uInt
)
-
1
;
uLong
left
;
left
=
*
destLen
;
*
destLen
=
0
;
stream
.
zalloc
=
(
alloc_func
)
0
;
stream
.
zfree
=
(
free_func
)
0
;
stream
.
opaque
=
(
voidpf
)
0
;
err
=
deflateInit
(
&
stream
,
level
);
if
(
err
!=
Z_OK
)
return
err
;
stream
.
next_out
=
dest
;
stream
.
avail_out
=
0
;
stream
.
next_in
=
(
z_const
Bytef
*
)
source
;
stream
.
avail_in
=
0
;
do
{
if
(
stream
.
avail_out
==
0
)
{
stream
.
avail_out
=
left
>
(
uLong
)
max
?
max
:
(
uInt
)
left
;
left
-=
stream
.
avail_out
;
}
if
(
stream
.
avail_in
==
0
)
{
stream
.
avail_in
=
sourceLen
>
(
uLong
)
max
?
max
:
(
uInt
)
sourceLen
;
sourceLen
-=
stream
.
avail_in
;
}
err
=
deflate
(
&
stream
,
sourceLen
?
Z_NO_FLUSH
:
Z_FINISH
);
}
while
(
err
==
Z_OK
);
*
destLen
=
stream
.
total_out
;
deflateEnd
(
&
stream
);
return
err
==
Z_STREAM_END
?
Z_OK
:
err
;
}
/* ===========================================================================
*/
int
ZEXPORT
compress
(
dest
,
destLen
,
source
,
sourceLen
)
Bytef
*
dest
;
uLongf
*
destLen
;
const
Bytef
*
source
;
uLong
sourceLen
;
{
return
compress2
(
dest
,
destLen
,
source
,
sourceLen
,
Z_DEFAULT_COMPRESSION
);
}
/* ===========================================================================
If the default memLevel or windowBits for deflateInit() is changed, then
this function needs to be updated.
*/
uLong
ZEXPORT
compressBound
(
sourceLen
)
uLong
sourceLen
;
{
return
sourceLen
+
(
sourceLen
>>
12
)
+
(
sourceLen
>>
14
)
+
(
sourceLen
>>
25
)
+
13
;
}
deps/zlib-1.2.11/deflate.c
deleted
100644 → 0
View file @
9cac6293
This diff is collapsed.
Click to expand it.
deps/zlib-1.2.11/deflate.h
deleted
100644 → 0
View file @
9cac6293
/* deflate.h -- internal compression state
* Copyright (C) 1995-2016 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* WARNING: this file should *not* be used by applications. It is
part of the implementation of the compression library and is
subject to change. Applications should only use zlib.h.
*/
/* @(#) $Id$ */
#ifndef DEFLATE_H
#define DEFLATE_H
#include "zutil.h"
/* define NO_GZIP when compiling if you want to disable gzip header and
trailer creation by deflate(). NO_GZIP would be used to avoid linking in
the crc code when it is not needed. For shared libraries, gzip encoding
should be left enabled. */
#ifndef NO_GZIP
# define GZIP
#endif
/* ===========================================================================
* Internal compression state.
*/
#define LENGTH_CODES 29
/* number of length codes, not counting the special END_BLOCK code */
#define LITERALS 256
/* number of literal bytes 0..255 */
#define L_CODES (LITERALS+1+LENGTH_CODES)
/* number of Literal or Length codes, including the END_BLOCK code */
#define D_CODES 30
/* number of distance codes */
#define BL_CODES 19
/* number of codes used to transfer the bit lengths */
#define HEAP_SIZE (2*L_CODES+1)
/* maximum heap size */
#define MAX_BITS 15
/* All codes must not exceed MAX_BITS bits */
#define Buf_size 16
/* size of bit buffer in bi_buf */
#define INIT_STATE 42
/* zlib header -> BUSY_STATE */
#ifdef GZIP
# define GZIP_STATE 57
/* gzip header -> BUSY_STATE | EXTRA_STATE */
#endif
#define EXTRA_STATE 69
/* gzip extra block -> NAME_STATE */
#define NAME_STATE 73
/* gzip file name -> COMMENT_STATE */
#define COMMENT_STATE 91
/* gzip comment -> HCRC_STATE */
#define HCRC_STATE 103
/* gzip header CRC -> BUSY_STATE */
#define BUSY_STATE 113
/* deflate -> FINISH_STATE */
#define FINISH_STATE 666
/* stream complete */
/* Stream status */
/* Data structure describing a single value and its code string. */
typedef
struct
ct_data_s
{
union
{
ush
freq
;
/* frequency count */
ush
code
;
/* bit string */
}
fc
;
union
{
ush
dad
;
/* father node in Huffman tree */
ush
len
;
/* length of bit string */
}
dl
;
}
FAR
ct_data
;
#define Freq fc.freq
#define Code fc.code
#define Dad dl.dad
#define Len dl.len
typedef
struct
static_tree_desc_s
static_tree_desc
;
typedef
struct
tree_desc_s
{
ct_data
*
dyn_tree
;
/* the dynamic tree */
int
max_code
;
/* largest code with non zero frequency */
const
static_tree_desc
*
stat_desc
;
/* the corresponding static tree */
}
FAR
tree_desc
;
typedef
ush
Pos
;
typedef
Pos
FAR
Posf
;
typedef
unsigned
IPos
;
/* A Pos is an index in the character window. We use short instead of int to
* save space in the various tables. IPos is used only for parameter passing.
*/
typedef
struct
internal_state
{
z_streamp
strm
;
/* pointer back to this zlib stream */
int
status
;
/* as the name implies */
Bytef
*
pending_buf
;
/* output still pending */
ulg
pending_buf_size
;
/* size of pending_buf */
Bytef
*
pending_out
;
/* next pending byte to output to the stream */
ulg
pending
;
/* nb of bytes in the pending buffer */
int
wrap
;
/* bit 0 true for zlib, bit 1 true for gzip */
gz_headerp
gzhead
;
/* gzip header information to write */
ulg
gzindex
;
/* where in extra, name, or comment */
Byte
method
;
/* can only be DEFLATED */
int
last_flush
;
/* value of flush param for previous deflate call */
/* used by deflate.c: */
uInt
w_size
;
/* LZ77 window size (32K by default) */
uInt
w_bits
;
/* log2(w_size) (8..16) */
uInt
w_mask
;
/* w_size - 1 */
Bytef
*
window
;
/* Sliding window. Input bytes are read into the second half of the window,
* and move to the first half later to keep a dictionary of at least wSize
* bytes. With this organization, matches are limited to a distance of
* wSize-MAX_MATCH bytes, but this ensures that IO is always
* performed with a length multiple of the block size. Also, it limits
* the window size to 64K, which is quite useful on MSDOS.
* To do: use the user input buffer as sliding window.
*/
ulg
window_size
;
/* Actual size of window: 2*wSize, except when the user input buffer
* is directly used as sliding window.
*/
Posf
*
prev
;
/* Link to older string with same hash index. To limit the size of this
* array to 64K, this link is maintained only for the last 32K strings.
* An index in this array is thus a window index modulo 32K.
*/
Posf
*
head
;
/* Heads of the hash chains or NIL. */
uInt
ins_h
;
/* hash index of string to be inserted */
uInt
hash_size
;
/* number of elements in hash table */
uInt
hash_bits
;
/* log2(hash_size) */
uInt
hash_mask
;
/* hash_size-1 */
uInt
hash_shift
;
/* Number of bits by which ins_h must be shifted at each input
* step. It must be such that after MIN_MATCH steps, the oldest
* byte no longer takes part in the hash key, that is:
* hash_shift * MIN_MATCH >= hash_bits
*/
long
block_start
;
/* Window position at the beginning of the current output block. Gets
* negative when the window is moved backwards.
*/
uInt
match_length
;
/* length of best match */
IPos
prev_match
;
/* previous match */
int
match_available
;
/* set if previous match exists */
uInt
strstart
;
/* start of string to insert */
uInt
match_start
;
/* start of matching string */
uInt
lookahead
;
/* number of valid bytes ahead in window */
uInt
prev_length
;
/* Length of the best match at previous step. Matches not greater than this
* are discarded. This is used in the lazy match evaluation.
*/
uInt
max_chain_length
;
/* To speed up deflation, hash chains are never searched beyond this
* length. A higher limit improves compression ratio but degrades the
* speed.
*/
uInt
max_lazy_match
;
/* Attempt to find a better match only when the current match is strictly
* smaller than this value. This mechanism is used only for compression
* levels >= 4.
*/
# define max_insert_length max_lazy_match
/* Insert new strings in the hash table only if the match length is not
* greater than this length. This saves time but degrades compression.
* max_insert_length is used only for compression levels <= 3.
*/
int
level
;
/* compression level (1..9) */
int
strategy
;
/* favor or force Huffman coding*/
uInt
good_match
;
/* Use a faster search when the previous match is longer than this */
int
nice_match
;
/* Stop searching when current match exceeds this */
/* used by trees.c: */
/* Didn't use ct_data typedef below to suppress compiler warning */
struct
ct_data_s
dyn_ltree
[
HEAP_SIZE
];
/* literal and length tree */
struct
ct_data_s
dyn_dtree
[
2
*
D_CODES
+
1
];
/* distance tree */
struct
ct_data_s
bl_tree
[
2
*
BL_CODES
+
1
];
/* Huffman tree for bit lengths */
struct
tree_desc_s
l_desc
;
/* desc. for literal tree */
struct
tree_desc_s
d_desc
;
/* desc. for distance tree */
struct
tree_desc_s
bl_desc
;
/* desc. for bit length tree */
ush
bl_count
[
MAX_BITS
+
1
];
/* number of codes at each bit length for an optimal tree */
int
heap
[
2
*
L_CODES
+
1
];
/* heap used to build the Huffman trees */
int
heap_len
;
/* number of elements in the heap */
int
heap_max
;
/* element of largest frequency */
/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
* The same heap array is used to build all trees.
*/
uch
depth
[
2
*
L_CODES
+
1
];
/* Depth of each subtree used as tie breaker for trees of equal frequency
*/
uchf
*
l_buf
;
/* buffer for literals or lengths */
uInt
lit_bufsize
;
/* Size of match buffer for literals/lengths. There are 4 reasons for
* limiting lit_bufsize to 64K:
* - frequencies can be kept in 16 bit counters
* - if compression is not successful for the first block, all input
* data is still in the window so we can still emit a stored block even
* when input comes from standard input. (This can also be done for
* all blocks if lit_bufsize is not greater than 32K.)
* - if compression is not successful for a file smaller than 64K, we can
* even emit a stored file instead of a stored block (saving 5 bytes).
* This is applicable only for zip (not gzip or zlib).
* - creating new Huffman trees less frequently may not provide fast
* adaptation to changes in the input data statistics. (Take for
* example a binary file with poorly compressible code followed by
* a highly compressible string table.) Smaller buffer sizes give
* fast adaptation but have of course the overhead of transmitting
* trees more frequently.
* - I can't count above 4
*/
uInt
last_lit
;
/* running index in l_buf */
ushf
*
d_buf
;
/* Buffer for distances. To simplify the code, d_buf and l_buf have
* the same number of elements. To use different lengths, an extra flag
* array would be necessary.
*/
ulg
opt_len
;
/* bit length of current block with optimal trees */
ulg
static_len
;
/* bit length of current block with static trees */
uInt
matches
;
/* number of string matches in current block */
uInt
insert
;
/* bytes at end of window left to insert */
#ifdef ZLIB_DEBUG
ulg
compressed_len
;
/* total bit length of compressed file mod 2^32 */
ulg
bits_sent
;
/* bit length of compressed data sent mod 2^32 */
#endif
ush
bi_buf
;
/* Output buffer. bits are inserted starting at the bottom (least
* significant bits).
*/
int
bi_valid
;
/* Number of valid bits in bi_buf. All bits above the last valid bit
* are always zero.
*/
ulg
high_water
;
/* High water mark offset in window for initialized bytes -- bytes above
* this are set to zero in order to avoid memory check warnings when
* longest match routines access bytes past the input. This is then
* updated to the new high water mark.
*/
}
FAR
deflate_state
;
/* Output a byte on the stream.
* IN assertion: there is enough room in pending_buf.
*/
#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
/* Minimum amount of lookahead, except at the end of the input file.
* See deflate.c for comments about the MIN_MATCH+1.
*/
#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
/* In order to simplify the code, particularly on 16 bit machines, match
* distances are limited to MAX_DIST instead of WSIZE.
*/
#define WIN_INIT MAX_MATCH
/* Number of bytes after end of data in window to initialize in order to avoid
memory checker errors from longest match routines */
/* in trees.c */
void
ZLIB_INTERNAL
_tr_init
OF
((
deflate_state
*
s
));
int
ZLIB_INTERNAL
_tr_tally
OF
((
deflate_state
*
s
,
unsigned
dist
,
unsigned
lc
));
void
ZLIB_INTERNAL
_tr_flush_block
OF
((
deflate_state
*
s
,
charf
*
buf
,
ulg
stored_len
,
int
last
));
void
ZLIB_INTERNAL
_tr_flush_bits
OF
((
deflate_state
*
s
));
void
ZLIB_INTERNAL
_tr_align
OF
((
deflate_state
*
s
));
void
ZLIB_INTERNAL
_tr_stored_block
OF
((
deflate_state
*
s
,
charf
*
buf
,
ulg
stored_len
,
int
last
));
#define d_code(dist) \
((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
/* Mapping from a distance to a distance code. dist is the distance - 1 and
* must not have side effects. _dist_code[256] and _dist_code[257] are never
* used.
*/
#ifndef ZLIB_DEBUG
/* Inline versions of _tr_tally for speed: */
#if defined(GEN_TREES_H) || !defined(STDC)
extern
uch
ZLIB_INTERNAL
_length_code
[];
extern
uch
ZLIB_INTERNAL
_dist_code
[];
#else
extern
const
uch
ZLIB_INTERNAL
_length_code
[];
extern
const
uch
ZLIB_INTERNAL
_dist_code
[];
#endif
# define _tr_tally_lit(s, c, flush) \
{ uch cc = (c); \
s->d_buf[s->last_lit] = 0; \
s->l_buf[s->last_lit++] = cc; \
s->dyn_ltree[cc].Freq++; \
flush = (s->last_lit == s->lit_bufsize-1); \
}
# define _tr_tally_dist(s, distance, length, flush) \
{ uch len = (uch)(length); \
ush dist = (ush)(distance); \
s->d_buf[s->last_lit] = dist; \
s->l_buf[s->last_lit++] = len; \
dist--; \
s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
s->dyn_dtree[d_code(dist)].Freq++; \
flush = (s->last_lit == s->lit_bufsize-1); \
}
#else
# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
# define _tr_tally_dist(s, distance, length, flush) \
flush = _tr_tally(s, distance, length)
#endif
#endif
/* DEFLATE_H */
deps/zlib-1.2.11/gzclose.c
deleted
100644 → 0
View file @
9cac6293
/* gzclose.c -- zlib gzclose() function
* Copyright (C) 2004, 2010 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "gzguts.h"
/* gzclose() is in a separate file so that it is linked in only if it is used.
That way the other gzclose functions can be used instead to avoid linking in
unneeded compression or decompression routines. */
int
ZEXPORT
gzclose
(
file
)
gzFile
file
;
{
#ifndef NO_GZCOMPRESS
gz_statep
state
;
if
(
file
==
NULL
)
return
Z_STREAM_ERROR
;
state
=
(
gz_statep
)
file
;
return
state
->
mode
==
GZ_READ
?
gzclose_r
(
file
)
:
gzclose_w
(
file
);
#else
return
gzclose_r
(
file
);
#endif
}
deps/zlib-1.2.11/gzlib.c
deleted
100644 → 0
View file @
9cac6293
/* gzlib.c -- zlib functions common to reading and writing gzip files
* Copyright (C) 2004-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "gzguts.h"
#if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
# define LSEEK _lseeki64
#else
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
# define LSEEK lseek64
#else
# define LSEEK lseek
#endif
#endif
/* Local functions */
local
void
gz_reset
OF
((
gz_statep
));
local
gzFile
gz_open
OF
((
const
void
*
,
int
,
const
char
*
));
#if defined UNDER_CE
/* Map the Windows error number in ERROR to a locale-dependent error message
string and return a pointer to it. Typically, the values for ERROR come
from GetLastError.
The string pointed to shall not be modified by the application, but may be
overwritten by a subsequent call to gz_strwinerror
The gz_strwinerror function does not change the current setting of
GetLastError. */
char
ZLIB_INTERNAL
*
gz_strwinerror
(
error
)
DWORD
error
;
{
static
char
buf
[
1024
];
wchar_t
*
msgbuf
;
DWORD
lasterr
=
GetLastError
();
DWORD
chars
=
FormatMessage
(
FORMAT_MESSAGE_FROM_SYSTEM
|
FORMAT_MESSAGE_ALLOCATE_BUFFER
,
NULL
,
error
,
0
,
/* Default language */
(
LPVOID
)
&
msgbuf
,
0
,
NULL
);
if
(
chars
!=
0
)
{
/* If there is an \r\n appended, zap it. */
if
(
chars
>=
2
&&
msgbuf
[
chars
-
2
]
==
'\r'
&&
msgbuf
[
chars
-
1
]
==
'\n'
)
{
chars
-=
2
;
msgbuf
[
chars
]
=
0
;
}
if
(
chars
>
sizeof
(
buf
)
-
1
)
{
chars
=
sizeof
(
buf
)
-
1
;
msgbuf
[
chars
]
=
0
;
}
wcstombs
(
buf
,
msgbuf
,
chars
+
1
);
LocalFree
(
msgbuf
);
}
else
{
sprintf
(
buf
,
"unknown win32 error (%ld)"
,
error
);
}
SetLastError
(
lasterr
);
return
buf
;
}
#endif
/* UNDER_CE */
/* Reset gzip file state */
local
void
gz_reset
(
state
)
gz_statep
state
;
{
state
->
x
.
have
=
0
;
/* no output data available */
if
(
state
->
mode
==
GZ_READ
)
{
/* for reading ... */
state
->
eof
=
0
;
/* not at end of file */
state
->
past
=
0
;
/* have not read past end yet */
state
->
how
=
LOOK
;
/* look for gzip header */
}
state
->
seek
=
0
;
/* no seek request pending */
gz_error
(
state
,
Z_OK
,
NULL
);
/* clear error */
state
->
x
.
pos
=
0
;
/* no uncompressed data yet */
state
->
strm
.
avail_in
=
0
;
/* no input data yet */
}
/* Open a gzip file either by name or file descriptor. */
local
gzFile
gz_open
(
path
,
fd
,
mode
)
const
void
*
path
;
int
fd
;
const
char
*
mode
;
{
gz_statep
state
;
z_size_t
len
;
int
oflag
;
#ifdef O_CLOEXEC
int
cloexec
=
0
;
#endif
#ifdef O_EXCL
int
exclusive
=
0
;
#endif
/* check input */
if
(
path
==
NULL
)
return
NULL
;
/* allocate gzFile structure to return */
state
=
(
gz_statep
)
malloc
(
sizeof
(
gz_state
));
if
(
state
==
NULL
)
return
NULL
;
state
->
size
=
0
;
/* no buffers allocated yet */
state
->
want
=
GZBUFSIZE
;
/* requested buffer size */
state
->
msg
=
NULL
;
/* no error message yet */
/* interpret mode */
state
->
mode
=
GZ_NONE
;
state
->
level
=
Z_DEFAULT_COMPRESSION
;
state
->
strategy
=
Z_DEFAULT_STRATEGY
;
state
->
direct
=
0
;
while
(
*
mode
)
{
if
(
*
mode
>=
'0'
&&
*
mode
<=
'9'
)
state
->
level
=
*
mode
-
'0'
;
else
switch
(
*
mode
)
{
case
'r'
:
state
->
mode
=
GZ_READ
;
break
;
#ifndef NO_GZCOMPRESS
case
'w'
:
state
->
mode
=
GZ_WRITE
;
break
;
case
'a'
:
state
->
mode
=
GZ_APPEND
;
break
;
#endif
case
'+'
:
/* can't read and write at the same time */
free
(
state
);
return
NULL
;
case
'b'
:
/* ignore -- will request binary anyway */
break
;
#ifdef O_CLOEXEC
case
'e'
: