| FazBrowse GitHub Viewer | Trending | | Home |
| Tools: [Download Repo ZIP] [Original HTTPS Page] |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -3,7 +3,7 @@ set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON) | |||
| 3 | 3 | ||
| 4 | 4 | project(zlib C) | |
| 5 | 5 | ||
| 6 | - set(VERSION "1.3") | ||
| 6 | + set(VERSION "1.3.0.1") | ||
| 7 | 7 | ||
| 8 | 8 | set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables") | |
| 9 | 9 | set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries") | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -1,8 +1,8 @@ | |||
| 1 | 1 | Name: zlib | |
| 2 | 2 | Short Name: zlib | |
| 3 | 3 | URL: http://zlib.net/ | |
| 4 | - Version: 1.2.13 | ||
| 5 | - CPEPrefix: cpe:/a:zlib:zlib:1.2.13 | ||
| 4 | + Version: 1.3.0.1 | ||
| 5 | + CPEPrefix: cpe:/a:zlib:zlib:1.3.0.1 | ||
| 6 | 6 | Security Critical: yes | |
| 7 | 7 | Shipped: yes | |
| 8 | 8 | License: Zlib | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -6,6 +6,7 @@ License: Zlib | |||
| 6 | 6 | License File: //third_party/zlib/LICENSE | |
| 7 | 7 | Security Critical: yes | |
| 8 | 8 | Shipped: yes | |
| 9 | + CPEPrefix: cpe:/a:minizip_project:minizip | ||
| 9 | 10 | ||
| 10 | 11 | Description: | |
| 11 | 12 | Minizip provides API on top of zlib that can enumerate and extract ZIP archive | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -1422,7 +1422,7 @@ int ZEXPORT inflateSync(z_streamp strm) { | |||
| 1422 | 1422 | /* if first time, start search in bit buffer */ | |
| 1423 | 1423 | if (state->mode != SYNC) { | |
| 1424 | 1424 | state->mode = SYNC; | |
| 1425 | - state->hold <<= state->bits & 7; | ||
| 1425 | + state->hold >>= state->bits & 7; | ||
| 1426 | 1426 | state->bits -= state->bits & 7; | |
| 1427 | 1427 | len = 0; | |
| 1428 | 1428 | while (state->bits >= 8) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -65,7 +65,7 @@ | |||
| 65 | 65 | #endif | |
| 66 | 66 | ||
| 67 | 67 | const char deflate_copyright[] = | |
| 68 | - " deflate 1.3 Copyright 1995-2023 Jean-loup Gailly and Mark Adler "; | ||
| 68 | + " deflate 1.3.0.1 Copyright 1995-2023 Jean-loup Gailly and Mark Adler "; | ||
| 69 | 69 | /* | |
| 70 | 70 | If you use the zlib library in a product, an acknowledgment is welcome | |
| 71 | 71 | in the documentation of your product. If for some reason you cannot | |
@@ -531,7 +531,11 @@ int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, | |||
| 531 | 531 | * the compressed data for a dynamic block also cannot overwrite the | |
| 532 | 532 | * symbols from which it is being constructed. | |
| 533 | 533 | */ | |
| 534 | + #ifdef LIT_MEM | ||
| 535 | + s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 5); | ||
| 536 | + #else | ||
| 534 | 537 | s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 4); | |
| 538 | + #endif | ||
| 535 | 539 | s->pending_buf_size = (ulg)s->lit_bufsize * 4; | |
| 536 | 540 | ||
| 537 | 541 | if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || | |
@@ -541,8 +545,14 @@ int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, | |||
| 541 | 545 | deflateEnd (strm); | |
| 542 | 546 | return Z_MEM_ERROR; | |
| 543 | 547 | } | |
| 548 | + #ifdef LIT_MEM | ||
| 549 | + s->d_buf = (ushf *)(s->pending_buf + (s->lit_bufsize << 1)); | ||
| 550 | + s->l_buf = s->pending_buf + (s->lit_bufsize << 2); | ||
| 551 | + s->sym_end = s->lit_bufsize - 1; | ||
| 552 | + #else | ||
| 544 | 553 | s->sym_buf = s->pending_buf + s->lit_bufsize; | |
| 545 | 554 | s->sym_end = (s->lit_bufsize - 1) * 3; | |
| 555 | + #endif | ||
| 546 | 556 | /* We avoid equality with lit_bufsize*3 because of wraparound at 64K | |
| 547 | 557 | * on 16 bit machines and because stored blocks are restricted to | |
| 548 | 558 | * 64K-1 bytes. | |
@@ -754,9 +764,15 @@ int ZEXPORT deflatePrime(z_streamp strm, int bits, int value) { | |||
| 754 | 764 | ||
| 755 | 765 | if (deflateStateCheck(strm)) return Z_STREAM_ERROR; | |
| 756 | 766 | s = strm->state; | |
| 767 | + #ifdef LIT_MEM | ||
| 768 | + if (bits < 0 || bits > 16 || | ||
| 769 | + (uchf *)s->d_buf < s->pending_out + ((Buf_size + 7) >> 3)) | ||
| 770 | + return Z_BUF_ERROR; | ||
| 771 | + #else | ||
| 757 | 772 | if (bits < 0 || bits > 16 || | |
| 758 | 773 | s->sym_buf < s->pending_out + ((Buf_size + 7) >> 3)) | |
| 759 | 774 | return Z_BUF_ERROR; | |
| 775 | + #endif | ||
| 760 | 776 | do { | |
| 761 | 777 | put = Buf_size - s->bi_valid; | |
| 762 | 778 | if (put > bits) | |
@@ -1343,7 +1359,12 @@ int ZEXPORT deflateCopy(z_streamp dest, z_streamp source) { | |||
| 1343 | 1359 | zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); | |
| 1344 | 1360 | ||
| 1345 | 1361 | ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); | |
| 1362 | + #ifdef LIT_MEM | ||
| 1363 | + ds->d_buf = (ushf *)(ds->pending_buf + (ds->lit_bufsize << 1)); | ||
| 1364 | + ds->l_buf = ds->pending_buf + (ds->lit_bufsize << 2); | ||
| 1365 | + #else | ||
| 1346 | 1366 | ds->sym_buf = ds->pending_buf + ds->lit_bufsize; | |
| 1367 | + #endif | ||
| 1347 | 1368 | ||
| 1348 | 1369 | ds->l_desc.dyn_tree = ds->dyn_ltree; | |
| 1349 | 1370 | ds->d_desc.dyn_tree = ds->dyn_dtree; | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -23,6 +23,10 @@ | |||
| 23 | 23 | # define GZIP | |
| 24 | 24 | #endif | |
| 25 | 25 | ||
| 26 | + /* define LIT_MEM to slightly increase the speed of deflate (order 1% to 2%) at | ||
| 27 | + the cost of a larger memory footprint */ | ||
| 28 | + /* #define LIT_MEM */ | ||
| 29 | + | ||
| 26 | 30 | /* =========================================================================== | |
| 27 | 31 | * Internal compression state. | |
| 28 | 32 | */ | |
@@ -217,7 +221,12 @@ typedef struct internal_state { | |||
| 217 | 221 | /* Depth of each subtree used as tie breaker for trees of equal frequency | |
| 218 | 222 | */ | |
| 219 | 223 | ||
| 224 | + #ifdef LIT_MEM | ||
| 225 | + ushf *d_buf; /* buffer for distances */ | ||
| 226 | + uchf *l_buf; /* buffer for literals/lengths */ | ||
| 227 | + #else | ||
| 220 | 228 | uchf *sym_buf; /* buffer for distances and literals/lengths */ | |
| 229 | + #endif | ||
| 221 | 230 | ||
| 222 | 231 | uInt lit_bufsize; | |
| 223 | 232 | /* Size of match buffer for literals/lengths. There are 4 reasons for | |
@@ -239,7 +248,7 @@ typedef struct internal_state { | |||
| 239 | 248 | * - I can't count above 4 | |
| 240 | 249 | */ | |
| 241 | 250 | ||
| 242 | - uInt sym_next; /* running index in sym_buf */ | ||
| 251 | + uInt sym_next; /* running index in symbol buffer */ | ||
| 243 | 252 | uInt sym_end; /* symbol table full when sym_next reaches this */ | |
| 244 | 253 | ||
| 245 | 254 | ulg opt_len; /* bit length of current block with optimal trees */ | |
@@ -323,6 +332,25 @@ void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf, | |||
| 323 | 332 | extern const uch ZLIB_INTERNAL _dist_code[]; | |
| 324 | 333 | #endif | |
| 325 | 334 | ||
| 335 | + #ifdef LIT_MEM | ||
| 336 | + # define _tr_tally_lit(s, c, flush) \ | ||
| 337 | + { uch cc = (c); \ | ||
| 338 | + s->d_buf[s->sym_next] = 0; \ | ||
| 339 | + s->l_buf[s->sym_next++] = cc; \ | ||
| 340 | + s->dyn_ltree[cc].Freq++; \ | ||
| 341 | + flush = (s->sym_next == s->sym_end); \ | ||
| 342 | + } | ||
| 343 | + # define _tr_tally_dist(s, distance, length, flush) \ | ||
| 344 | + { uch len = (uch)(length); \ | ||
| 345 | + ush dist = (ush)(distance); \ | ||
| 346 | + s->d_buf[s->sym_next] = dist; \ | ||
| 347 | + s->l_buf[s->sym_next++] = len; \ | ||
| 348 | + dist--; \ | ||
| 349 | + s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ | ||
| 350 | + s->dyn_dtree[d_code(dist)].Freq++; \ | ||
| 351 | + flush = (s->sym_next == s->sym_end); \ | ||
| 352 | + } | ||
| 353 | + #else | ||
| 326 | 354 | # define _tr_tally_lit(s, c, flush) \ | |
| 327 | 355 | { uch cc = (c); \ | |
| 328 | 356 | s->sym_buf[s->sym_next++] = 0; \ | |
@@ -342,6 +370,7 @@ void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf, | |||
| 342 | 370 | s->dyn_dtree[d_code(dist)].Freq++; \ | |
| 343 | 371 | flush = (s->sym_next == s->sym_end); \ | |
| 344 | 372 | } | |
| 373 | + #endif | ||
| 345 | 374 | #else | |
| 346 | 375 | # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) | |
| 347 | 376 | # define _tr_tally_dist(s, distance, length, flush) \ | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -1389,7 +1389,7 @@ int ZEXPORT inflateSync(z_streamp strm) { | |||
| 1389 | 1389 | /* if first time, start search in bit buffer */ | |
| 1390 | 1390 | if (state->mode != SYNC) { | |
| 1391 | 1391 | state->mode = SYNC; | |
| 1392 | - state->hold <<= state->bits & 7; | ||
| 1392 | + state->hold >>= state->bits & 7; | ||
| 1393 | 1393 | state->bits -= state->bits & 7; | |
| 1394 | 1394 | len = 0; | |
| 1395 | 1395 | while (state->bits >= 8) { | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -9,7 +9,7 @@ | |||
| 9 | 9 | #define MAXBITS 15 | |
| 10 | 10 | ||
| 11 | 11 | const char inflate_copyright[] = | |
| 12 | - " inflate 1.3 Copyright 1995-2023 Mark Adler "; | ||
| 12 | + " inflate 1.3.0.1 Copyright 1995-2023 Mark Adler "; | ||
| 13 | 13 | /* | |
| 14 | 14 | If you use the zlib library in a product, an acknowledgment is welcome | |
| 15 | 15 | in the documentation of your product. If for some reason you cannot | |
@@ -57,7 +57,7 @@ int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, | |||
| 57 | 57 | 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; | |
| 58 | 58 | static const unsigned short lext[31] = { /* Length codes 257..285 extra */ | |
| 59 | 59 | 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, | |
| 60 | - 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 198, 203}; | ||
| 60 | + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 70, 200}; | ||
| 61 | 61 | static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ | |
| 62 | 62 | 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, | |
| 63 | 63 | 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -899,14 +899,19 @@ local void compress_block(deflate_state *s, const ct_data *ltree, | |||
| 899 | 899 | const ct_data *dtree) { | |
| 900 | 900 | unsigned dist; /* distance of matched string */ | |
| 901 | 901 | int lc; /* match length or unmatched char (if dist == 0) */ | |
| 902 | - unsigned sx = 0; /* running index in sym_buf */ | ||
| 902 | + unsigned sx = 0; /* running index in symbol buffers */ | ||
| 903 | 903 | unsigned code; /* the code to send */ | |
| 904 | 904 | int extra; /* number of extra bits to send */ | |
| 905 | 905 | ||
| 906 | 906 | if (s->sym_next != 0) do { | |
| 907 | + #ifdef LIT_MEM | ||
| 908 | + dist = s->d_buf[sx]; | ||
| 909 | + lc = s->l_buf[sx++]; | ||
| 910 | + #else | ||
| 907 | 911 | dist = s->sym_buf[sx++] & 0xff; | |
| 908 | 912 | dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8; | |
| 909 | 913 | lc = s->sym_buf[sx++]; | |
| 914 | + #endif | ||
| 910 | 915 | if (dist == 0) { | |
| 911 | 916 | send_code(s, lc, ltree); /* send a literal byte */ | |
| 912 | 917 | Tracecv(isgraph(lc), (stderr," '%c' ", lc)); | |
@@ -931,8 +936,12 @@ local void compress_block(deflate_state *s, const ct_data *ltree, | |||
| 931 | 936 | } | |
| 932 | 937 | } /* literal or match pair ? */ | |
| 933 | 938 | ||
| 934 | - /* Check that the overlay between pending_buf and sym_buf is ok: */ | ||
| 939 | + /* Check for no overlay of pending_buf on needed symbols */ | ||
| 940 | + #ifdef LIT_MEM | ||
| 941 | + Assert(s->pending < (s->lit_bufsize << 1) + sx, "pendingBuf overflow"); | ||
| 942 | + #else | ||
| 935 | 943 | Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow"); | |
| 944 | + #endif | ||
| 936 | 945 | ||
| 937 | 946 | } while (sx < s->sym_next); | |
| 938 | 947 | ||
@@ -1082,9 +1091,14 @@ void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf, | |||
| 1082 | 1091 | * the current block must be flushed. | |
| 1083 | 1092 | */ | |
| 1084 | 1093 | int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc) { | |
| 1094 | + #ifdef LIT_MEM | ||
| 1095 | + s->d_buf[s->sym_next] = (ush)dist; | ||
| 1096 | + s->l_buf[s->sym_next++] = (uch)lc; | ||
| 1097 | + #else | ||
| 1085 | 1098 | s->sym_buf[s->sym_next++] = (uch)dist; | |
| 1086 | 1099 | s->sym_buf[s->sym_next++] = (uch)(dist >> 8); | |
| 1087 | 1100 | s->sym_buf[s->sym_next++] = (uch)lc; | |
| 1101 | + #endif | ||
| 1088 | 1102 | if (dist == 0) { | |
| 1089 | 1103 | /* lc is the unmatched char */ | |
| 1090 | 1104 | s->dyn_ltree[lc].Freq++; | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -1,4 +1,4 @@ | |||
| 1 | - .TH ZLIB 3 "xx Oct 2022" | ||
| 1 | + .TH ZLIB 3 "xx Aug 2023" | ||
| 2 | 2 | .SH NAME | |
| 3 | 3 | zlib \- compression/decompression library | |
| 4 | 4 | .SH SYNOPSIS | |
@@ -105,7 +105,7 @@ before asking for help. | |||
| 105 | 105 | Send questions and/or comments to zlib@gzip.org, | |
| 106 | 106 | or (for the Windows DLL version) to Gilles Vollant (info@winimage.com). | |
| 107 | 107 | .SH AUTHORS AND LICENSE | |
| 108 | - Version 1.2.13.1 | ||
| 108 | + Version 1.2.3.0.1 | ||
| 109 | 109 | .LP | |
| 110 | 110 | Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler | |
| 111 | 111 | .LP | |
| Back | FazBrowse Home | New Git URL |
0 commit comments