LLVMFuzzerTestOneInput: 6| 2.25k|int LLVMFuzzerTestOneInput(const uint8_t *data, const size_t size) { 7| | /* Discard inputs larger than 1MB. */ 8| 2.25k| static const size_t MaxSize = 1024 * 1024; 9| 2.25k| if (size < 1 || size > MaxSize) { ------------------ | Branch (9:7): [True: 0, False: 2.25k] | Branch (9:19): [True: 0, False: 2.25k] ------------------ 10| 0| return 0; 11| 0| } 12| | 13| 2.25k| char *outbuf = NULL; 14| 2.25k| size_t outbufsize = 0; 15| 2.25k| { 16| 2.25k| struct zip_t *zip = 17| 2.25k| zip_stream_open(NULL, 0, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w'); ------------------ | | 88| 2.25k|#define ZIP_DEFAULT_COMPRESSION_LEVEL 6 ------------------ 18| 2.25k| zip_entry_open(zip, "test"); 19| 2.25k| zip_entry_write(zip, data, size); 20| 2.25k| zip_entry_close(zip); 21| 2.25k| zip_stream_copy(zip, (void **)&outbuf, &outbufsize); 22| 2.25k| zip_stream_close(zip); 23| 2.25k| } 24| | 25| 2.25k| void *inbuf = NULL; 26| 2.25k| size_t inbufsize = 0; 27| 2.25k| { 28| 2.25k| struct zip_t *zip = zip_stream_open(outbuf, outbufsize, 0, 'r'); 29| 2.25k| zip_entry_open(zip, "test"); 30| 2.25k| zip_entry_read(zip, &inbuf, &inbufsize); 31| 2.25k| zip_entry_close(zip); 32| 2.25k| zip_stream_close(zip); 33| 2.25k| } 34| 2.25k| free(inbuf); 35| 2.25k| free(outbuf); 36| | 37| 2.25k| assert(inbufsize == size); 38| | 39| 2.25k| return 0; 40| 2.25k|} mz_crc32: 1988| 4.51k|mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len) { 1989| 4.51k| static const mz_uint32 s_crc_table[256] = { 1990| 4.51k| 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 1991| 4.51k| 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 1992| 4.51k| 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 1993| 4.51k| 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 1994| 4.51k| 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 1995| 4.51k| 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 1996| 4.51k| 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 1997| 4.51k| 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 1998| 4.51k| 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 1999| 4.51k| 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 2000| 4.51k| 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 2001| 4.51k| 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 2002| 4.51k| 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 2003| 4.51k| 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 2004| 4.51k| 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 2005| 4.51k| 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 2006| 4.51k| 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 2007| 4.51k| 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 2008| 4.51k| 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 2009| 4.51k| 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 2010| 4.51k| 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 2011| 4.51k| 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 2012| 4.51k| 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 2013| 4.51k| 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 2014| 4.51k| 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 2015| 4.51k| 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 2016| 4.51k| 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, 2017| 4.51k| 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 2018| 4.51k| 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 2019| 4.51k| 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 2020| 4.51k| 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 2021| 4.51k| 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 2022| 4.51k| 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 2023| 4.51k| 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 2024| 4.51k| 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 2025| 4.51k| 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 2026| 4.51k| 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 2027| 4.51k| 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 2028| 4.51k| 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 2029| 4.51k| 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 2030| 4.51k| 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 2031| 4.51k| 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 2032| 4.51k| 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D}; 2033| | 2034| 4.51k| mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF; 2035| 4.51k| const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr; 2036| | 2037| 87.5M| while (buf_len >= 4) { ------------------ | Branch (2037:10): [True: 87.5M, False: 4.51k] ------------------ 2038| 87.5M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; 2039| 87.5M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF]; 2040| 87.5M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF]; 2041| 87.5M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF]; 2042| 87.5M| pByte_buf += 4; 2043| 87.5M| buf_len -= 4; 2044| 87.5M| } 2045| | 2046| 11.2k| while (buf_len) { ------------------ | Branch (2046:10): [True: 6.68k, False: 4.51k] ------------------ 2047| 6.68k| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; 2048| 6.68k| ++pByte_buf; 2049| 6.68k| --buf_len; 2050| 6.68k| } 2051| | 2052| 4.51k| return ~crc32; 2053| 4.51k|} miniz_def_alloc_func: 2059| 9.03k| size_t size) { 2060| 9.03k| (void)opaque, (void)items, (void)size; 2061| 9.03k| return MZ_MALLOC(items * size); ------------------ | | 753| 9.03k|#define MZ_MALLOC(x) malloc(x) ------------------ 2062| 9.03k|} miniz_def_free_func: 2063| 20.3k|MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address) { 2064| 20.3k| (void)opaque, (void)address; 2065| 20.3k| MZ_FREE(address); ------------------ | | 754| 20.3k|#define MZ_FREE(x) free(x) ------------------ 2066| 20.3k|} miniz_def_realloc_func: 2068| 13.5k| size_t items, size_t size) { 2069| 13.5k| (void)opaque, (void)address, (void)items, (void)size; 2070| 13.5k| return MZ_REALLOC(address, items * size); ------------------ | | 755| 13.5k|#define MZ_REALLOC(p, x) realloc(p, x) ------------------ 2071| 13.5k|} tdefl_compress: 3854| 4.51k| size_t *pOut_buf_size, tdefl_flush flush) { 3855| 4.51k| if (!d) { ------------------ | Branch (3855:7): [True: 0, False: 4.51k] ------------------ 3856| 0| if (pIn_buf_size) ------------------ | Branch (3856:9): [True: 0, False: 0] ------------------ 3857| 0| *pIn_buf_size = 0; 3858| 0| if (pOut_buf_size) ------------------ | Branch (3858:9): [True: 0, False: 0] ------------------ 3859| 0| *pOut_buf_size = 0; 3860| 0| return TDEFL_STATUS_BAD_PARAM; 3861| 0| } 3862| | 3863| 4.51k| d->m_pIn_buf = pIn_buf; 3864| 4.51k| d->m_pIn_buf_size = pIn_buf_size; 3865| 4.51k| d->m_pOut_buf = pOut_buf; 3866| 4.51k| d->m_pOut_buf_size = pOut_buf_size; 3867| 4.51k| d->m_pSrc = (const mz_uint8 *)(pIn_buf); 3868| 4.51k| d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; ------------------ | Branch (3868:23): [True: 4.51k, False: 0] ------------------ 3869| 4.51k| d->m_out_buf_ofs = 0; 3870| 4.51k| d->m_flush = flush; 3871| | 3872| 4.51k| if (((d->m_pPut_buf_func != NULL) == ------------------ | Branch (3872:7): [True: 0, False: 4.51k] ------------------ 3873| 4.51k| ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || ------------------ | Branch (3873:9): [True: 0, False: 4.51k] | Branch (3873:31): [True: 0, False: 4.51k] ------------------ 3874| 4.51k| (d->m_prev_return_status != TDEFL_STATUS_OKAY) || ------------------ | Branch (3874:7): [True: 0, False: 4.51k] ------------------ 3875| 4.51k| (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || ------------------ | Branch (3875:8): [True: 0, False: 4.51k] | Branch (3875:32): [True: 0, False: 0] ------------------ 3876| 4.51k| (pIn_buf_size && *pIn_buf_size && !pIn_buf) || ------------------ | Branch (3876:8): [True: 4.51k, False: 0] | Branch (3876:24): [True: 2.25k, False: 2.25k] | Branch (3876:41): [True: 0, False: 2.25k] ------------------ 3877| 4.51k| (pOut_buf_size && *pOut_buf_size && !pOut_buf)) { ------------------ | Branch (3877:8): [True: 0, False: 4.51k] | Branch (3877:25): [True: 0, False: 0] | Branch (3877:43): [True: 0, False: 0] ------------------ 3878| 0| if (pIn_buf_size) ------------------ | Branch (3878:9): [True: 0, False: 0] ------------------ 3879| 0| *pIn_buf_size = 0; 3880| 0| if (pOut_buf_size) ------------------ | Branch (3880:9): [True: 0, False: 0] ------------------ 3881| 0| *pOut_buf_size = 0; 3882| 0| return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM); 3883| 0| } 3884| 4.51k| d->m_wants_to_finish |= (flush == TDEFL_FINISH); 3885| | 3886| 4.51k| if ((d->m_output_flush_remaining) || (d->m_finished)) ------------------ | Branch (3886:7): [True: 0, False: 4.51k] | Branch (3886:40): [True: 0, False: 4.51k] ------------------ 3887| 0| return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); 3888| | 3889| |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN 3890| | if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) && 3891| | ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) && 3892| | ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | 3893| | TDEFL_RLE_MATCHES)) == 0)) { 3894| | if (!tdefl_compress_fast(d)) 3895| | return d->m_prev_return_status; 3896| | } else 3897| |#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */ 3898| 4.51k| { 3899| 4.51k| if (!tdefl_compress_normal(d)) ------------------ | Branch (3899:9): [True: 0, False: 4.51k] ------------------ 3900| 0| return d->m_prev_return_status; 3901| 4.51k| } 3902| | 3903| 4.51k| if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && ------------------ | Branch (3903:7): [True: 0, False: 4.51k] ------------------ 3904| 0| (pIn_buf)) ------------------ | Branch (3904:7): [True: 0, False: 0] ------------------ 3905| 0| d->m_adler32 = 3906| 0| (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, 3907| 0| d->m_pSrc - (const mz_uint8 *)pIn_buf); 3908| | 3909| 4.51k| if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && ------------------ | Branch (3909:7): [True: 2.25k, False: 2.25k] | Branch (3909:18): [True: 2.25k, False: 0] | Branch (3909:44): [True: 2.25k, False: 0] ------------------ 3910| 2.25k| (!d->m_output_flush_remaining)) { ------------------ | Branch (3910:7): [True: 2.25k, False: 0] ------------------ 3911| 2.25k| if (tdefl_flush_block(d, flush) < 0) ------------------ | Branch (3911:9): [True: 0, False: 2.25k] ------------------ 3912| 0| return d->m_prev_return_status; 3913| 2.25k| d->m_finished = (flush == TDEFL_FINISH); 3914| 2.25k| if (flush == TDEFL_FULL_FLUSH) { ------------------ | Branch (3914:9): [True: 0, False: 2.25k] ------------------ 3915| 0| MZ_CLEAR_ARR(d->m_hash); ------------------ | | 761| 0|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 3916| 0| MZ_CLEAR_ARR(d->m_next); ------------------ | | 761| 0|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 3917| 0| d->m_dict_size = 0; 3918| 0| } 3919| 2.25k| } 3920| | 3921| 4.51k| return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); 3922| 4.51k|} tdefl_compress_buffer: 3925| 4.51k| size_t in_buf_size, tdefl_flush flush) { 3926| 4.51k| MZ_ASSERT(d->m_pPut_buf_func); ------------------ | | 746| 4.51k|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3926:3): [True: 0, False: 4.51k] | Branch (3926:3): [True: 4.51k, False: 0] ------------------ 3927| 4.51k| return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush); 3928| 4.51k|} tdefl_init: 3932| 2.25k| void *pPut_buf_user, int flags) { 3933| 2.25k| d->m_pPut_buf_func = pPut_buf_func; 3934| 2.25k| d->m_pPut_buf_user = pPut_buf_user; 3935| 2.25k| d->m_flags = (mz_uint)(flags); 3936| 2.25k| d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; 3937| 2.25k| d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0; 3938| 2.25k| d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3; 3939| 2.25k| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (3939:7): [True: 2.25k, False: 0] ------------------ 3940| 2.25k| MZ_CLEAR_ARR(d->m_hash); ------------------ | | 761| 2.25k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 3941| 2.25k| d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = 3942| 2.25k| d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0; 3943| 2.25k| d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = 3944| 2.25k| d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0; 3945| 2.25k| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 3946| 2.25k| d->m_pLZ_flags = d->m_lz_code_buf; 3947| 2.25k| *d->m_pLZ_flags = 0; 3948| 2.25k| d->m_num_flags_left = 8; 3949| 2.25k| d->m_pOutput_buf = d->m_output_buf; 3950| 2.25k| d->m_pOutput_buf_end = d->m_output_buf; 3951| 2.25k| d->m_prev_return_status = TDEFL_STATUS_OKAY; 3952| 2.25k| d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; 3953| 2.25k| d->m_adler32 = 1; 3954| 2.25k| d->m_pIn_buf = NULL; 3955| 2.25k| d->m_pOut_buf = NULL; 3956| 2.25k| d->m_pIn_buf_size = NULL; 3957| 2.25k| d->m_pOut_buf_size = NULL; 3958| 2.25k| d->m_flush = TDEFL_NO_FLUSH; 3959| 2.25k| d->m_pSrc = NULL; 3960| 2.25k| d->m_src_buf_left = 0; 3961| 2.25k| d->m_out_buf_ofs = 0; 3962| 2.25k| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (3962:7): [True: 2.25k, False: 0] ------------------ 3963| 2.25k| MZ_CLEAR_ARR(d->m_dict); ------------------ | | 761| 2.25k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 3964| 2.25k| memset(&d->m_huff_count[0][0], 0, 3965| 2.25k| sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 3966| 2.25k| memset(&d->m_huff_count[1][0], 0, 3967| 2.25k| sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 3968| 2.25k| return TDEFL_STATUS_OKAY; 3969| 2.25k|} tdefl_create_comp_flags_from_zip_params: 4060| 2.25k| int strategy) { 4061| 2.25k| mz_uint comp_flags = 4062| 2.25k| s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ------------------ | | 759| 2.25k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 2.25k] | | ------------------ ------------------ | Branch (4062:26): [True: 2.25k, False: 0] ------------------ 4063| 2.25k| ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); ------------------ | Branch (4063:8): [True: 0, False: 2.25k] ------------------ 4064| 2.25k| if (window_bits > 0) ------------------ | Branch (4064:7): [True: 0, False: 2.25k] ------------------ 4065| 0| comp_flags |= TDEFL_WRITE_ZLIB_HEADER; 4066| | 4067| 2.25k| if (!level) ------------------ | Branch (4067:7): [True: 0, False: 2.25k] ------------------ 4068| 0| comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; 4069| 2.25k| else if (strategy == MZ_FILTERED) ------------------ | Branch (4069:12): [True: 0, False: 2.25k] ------------------ 4070| 0| comp_flags |= TDEFL_FILTER_MATCHES; 4071| 2.25k| else if (strategy == MZ_HUFFMAN_ONLY) ------------------ | Branch (4071:12): [True: 0, False: 2.25k] ------------------ 4072| 0| comp_flags &= ~TDEFL_MAX_PROBES_MASK; 4073| 2.25k| else if (strategy == MZ_FIXED) ------------------ | Branch (4073:12): [True: 0, False: 2.25k] ------------------ 4074| 0| comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS; 4075| 2.25k| else if (strategy == MZ_RLE) ------------------ | Branch (4075:12): [True: 0, False: 2.25k] ------------------ 4076| 0| comp_flags |= TDEFL_RLE_MATCHES; 4077| | 4078| 2.25k| return comp_flags; 4079| 2.25k|} tinfl_decompress: 4387| 2.25k| const mz_uint32 decomp_flags) { 4388| 2.25k| static const mz_uint16 s_length_base[31] = { 4389| 2.25k| 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 4390| 2.25k| 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; 4391| 2.25k| static const mz_uint8 s_length_extra[31] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4392| 2.25k| 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4393| 2.25k| 4, 4, 5, 5, 5, 5, 0, 0, 0}; 4394| 2.25k| static const mz_uint16 s_dist_base[32] = { 4395| 2.25k| 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 4396| 2.25k| 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 4397| 2.25k| 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0}; 4398| 2.25k| static const mz_uint8 s_dist_extra[32] = { 4399| 2.25k| 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 4400| 2.25k| 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; 4401| 2.25k| static const mz_uint8 s_length_dezigzag[19] = { 4402| 2.25k| 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; 4403| 2.25k| static const mz_uint16 s_min_table_sizes[3] = {257, 1, 4}; 4404| | 4405| 2.25k| mz_int16 *pTrees[3]; 4406| 2.25k| mz_uint8 *pCode_sizes[3]; 4407| | 4408| 2.25k| tinfl_status status = TINFL_STATUS_FAILED; 4409| 2.25k| mz_uint32 num_bits, dist, counter, num_extra; 4410| 2.25k| tinfl_bit_buf_t bit_buf; 4411| 2.25k| const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = 4412| 2.25k| pIn_buf_next + *pIn_buf_size; 4413| 2.25k| mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = 4414| 2.25k| pOut_buf_next ? pOut_buf_next + ------------------ | Branch (4414:47): [True: 2.25k, False: 0] ------------------ 4415| 2.25k| *pOut_buf_size 4416| 2.25k| : NULL; 4417| 2.25k| size_t out_buf_size_mask = 4418| 2.25k| (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ------------------ | Branch (4418:14): [True: 2.25k, False: 0] ------------------ 4419| 2.25k| ? (size_t)-1 4420| 2.25k| : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, 4421| 2.25k| dist_from_out_buf_start; 4422| | 4423| | /* Ensure the output buffer's size is a power of 2, unless the output buffer 4424| | * is large enough to hold the entire output file (in which case it doesn't 4425| | * matter). */ 4426| 2.25k| if (((out_buf_size_mask + 1) & out_buf_size_mask) || ------------------ | Branch (4426:7): [True: 0, False: 2.25k] ------------------ 4427| 2.25k| (pOut_buf_next < pOut_buf_start)) { ------------------ | Branch (4427:7): [True: 0, False: 2.25k] ------------------ 4428| 0| *pIn_buf_size = *pOut_buf_size = 0; 4429| 0| return TINFL_STATUS_BAD_PARAM; 4430| 0| } 4431| | 4432| 2.25k| pTrees[0] = r->m_tree_0; 4433| 2.25k| pTrees[1] = r->m_tree_1; 4434| 2.25k| pTrees[2] = r->m_tree_2; 4435| 2.25k| pCode_sizes[0] = r->m_code_size_0; 4436| 2.25k| pCode_sizes[1] = r->m_code_size_1; 4437| 2.25k| pCode_sizes[2] = r->m_code_size_2; 4438| | 4439| 2.25k| num_bits = r->m_num_bits; 4440| 2.25k| bit_buf = r->m_bit_buf; 4441| 2.25k| dist = r->m_dist; 4442| 2.25k| counter = r->m_counter; 4443| 2.25k| num_extra = r->m_num_extra; 4444| 2.25k| dist_from_out_buf_start = r->m_dist_from_out_buf_start; 4445| 2.25k| TINFL_CR_BEGIN ------------------ | | 4244| 4.51k| switch (r->m_state) { \ | | ------------------ | | | Branch (4244:11): [True: 2.25k, False: 0] | | ------------------ | | 4245| 2.25k| case 0: | | ------------------ | | | Branch (4245:3): [True: 2.25k, False: 0] | | ------------------ ------------------ 4446| | 4447| 2.25k| bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; 4448| 2.25k| r->m_z_adler32 = r->m_check_adler32 = 1; 4449| 2.25k| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) { ------------------ | Branch (4449:7): [True: 0, False: 2.25k] ------------------ 4450| 0| TINFL_GET_BYTE(1, r->m_zhdr0); ------------------ | | 4264| 0| do { \ | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | ------------------ | | | Branch (4265:12): [True: 0, False: 0] | | ------------------ | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | ------------------ | | | | | Branch (4248:14): [True: 0, False: 0] | | | | ------------------ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | 4270| 0| } \ | | 4271| 0| c = *pIn_buf_cur++; \ | | 4272| 0| } \ | | 4273| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4451| 0| TINFL_GET_BYTE(2, r->m_zhdr1); ------------------ | | 4264| 0| do { \ | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | ------------------ | | | Branch (4265:12): [True: 0, False: 0] | | ------------------ | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | ------------------ | | | | | Branch (4248:14): [True: 0, False: 0] | | | | ------------------ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | 4270| 0| } \ | | 4271| 0| c = *pIn_buf_cur++; \ | | 4272| 0| } \ | | 4273| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4452| 0| counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || ------------------ | Branch (4452:16): [True: 0, False: 0] ------------------ 4453| 0| (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); ------------------ | Branch (4453:16): [True: 0, False: 0] | Branch (4453:37): [True: 0, False: 0] ------------------ 4454| 0| if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) ------------------ | Branch (4454:9): [True: 0, False: 0] ------------------ 4455| 0| counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ------------------ | Branch (4455:19): [True: 0, False: 0] ------------------ 4456| 0| ((out_buf_size_mask + 1) < ------------------ | Branch (4456:19): [True: 0, False: 0] ------------------ 4457| 0| (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4))))); 4458| 0| if (counter) { ------------------ | Branch (4458:9): [True: 0, False: 0] ------------------ 4459| 0| TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); ------------------ | | 4255| 0| do { \ | | 4256| 0| for (;;) { \ | | 4257| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 0| } \ | | 4259| 0| } \ | | 4260| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4460| 0| } 4461| 0| } 4462| | 4463| 6.47k| do { 4464| 6.47k| TINFL_GET_BITS(3, r->m_final, 3); ------------------ | | 4292| 6.47k| do { \ | | 4293| 6.47k| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 4.43k, False: 2.04k] | | ------------------ | | 4294| 4.43k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 4.43k| do { \ | | | | 4277| 4.43k| mz_uint c; \ | | | | 4278| 4.43k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 4.43k| do { \ | | | | | | 4265| 4.43k| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 4.43k] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 4.43k| c = *pIn_buf_cur++; \ | | | | | | 4272| 4.43k| } \ | | | | | | 4273| 4.43k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 4.43k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 4.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 4.43k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 4.43k| num_bits += 8; \ | | | | 4281| 4.43k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 4.43k] | | | | ------------------ | | ------------------ | | 4295| 4.43k| } \ | | 4296| 6.47k| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 6.47k| bit_buf >>= (n); \ | | 4298| 6.47k| num_bits -= (n); \ | | 4299| 6.47k| } \ | | 4300| 6.47k| MZ_MACRO_END | | ------------------ | | | | 726| 6.47k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 6.47k] | | | | ------------------ | | ------------------ ------------------ 4465| 6.47k| r->m_type = r->m_final >> 1; 4466| 6.47k| if (r->m_type == 0) { ------------------ | Branch (4466:9): [True: 2.90k, False: 3.57k] ------------------ 4467| 2.90k| TINFL_SKIP_BITS(5, num_bits & 7); ------------------ | | 4283| 2.90k| do { \ | | 4284| 2.90k| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4284:9): [True: 0, False: 2.90k] | | ------------------ | | 4285| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 0| do { \ | | | | 4277| 0| mz_uint c; \ | | | | 4278| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 0| do { \ | | | | | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 0| c = *pIn_buf_cur++; \ | | | | | | 4272| 0| } \ | | | | | | 4273| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 0| num_bits += 8; \ | | | | 4281| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 4286| 0| } \ | | 4287| 2.90k| bit_buf >>= (n); \ | | 4288| 2.90k| num_bits -= (n); \ | | 4289| 2.90k| } \ | | 4290| 2.90k| MZ_MACRO_END | | ------------------ | | | | 726| 2.90k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.90k] | | | | ------------------ | | ------------------ ------------------ 4468| 14.5k| for (counter = 0; counter < 4; ++counter) { ------------------ | Branch (4468:25): [True: 11.6k, False: 2.90k] ------------------ 4469| 11.6k| if (num_bits) ------------------ | Branch (4469:13): [True: 754, False: 10.8k] ------------------ 4470| 754| TINFL_GET_BITS(6, r->m_raw_header[counter], 8); ------------------ | | 4292| 754| do { \ | | 4293| 754| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 0, False: 754] | | ------------------ | | 4294| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 0| do { \ | | | | 4277| 0| mz_uint c; \ | | | | 4278| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 0| do { \ | | | | | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 0| c = *pIn_buf_cur++; \ | | | | | | 4272| 0| } \ | | | | | | 4273| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 0| num_bits += 8; \ | | | | 4281| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 4295| 0| } \ | | 4296| 754| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 754| bit_buf >>= (n); \ | | 4298| 754| num_bits -= (n); \ | | 4299| 754| } \ | | 4300| 754| MZ_MACRO_END | | ------------------ | | | | 726| 754|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 754] | | | | ------------------ | | ------------------ ------------------ 4471| 10.8k| else 4472| 10.8k| TINFL_GET_BYTE(7, r->m_raw_header[counter]); ------------------ | | 4264| 10.8k| do { \ | | 4265| 10.8k| while (pIn_buf_cur >= pIn_buf_end) { \ | | ------------------ | | | Branch (4265:12): [True: 0, False: 10.8k] | | ------------------ | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | ------------------ | | | | | Branch (4248:14): [True: 0, False: 0] | | | | ------------------ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | 4270| 0| } \ | | 4271| 10.8k| c = *pIn_buf_cur++; \ | | 4272| 10.8k| } \ | | 4273| 10.8k| MZ_MACRO_END | | ------------------ | | | | 726| 10.8k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 10.8k] | | | | ------------------ | | ------------------ ------------------ 4473| 11.6k| } 4474| 2.90k| if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != ------------------ | Branch (4474:11): [True: 0, False: 2.90k] ------------------ 4475| 2.90k| (mz_uint)(0xFFFF ^ 4476| 2.90k| (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) { 4477| 0| TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); ------------------ | | 4255| 0| do { \ | | 4256| 0| for (;;) { \ | | 4257| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 0| } \ | | 4259| 0| } \ | | 4260| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4478| 0| } 4479| 2.96k| while ((counter) && (num_bits)) { ------------------ | Branch (4479:14): [True: 2.96k, False: 3] | Branch (4479:27): [True: 64, False: 2.90k] ------------------ 4480| 64| TINFL_GET_BITS(51, dist, 8); ------------------ | | 4292| 64| do { \ | | 4293| 64| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 0, False: 64] | | ------------------ | | 4294| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 0| do { \ | | | | 4277| 0| mz_uint c; \ | | | | 4278| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 0| do { \ | | | | | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 0| c = *pIn_buf_cur++; \ | | | | | | 4272| 0| } \ | | | | | | 4273| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 0| num_bits += 8; \ | | | | 4281| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 4295| 0| } \ | | 4296| 64| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 64| bit_buf >>= (n); \ | | 4298| 64| num_bits -= (n); \ | | 4299| 64| } \ | | 4300| 64| MZ_MACRO_END | | ------------------ | | | | 726| 64|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 64] | | | | ------------------ | | ------------------ ------------------ 4481| 64| while (pOut_buf_cur >= pOut_buf_end) { ------------------ | Branch (4481:16): [True: 0, False: 64] ------------------ 4482| 0| TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 4247| 0| do { \ | | 4248| 0| status = result; \ | | 4249| 0| r->m_state = state_index; \ | | 4250| 0| goto common_exit; \ | | 4251| 0| case state_index:; \ | | ------------------ | | | Branch (4251:3): [True: 0, False: 2.25k] | | ------------------ | | 4252| 0| } \ | | 4253| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4483| 0| } 4484| 64| *pOut_buf_cur++ = (mz_uint8)dist; 4485| 64| counter--; 4486| 64| } 4487| 5.80k| while (counter) { ------------------ | Branch (4487:14): [True: 2.90k, False: 2.90k] ------------------ 4488| 2.90k| size_t n; 4489| 2.90k| while (pOut_buf_cur >= pOut_buf_end) { ------------------ | Branch (4489:16): [True: 0, False: 2.90k] ------------------ 4490| 0| TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 4247| 0| do { \ | | 4248| 0| status = result; \ | | 4249| 0| r->m_state = state_index; \ | | 4250| 0| goto common_exit; \ | | 4251| 0| case state_index:; \ | | ------------------ | | | Branch (4251:3): [True: 0, False: 2.25k] | | ------------------ | | 4252| 0| } \ | | 4253| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4491| 0| } 4492| 2.90k| while (pIn_buf_cur >= pIn_buf_end) { ------------------ | Branch (4492:16): [True: 0, False: 2.90k] ------------------ 4493| 0| TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ------------------ | | 4247| 0| do { \ | | 4248| 0| status = result; \ | | ------------------ | | | Branch (4248:14): [True: 0, False: 0] | | ------------------ | | 4249| 0| r->m_state = state_index; \ | | 4250| 0| goto common_exit; \ | | 4251| 0| case state_index:; \ | | ------------------ | | | Branch (4251:3): [True: 0, False: 2.25k] | | ------------------ | | 4252| 0| } \ | | 4253| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4494| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT 4495| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); 4496| 0| } 4497| 2.90k| n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), ------------------ | | 759| 5.80k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 2.90k] | | | Branch (759:25): [True: 1.60k, False: 1.30k] | | | Branch (759:38): [True: 0, False: 0] | | ------------------ ------------------ 4498| 2.90k| (size_t)(pIn_buf_end - pIn_buf_cur)), 4499| 2.90k| counter); 4500| 2.90k| TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); ------------------ | | 4240| 2.90k|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 4501| 2.90k| pIn_buf_cur += n; 4502| 2.90k| pOut_buf_cur += n; 4503| 2.90k| counter -= (mz_uint)n; 4504| 2.90k| } 4505| 3.57k| } else if (r->m_type == 3) { ------------------ | Branch (4505:16): [True: 0, False: 3.57k] ------------------ 4506| 0| TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED); ------------------ | | 4255| 0| do { \ | | 4256| 0| for (;;) { \ | | 4257| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 0| } \ | | 4259| 0| } \ | | 4260| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4507| 3.57k| } else { 4508| 3.57k| if (r->m_type == 1) { ------------------ | Branch (4508:11): [True: 298, False: 3.27k] ------------------ 4509| 298| mz_uint8 *p = r->m_code_size_0; 4510| 298| mz_uint i; 4511| 298| r->m_table_sizes[0] = 288; 4512| 298| r->m_table_sizes[1] = 32; 4513| 298| TINFL_MEMSET(r->m_code_size_1, 5, 32); ------------------ | | 4241| 298|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 4514| 43.2k| for (i = 0; i <= 143; ++i) ------------------ | Branch (4514:21): [True: 42.9k, False: 298] ------------------ 4515| 42.9k| *p++ = 8; 4516| 33.6k| for (; i <= 255; ++i) ------------------ | Branch (4516:16): [True: 33.3k, False: 298] ------------------ 4517| 33.3k| *p++ = 9; 4518| 7.45k| for (; i <= 279; ++i) ------------------ | Branch (4518:16): [True: 7.15k, False: 298] ------------------ 4519| 7.15k| *p++ = 7; 4520| 2.68k| for (; i <= 287; ++i) ------------------ | Branch (4520:16): [True: 2.38k, False: 298] ------------------ 4521| 2.38k| *p++ = 8; 4522| 3.27k| } else { 4523| 13.0k| for (counter = 0; counter < 3; counter++) { ------------------ | Branch (4523:27): [True: 9.82k, False: 3.27k] ------------------ 4524| 9.82k| TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); ------------------ | | 4292| 9.82k| do { \ | | 4293| 9.82k| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 3.36k, False: 6.45k] | | ------------------ | | 4294| 3.36k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 3.36k| do { \ | | | | 4277| 3.36k| mz_uint c; \ | | | | 4278| 3.36k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 3.36k| do { \ | | | | | | 4265| 3.36k| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 3.36k] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 3.36k| c = *pIn_buf_cur++; \ | | | | | | 4272| 3.36k| } \ | | | | | | 4273| 3.36k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 3.36k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 3.36k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 3.36k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 3.36k| num_bits += 8; \ | | | | 4281| 3.36k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 3.36k] | | | | ------------------ | | ------------------ | | 4295| 3.36k| } \ | | 4296| 9.82k| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 9.82k| bit_buf >>= (n); \ | | 4298| 9.82k| num_bits -= (n); \ | | 4299| 9.82k| } \ | | 4300| 9.82k| MZ_MACRO_END | | ------------------ | | | | 726| 9.82k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 9.82k] | | | | ------------------ | | ------------------ ------------------ 4525| 9.82k| r->m_table_sizes[counter] += s_min_table_sizes[counter]; 4526| 9.82k| } 4527| 3.27k| MZ_CLEAR_ARR(r->m_code_size_2); ------------------ | | 761| 3.27k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 4528| 60.6k| for (counter = 0; counter < r->m_table_sizes[2]; counter++) { ------------------ | Branch (4528:27): [True: 57.3k, False: 3.27k] ------------------ 4529| 57.3k| mz_uint s; 4530| 57.3k| TINFL_GET_BITS(14, s, 3); ------------------ | | 4292| 57.3k| do { \ | | 4293| 57.3k| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 19.0k, False: 38.2k] | | ------------------ | | 4294| 19.0k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 19.0k| do { \ | | | | 4277| 19.0k| mz_uint c; \ | | | | 4278| 19.0k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 19.0k| do { \ | | | | | | 4265| 19.0k| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 19.0k] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 19.0k| c = *pIn_buf_cur++; \ | | | | | | 4272| 19.0k| } \ | | | | | | 4273| 19.0k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 19.0k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 19.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 19.0k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 19.0k| num_bits += 8; \ | | | | 4281| 19.0k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 19.0k] | | | | ------------------ | | ------------------ | | 4295| 19.0k| } \ | | 4296| 57.3k| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 57.3k| bit_buf >>= (n); \ | | 4298| 57.3k| num_bits -= (n); \ | | 4299| 57.3k| } \ | | 4300| 57.3k| MZ_MACRO_END | | ------------------ | | | | 726| 57.3k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 57.3k] | | | | ------------------ | | ------------------ ------------------ 4531| 57.3k| r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s; 4532| 57.3k| } 4533| 3.27k| r->m_table_sizes[2] = 19; 4534| 3.27k| } 4535| 13.9k| for (; (int)r->m_type >= 0; r->m_type--) { ------------------ | Branch (4535:14): [True: 10.4k, False: 3.57k] ------------------ 4536| 10.4k| int tree_next, tree_cur; 4537| 10.4k| mz_int16 *pLookUp; 4538| 10.4k| mz_int16 *pTree; 4539| 10.4k| mz_uint8 *pCode_size; 4540| 10.4k| mz_uint i, j, used_syms, total, sym_index, next_code[17], 4541| 10.4k| total_syms[16]; 4542| 10.4k| pLookUp = r->m_look_up[r->m_type]; 4543| 10.4k| pTree = pTrees[r->m_type]; 4544| 10.4k| pCode_size = pCode_sizes[r->m_type]; 4545| 10.4k| MZ_CLEAR_ARR(total_syms); ------------------ | | 761| 10.4k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 4546| 10.4k| TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0])); ------------------ | | 4241| 10.4k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 4547| 10.4k| tinfl_clear_tree(r); 4548| 1.12M| for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) ------------------ | Branch (4548:21): [True: 1.11M, False: 10.4k] ------------------ 4549| 1.11M| total_syms[pCode_size[i]]++; 4550| 10.4k| used_syms = 0, total = 0; 4551| 10.4k| next_code[0] = next_code[1] = 0; 4552| 166k| for (i = 1; i <= 15; ++i) { ------------------ | Branch (4552:21): [True: 156k, False: 10.4k] ------------------ 4553| 156k| used_syms += total_syms[i]; 4554| 156k| next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); 4555| 156k| } 4556| 10.4k| if ((65536 != total) && (used_syms > 1)) { ------------------ | Branch (4556:13): [True: 655, False: 9.76k] | Branch (4556:33): [True: 0, False: 655] ------------------ 4557| 0| TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED); ------------------ | | 4255| 0| do { \ | | 4256| 0| for (;;) { \ | | 4257| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 0| } \ | | 4259| 0| } \ | | 4260| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4558| 0| } 4559| 10.4k| for (tree_next = -1, sym_index = 0; 4560| 1.12M| sym_index < r->m_table_sizes[r->m_type]; ++sym_index) { ------------------ | Branch (4560:14): [True: 1.11M, False: 10.4k] ------------------ 4561| 1.11M| mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index]; 4562| 1.11M| if (!code_size) ------------------ | Branch (4562:15): [True: 336k, False: 777k] ------------------ 4563| 336k| continue; 4564| 777k| cur_code = next_code[code_size]++; 4565| 7.22M| for (l = code_size; l > 0; l--, cur_code >>= 1) ------------------ | Branch (4565:31): [True: 6.44M, False: 777k] ------------------ 4566| 6.44M| rev_code = (rev_code << 1) | (cur_code & 1); 4567| 777k| if (code_size <= TINFL_FAST_LOOKUP_BITS) { ------------------ | Branch (4567:15): [True: 701k, False: 76.5k] ------------------ 4568| 701k| mz_int16 k = (mz_int16)((code_size << 9) | sym_index); 4569| 10.9M| while (rev_code < TINFL_FAST_LOOKUP_SIZE) { ------------------ | Branch (4569:20): [True: 10.2M, False: 701k] ------------------ 4570| 10.2M| pLookUp[rev_code] = k; 4571| 10.2M| rev_code += (1 << code_size); 4572| 10.2M| } 4573| 701k| continue; 4574| 701k| } 4575| 76.5k| if (0 == ------------------ | Branch (4575:15): [True: 14.1k, False: 62.3k] ------------------ 4576| 76.5k| (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) { 4577| 14.1k| pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = 4578| 14.1k| (mz_int16)tree_next; 4579| 14.1k| tree_cur = tree_next; 4580| 14.1k| tree_next -= 2; 4581| 14.1k| } 4582| 76.5k| rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1); 4583| 247k| for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) { ------------------ | Branch (4583:31): [True: 171k, False: 76.5k] ------------------ 4584| 171k| tree_cur -= ((rev_code >>= 1) & 1); 4585| 171k| if (!pTree[-tree_cur - 1]) { ------------------ | Branch (4585:17): [True: 48.2k, False: 122k] ------------------ 4586| 48.2k| pTree[-tree_cur - 1] = (mz_int16)tree_next; 4587| 48.2k| tree_cur = tree_next; 4588| 48.2k| tree_next -= 2; 4589| 48.2k| } else 4590| 122k| tree_cur = pTree[-tree_cur - 1]; 4591| 171k| } 4592| 76.5k| tree_cur -= ((rev_code >>= 1) & 1); 4593| 76.5k| pTree[-tree_cur - 1] = (mz_int16)sym_index; 4594| 76.5k| } 4595| 10.4k| if (r->m_type == 2) { ------------------ | Branch (4595:13): [True: 3.27k, False: 7.14k] ------------------ 4596| 3.27k| for (counter = 0; 4597| 590k| counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) { ------------------ | Branch (4597:16): [True: 587k, False: 3.27k] ------------------ 4598| 587k| mz_uint s; 4599| 587k| TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); ------------------ | | 4347| 587k| do { \ | | 4348| 587k| int temp; \ | | 4349| 587k| mz_uint code_len, c; \ | | 4350| 587k| if (num_bits < 15) { \ | | ------------------ | | | Branch (4350:9): [True: 106k, False: 480k] | | ------------------ | | 4351| 106k| if ((pIn_buf_end - pIn_buf_cur) < 2) { \ | | ------------------ | | | Branch (4351:11): [True: 53, False: 106k] | | ------------------ | | 4352| 53| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 4312| 54| do { \ | | | | 4313| 54| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 4314| 54| if (temp >= 0) { \ | | | | ------------------ | | | | | Branch (4314:9): [True: 54, False: 0] | | | | ------------------ | | | | 4315| 54| code_len = temp >> 9; \ | | | | 4316| 54| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (4316:11): [True: 54, False: 0] | | | | | Branch (4316:25): [True: 53, False: 1] | | | | ------------------ | | | | 4317| 54| break; \ | | | | 4318| 54| } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \ | | | | ------------------ | | | | | Branch (4318:16): [True: 0, False: 0] | | | | ------------------ | | | | 4319| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 4320| 0| do { \ | | | | 4321| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 4322| 0| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (4322:16): [True: 0, False: 0] | | | | | Branch (4322:30): [True: 0, False: 0] | | | | ------------------ | | | | 4323| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (4323:11): [True: 0, False: 0] | | | | ------------------ | | | | 4324| 0| break; \ | | | | 4325| 0| } \ | | | | 4326| 54| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 1| do { \ | | | | | | 4265| 1| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 1| c = *pIn_buf_cur++; \ | | | | | | 4272| 1| } \ | | | | | | 4273| 54| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 54|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4327| 1| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4328| 1| num_bits += 8; \ | | | | 4329| 1| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (4329:12): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 4353| 106k| } else { \ | | 4354| 106k| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | \ | | 4355| 106k| (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 4356| 106k| pIn_buf_cur += 2; \ | | 4357| 106k| num_bits += 16; \ | | 4358| 106k| } \ | | 4359| 106k| } \ | | 4360| 587k| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (4360:9): [True: 587k, False: 0] | | ------------------ | | 4361| 587k| code_len = temp >> 9, temp &= 511; \ | | 4362| 587k| else { \ | | 4363| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 4364| 0| do { \ | | 4365| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 4366| 0| } while (temp < 0); \ | | ------------------ | | | Branch (4366:16): [True: 0, False: 0] | | ------------------ | | 4367| 0| } \ | | 4368| 587k| sym = temp; \ | | 4369| 587k| bit_buf >>= code_len; \ | | 4370| 587k| num_bits -= code_len; \ | | 4371| 587k| } \ | | 4372| 587k| MZ_MACRO_END | | ------------------ | | | | 726| 587k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 587k] | | | | ------------------ | | ------------------ ------------------ 4600| 587k| if (dist < 16) { ------------------ | Branch (4600:17): [True: 533k, False: 54.1k] ------------------ 4601| 533k| r->m_len_codes[counter++] = (mz_uint8)dist; 4602| 533k| continue; 4603| 533k| } 4604| 54.1k| if ((dist == 16) && (!counter)) { ------------------ | Branch (4604:17): [True: 39.0k, False: 15.0k] | Branch (4604:33): [True: 0, False: 39.0k] ------------------ 4605| 0| TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED); ------------------ | | 4255| 0| do { \ | | 4256| 0| for (;;) { \ | | 4257| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 0| } \ | | 4259| 0| } \ | | 4260| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4606| 0| } 4607| 54.1k| num_extra = "\02\03\07"[dist - 16]; 4608| 54.1k| TINFL_GET_BITS(18, s, num_extra); ------------------ | | 4292| 54.1k| do { \ | | 4293| 54.1k| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 1, False: 54.1k] | | ------------------ | | 4294| 1| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 1| do { \ | | | | 4277| 1| mz_uint c; \ | | | | 4278| 1| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 1| do { \ | | | | | | 4265| 1| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 1| c = *pIn_buf_cur++; \ | | | | | | 4272| 1| } \ | | | | | | 4273| 1| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 1|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 1| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 1| num_bits += 8; \ | | | | 4281| 1| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | 4295| 1| } \ | | 4296| 54.1k| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 54.1k| bit_buf >>= (n); \ | | 4298| 54.1k| num_bits -= (n); \ | | 4299| 54.1k| } \ | | 4300| 54.1k| MZ_MACRO_END | | ------------------ | | | | 726| 54.1k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 54.1k] | | | | ------------------ | | ------------------ ------------------ 4609| 54.1k| s += "\03\03\013"[dist - 16]; 4610| 54.1k| TINFL_MEMSET(r->m_len_codes + counter, ------------------ | | 4241| 108k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) | | ------------------ | | | Branch (4241:41): [True: 39.0k, False: 15.0k] | | ------------------ ------------------ 4611| 54.1k| (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); 4612| 54.1k| counter += s; 4613| 54.1k| } 4614| 3.27k| if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) { ------------------ | Branch (4614:15): [True: 0, False: 3.27k] ------------------ 4615| 0| TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED); ------------------ | | 4255| 0| do { \ | | 4256| 0| for (;;) { \ | | 4257| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 0| } \ | | 4259| 0| } \ | | 4260| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4616| 0| } 4617| 3.27k| TINFL_MEMCPY(r->m_code_size_0, r->m_len_codes, r->m_table_sizes[0]); ------------------ | | 4240| 3.27k|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 4618| 3.27k| TINFL_MEMCPY(r->m_code_size_1, r->m_len_codes + r->m_table_sizes[0], ------------------ | | 4240| 3.27k|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 4619| 3.27k| r->m_table_sizes[1]); 4620| 3.27k| } 4621| 10.4k| } 4622| 2.07M| for (;;) { 4623| 2.07M| mz_uint8 *pSrc; 4624| 38.3M| for (;;) { 4625| 38.3M| if (((pIn_buf_end - pIn_buf_cur) < 4) || ------------------ | Branch (4625:15): [True: 10.2k, False: 38.3M] ------------------ 4626| 38.3M| ((pOut_buf_end - pOut_buf_cur) < 2)) { ------------------ | Branch (4626:15): [True: 12, False: 38.3M] ------------------ 4627| 10.2k| TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); ------------------ | | 4347| 10.2k| do { \ | | 4348| 10.2k| int temp; \ | | 4349| 10.2k| mz_uint code_len, c; \ | | 4350| 10.2k| if (num_bits < 15) { \ | | ------------------ | | | Branch (4350:9): [True: 3.00k, False: 7.21k] | | ------------------ | | 4351| 3.00k| if ((pIn_buf_end - pIn_buf_cur) < 2) { \ | | ------------------ | | | Branch (4351:11): [True: 2.44k, False: 562] | | ------------------ | | 4352| 2.44k| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 4312| 2.96k| do { \ | | | | 4313| 2.96k| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 4314| 2.96k| if (temp >= 0) { \ | | | | ------------------ | | | | | Branch (4314:9): [True: 2.71k, False: 248] | | | | ------------------ | | | | 4315| 2.71k| code_len = temp >> 9; \ | | | | 4316| 2.71k| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (4316:11): [True: 2.71k, False: 0] | | | | | Branch (4316:25): [True: 2.12k, False: 594] | | | | ------------------ | | | | 4317| 2.71k| break; \ | | | | 4318| 2.71k| } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \ | | | | ------------------ | | | | | Branch (4318:16): [True: 175, False: 73] | | | | ------------------ | | | | 4319| 175| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 4320| 316| do { \ | | | | 4321| 316| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 4322| 316| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (4322:16): [True: 194, False: 122] | | | | | Branch (4322:30): [True: 141, False: 53] | | | | ------------------ | | | | 4323| 175| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (4323:11): [True: 122, False: 53] | | | | ------------------ | | | | 4324| 175| break; \ | | | | 4325| 175| } \ | | | | 4326| 2.96k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 720| do { \ | | | | | | 4265| 720| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 720] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 720| c = *pIn_buf_cur++; \ | | | | | | 4272| 720| } \ | | | | | | 4273| 2.96k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 2.96k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 720] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4327| 720| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4328| 720| num_bits += 8; \ | | | | 4329| 720| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (4329:12): [True: 521, False: 199] | | | | ------------------ | | ------------------ | | 4353| 2.44k| } else { \ | | 4354| 562| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | \ | | 4355| 562| (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 4356| 562| pIn_buf_cur += 2; \ | | 4357| 562| num_bits += 16; \ | | 4358| 562| } \ | | 4359| 3.00k| } \ | | 4360| 10.2k| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (4360:9): [True: 9.61k, False: 604] | | ------------------ | | 4361| 10.2k| code_len = temp >> 9, temp &= 511; \ | | 4362| 10.2k| else { \ | | 4363| 604| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 4364| 1.55k| do { \ | | 4365| 1.55k| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 4366| 1.55k| } while (temp < 0); \ | | ------------------ | | | Branch (4366:16): [True: 946, False: 604] | | ------------------ | | 4367| 604| } \ | | 4368| 10.2k| sym = temp; \ | | 4369| 10.2k| bit_buf >>= code_len; \ | | 4370| 10.2k| num_bits -= code_len; \ | | 4371| 10.2k| } \ | | 4372| 10.2k| MZ_MACRO_END | | ------------------ | | | | 726| 10.2k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 10.2k] | | | | ------------------ | | ------------------ ------------------ 4628| 10.2k| if (counter >= 256) ------------------ | Branch (4628:17): [True: 3.63k, False: 6.58k] ------------------ 4629| 3.63k| break; 4630| 6.58k| while (pOut_buf_cur >= pOut_buf_end) { ------------------ | Branch (4630:20): [True: 0, False: 6.58k] ------------------ 4631| 0| TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 4247| 0| do { \ | | 4248| 0| status = result; \ | | 4249| 0| r->m_state = state_index; \ | | 4250| 0| goto common_exit; \ | | 4251| 0| case state_index:; \ | | ------------------ | | | Branch (4251:3): [True: 0, False: 2.25k] | | ------------------ | | 4252| 0| } \ | | 4253| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4632| 0| } 4633| 6.58k| *pOut_buf_cur++ = (mz_uint8)counter; 4634| 38.3M| } else { 4635| 38.3M| int sym2; 4636| 38.3M| mz_uint code_len; 4637| 38.3M|#if TINFL_USE_64BIT_BITBUF 4638| 38.3M| if (num_bits < 30) { ------------------ | Branch (4638:17): [True: 16.5M, False: 21.8M] ------------------ 4639| 16.5M| bit_buf |= 4640| 16.5M| (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); ------------------ | | 772| 16.5M| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 16.5M| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 16.5M| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 16.5M| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 4641| 16.5M| pIn_buf_cur += 4; 4642| 16.5M| num_bits += 32; 4643| 16.5M| } 4644| |#else 4645| | if (num_bits < 15) { 4646| | bit_buf |= 4647| | (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 4648| | pIn_buf_cur += 2; 4649| | num_bits += 16; 4650| | } 4651| |#endif 4652| 38.3M| if ((sym2 = ------------------ | Branch (4652:17): [True: 38.2M, False: 171k] ------------------ 4653| 38.3M| r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 4654| 38.3M| 0) 4655| 38.2M| code_len = sym2 >> 9; 4656| 171k| else { 4657| 171k| code_len = TINFL_FAST_LOOKUP_BITS; 4658| 373k| do { 4659| 373k| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 4660| 373k| } while (sym2 < 0); ------------------ | Branch (4660:24): [True: 201k, False: 171k] ------------------ 4661| 171k| } 4662| 38.3M| counter = sym2; 4663| 38.3M| bit_buf >>= code_len; 4664| 38.3M| num_bits -= code_len; 4665| 38.3M| if (counter & 256) ------------------ | Branch (4665:17): [True: 1.38M, False: 36.9M] ------------------ 4666| 1.38M| break; 4667| | 4668| |#if !TINFL_USE_64BIT_BITBUF 4669| | if (num_bits < 15) { 4670| | bit_buf |= 4671| | (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 4672| | pIn_buf_cur += 2; 4673| | num_bits += 16; 4674| | } 4675| |#endif 4676| 36.9M| if ((sym2 = ------------------ | Branch (4676:17): [True: 36.8M, False: 143k] ------------------ 4677| 36.9M| r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 4678| 36.9M| 0) 4679| 36.8M| code_len = sym2 >> 9; 4680| 143k| else { 4681| 143k| code_len = TINFL_FAST_LOOKUP_BITS; 4682| 288k| do { 4683| 288k| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 4684| 288k| } while (sym2 < 0); ------------------ | Branch (4684:24): [True: 144k, False: 143k] ------------------ 4685| 143k| } 4686| 36.9M| bit_buf >>= code_len; 4687| 36.9M| num_bits -= code_len; 4688| | 4689| 36.9M| pOut_buf_cur[0] = (mz_uint8)counter; 4690| 36.9M| if (sym2 & 256) { ------------------ | Branch (4690:17): [True: 685k, False: 36.3M] ------------------ 4691| 685k| pOut_buf_cur++; 4692| 685k| counter = sym2; 4693| 685k| break; 4694| 685k| } 4695| 36.3M| pOut_buf_cur[1] = (mz_uint8)sym2; 4696| 36.3M| pOut_buf_cur += 2; 4697| 36.3M| } 4698| 38.3M| } 4699| 2.07M| if ((counter &= 511) == 256) ------------------ | Branch (4699:13): [True: 3.57k, False: 2.07M] ------------------ 4700| 3.57k| break; 4701| | 4702| 2.07M| num_extra = s_length_extra[counter - 257]; 4703| 2.07M| counter = s_length_base[counter - 257]; 4704| 2.07M| if (num_extra) { ------------------ | Branch (4704:13): [True: 134k, False: 1.94M] ------------------ 4705| 134k| mz_uint extra_bits; 4706| 134k| TINFL_GET_BITS(25, extra_bits, num_extra); ------------------ | | 4292| 134k| do { \ | | 4293| 134k| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 69, False: 134k] | | ------------------ | | 4294| 69| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 69| do { \ | | | | 4277| 69| mz_uint c; \ | | | | 4278| 69| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 69| do { \ | | | | | | 4265| 69| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 69] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 69| c = *pIn_buf_cur++; \ | | | | | | 4272| 69| } \ | | | | | | 4273| 69| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 69|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 69] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 69| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 69| num_bits += 8; \ | | | | 4281| 69| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 69] | | | | ------------------ | | ------------------ | | 4295| 69| } \ | | 4296| 134k| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 134k| bit_buf >>= (n); \ | | 4298| 134k| num_bits -= (n); \ | | 4299| 134k| } \ | | 4300| 134k| MZ_MACRO_END | | ------------------ | | | | 726| 134k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 134k] | | | | ------------------ | | ------------------ ------------------ 4707| 134k| counter += extra_bits; 4708| 134k| } 4709| | 4710| 2.07M| TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); ------------------ | | 4347| 2.07M| do { \ | | 4348| 2.07M| int temp; \ | | 4349| 2.07M| mz_uint code_len, c; \ | | 4350| 2.07M| if (num_bits < 15) { \ | | ------------------ | | | Branch (4350:9): [True: 10.8k, False: 2.06M] | | ------------------ | | 4351| 10.8k| if ((pIn_buf_end - pIn_buf_cur) < 2) { \ | | ------------------ | | | Branch (4351:11): [True: 560, False: 10.3k] | | ------------------ | | 4352| 560| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 4312| 580| do { \ | | | | 4313| 580| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 4314| 580| if (temp >= 0) { \ | | | | ------------------ | | | | | Branch (4314:9): [True: 570, False: 10] | | | | ------------------ | | | | 4315| 570| code_len = temp >> 9; \ | | | | 4316| 570| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (4316:11): [True: 570, False: 0] | | | | | Branch (4316:25): [True: 547, False: 23] | | | | ------------------ | | | | 4317| 570| break; \ | | | | 4318| 570| } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \ | | | | ------------------ | | | | | Branch (4318:16): [True: 9, False: 1] | | | | ------------------ | | | | 4319| 9| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 4320| 12| do { \ | | | | 4321| 12| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 4322| 12| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (4322:16): [True: 3, False: 9] | | | | | Branch (4322:30): [True: 3, False: 0] | | | | ------------------ | | | | 4323| 9| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (4323:11): [True: 9, False: 0] | | | | ------------------ | | | | 4324| 9| break; \ | | | | 4325| 9| } \ | | | | 4326| 580| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 24| do { \ | | | | | | 4265| 24| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 24] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 24| c = *pIn_buf_cur++; \ | | | | | | 4272| 24| } \ | | | | | | 4273| 580| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 580|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 24] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4327| 24| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4328| 24| num_bits += 8; \ | | | | 4329| 24| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (4329:12): [True: 20, False: 4] | | | | ------------------ | | ------------------ | | 4353| 10.3k| } else { \ | | 4354| 10.3k| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | \ | | 4355| 10.3k| (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 4356| 10.3k| pIn_buf_cur += 2; \ | | 4357| 10.3k| num_bits += 16; \ | | 4358| 10.3k| } \ | | 4359| 10.8k| } \ | | 4360| 2.07M| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (4360:9): [True: 2.07M, False: 3.97k] | | ------------------ | | 4361| 2.07M| code_len = temp >> 9, temp &= 511; \ | | 4362| 2.07M| else { \ | | 4363| 3.97k| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 4364| 6.31k| do { \ | | 4365| 6.31k| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 4366| 6.31k| } while (temp < 0); \ | | ------------------ | | | Branch (4366:16): [True: 2.33k, False: 3.97k] | | ------------------ | | 4367| 3.97k| } \ | | 4368| 2.07M| sym = temp; \ | | 4369| 2.07M| bit_buf >>= code_len; \ | | 4370| 2.07M| num_bits -= code_len; \ | | 4371| 2.07M| } \ | | 4372| 2.07M| MZ_MACRO_END | | ------------------ | | | | 726| 2.07M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.07M] | | | | ------------------ | | ------------------ ------------------ 4711| 2.07M| num_extra = s_dist_extra[dist]; 4712| 2.07M| dist = s_dist_base[dist]; 4713| 2.07M| if (num_extra) { ------------------ | Branch (4713:13): [True: 1.97M, False: 99.6k] ------------------ 4714| 1.97M| mz_uint extra_bits; 4715| 1.97M| TINFL_GET_BITS(27, extra_bits, num_extra); ------------------ | | 4292| 1.97M| do { \ | | 4293| 1.97M| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 2.01k, False: 1.97M] | | ------------------ | | 4294| 2.01k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 2.02k| do { \ | | | | 4277| 2.02k| mz_uint c; \ | | | | 4278| 2.02k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 2.02k| do { \ | | | | | | 4265| 2.02k| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 2.02k] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 2.02k| c = *pIn_buf_cur++; \ | | | | | | 4272| 2.02k| } \ | | | | | | 4273| 2.02k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 2.02k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 2.02k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 2.02k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 2.02k| num_bits += 8; \ | | | | 4281| 2.02k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 10, False: 2.01k] | | | | ------------------ | | ------------------ | | 4295| 2.01k| } \ | | 4296| 1.97M| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 1.97M| bit_buf >>= (n); \ | | 4298| 1.97M| num_bits -= (n); \ | | 4299| 1.97M| } \ | | 4300| 1.97M| MZ_MACRO_END | | ------------------ | | | | 726| 1.97M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 1.97M] | | | | ------------------ | | ------------------ ------------------ 4716| 1.97M| dist += extra_bits; 4717| 1.97M| } 4718| | 4719| 2.07M| dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start; 4720| 2.07M| if ((dist == 0 || dist > dist_from_out_buf_start || ------------------ | Branch (4720:14): [True: 0, False: 2.07M] | Branch (4720:27): [True: 0, False: 2.07M] ------------------ 4721| 2.07M| dist_from_out_buf_start == 0) && ------------------ | Branch (4721:14): [True: 0, False: 2.07M] ------------------ 4722| 0| (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) { ------------------ | Branch (4722:13): [True: 0, False: 0] ------------------ 4723| 0| TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED); ------------------ | | 4255| 0| do { \ | | 4256| 0| for (;;) { \ | | 4257| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 0| } \ | | 4259| 0| } \ | | 4260| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4724| 0| } 4725| | 4726| 2.07M| pSrc = pOut_buf_start + 4727| 2.07M| ((dist_from_out_buf_start - dist) & out_buf_size_mask); 4728| | 4729| 2.07M| if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) { ------------------ | | 758| 2.07M|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 2.07M, False: 0] | | ------------------ ------------------ | Branch (4729:13): [True: 0, False: 2.07M] ------------------ 4730| 0| while (counter--) { ------------------ | Branch (4730:18): [True: 0, False: 0] ------------------ 4731| 0| while (pOut_buf_cur >= pOut_buf_end) { ------------------ | Branch (4731:20): [True: 0, False: 0] ------------------ 4732| 0| TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 4247| 0| do { \ | | 4248| 0| status = result; \ | | 4249| 0| r->m_state = state_index; \ | | 4250| 0| goto common_exit; \ | | 4251| 0| case state_index:; \ | | ------------------ | | | Branch (4251:3): [True: 0, False: 2.25k] | | ------------------ | | 4252| 0| } \ | | 4253| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4733| 0| } 4734| 0| *pOut_buf_cur++ = 4735| 0| pOut_buf_start[(dist_from_out_buf_start++ - dist) & 4736| 0| out_buf_size_mask]; 4737| 0| } 4738| 0| continue; 4739| 0| } 4740| |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES 4741| | else if ((counter >= 9) && (counter <= dist)) { 4742| | const mz_uint8 *pSrc_end = pSrc + (counter & ~7); 4743| | do { 4744| |#ifdef MINIZ_UNALIGNED_USE_MEMCPY 4745| | memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32) * 2); 4746| |#else 4747| | ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; 4748| | ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; 4749| |#endif 4750| | pOut_buf_cur += 8; 4751| | } while ((pSrc += 8) < pSrc_end); 4752| | if ((counter &= 7) < 3) { 4753| | if (counter) { 4754| | pOut_buf_cur[0] = pSrc[0]; 4755| | if (counter > 1) 4756| | pOut_buf_cur[1] = pSrc[1]; 4757| | pOut_buf_cur += counter; 4758| | } 4759| | continue; 4760| | } 4761| | } 4762| |#endif 4763| 11.9M| while (counter > 2) { ------------------ | Branch (4763:16): [True: 9.88M, False: 2.07M] ------------------ 4764| 9.88M| pOut_buf_cur[0] = pSrc[0]; 4765| 9.88M| pOut_buf_cur[1] = pSrc[1]; 4766| 9.88M| pOut_buf_cur[2] = pSrc[2]; 4767| 9.88M| pOut_buf_cur += 3; 4768| 9.88M| pSrc += 3; 4769| 9.88M| counter -= 3; 4770| 9.88M| } 4771| 2.07M| if (counter > 0) { ------------------ | Branch (4771:13): [True: 1.28M, False: 788k] ------------------ 4772| 1.28M| pOut_buf_cur[0] = pSrc[0]; 4773| 1.28M| if (counter > 1) ------------------ | Branch (4773:15): [True: 492k, False: 793k] ------------------ 4774| 492k| pOut_buf_cur[1] = pSrc[1]; 4775| 1.28M| pOut_buf_cur += counter; 4776| 1.28M| } 4777| 2.07M| } 4778| 3.57k| } 4779| 6.47k| } while (!(r->m_final & 1)); ------------------ | Branch (4779:12): [True: 4.21k, False: 2.25k] ------------------ 4780| | 4781| | /* Ensure byte alignment and put back any bytes from the bitbuf if we've 4782| | * looked ahead too far on gzip, or other Deflate streams followed by 4783| | * arbitrary data. */ 4784| | /* I'm being super conservative here. A number of simplifications can be made 4785| | * to the byte alignment part, and the Adler32 check shouldn't ever need to 4786| | * worry about reading from the bitbuf now. */ 4787| 2.25k| TINFL_SKIP_BITS(32, num_bits & 7); ------------------ | | 4283| 2.25k| do { \ | | 4284| 2.25k| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4284:9): [True: 0, False: 2.25k] | | ------------------ | | 4285| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 0| do { \ | | | | 4277| 0| mz_uint c; \ | | | | 4278| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 0| do { \ | | | | | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 0| c = *pIn_buf_cur++; \ | | | | | | 4272| 0| } \ | | | | | | 4273| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 0| num_bits += 8; \ | | | | 4281| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 4286| 0| } \ | | 4287| 2.25k| bit_buf >>= (n); \ | | 4288| 2.25k| num_bits -= (n); \ | | 4289| 2.25k| } \ | | 4290| 2.25k| MZ_MACRO_END | | ------------------ | | | | 726| 2.25k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.25k] | | | | ------------------ | | ------------------ ------------------ 4788| 2.25k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) { ------------------ | Branch (4788:10): [True: 2.25k, False: 0] | Branch (4788:42): [True: 0, False: 2.25k] ------------------ 4789| 0| --pIn_buf_cur; 4790| 0| num_bits -= 8; 4791| 0| } 4792| 2.25k| bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits); 4793| 2.25k| MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end ------------------ | | 746| 2.25k|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (4793:3): [True: 0, False: 2.25k] | Branch (4793:3): [True: 2.25k, False: 0] ------------------ 4794| | of non-deflate/zlib streams with following data (such 4795| | as gzip streams). */ 4796| | 4797| 2.25k| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) { ------------------ | Branch (4797:7): [True: 0, False: 2.25k] ------------------ 4798| 0| for (counter = 0; counter < 4; ++counter) { ------------------ | Branch (4798:23): [True: 0, False: 0] ------------------ 4799| 0| mz_uint s; 4800| 0| if (num_bits) ------------------ | Branch (4800:11): [True: 0, False: 0] ------------------ 4801| 0| TINFL_GET_BITS(41, s, 8); ------------------ | | 4292| 0| do { \ | | 4293| 0| if (num_bits < (mz_uint)(n)) { \ | | ------------------ | | | Branch (4293:9): [True: 0, False: 0] | | ------------------ | | 4294| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 4276| 0| do { \ | | | | 4277| 0| mz_uint c; \ | | | | 4278| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 4264| 0| do { \ | | | | | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | | | | | ------------------ | | | | | | | Branch (4265:12): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | | | | | ------------------ | | | | | | | | 4247| 0| do { \ | | | | | | | | 4248| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4248:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 4249| 0| r->m_state = state_index; \ | | | | | | | | 4250| 0| goto common_exit; \ | | | | | | | | 4251| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | | | | | ------------------ | | | | | | | | 4252| 0| } \ | | | | | | | | 4253| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | | | | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | | | | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | 4270| 0| } \ | | | | | | 4271| 0| c = *pIn_buf_cur++; \ | | | | | | 4272| 0| } \ | | | | | | 4273| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 4279| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 4280| 0| num_bits += 8; \ | | | | 4281| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (4281:12): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 4295| 0| } \ | | 4296| 0| b = bit_buf & ((1 << (n)) - 1); \ | | 4297| 0| bit_buf >>= (n); \ | | 4298| 0| num_bits -= (n); \ | | 4299| 0| } \ | | 4300| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4802| 0| else 4803| 0| TINFL_GET_BYTE(42, s); ------------------ | | 4264| 0| do { \ | | 4265| 0| while (pIn_buf_cur >= pIn_buf_end) { \ | | ------------------ | | | Branch (4265:12): [True: 0, False: 0] | | ------------------ | | 4266| 0| TINFL_CR_RETURN(state_index, \ | | ------------------ | | | | 4247| 0| do { \ | | | | 4248| 0| status = result; \ | | | | ------------------ | | | | | Branch (4248:14): [True: 0, False: 0] | | | | ------------------ | | | | 4249| 0| r->m_state = state_index; \ | | | | 4250| 0| goto common_exit; \ | | | | 4251| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4267| 0| (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ | | 4268| 0| ? TINFL_STATUS_NEEDS_MORE_INPUT \ | | 4269| 0| : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | 4270| 0| } \ | | 4271| 0| c = *pIn_buf_cur++; \ | | 4272| 0| } \ | | 4273| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4804| 0| r->m_z_adler32 = (r->m_z_adler32 << 8) | s; 4805| 0| } 4806| 0| } 4807| 2.25k| TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE); ------------------ | | 4255| 2.25k| do { \ | | 4256| 2.25k| for (;;) { \ | | 4257| 2.25k| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 4247| 2.25k| do { \ | | | | 4248| 2.25k| status = result; \ | | | | 4249| 2.25k| r->m_state = state_index; \ | | | | 4250| 2.25k| goto common_exit; \ | | | | 4251| 2.25k| case state_index:; \ | | | | ------------------ | | | | | Branch (4251:3): [True: 0, False: 2.25k] | | | | ------------------ | | | | 4252| 0| } \ | | | | 4253| 2.25k| MZ_MACRO_END | | | | ------------------ | | | | | | 726| 2.25k|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (726:29): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 4258| 2.25k| } \ | | 4259| 2.25k| } \ | | 4260| 2.25k| MZ_MACRO_END | | ------------------ | | | | 726| 2.25k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4808| | 4809| 2.25k| TINFL_CR_FINISH ------------------ | | 4261| 2.25k|#define TINFL_CR_FINISH } ------------------ 4810| | 4811| 2.25k|common_exit: 4812| | /* As long as we aren't telling the caller that we NEED more input to make 4813| | * forward progress: */ 4814| | /* Put back any bytes from the bitbuf in case we've looked ahead too far on 4815| | * gzip, or other Deflate streams followed by arbitrary data. */ 4816| | /* We need to be very careful here to NOT push back any bytes we definitely 4817| | * know we need to make forward progress, though, or we'll lock the caller up 4818| | * into an inf loop. */ 4819| 2.25k| if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && ------------------ | Branch (4819:7): [True: 2.25k, False: 0] ------------------ 4820| 2.25k| (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) { ------------------ | Branch (4820:7): [True: 2.25k, False: 0] ------------------ 4821| 2.25k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) { ------------------ | Branch (4821:12): [True: 2.25k, False: 0] | Branch (4821:44): [True: 0, False: 2.25k] ------------------ 4822| 0| --pIn_buf_cur; 4823| 0| num_bits -= 8; 4824| 0| } 4825| 2.25k| } 4826| 2.25k| r->m_num_bits = num_bits; 4827| 2.25k| r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits); 4828| 2.25k| r->m_dist = dist; 4829| 2.25k| r->m_counter = counter; 4830| 2.25k| r->m_num_extra = num_extra; 4831| 2.25k| r->m_dist_from_out_buf_start = dist_from_out_buf_start; 4832| 2.25k| *pIn_buf_size = pIn_buf_cur - pIn_buf_next; 4833| 2.25k| *pOut_buf_size = pOut_buf_cur - pOut_buf_next; 4834| 2.25k| if ((decomp_flags & ------------------ | Branch (4834:7): [True: 0, False: 2.25k] ------------------ 4835| 2.25k| (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && 4836| 0| (status >= 0)) { ------------------ | Branch (4836:7): [True: 0, False: 0] ------------------ 4837| 0| const mz_uint8 *ptr = pOut_buf_next; 4838| 0| size_t buf_len = *pOut_buf_size; 4839| 0| mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, 4840| 0| s2 = r->m_check_adler32 >> 16; 4841| 0| size_t block_len = buf_len % 5552; 4842| 0| while (buf_len) { ------------------ | Branch (4842:12): [True: 0, False: 0] ------------------ 4843| 0| for (i = 0; i + 7 < block_len; i += 8, ptr += 8) { ------------------ | Branch (4843:19): [True: 0, False: 0] ------------------ 4844| 0| s1 += ptr[0], s2 += s1; 4845| 0| s1 += ptr[1], s2 += s1; 4846| 0| s1 += ptr[2], s2 += s1; 4847| 0| s1 += ptr[3], s2 += s1; 4848| 0| s1 += ptr[4], s2 += s1; 4849| 0| s1 += ptr[5], s2 += s1; 4850| 0| s1 += ptr[6], s2 += s1; 4851| 0| s1 += ptr[7], s2 += s1; 4852| 0| } 4853| 0| for (; i < block_len; ++i) ------------------ | Branch (4853:14): [True: 0, False: 0] ------------------ 4854| 0| s1 += *ptr++, s2 += s1; 4855| 0| s1 %= 65521U, s2 %= 65521U; 4856| 0| buf_len -= block_len; 4857| 0| block_len = 5552; 4858| 0| } 4859| 0| r->m_check_adler32 = (s2 << 16) + s1; 4860| 0| if ((status == TINFL_STATUS_DONE) && ------------------ | Branch (4860:9): [True: 0, False: 0] ------------------ 4861| 0| (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && ------------------ | Branch (4861:9): [True: 0, False: 0] ------------------ 4862| 0| (r->m_check_adler32 != r->m_z_adler32)) ------------------ | Branch (4862:9): [True: 0, False: 0] ------------------ 4863| 0| status = TINFL_STATUS_ADLER32_MISMATCH; 4864| 0| } 4865| 2.25k| return status; 4866| 2.25k|} mz_zip_reader_end: 6093| 4.51k|mz_bool mz_zip_reader_end(mz_zip_archive *pZip) { 6094| 4.51k| return mz_zip_reader_end_internal(pZip, MZ_TRUE); ------------------ | | 719| 4.51k|#define MZ_TRUE (1) ------------------ 6095| 4.51k|} mz_zip_reader_init_mem: 6126| 2.25k| size_t size, mz_uint flags) { 6127| 2.25k| if (!pMem) ------------------ | Branch (6127:7): [True: 0, False: 2.25k] ------------------ 6128| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6129| | 6130| 2.25k| if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) ------------------ | Branch (6130:7): [True: 0, False: 2.25k] ------------------ 6131| 0| return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); 6132| | 6133| 2.25k| if (!mz_zip_reader_init_internal(pZip, flags)) ------------------ | Branch (6133:7): [True: 0, False: 2.25k] ------------------ 6134| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6135| | 6136| 2.25k| pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY; 6137| 2.25k| pZip->m_archive_size = size; 6138| 2.25k| pZip->m_pRead = mz_zip_mem_read_func; 6139| 2.25k| pZip->m_pIO_opaque = pZip; 6140| 2.25k| pZip->m_pNeeds_keepalive = NULL; 6141| | 6142| |#ifdef __cplusplus 6143| | pZip->m_pState->m_pMem = const_cast(pMem); 6144| |#else 6145| 2.25k| pZip->m_pState->m_pMem = (void *)pMem; 6146| 2.25k|#endif 6147| | 6148| 2.25k| pZip->m_pState->m_mem_size = size; 6149| | 6150| 2.25k| if (!mz_zip_reader_read_central_dir(pZip, flags)) { ------------------ | Branch (6150:7): [True: 0, False: 2.25k] ------------------ 6151| 0| mz_zip_reader_end_internal(pZip, MZ_FALSE); ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6152| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6153| 0| } 6154| | 6155| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 6156| 2.25k|} mz_zip_reader_is_file_encrypted: 6284| 4.51k| mz_uint file_index) { 6285| 4.51k| mz_uint m_bit_flag; 6286| 4.51k| const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); 6287| 4.51k| if (!p) { ------------------ | Branch (6287:7): [True: 0, False: 4.51k] ------------------ 6288| 0| mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6289| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6290| 0| } 6291| | 6292| 4.51k| m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6293| 4.51k| return (m_bit_flag & 6294| 4.51k| (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | 6295| 4.51k| MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0; 6296| 4.51k|} mz_zip_reader_is_file_supported: 6299| 4.51k| mz_uint file_index) { 6300| 4.51k| mz_uint bit_flag; 6301| 4.51k| mz_uint method; 6302| | 6303| 4.51k| const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); 6304| 4.51k| if (!p) { ------------------ | Branch (6304:7): [True: 0, False: 4.51k] ------------------ 6305| 0| mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6306| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6307| 0| } 6308| | 6309| 4.51k| method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6310| 4.51k| bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6311| | 6312| 4.51k| if ((method != 0) && (method != MZ_DEFLATED)) { ------------------ | | 316| 4.51k|#define MZ_DEFLATED 8 ------------------ | Branch (6312:7): [True: 4.51k, False: 0] | Branch (6312:24): [True: 0, False: 4.51k] ------------------ 6313| 0| mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); 6314| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6315| 0| } 6316| | 6317| 4.51k| if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | ------------------ | Branch (6317:7): [True: 0, False: 4.51k] ------------------ 6318| 4.51k| MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) { 6319| 0| mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); 6320| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6321| 0| } 6322| | 6323| 4.51k| if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG) { ------------------ | Branch (6323:7): [True: 0, False: 4.51k] ------------------ 6324| 0| mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); 6325| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6326| 0| } 6327| | 6328| 4.51k| return MZ_TRUE; ------------------ | | 719| 4.51k|#define MZ_TRUE (1) ------------------ 6329| 4.51k|} mz_zip_reader_is_file_a_directory: 6332| 6.77k| mz_uint file_index) { 6333| 6.77k| mz_uint filename_len, attribute_mapping_id, external_attr; 6334| 6.77k| const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); 6335| 6.77k| if (!p) { ------------------ | Branch (6335:7): [True: 0, False: 6.77k] ------------------ 6336| 0| mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6337| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6338| 0| } 6339| | 6340| 6.77k| filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); ------------------ | | 769| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6341| 6.77k| if (filename_len) { ------------------ | Branch (6341:7): [True: 6.77k, False: 0] ------------------ 6342| 6.77k| if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/') ------------------ | Branch (6342:9): [True: 0, False: 6.77k] ------------------ 6343| 0| return MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 6344| 6.77k| } 6345| | 6346| | /* Bugfix: This code was also checking if the internal attribute was non-zero, 6347| | * which wasn't correct. */ 6348| | /* Most/all zip writers (hopefully) set DOS file/directory attributes in the 6349| | * low 16-bits, so check for the DOS directory flag and ignore the source OS 6350| | * ID in the created by field. */ 6351| | /* FIXME: Remove this check? Is it necessary - we already check the filename. 6352| | */ 6353| 6.77k| attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8; ------------------ | | 769| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6354| 6.77k| (void)attribute_mapping_id; 6355| | 6356| 6.77k| external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS); ------------------ | | 772| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 6.77k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 6357| 6.77k| if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0) { ------------------ | Branch (6357:7): [True: 0, False: 6.77k] ------------------ 6358| 0| return MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 6359| 0| } 6360| | 6361| 6.77k| return MZ_FALSE; ------------------ | | 718| 6.77k|#define MZ_FALSE (0) ------------------ 6362| 6.77k|} mz_zip_reader_locate_file: 6569| 2.25k| const char *pComment, mz_uint flags) { 6570| 2.25k| mz_uint32 index; 6571| 2.25k| if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index)) ------------------ | Branch (6571:7): [True: 0, False: 2.25k] ------------------ 6572| 0| return -1; 6573| 2.25k| else 6574| 2.25k| return (int)index; 6575| 2.25k|} mz_zip_reader_locate_file_v2: 6579| 2.25k| mz_uint32 *pIndex) { 6580| 2.25k| mz_uint file_index; 6581| 2.25k| size_t name_len, comment_len; 6582| | 6583| 2.25k| if (pIndex) ------------------ | Branch (6583:7): [True: 2.25k, False: 0] ------------------ 6584| 2.25k| *pIndex = 0; 6585| | 6586| 2.25k| if ((!pZip) || (!pZip->m_pState) || (!pName)) ------------------ | Branch (6586:7): [True: 0, False: 2.25k] | Branch (6586:18): [True: 0, False: 2.25k] | Branch (6586:39): [True: 0, False: 2.25k] ------------------ 6587| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6588| | 6589| | /* See if we can use a binary search */ 6590| 2.25k| if (((pZip->m_pState->m_init_flags & ------------------ | Branch (6590:7): [True: 2.25k, False: 0] ------------------ 6591| 2.25k| MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) && 6592| 2.25k| (pZip->m_zip_mode == MZ_ZIP_MODE_READING) && ------------------ | Branch (6592:7): [True: 2.25k, False: 0] ------------------ 6593| 2.25k| ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && ------------------ | Branch (6593:7): [True: 2.25k, False: 0] ------------------ 6594| 2.25k| (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size)) { ------------------ | Branch (6594:7): [True: 2.25k, False: 0] | Branch (6594:22): [True: 2.25k, False: 0] ------------------ 6595| 2.25k| return mz_zip_locate_file_binary_search(pZip, pName, pIndex); 6596| 2.25k| } 6597| | 6598| | /* Locate the entry by scanning the entire central directory */ 6599| 0| name_len = strlen(pName); 6600| 0| if (name_len > MZ_UINT16_MAX) ------------------ | | 793| 0|#define MZ_UINT16_MAX (0xFFFFU) ------------------ | Branch (6600:7): [True: 0, False: 0] ------------------ 6601| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6602| | 6603| 0| comment_len = pComment ? strlen(pComment) : 0; ------------------ | Branch (6603:17): [True: 0, False: 0] ------------------ 6604| 0| if (comment_len > MZ_UINT16_MAX) ------------------ | | 793| 0|#define MZ_UINT16_MAX (0xFFFFU) ------------------ | Branch (6604:7): [True: 0, False: 0] ------------------ 6605| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6606| | 6607| 0| for (file_index = 0; file_index < pZip->m_total_files; file_index++) { ------------------ | Branch (6607:24): [True: 0, False: 0] ------------------ 6608| 0| const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT( ------------------ | | 5354| 0| ((element_type *)((array_ptr)->m_p))[index] ------------------ 6609| 0| &pZip->m_pState->m_central_dir, mz_uint8, 6610| 0| MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, 6611| 0| file_index)); 6612| 0| mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6613| 0| const char *pFilename = 6614| 0| (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; 6615| 0| if (filename_len < name_len) ------------------ | Branch (6615:9): [True: 0, False: 0] ------------------ 6616| 0| continue; 6617| 0| if (comment_len) { ------------------ | Branch (6617:9): [True: 0, False: 0] ------------------ 6618| 0| mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS), ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6619| 0| file_comment_len = 6620| 0| MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6621| 0| const char *pFile_comment = pFilename + filename_len + file_extra_len; 6622| 0| if ((file_comment_len != comment_len) || ------------------ | Branch (6622:11): [True: 0, False: 0] ------------------ 6623| 0| (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, ------------------ | Branch (6623:11): [True: 0, False: 0] ------------------ 6624| 0| flags))) 6625| 0| continue; 6626| 0| } 6627| 0| if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len)) { ------------------ | Branch (6627:9): [True: 0, False: 0] | Branch (6627:46): [True: 0, False: 0] ------------------ 6628| 0| int ofs = filename_len - 1; 6629| 0| do { 6630| 0| if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || ------------------ | Branch (6630:13): [True: 0, False: 0] | Branch (6630:40): [True: 0, False: 0] ------------------ 6631| 0| (pFilename[ofs] == ':')) ------------------ | Branch (6631:13): [True: 0, False: 0] ------------------ 6632| 0| break; 6633| 0| } while (--ofs >= 0); ------------------ | Branch (6633:16): [True: 0, False: 0] ------------------ 6634| 0| ofs++; 6635| 0| pFilename += ofs; 6636| 0| filename_len -= ofs; 6637| 0| } 6638| 0| if ((filename_len == name_len) && ------------------ | Branch (6638:9): [True: 0, False: 0] ------------------ 6639| 0| (mz_zip_string_equal(pName, pFilename, filename_len, flags))) { ------------------ | Branch (6639:9): [True: 0, False: 0] ------------------ 6640| 0| if (pIndex) ------------------ | Branch (6640:11): [True: 0, False: 0] ------------------ 6641| 0| *pIndex = file_index; 6642| 0| return MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 6643| 0| } 6644| 0| } 6645| | 6646| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND); 6647| 0|} mz_zip_reader_extract_to_heap: 6845| 2.25k| size_t *pSize, mz_uint flags) { 6846| 2.25k| mz_zip_archive_file_stat file_stat; 6847| 2.25k| mz_uint64 alloc_size; 6848| 2.25k| void *pBuf; 6849| | 6850| 2.25k| if (pSize) ------------------ | Branch (6850:7): [True: 2.25k, False: 0] ------------------ 6851| 2.25k| *pSize = 0; 6852| | 6853| 2.25k| if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) ------------------ | Branch (6853:7): [True: 0, False: 2.25k] ------------------ 6854| 0| return NULL; 6855| | 6856| 2.25k| alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size ------------------ | Branch (6856:16): [True: 0, False: 2.25k] ------------------ 6857| 2.25k| : file_stat.m_uncomp_size; 6858| 2.25k| if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF)) { ------------------ | Branch (6858:7): [Folded, False: 2.25k] | Branch (6858:50): [True: 0, False: 0] ------------------ 6859| 0| mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); 6860| 0| return NULL; 6861| 0| } 6862| | 6863| 2.25k| if (NULL == ------------------ | Branch (6863:7): [True: 0, False: 2.25k] ------------------ 6864| 2.25k| (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size))) { 6865| 0| mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 6866| 0| return NULL; 6867| 0| } 6868| | 6869| 2.25k| if (!mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, ------------------ | Branch (6869:7): [True: 0, False: 2.25k] ------------------ 6870| 2.25k| (size_t)alloc_size, flags, NULL, 6871| 2.25k| 0, &file_stat)) { 6872| 0| pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); 6873| 0| return NULL; 6874| 0| } 6875| | 6876| 2.25k| if (pSize) ------------------ | Branch (6876:7): [True: 2.25k, False: 0] ------------------ 6877| 2.25k| *pSize = (size_t)alloc_size; 6878| 2.25k| return pBuf; 6879| 2.25k|} mz_zip_writer_init_v2: 7985| 2.25k| mz_uint flags) { 7986| 2.25k| mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0; 7987| | 7988| 2.25k| if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || ------------------ | Branch (7988:7): [True: 0, False: 2.25k] | Branch (7988:18): [True: 0, False: 2.25k] | Branch (7988:38): [True: 0, False: 2.25k] ------------------ 7989| 2.25k| (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) ------------------ | Branch (7989:7): [True: 0, False: 2.25k] ------------------ 7990| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 7991| | 7992| 2.25k| if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) { ------------------ | Branch (7992:7): [True: 0, False: 2.25k] ------------------ 7993| 0| if (!pZip->m_pRead) ------------------ | Branch (7993:9): [True: 0, False: 0] ------------------ 7994| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 7995| 0| } 7996| | 7997| 2.25k| if (pZip->m_file_offset_alignment) { ------------------ | Branch (7997:7): [True: 0, False: 2.25k] ------------------ 7998| | /* Ensure user specified file offset alignment is a power of 2. */ 7999| 0| if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1)) ------------------ | Branch (7999:9): [True: 0, False: 0] ------------------ 8000| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 8001| 0| } 8002| | 8003| 2.25k| if (!pZip->m_pAlloc) ------------------ | Branch (8003:7): [True: 2.25k, False: 0] ------------------ 8004| 2.25k| pZip->m_pAlloc = miniz_def_alloc_func; 8005| 2.25k| if (!pZip->m_pFree) ------------------ | Branch (8005:7): [True: 2.25k, False: 0] ------------------ 8006| 2.25k| pZip->m_pFree = miniz_def_free_func; 8007| 2.25k| if (!pZip->m_pRealloc) ------------------ | Branch (8007:7): [True: 2.25k, False: 0] ------------------ 8008| 2.25k| pZip->m_pRealloc = miniz_def_realloc_func; 8009| | 8010| 2.25k| pZip->m_archive_size = existing_size; 8011| 2.25k| pZip->m_central_directory_file_ofs = 0; 8012| 2.25k| pZip->m_total_files = 0; 8013| | 8014| 2.25k| if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc( ------------------ | Branch (8014:7): [True: 0, False: 2.25k] ------------------ 8015| 2.25k| pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) 8016| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 8017| | 8018| 2.25k| memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state)); 8019| | 8020| 2.25k| MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, ------------------ | | 5341| 2.25k| (array_ptr)->m_element_size = element_size ------------------ 8021| 2.25k| sizeof(mz_uint8)); 8022| 2.25k| MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, ------------------ | | 5341| 2.25k| (array_ptr)->m_element_size = element_size ------------------ 8023| 2.25k| sizeof(mz_uint32)); 8024| 2.25k| MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, ------------------ | | 5341| 2.25k| (array_ptr)->m_element_size = element_size ------------------ 8025| 2.25k| sizeof(mz_uint32)); 8026| | 8027| 2.25k| pZip->m_pState->m_zip64 = zip64; 8028| 2.25k| pZip->m_pState->m_zip64_has_extended_info_fields = zip64; 8029| | 8030| 2.25k| pZip->m_zip_type = MZ_ZIP_TYPE_USER; 8031| 2.25k| pZip->m_zip_mode = MZ_ZIP_MODE_WRITING; 8032| | 8033| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 8034| 2.25k|} mz_zip_writer_init_heap_v2: 8043| 2.25k| mz_uint flags) { 8044| 2.25k| pZip->m_pWrite = mz_zip_heap_write_func; 8045| 2.25k| pZip->m_pNeeds_keepalive = NULL; 8046| | 8047| 2.25k| if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ------------------ | Branch (8047:7): [True: 0, False: 2.25k] ------------------ 8048| 0| pZip->m_pRead = mz_zip_mem_read_func; 8049| | 8050| 2.25k| pZip->m_pIO_opaque = pZip; 8051| | 8052| 2.25k| if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags)) ------------------ | Branch (8052:7): [True: 0, False: 2.25k] ------------------ 8053| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 8054| | 8055| 2.25k| pZip->m_zip_type = MZ_ZIP_TYPE_HEAP; 8056| | 8057| 2.25k| if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, ------------------ | | 758| 2.25k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 2.25k, False: 0] | | ------------------ ------------------ | Branch (8057:7): [True: 2.25k, False: 0] ------------------ 8058| 2.25k| size_to_reserve_at_beginning))) { 8059| 2.25k| if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc( ------------------ | Branch (8059:9): [True: 0, False: 2.25k] ------------------ 8060| 2.25k| pZip->m_pAlloc_opaque, 1, initial_allocation_size))) { 8061| 0| mz_zip_writer_end_internal(pZip, MZ_FALSE); ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 8062| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 8063| 0| } 8064| 2.25k| pZip->m_pState->m_mem_capacity = initial_allocation_size; 8065| 2.25k| } 8066| | 8067| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 8068| 2.25k|} mz_zip_writer_finalize_archive: 9739| 2.25k|mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip) { 9740| 2.25k| mz_zip_internal_state *pState; 9741| 2.25k| mz_uint64 central_dir_ofs, central_dir_size; 9742| 2.25k| mz_uint8 hdr[256]; 9743| | 9744| 2.25k| if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING)) ------------------ | Branch (9744:7): [True: 0, False: 2.25k] | Branch (9744:18): [True: 0, False: 2.25k] | Branch (9744:39): [True: 0, False: 2.25k] ------------------ 9745| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 9746| | 9747| 2.25k| pState = pZip->m_pState; 9748| | 9749| 2.25k| if (pState->m_zip64) { ------------------ | Branch (9749:7): [True: 2.25k, False: 0] ------------------ 9750| 2.25k| if ((mz_uint64)pState->m_central_dir.m_size >= MZ_UINT32_MAX) ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (9750:9): [True: 0, False: 2.25k] ------------------ 9751| 0| return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); 9752| 2.25k| } else { 9753| 0| if ((pZip->m_total_files > MZ_UINT16_MAX) || ------------------ | | 793| 0|#define MZ_UINT16_MAX (0xFFFFU) ------------------ | Branch (9753:9): [True: 0, False: 0] ------------------ 9754| 0| ((pZip->m_archive_size + pState->m_central_dir.m_size + ------------------ | Branch (9754:9): [True: 0, False: 0] ------------------ 9755| 0| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)) ------------------ | | 794| 0|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ 9756| 0| return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); 9757| 0| } 9758| | 9759| 2.25k| central_dir_ofs = 0; 9760| 2.25k| central_dir_size = 0; 9761| 2.25k| if (pZip->m_total_files) { ------------------ | Branch (9761:7): [True: 2.25k, False: 0] ------------------ 9762| | /* Write central directory */ 9763| 2.25k| central_dir_ofs = pZip->m_archive_size; 9764| 2.25k| central_dir_size = pState->m_central_dir.m_size; 9765| 2.25k| pZip->m_central_directory_file_ofs = central_dir_ofs; 9766| 2.25k| if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, ------------------ | Branch (9766:9): [True: 0, False: 2.25k] ------------------ 9767| 2.25k| pState->m_central_dir.m_p, 9768| 2.25k| (size_t)central_dir_size) != central_dir_size) 9769| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); 9770| | 9771| 2.25k| pZip->m_archive_size += central_dir_size; 9772| 2.25k| } 9773| | 9774| 2.25k| if (pState->m_zip64) { ------------------ | Branch (9774:7): [True: 2.25k, False: 0] ------------------ 9775| | /* Write zip64 end of central directory header */ 9776| 2.25k| mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size; 9777| | 9778| 2.25k| MZ_CLEAR_ARR(hdr); ------------------ | | 761| 2.25k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 9779| 2.25k| MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDH_SIG_OFS, ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 9780| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG); 9781| 2.25k| MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS, ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 9782| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - sizeof(mz_uint32) - 9783| 2.25k| sizeof(mz_uint64)); 9784| 2.25k| MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 9785| 2.25k| 0x031E); /* TODO: always Unix */ 9786| 2.25k| MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, 0x002D); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 9787| 2.25k| MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 9788| 2.25k| pZip->m_total_files); 9789| 2.25k| MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 9790| 2.25k| pZip->m_total_files); 9791| 2.25k| MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size); ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 9792| 2.25k| MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs); ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 9793| 2.25k| if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, ------------------ | Branch (9793:9): [True: 0, False: 2.25k] ------------------ 9794| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) != 9795| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) 9796| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); 9797| | 9798| 2.25k| pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE; 9799| | 9800| | /* Write zip64 end of central directory locator */ 9801| 2.25k| MZ_CLEAR_ARR(hdr); ------------------ | | 761| 2.25k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 9802| 2.25k| MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_SIG_OFS, ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 9803| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG); 9804| 2.25k| MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 9805| 2.25k| rel_ofs_to_zip64_ecdr); 9806| 2.25k| MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, 1); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 9807| 2.25k| if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, ------------------ | Branch (9807:9): [True: 0, False: 2.25k] ------------------ 9808| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) != 9809| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) 9810| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); 9811| | 9812| 2.25k| pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE; 9813| 2.25k| } 9814| | 9815| | /* Write end of central directory record */ 9816| 2.25k| MZ_CLEAR_ARR(hdr); ------------------ | | 761| 2.25k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 9817| 2.25k| MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 9818| 2.25k| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG); 9819| 2.25k| MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) | | ------------------ | | | Branch (7900:72): [True: 0, False: 2.25k] | | ------------------ ------------------ 9820| 2.25k| MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); 9821| 2.25k| MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) | | ------------------ | | | Branch (7900:72): [True: 0, False: 2.25k] | | ------------------ ------------------ 9822| 2.25k| MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); 9823| 2.25k| MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, ------------------ | | 7901| 4.51k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 0, False: 2.25k] | | ------------------ ------------------ 9824| 2.25k| MZ_MIN(MZ_UINT32_MAX, central_dir_size)); 9825| 2.25k| MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, ------------------ | | 7901| 4.51k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 0, False: 2.25k] | | ------------------ ------------------ 9826| 2.25k| MZ_MIN(MZ_UINT32_MAX, central_dir_ofs)); 9827| | 9828| 2.25k| if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, ------------------ | Branch (9828:7): [True: 0, False: 2.25k] ------------------ 9829| 2.25k| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != 9830| 2.25k| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) 9831| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); 9832| | 9833| 2.25k|#ifndef MINIZ_NO_STDIO 9834| 2.25k| if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF)) ------------------ | | 5179| 0|#define MZ_FFLUSH fflush ------------------ | Branch (9834:7): [True: 0, False: 2.25k] | Branch (9834:28): [True: 0, False: 0] ------------------ 9835| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); 9836| 2.25k|#endif /* #ifndef MINIZ_NO_STDIO */ 9837| | 9838| 2.25k| pZip->m_archive_size += MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE; 9839| | 9840| 2.25k| pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED; 9841| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 9842| 2.25k|} mz_zip_writer_end: 9869| 4.51k|mz_bool mz_zip_writer_end(mz_zip_archive *pZip) { 9870| 4.51k| return mz_zip_writer_end_internal(pZip, MZ_TRUE); ------------------ | | 719| 4.51k|#define MZ_TRUE (1) ------------------ 9871| 4.51k|} mz_zip_reader_file_stat: 10219| 4.51k| mz_zip_archive_file_stat *pStat) { 10220| 4.51k| return mz_zip_file_stat_internal( 10221| | pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL); 10222| 4.51k|} zip.c:tdefl_flush_output_buffer: 3831| 4.51k|static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d) { 3832| 4.51k| if (d->m_pIn_buf_size) { ------------------ | Branch (3832:7): [True: 4.51k, False: 0] ------------------ 3833| 4.51k| *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; 3834| 4.51k| } 3835| | 3836| 4.51k| if (d->m_pOut_buf_size) { ------------------ | Branch (3836:7): [True: 0, False: 4.51k] ------------------ 3837| 0| size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, ------------------ | | 759| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 0] | | ------------------ ------------------ 3838| 0| d->m_output_flush_remaining); 3839| 0| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, 3840| 0| d->m_output_buf + d->m_output_flush_ofs, n); 3841| 0| d->m_output_flush_ofs += (mz_uint)n; 3842| 0| d->m_output_flush_remaining -= (mz_uint)n; 3843| 0| d->m_out_buf_ofs += n; 3844| | 3845| 0| *d->m_pOut_buf_size = d->m_out_buf_ofs; 3846| 0| } 3847| | 3848| 4.51k| return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE ------------------ | Branch (3848:11): [True: 2.25k, False: 2.25k] | Branch (3848:28): [True: 2.25k, False: 0] ------------------ 3849| 4.51k| : TDEFL_STATUS_OKAY; 3850| 4.51k|} zip.c:tdefl_compress_normal: 3687| 4.51k|static mz_bool tdefl_compress_normal(tdefl_compressor *d) { 3688| 4.51k| const mz_uint8 *pSrc = d->m_pSrc; 3689| 4.51k| size_t src_buf_left = d->m_src_buf_left; 3690| 4.51k| tdefl_flush flush = d->m_flush; 3691| | 3692| 147M| while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) { ------------------ | Branch (3692:10): [True: 147M, False: 295k] | Branch (3692:29): [True: 294k, False: 1.03k] | Branch (3692:40): [True: 292k, False: 2.25k] ------------------ 3693| 147M| mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos; 3694| | /* Update dictionary and hash chains. Keeps the lookahead size equal to 3695| | * TDEFL_MAX_MATCH_LEN. */ 3696| 147M| if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) { ------------------ | Branch (3696:9): [True: 147M, False: 2.26k] ------------------ 3697| 147M| mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & 3698| 147M| TDEFL_LZ_DICT_SIZE_MASK, 3699| 147M| ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2; 3700| 147M| mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] 3701| 147M| << TDEFL_LZ_HASH_SHIFT) ^ 3702| 147M| d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK]; 3703| 147M| mz_uint num_bytes_to_process = (mz_uint)MZ_MIN( ------------------ | | 759| 147M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 292k, False: 147M] | | ------------------ ------------------ 3704| 147M| src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size); 3705| 147M| const mz_uint8 *pSrc_end = pSrc ? pSrc + num_bytes_to_process : NULL; ------------------ | Branch (3705:34): [True: 147M, False: 0] ------------------ 3706| 147M| src_buf_left -= num_bytes_to_process; 3707| 147M| d->m_lookahead_size += num_bytes_to_process; 3708| 322M| while (pSrc != pSrc_end) { ------------------ | Branch (3708:14): [True: 174M, False: 147M] ------------------ 3709| 174M| mz_uint8 c = *pSrc++; 3710| 174M| d->m_dict[dst_pos] = c; 3711| 174M| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (3711:13): [True: 1.21M, False: 173M] ------------------ 3712| 1.21M| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 3713| 174M| hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); 3714| 174M| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 3715| 174M| d->m_hash[hash] = (mz_uint16)(ins_pos); 3716| 174M| dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; 3717| 174M| ins_pos++; 3718| 174M| } 3719| 147M| } else { 3720| 419k| while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) { ------------------ | Branch (3720:14): [True: 418k, False: 855] | Branch (3720:32): [True: 417k, False: 1.40k] ------------------ 3721| 417k| mz_uint8 c = *pSrc++; 3722| 417k| mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & 3723| 417k| TDEFL_LZ_DICT_SIZE_MASK; 3724| 417k| src_buf_left--; 3725| 417k| d->m_dict[dst_pos] = c; 3726| 417k| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (3726:13): [True: 415k, False: 1.41k] ------------------ 3727| 415k| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 3728| 417k| if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) { ------------------ | Branch (3728:13): [True: 412k, False: 4.51k] ------------------ 3729| 412k| mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2; 3730| 412k| mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] 3731| 412k| << (TDEFL_LZ_HASH_SHIFT * 2)) ^ 3732| 412k| (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] 3733| 412k| << TDEFL_LZ_HASH_SHIFT) ^ 3734| 412k| c) & 3735| 412k| (TDEFL_LZ_HASH_SIZE - 1); 3736| 412k| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 3737| 412k| d->m_hash[hash] = (mz_uint16)(ins_pos); 3738| 412k| } 3739| 417k| } 3740| 2.26k| } 3741| 147M| d->m_dict_size = 3742| 147M| MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size); ------------------ | | 759| 147M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 127M, False: 19.9M] | | ------------------ ------------------ 3743| 147M| if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) ------------------ | Branch (3743:9): [True: 147M, False: 292k] | Branch (3743:21): [True: 1.22k, False: 147M] ------------------ 3744| 1.22k| break; 3745| | 3746| | /* Simple lazy/greedy parsing state machine. */ 3747| 147M| len_to_move = 1; 3748| 147M| cur_match_dist = 0; 3749| 147M| cur_match_len = 3750| 147M| d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); ------------------ | Branch (3750:9): [True: 2.36M, False: 145M] ------------------ 3751| 147M| cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; 3752| 147M| if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) { ------------------ | Branch (3752:9): [True: 0, False: 147M] ------------------ 3753| 0| if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) { ------------------ | Branch (3753:11): [True: 0, False: 0] | Branch (3753:31): [True: 0, False: 0] ------------------ 3754| 0| mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK]; 3755| 0| cur_match_len = 0; 3756| 0| while (cur_match_len < d->m_lookahead_size) { ------------------ | Branch (3756:16): [True: 0, False: 0] ------------------ 3757| 0| if (d->m_dict[cur_pos + cur_match_len] != c) ------------------ | Branch (3757:15): [True: 0, False: 0] ------------------ 3758| 0| break; 3759| 0| cur_match_len++; 3760| 0| } 3761| 0| if (cur_match_len < TDEFL_MIN_MATCH_LEN) ------------------ | Branch (3761:13): [True: 0, False: 0] ------------------ 3762| 0| cur_match_len = 0; 3763| 0| else 3764| 0| cur_match_dist = 1; 3765| 0| } 3766| 147M| } else { 3767| 147M| tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, 3768| 147M| d->m_lookahead_size, &cur_match_dist, &cur_match_len); 3769| 147M| } 3770| 147M| if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && ------------------ | Branch (3770:10): [True: 2.29M, False: 145M] ------------------ 3771| 2.29M| (cur_match_dist >= 8U * 1024U)) || ------------------ | Branch (3771:10): [True: 930k, False: 1.36M] ------------------ 3772| 146M| (cur_pos == cur_match_dist) || ------------------ | Branch (3772:9): [True: 6.26k, False: 146M] ------------------ 3773| 146M| ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) { ------------------ | Branch (3773:10): [True: 0, False: 146M] | Branch (3773:49): [True: 0, False: 0] ------------------ 3774| 936k| cur_match_dist = cur_match_len = 0; 3775| 936k| } 3776| 147M| if (d->m_saved_match_len) { ------------------ | Branch (3776:9): [True: 2.36M, False: 145M] ------------------ 3777| 2.36M| if (cur_match_len > d->m_saved_match_len) { ------------------ | Branch (3777:11): [True: 327k, False: 2.03M] ------------------ 3778| 327k| tdefl_record_literal(d, (mz_uint8)d->m_saved_lit); 3779| 327k| if (cur_match_len >= 128) { ------------------ | Branch (3779:13): [True: 7.17k, False: 319k] ------------------ 3780| 7.17k| tdefl_record_match(d, cur_match_len, cur_match_dist); 3781| 7.17k| d->m_saved_match_len = 0; 3782| 7.17k| len_to_move = cur_match_len; 3783| 319k| } else { 3784| 319k| d->m_saved_lit = d->m_dict[cur_pos]; 3785| 319k| d->m_saved_match_dist = cur_match_dist; 3786| 319k| d->m_saved_match_len = cur_match_len; 3787| 319k| } 3788| 2.03M| } else { 3789| 2.03M| tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); 3790| 2.03M| len_to_move = d->m_saved_match_len - 1; 3791| 2.03M| d->m_saved_match_len = 0; 3792| 2.03M| } 3793| 145M| } else if (!cur_match_dist) ------------------ | Branch (3793:16): [True: 143M, False: 2.11M] ------------------ 3794| 143M| tdefl_record_literal(d, 3795| 143M| d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); ------------------ | | 759| 143M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 143M, False: 0] | | ------------------ ------------------ 3796| 2.11M| else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || ------------------ | Branch (3796:14): [True: 0, False: 2.11M] | Branch (3796:39): [True: 0, False: 2.11M] ------------------ 3797| 2.11M| (cur_match_len >= 128)) { ------------------ | Branch (3797:14): [True: 73.2k, False: 2.04M] ------------------ 3798| 73.2k| tdefl_record_match(d, cur_match_len, cur_match_dist); 3799| 73.2k| len_to_move = cur_match_len; 3800| 2.04M| } else { 3801| 2.04M| d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; ------------------ | | 759| 2.04M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 2.04M, False: 0] | | ------------------ ------------------ 3802| 2.04M| d->m_saved_match_dist = cur_match_dist; 3803| 2.04M| d->m_saved_match_len = cur_match_len; 3804| 2.04M| } 3805| | /* Move the lookahead forward by len_to_move bytes. */ 3806| 147M| d->m_lookahead_pos += len_to_move; 3807| 147M| MZ_ASSERT(d->m_lookahead_size >= len_to_move); ------------------ | | 746| 147M|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3807:5): [True: 0, False: 147M] | Branch (3807:5): [True: 147M, False: 0] ------------------ 3808| 147M| d->m_lookahead_size -= len_to_move; 3809| 147M| d->m_dict_size = 3810| 147M| MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE); ------------------ | | 759| 147M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 147M, False: 55.9k] | | ------------------ ------------------ 3811| | /* Check if it's time to flush the current LZ codes to the internal output 3812| | * buffer. */ 3813| 147M| if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || ------------------ | Branch (3813:9): [True: 294, False: 147M] ------------------ 3814| 147M| ((d->m_total_lz_bytes > 31 * 1024) && ------------------ | Branch (3814:10): [True: 10.0M, False: 137M] ------------------ 3815| 10.0M| (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= ------------------ | Branch (3815:11): [True: 3.92k, False: 10.0M] ------------------ 3816| 10.0M| d->m_total_lz_bytes) || 3817| 10.0M| (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))) { ------------------ | Branch (3817:11): [True: 0, False: 10.0M] ------------------ 3818| 4.21k| int n; 3819| 4.21k| d->m_pSrc = pSrc; 3820| 4.21k| d->m_src_buf_left = src_buf_left; 3821| 4.21k| if ((n = tdefl_flush_block(d, 0)) != 0) ------------------ | Branch (3821:11): [True: 0, False: 4.21k] ------------------ 3822| 0| return (n < 0) ? MZ_FALSE : MZ_TRUE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ return (n < 0) ? MZ_FALSE : MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ | Branch (3822:16): [True: 0, False: 0] ------------------ 3823| 4.21k| } 3824| 147M| } 3825| | 3826| 4.51k| d->m_pSrc = pSrc; 3827| 4.51k| d->m_src_buf_left = src_buf_left; 3828| 4.51k| return MZ_TRUE; ------------------ | | 719| 4.51k|#define MZ_TRUE (1) ------------------ 3829| 4.51k|} zip.c:tdefl_find_match: 3406| 147M| mz_uint *pMatch_len) { 3407| 147M| mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, 3408| 147M| match_len = *pMatch_len, probe_pos = pos, next_probe_pos, 3409| 147M| probe_len; 3410| 147M| mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; 3411| 147M| const mz_uint8 *s = d->m_dict + pos, *p, *q; 3412| 147M| mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1]; 3413| 147M| MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); ------------------ | | 746| 147M|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3413:3): [True: 0, False: 147M] | Branch (3413:3): [True: 147M, False: 0] ------------------ 3414| 147M| if (max_match_len <= match_len) ------------------ | Branch (3414:7): [True: 3.68k, False: 147M] ------------------ 3415| 3.68k| return; 3416| 214M| for (;;) { 3417| 348M| for (;;) { 3418| 348M| if (--num_probes_left == 0) ------------------ | Branch (3418:11): [True: 424k, False: 348M] ------------------ 3419| 424k| return; 3420| 348M|#define TDEFL_PROBE \ 3421| 348M| next_probe_pos = d->m_next[probe_pos]; \ 3422| 348M| if ((!next_probe_pos) || \ 3423| 348M| ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ 3424| 348M| return; \ 3425| 348M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ 3426| 348M| if ((d->m_dict[probe_pos + match_len] == c0) && \ 3427| 348M| (d->m_dict[probe_pos + match_len - 1] == c1)) \ 3428| 348M| break; 3429| 857M| TDEFL_PROBE; ------------------ | | 3421| 348M| next_probe_pos = d->m_next[probe_pos]; \ | | 3422| 348M| if ((!next_probe_pos) || \ | | ------------------ | | | Branch (3422:7): [True: 17.8M, False: 330M] | | ------------------ | | 3423| 348M| ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (3423:7): [True: 49.9M, False: 280M] | | ------------------ | | 3424| 348M| return; \ | | 3425| 348M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 3426| 280M| if ((d->m_dict[probe_pos + match_len] == c0) && \ | | ------------------ | | | Branch (3426:7): [True: 123M, False: 157M] | | ------------------ | | 3427| 280M| (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (3427:7): [True: 52.5M, False: 70.6M] | | ------------------ | | 3428| 280M| break; ------------------ 3430| 857M| TDEFL_PROBE; ------------------ | | 3421| 228M| next_probe_pos = d->m_next[probe_pos]; \ | | 3422| 228M| if ((!next_probe_pos) || \ | | ------------------ | | | Branch (3422:7): [True: 7.98M, False: 220M] | | ------------------ | | 3423| 228M| ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (3423:7): [True: 40.2M, False: 180M] | | ------------------ | | 3424| 228M| return; \ | | 3425| 228M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 3426| 180M| if ((d->m_dict[probe_pos + match_len] == c0) && \ | | ------------------ | | | Branch (3426:7): [True: 63.8M, False: 116M] | | ------------------ | | 3427| 180M| (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (3427:7): [True: 11.6M, False: 52.1M] | | ------------------ | | 3428| 180M| break; ------------------ 3431| 348M| TDEFL_PROBE; ------------------ | | 3421| 168M| next_probe_pos = d->m_next[probe_pos]; \ | | 3422| 168M| if ((!next_probe_pos) || \ | | ------------------ | | | Branch (3422:7): [True: 4.05M, False: 164M] | | ------------------ | | 3423| 168M| ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (3423:7): [True: 27.1M, False: 137M] | | ------------------ | | 3424| 168M| return; \ | | 3425| 168M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 3426| 137M| if ((d->m_dict[probe_pos + match_len] == c0) && \ | | ------------------ | | | Branch (3426:7): [True: 45.8M, False: 91.2M] | | ------------------ | | 3427| 137M| (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (3427:7): [True: 2.90M, False: 42.9M] | | ------------------ | | 3428| 137M| break; ------------------ 3432| 271M| } 3433| 67.1M| if (!dist) ------------------ | Branch (3433:9): [True: 2.54k, False: 67.1M] ------------------ 3434| 2.54k| break; 3435| 67.1M| p = s; 3436| 67.1M| q = d->m_dict + probe_pos; 3437| 126M| for (probe_len = 0; probe_len < max_match_len; probe_len++) ------------------ | Branch (3437:25): [True: 126M, False: 66.6k] ------------------ 3438| 126M| if (*p++ != *q++) ------------------ | Branch (3438:11): [True: 67.0M, False: 59.7M] ------------------ 3439| 67.0M| break; 3440| 67.1M| if (probe_len > match_len) { ------------------ | Branch (3440:9): [True: 5.08M, False: 62.0M] ------------------ 3441| 5.08M| *pMatch_dist = dist; 3442| 5.08M| if ((*pMatch_len = match_len = probe_len) == max_match_len) ------------------ | Branch (3442:11): [True: 66.6k, False: 5.01M] ------------------ 3443| 66.6k| return; 3444| 5.01M| c0 = d->m_dict[pos + match_len]; 3445| 5.01M| c1 = d->m_dict[pos + match_len - 1]; 3446| 5.01M| } 3447| 67.1M| } 3448| 147M|} zip.c:tdefl_record_literal: 3648| 143M| mz_uint8 lit) { 3649| 143M| d->m_total_lz_bytes++; 3650| 143M| *d->m_pLZ_code_buf++ = lit; 3651| 143M| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); 3652| 143M| if (--d->m_num_flags_left == 0) { ------------------ | Branch (3652:7): [True: 17.9M, False: 125M] ------------------ 3653| 17.9M| d->m_num_flags_left = 8; 3654| 17.9M| d->m_pLZ_flags = d->m_pLZ_code_buf++; 3655| 17.9M| } 3656| 143M| d->m_huff_count[0][lit]++; 3657| 143M|} zip.c:tdefl_record_match: 3660| 2.11M|tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist) { 3661| 2.11M| mz_uint32 s0, s1; 3662| | 3663| 2.11M| MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && ------------------ | | 746| 2.11M|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3663:3): [True: 0, False: 2.11M] | Branch (3663:3): [True: 0, False: 0] | Branch (3663:3): [True: 0, False: 0] | Branch (3663:3): [True: 2.11M, False: 0] | Branch (3663:3): [True: 2.11M, False: 0] | Branch (3663:3): [True: 2.11M, False: 0] ------------------ 3664| 2.11M| (match_dist <= TDEFL_LZ_DICT_SIZE)); 3665| | 3666| 2.11M| d->m_total_lz_bytes += match_len; 3667| | 3668| 2.11M| d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN); 3669| | 3670| 2.11M| match_dist -= 1; 3671| 2.11M| d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF); 3672| 2.11M| d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); 3673| 2.11M| d->m_pLZ_code_buf += 3; 3674| | 3675| 2.11M| *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); 3676| 2.11M| if (--d->m_num_flags_left == 0) { ------------------ | Branch (3676:7): [True: 264k, False: 1.84M] ------------------ 3677| 264k| d->m_num_flags_left = 8; 3678| 264k| d->m_pLZ_flags = d->m_pLZ_code_buf++; 3679| 264k| } 3680| | 3681| 2.11M| s0 = s_tdefl_small_dist_sym[match_dist & 511]; 3682| 2.11M| s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127]; 3683| 2.11M| d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; ------------------ | Branch (3683:22): [True: 361k, False: 1.75M] ------------------ 3684| 2.11M| d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++; 3685| 2.11M|} zip.c:tdefl_flush_block: 3176| 6.47k|static int tdefl_flush_block(tdefl_compressor *d, int flush) { 3177| 6.47k| mz_uint saved_bit_buf, saved_bits_in; 3178| 6.47k| mz_uint8 *pSaved_output_buf; 3179| 6.47k| mz_bool comp_block_succeeded = MZ_FALSE; ------------------ | | 718| 6.47k|#define MZ_FALSE (0) ------------------ 3180| 6.47k| int n, use_raw_block = 3181| 6.47k| ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && ------------------ | Branch (3181:14): [True: 0, False: 6.47k] ------------------ 3182| 0| (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size; ------------------ | Branch (3182:14): [True: 0, False: 0] ------------------ 3183| 6.47k| mz_uint8 *pOutput_buf_start = 3184| 6.47k| ((d->m_pPut_buf_func == NULL) && ------------------ | Branch (3184:8): [True: 0, False: 6.47k] ------------------ 3185| 0| ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ------------------ | Branch (3185:8): [True: 0, False: 0] ------------------ 3186| 6.47k| ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) 3187| 6.47k| : d->m_output_buf; 3188| | 3189| 6.47k| d->m_pOutput_buf = pOutput_buf_start; 3190| 6.47k| d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16; 3191| | 3192| 6.47k| MZ_ASSERT(!d->m_output_flush_remaining); ------------------ | | 746| 6.47k|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3192:3): [True: 0, False: 6.47k] | Branch (3192:3): [True: 6.47k, False: 0] ------------------ 3193| 6.47k| d->m_output_flush_ofs = 0; 3194| 6.47k| d->m_output_flush_remaining = 0; 3195| | 3196| 6.47k| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left); 3197| 6.47k| d->m_pLZ_code_buf -= (d->m_num_flags_left == 8); 3198| | 3199| 6.47k| if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) { ------------------ | Branch (3199:7): [True: 0, False: 6.47k] | Branch (3199:49): [True: 0, False: 0] ------------------ 3200| 0| const mz_uint8 cmf = 0x78; 3201| 0| mz_uint8 flg, flevel = 3; 3202| 0| mz_uint header, i, mz_un = sizeof(s_tdefl_num_probes) / sizeof(mz_uint); 3203| | 3204| | /* Determine compression level by reversing the process in 3205| | * tdefl_create_comp_flags_from_zip_params() */ 3206| 0| for (i = 0; i < mz_un; i++) ------------------ | Branch (3206:17): [True: 0, False: 0] ------------------ 3207| 0| if (s_tdefl_num_probes[i] == (d->m_flags & 0xFFF)) ------------------ | Branch (3207:11): [True: 0, False: 0] ------------------ 3208| 0| break; 3209| | 3210| 0| if (i < 2) ------------------ | Branch (3210:9): [True: 0, False: 0] ------------------ 3211| 0| flevel = 0; 3212| 0| else if (i < 6) ------------------ | Branch (3212:14): [True: 0, False: 0] ------------------ 3213| 0| flevel = 1; 3214| 0| else if (i == 6) ------------------ | Branch (3214:14): [True: 0, False: 0] ------------------ 3215| 0| flevel = 2; 3216| | 3217| 0| header = cmf << 8 | (flevel << 6); 3218| 0| header += 31 - (header % 31); 3219| 0| flg = header & 0xFF; 3220| | 3221| 0| TDEFL_PUT_BITS(cmf, 8); ------------------ | | 2853| 0| do { \ | | 2854| 0| mz_uint bits = b; \ | | 2855| 0| mz_uint len = l; \ | | 2856| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 0| d->m_bits_in += len; \ | | 2859| 0| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 0, False: 0] | | ------------------ | | 2860| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 0, False: 0] | | ------------------ | | 2861| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 0| d->m_bit_buffer >>= 8; \ | | 2863| 0| d->m_bits_in -= 8; \ | | 2864| 0| } \ | | 2865| 0| } \ | | 2866| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3221:5): [True: 0, False: 0] | Branch (3221:5): [True: 0, False: 0] ------------------ 3222| 0| TDEFL_PUT_BITS(flg, 8); ------------------ | | 2853| 0| do { \ | | 2854| 0| mz_uint bits = b; \ | | 2855| 0| mz_uint len = l; \ | | 2856| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 0| d->m_bits_in += len; \ | | 2859| 0| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 0, False: 0] | | ------------------ | | 2860| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 0, False: 0] | | ------------------ | | 2861| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 0| d->m_bit_buffer >>= 8; \ | | 2863| 0| d->m_bits_in -= 8; \ | | 2864| 0| } \ | | 2865| 0| } \ | | 2866| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3222:5): [True: 0, False: 0] | Branch (3222:5): [True: 0, False: 0] ------------------ 3223| 0| } 3224| | 3225| 6.47k| TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); ------------------ | | 2853| 6.47k| do { \ | | 2854| 6.47k| mz_uint bits = b; \ | | 2855| 6.47k| mz_uint len = l; \ | | 2856| 6.47k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 6.47k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 6.47k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 6.47k| d->m_bits_in += len; \ | | 2859| 6.76k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 288, False: 6.47k] | | ------------------ | | 2860| 288| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 288, False: 0] | | ------------------ | | 2861| 288| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 288| d->m_bit_buffer >>= 8; \ | | 2863| 288| d->m_bits_in -= 8; \ | | 2864| 288| } \ | | 2865| 6.47k| } \ | | 2866| 6.47k| MZ_MACRO_END | | ------------------ | | | | 726| 6.47k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 6.47k] | | | | ------------------ | | ------------------ ------------------ | Branch (3225:3): [True: 0, False: 6.47k] | Branch (3225:3): [True: 6.47k, False: 0] ------------------ 3226| | 3227| 6.47k| pSaved_output_buf = d->m_pOutput_buf; 3228| 6.47k| saved_bit_buf = d->m_bit_buffer; 3229| 6.47k| saved_bits_in = d->m_bits_in; 3230| | 3231| 6.47k| if (!use_raw_block) ------------------ | Branch (3231:7): [True: 6.47k, False: 0] ------------------ 3232| 6.47k| comp_block_succeeded = 3233| 6.47k| tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || ------------------ | Branch (3233:33): [True: 0, False: 6.47k] ------------------ 3234| 6.47k| (d->m_total_lz_bytes < 48)); ------------------ | Branch (3234:37): [True: 519, False: 5.95k] ------------------ 3235| | 3236| | /* If the block gets expanded, forget the current contents of the output 3237| | * buffer and send a raw block instead. */ 3238| 6.47k| if (((use_raw_block) || ------------------ | Branch (3238:8): [True: 0, False: 6.47k] ------------------ 3239| 6.47k| ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= ------------------ | Branch (3239:9): [True: 6.43k, False: 39] | Branch (3239:34): [True: 2.90k, False: 3.53k] ------------------ 3240| 6.43k| d->m_total_lz_bytes))) && 3241| 2.90k| ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size)) { ------------------ | Branch (3241:7): [True: 2.90k, False: 0] ------------------ 3242| 2.90k| mz_uint i; 3243| 2.90k| d->m_pOutput_buf = pSaved_output_buf; 3244| 2.90k| d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; 3245| 2.90k| TDEFL_PUT_BITS(0, 2); ------------------ | | 2853| 2.90k| do { \ | | 2854| 2.90k| mz_uint bits = b; \ | | 2855| 2.90k| mz_uint len = l; \ | | 2856| 2.90k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 2.90k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 2.90k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 2.90k| d->m_bits_in += len; \ | | 2859| 3.01k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 109, False: 2.90k] | | ------------------ | | 2860| 109| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 109, False: 0] | | ------------------ | | 2861| 109| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 109| d->m_bit_buffer >>= 8; \ | | 2863| 109| d->m_bits_in -= 8; \ | | 2864| 109| } \ | | 2865| 2.90k| } \ | | 2866| 2.90k| MZ_MACRO_END | | ------------------ | | | | 726| 2.90k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.90k] | | | | ------------------ | | ------------------ ------------------ | Branch (3245:5): [True: 0, False: 2.90k] | Branch (3245:5): [True: 2.90k, False: 0] ------------------ 3246| 2.90k| if (d->m_bits_in) { ------------------ | Branch (3246:9): [True: 2.83k, False: 70] ------------------ 3247| 2.83k| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 2853| 2.83k| do { \ | | 2854| 2.83k| mz_uint bits = b; \ | | 2855| 2.83k| mz_uint len = l; \ | | 2856| 2.83k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 2.83k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 2.83k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 2.83k| d->m_bits_in += len; \ | | 2859| 5.67k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 2.83k, False: 2.83k] | | ------------------ | | 2860| 2.83k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 2.83k, False: 0] | | ------------------ | | 2861| 2.83k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 2.83k| d->m_bit_buffer >>= 8; \ | | 2863| 2.83k| d->m_bits_in -= 8; \ | | 2864| 2.83k| } \ | | 2865| 2.83k| } \ | | 2866| 2.83k| MZ_MACRO_END | | ------------------ | | | | 726| 2.83k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.83k] | | | | ------------------ | | ------------------ ------------------ | Branch (3247:7): [True: 0, False: 2.83k] | Branch (3247:7): [True: 2.83k, False: 0] ------------------ 3248| 2.83k| } 3249| 8.71k| for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF) { ------------------ | Branch (3249:17): [True: 5.81k, False: 2.90k] ------------------ 3250| 5.81k| TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); ------------------ | | 2853| 5.81k| do { \ | | 2854| 5.81k| mz_uint bits = b; \ | | 2855| 5.81k| mz_uint len = l; \ | | 2856| 5.81k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 5.81k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 5.81k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 5.81k| d->m_bits_in += len; \ | | 2859| 17.4k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 11.6k, False: 5.81k] | | ------------------ | | 2860| 11.6k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 11.6k, False: 0] | | ------------------ | | 2861| 11.6k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 11.6k| d->m_bit_buffer >>= 8; \ | | 2863| 11.6k| d->m_bits_in -= 8; \ | | 2864| 11.6k| } \ | | 2865| 5.81k| } \ | | 2866| 5.81k| MZ_MACRO_END | | ------------------ | | | | 726| 5.81k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 5.81k] | | | | ------------------ | | ------------------ ------------------ | Branch (3250:7): [True: 0, False: 5.81k] | Branch (3250:7): [True: 5.81k, False: 0] ------------------ 3251| 5.81k| } 3252| 70.3M| for (i = 0; i < d->m_total_lz_bytes; ++i) { ------------------ | Branch (3252:17): [True: 70.3M, False: 2.90k] ------------------ 3253| 70.3M| TDEFL_PUT_BITS( ------------------ | | 2853| 70.3M| do { \ | | 2854| 70.3M| mz_uint bits = b; \ | | 2855| 70.3M| mz_uint len = l; \ | | 2856| 70.3M| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 70.3M|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 70.3M| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 70.3M| d->m_bits_in += len; \ | | 2859| 140M| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 70.3M, False: 70.3M] | | ------------------ | | 2860| 70.3M| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 70.3M, False: 0] | | ------------------ | | 2861| 70.3M| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 70.3M| d->m_bit_buffer >>= 8; \ | | 2863| 70.3M| d->m_bits_in -= 8; \ | | 2864| 70.3M| } \ | | 2865| 70.3M| } \ | | 2866| 70.3M| MZ_MACRO_END | | ------------------ | | | | 726| 70.3M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 70.3M] | | | | ------------------ | | ------------------ ------------------ | Branch (3253:7): [True: 0, False: 70.3M] | Branch (3253:7): [True: 70.3M, False: 0] ------------------ 3254| 70.3M| d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 3255| 70.3M| 8); 3256| 70.3M| } 3257| 2.90k| } 3258| | /* Check for the extremely unlikely (if not impossible) case of the compressed 3259| | block not fitting into the output buffer when using dynamic codes. */ 3260| 3.57k| else if (!comp_block_succeeded) { ------------------ | Branch (3260:12): [True: 0, False: 3.57k] ------------------ 3261| 0| d->m_pOutput_buf = pSaved_output_buf; 3262| 0| d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; 3263| 0| tdefl_compress_block(d, MZ_TRUE); ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 3264| 0| } 3265| | 3266| 6.47k| if (flush) { ------------------ | Branch (3266:7): [True: 2.25k, False: 4.21k] ------------------ 3267| 2.25k| if (flush == TDEFL_FINISH) { ------------------ | Branch (3267:9): [True: 2.25k, False: 0] ------------------ 3268| 2.25k| if (d->m_bits_in) { ------------------ | Branch (3268:11): [True: 1.33k, False: 929] ------------------ 3269| 1.33k| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 2853| 1.33k| do { \ | | 2854| 1.33k| mz_uint bits = b; \ | | 2855| 1.33k| mz_uint len = l; \ | | 2856| 1.33k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 1.33k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 1.33k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 1.33k| d->m_bits_in += len; \ | | 2859| 2.66k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 1.33k, False: 1.33k] | | ------------------ | | 2860| 1.33k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 1.33k, False: 0] | | ------------------ | | 2861| 1.33k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 1.33k| d->m_bit_buffer >>= 8; \ | | 2863| 1.33k| d->m_bits_in -= 8; \ | | 2864| 1.33k| } \ | | 2865| 1.33k| } \ | | 2866| 1.33k| MZ_MACRO_END | | ------------------ | | | | 726| 1.33k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 1.33k] | | | | ------------------ | | ------------------ ------------------ | Branch (3269:9): [True: 0, False: 1.33k] | Branch (3269:9): [True: 1.33k, False: 0] ------------------ 3270| 1.33k| } 3271| 2.25k| if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) { ------------------ | Branch (3271:11): [True: 0, False: 2.25k] ------------------ 3272| 0| mz_uint i, a = d->m_adler32; 3273| 0| for (i = 0; i < 4; i++) { ------------------ | Branch (3273:21): [True: 0, False: 0] ------------------ 3274| 0| TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); ------------------ | | 2853| 0| do { \ | | 2854| 0| mz_uint bits = b; \ | | 2855| 0| mz_uint len = l; \ | | 2856| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 0| d->m_bits_in += len; \ | | 2859| 0| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 0, False: 0] | | ------------------ | | 2860| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 0, False: 0] | | ------------------ | | 2861| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 0| d->m_bit_buffer >>= 8; \ | | 2863| 0| d->m_bits_in -= 8; \ | | 2864| 0| } \ | | 2865| 0| } \ | | 2866| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3274:11): [True: 0, False: 0] | Branch (3274:11): [True: 0, False: 0] ------------------ 3275| 0| a <<= 8; 3276| 0| } 3277| 0| } 3278| 2.25k| } else { 3279| 0| mz_uint i, z = 0; 3280| 0| TDEFL_PUT_BITS(0, 3); ------------------ | | 2853| 0| do { \ | | 2854| 0| mz_uint bits = b; \ | | 2855| 0| mz_uint len = l; \ | | 2856| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 0| d->m_bits_in += len; \ | | 2859| 0| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 0, False: 0] | | ------------------ | | 2860| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 0, False: 0] | | ------------------ | | 2861| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 0| d->m_bit_buffer >>= 8; \ | | 2863| 0| d->m_bits_in -= 8; \ | | 2864| 0| } \ | | 2865| 0| } \ | | 2866| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3280:7): [True: 0, False: 0] | Branch (3280:7): [True: 0, False: 0] ------------------ 3281| 0| if (d->m_bits_in) { ------------------ | Branch (3281:11): [True: 0, False: 0] ------------------ 3282| 0| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 2853| 0| do { \ | | 2854| 0| mz_uint bits = b; \ | | 2855| 0| mz_uint len = l; \ | | 2856| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 0| d->m_bits_in += len; \ | | 2859| 0| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 0, False: 0] | | ------------------ | | 2860| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 0, False: 0] | | ------------------ | | 2861| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 0| d->m_bit_buffer >>= 8; \ | | 2863| 0| d->m_bits_in -= 8; \ | | 2864| 0| } \ | | 2865| 0| } \ | | 2866| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3282:9): [True: 0, False: 0] | Branch (3282:9): [True: 0, False: 0] ------------------ 3283| 0| } 3284| 0| for (i = 2; i; --i, z ^= 0xFFFF) { ------------------ | Branch (3284:19): [True: 0, False: 0] ------------------ 3285| 0| TDEFL_PUT_BITS(z & 0xFFFF, 16); ------------------ | | 2853| 0| do { \ | | 2854| 0| mz_uint bits = b; \ | | 2855| 0| mz_uint len = l; \ | | 2856| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 0| d->m_bits_in += len; \ | | 2859| 0| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 0, False: 0] | | ------------------ | | 2860| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 0, False: 0] | | ------------------ | | 2861| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 0| d->m_bit_buffer >>= 8; \ | | 2863| 0| d->m_bits_in -= 8; \ | | 2864| 0| } \ | | 2865| 0| } \ | | 2866| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3285:9): [True: 0, False: 0] | Branch (3285:9): [True: 0, False: 0] ------------------ 3286| 0| } 3287| 0| } 3288| 2.25k| } 3289| | 3290| 6.47k| MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end); ------------------ | | 746| 6.47k|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3290:3): [True: 0, False: 6.47k] | Branch (3290:3): [True: 6.47k, False: 0] ------------------ 3291| | 3292| 6.47k| memset(&d->m_huff_count[0][0], 0, 3293| 6.47k| sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 3294| 6.47k| memset(&d->m_huff_count[1][0], 0, 3295| 6.47k| sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 3296| | 3297| 6.47k| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 3298| 6.47k| d->m_pLZ_flags = d->m_lz_code_buf; 3299| 6.47k| d->m_num_flags_left = 8; 3300| 6.47k| d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; 3301| 6.47k| d->m_total_lz_bytes = 0; 3302| 6.47k| d->m_block_index++; 3303| | 3304| 6.47k| if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) { ------------------ | Branch (3304:7): [True: 6.47k, False: 0] ------------------ 3305| 6.47k| if (d->m_pPut_buf_func) { ------------------ | Branch (3305:9): [True: 6.47k, False: 0] ------------------ 3306| 6.47k| *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; 3307| 6.47k| if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user)) ------------------ | Branch (3307:11): [True: 0, False: 6.47k] ------------------ 3308| 0| return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED); 3309| 6.47k| } else if (pOutput_buf_start == d->m_output_buf) { ------------------ | Branch (3309:16): [True: 0, False: 0] ------------------ 3310| 0| int bytes_to_copy = (int)MZ_MIN( ------------------ | | 759| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 0] | | ------------------ ------------------ 3311| 0| (size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); 3312| 0| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, 3313| 0| bytes_to_copy); 3314| 0| d->m_out_buf_ofs += bytes_to_copy; 3315| 0| if ((n -= bytes_to_copy) != 0) { ------------------ | Branch (3315:11): [True: 0, False: 0] ------------------ 3316| 0| d->m_output_flush_ofs = bytes_to_copy; 3317| 0| d->m_output_flush_remaining = n; 3318| 0| } 3319| 0| } else { 3320| 0| d->m_out_buf_ofs += n; 3321| 0| } 3322| 6.47k| } 3323| | 3324| 6.47k| return d->m_output_flush_remaining; 3325| 6.47k|} zip.c:tdefl_compress_block: 3165| 6.47k|static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block) { 3166| 6.47k| if (static_block) ------------------ | Branch (3166:7): [True: 519, False: 5.95k] ------------------ 3167| 519| tdefl_start_static_block(d); 3168| 5.95k| else 3169| 5.95k| tdefl_start_dynamic_block(d); 3170| 6.47k| return tdefl_compress_lz_codes(d); 3171| 6.47k|} zip.c:tdefl_start_static_block: 2998| 519|static void tdefl_start_static_block(tdefl_compressor *d) { 2999| 519| mz_uint i; 3000| 519| mz_uint8 *p = &d->m_huff_code_sizes[0][0]; 3001| | 3002| 75.2k| for (i = 0; i <= 143; ++i) ------------------ | Branch (3002:15): [True: 74.7k, False: 519] ------------------ 3003| 74.7k| *p++ = 8; 3004| 58.6k| for (; i <= 255; ++i) ------------------ | Branch (3004:10): [True: 58.1k, False: 519] ------------------ 3005| 58.1k| *p++ = 9; 3006| 12.9k| for (; i <= 279; ++i) ------------------ | Branch (3006:10): [True: 12.4k, False: 519] ------------------ 3007| 12.4k| *p++ = 7; 3008| 4.67k| for (; i <= 287; ++i) ------------------ | Branch (3008:10): [True: 4.15k, False: 519] ------------------ 3009| 4.15k| *p++ = 8; 3010| | 3011| 519| memset(d->m_huff_code_sizes[1], 5, 32); 3012| | 3013| 519| tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE); ------------------ | | 719| 519|#define MZ_TRUE (1) ------------------ 3014| 519| tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE); ------------------ | | 719| 519|#define MZ_TRUE (1) ------------------ 3015| | 3016| | TDEFL_PUT_BITS(1, 2); ------------------ | | 2853| 519| do { \ | | 2854| 519| mz_uint bits = b; \ | | 2855| 519| mz_uint len = l; \ | | 2856| 519| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 519|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 519| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 519| d->m_bits_in += len; \ | | 2859| 546| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 27, False: 519] | | ------------------ | | 2860| 27| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 27, False: 0] | | ------------------ | | 2861| 27| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 27| d->m_bit_buffer >>= 8; \ | | 2863| 27| d->m_bits_in -= 8; \ | | 2864| 27| } \ | | 2865| 519| } \ | | 2866| 519| MZ_MACRO_END | | ------------------ | | | | 726| 519|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 519] | | | | ------------------ | | ------------------ ------------------ | Branch (3016:3): [True: 0, False: 519] | Branch (3016:3): [True: 519, False: 0] ------------------ 3017| 519|} zip.c:tdefl_optimize_huffman_table: 2803| 18.9k| int static_table) { 2804| 18.9k| int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; 2805| 18.9k| mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; 2806| 18.9k| MZ_CLEAR_ARR(num_codes); ------------------ | | 761| 18.9k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2807| 18.9k| if (static_table) { ------------------ | Branch (2807:7): [True: 1.03k, False: 17.8k] ------------------ 2808| 167k| for (i = 0; i < table_len; i++) ------------------ | Branch (2808:17): [True: 166k, False: 1.03k] ------------------ 2809| 166k| num_codes[d->m_huff_code_sizes[table_num][i]]++; 2810| 17.8k| } else { 2811| 17.8k| tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], 2812| 17.8k| *pSyms; 2813| 17.8k| int num_used_syms = 0; 2814| 17.8k| const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0]; 2815| 2.03M| for (i = 0; i < table_len; i++) ------------------ | Branch (2815:17): [True: 2.01M, False: 17.8k] ------------------ 2816| 2.01M| if (pSym_count[i]) { ------------------ | Branch (2816:11): [True: 1.38M, False: 639k] ------------------ 2817| 1.38M| syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; 2818| 1.38M| syms0[num_used_syms++].m_sym_index = (mz_uint16)i; 2819| 1.38M| } 2820| | 2821| 17.8k| pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); 2822| 17.8k| tdefl_calculate_minimum_redundancy(pSyms, num_used_syms); 2823| | 2824| 1.39M| for (i = 0; i < num_used_syms; i++) ------------------ | Branch (2824:17): [True: 1.38M, False: 17.8k] ------------------ 2825| 1.38M| num_codes[pSyms[i].m_key]++; 2826| | 2827| 17.8k| tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, 2828| 17.8k| code_size_limit); 2829| | 2830| 17.8k| MZ_CLEAR_ARR(d->m_huff_code_sizes[table_num]); ------------------ | | 761| 17.8k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2831| 17.8k| MZ_CLEAR_ARR(d->m_huff_codes[table_num]); ------------------ | | 761| 17.8k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2832| 238k| for (i = 1, j = num_used_syms; i <= code_size_limit; i++) ------------------ | Branch (2832:36): [True: 220k, False: 17.8k] ------------------ 2833| 1.60M| for (l = num_codes[i]; l > 0; l--) ------------------ | Branch (2833:30): [True: 1.38M, False: 220k] ------------------ 2834| 1.38M| d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i); 2835| 17.8k| } 2836| | 2837| 18.9k| next_code[1] = 0; 2838| 236k| for (j = 0, i = 2; i <= code_size_limit; i++) ------------------ | Branch (2838:22): [True: 217k, False: 18.9k] ------------------ 2839| 217k| next_code[i] = j = ((j + num_codes[i - 1]) << 1); 2840| | 2841| 2.20M| for (i = 0; i < table_len; i++) { ------------------ | Branch (2841:15): [True: 2.18M, False: 18.9k] ------------------ 2842| 2.18M| mz_uint rev_code = 0, code, code_size; 2843| 2.18M| if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) ------------------ | Branch (2843:9): [True: 639k, False: 1.54M] ------------------ 2844| 639k| continue; 2845| 1.54M| code = next_code[code_size]++; 2846| 13.9M| for (l = code_size; l > 0; l--, code >>= 1) ------------------ | Branch (2846:25): [True: 12.4M, False: 1.54M] ------------------ 2847| 12.4M| rev_code = (rev_code << 1) | (code & 1); 2848| 1.54M| d->m_huff_codes[table_num][i] = (mz_uint16)rev_code; 2849| 1.54M| } 2850| 18.9k|} zip.c:tdefl_radix_sort_syms: 2699| 17.8k| tdefl_sym_freq *pSyms1) { 2700| 17.8k| mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; 2701| 17.8k| tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1; 2702| 17.8k| MZ_CLEAR_ARR(hist); ------------------ | | 761| 17.8k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2703| 1.39M| for (i = 0; i < num_syms; i++) { ------------------ | Branch (2703:15): [True: 1.38M, False: 17.8k] ------------------ 2704| 1.38M| mz_uint freq = pSyms0[i].m_key; 2705| 1.38M| hist[freq & 0xFF]++; 2706| 1.38M| hist[256 + ((freq >> 8) & 0xFF)]++; 2707| 1.38M| } 2708| 33.3k| while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) ------------------ | Branch (2708:10): [True: 17.8k, False: 15.4k] | Branch (2708:32): [True: 15.4k, False: 2.43k] ------------------ 2709| 15.4k| total_passes--; 2710| 38.1k| for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) { ------------------ | Branch (2710:34): [True: 20.3k, False: 17.8k] ------------------ 2711| 20.3k| const mz_uint32 *pHist = &hist[pass << 8]; 2712| 20.3k| mz_uint offsets[256], cur_ofs = 0; 2713| 5.21M| for (i = 0; i < 256; i++) { ------------------ | Branch (2713:17): [True: 5.19M, False: 20.3k] ------------------ 2714| 5.19M| offsets[i] = cur_ofs; 2715| 5.19M| cur_ofs += pHist[i]; 2716| 5.19M| } 2717| 1.85M| for (i = 0; i < num_syms; i++) ------------------ | Branch (2717:17): [True: 1.83M, False: 20.3k] ------------------ 2718| 1.83M| pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = 2719| 1.83M| pCur_syms[i]; 2720| 20.3k| { 2721| 20.3k| tdefl_sym_freq *t = pCur_syms; 2722| 20.3k| pCur_syms = pNew_syms; 2723| 20.3k| pNew_syms = t; 2724| 20.3k| } 2725| 20.3k| } 2726| 17.8k| return pCur_syms; 2727| 17.8k|} zip.c:tdefl_calculate_minimum_redundancy: 2731| 17.8k|static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n) { 2732| 17.8k| int root, leaf, next, avbl, used, dpth; 2733| 17.8k| if (n == 0) ------------------ | Branch (2733:7): [True: 384, False: 17.4k] ------------------ 2734| 384| return; 2735| 17.4k| else if (n == 1) { ------------------ | Branch (2735:12): [True: 546, False: 16.9k] ------------------ 2736| 546| A[0].m_key = 1; 2737| 546| return; 2738| 546| } 2739| 16.9k| A[0].m_key += A[1].m_key; 2740| 16.9k| root = 0; 2741| 16.9k| leaf = 2; 2742| 1.36M| for (next = 1; next < n - 1; next++) { ------------------ | Branch (2742:18): [True: 1.34M, False: 16.9k] ------------------ 2743| 1.34M| if (leaf >= n || A[root].m_key < A[leaf].m_key) { ------------------ | Branch (2743:9): [True: 382k, False: 964k] | Branch (2743:22): [True: 290k, False: 673k] ------------------ 2744| 672k| A[next].m_key = A[root].m_key; 2745| 672k| A[root++].m_key = (mz_uint16)next; 2746| 672k| } else 2747| 673k| A[next].m_key = A[leaf++].m_key; 2748| 1.34M| if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) { ------------------ | Branch (2748:9): [True: 387k, False: 958k] | Branch (2748:23): [True: 945k, False: 12.5k] | Branch (2748:38): [True: 285k, False: 660k] ------------------ 2749| 673k| A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); 2750| 673k| A[root++].m_key = (mz_uint16)next; 2751| 673k| } else 2752| 672k| A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key); 2753| 1.34M| } 2754| 16.9k| A[n - 2].m_key = 0; 2755| 1.36M| for (next = n - 3; next >= 0; next--) ------------------ | Branch (2755:22): [True: 1.34M, False: 16.9k] ------------------ 2756| 1.34M| A[next].m_key = A[A[next].m_key].m_key + 1; 2757| 16.9k| avbl = 1; 2758| 16.9k| used = dpth = 0; 2759| 16.9k| root = n - 2; 2760| 16.9k| next = n - 1; 2761| 159k| while (avbl > 0) { ------------------ | Branch (2761:10): [True: 142k, False: 16.9k] ------------------ 2762| 1.50M| while (root >= 0 && (int)A[root].m_key == dpth) { ------------------ | Branch (2762:12): [True: 1.47M, False: 33.8k] | Branch (2762:25): [True: 1.36M, False: 108k] ------------------ 2763| 1.36M| used++; 2764| 1.36M| root--; 2765| 1.36M| } 2766| 1.52M| while (avbl > used) { ------------------ | Branch (2766:12): [True: 1.38M, False: 142k] ------------------ 2767| 1.38M| A[next--].m_key = (mz_uint16)(dpth); 2768| 1.38M| avbl--; 2769| 1.38M| } 2770| 142k| avbl = 2 * used; 2771| 142k| dpth++; 2772| 142k| used = 0; 2773| 142k| } 2774| 16.9k|} zip.c:tdefl_huffman_enforce_max_code_size: 2780| 17.8k| int max_code_size) { 2781| 17.8k| int i; 2782| 17.8k| mz_uint32 total = 0; 2783| 17.8k| if (code_list_len <= 1) ------------------ | Branch (2783:7): [True: 930, False: 16.9k] ------------------ 2784| 930| return; 2785| 352k| for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) ------------------ | Branch (2785:31): [True: 335k, False: 16.9k] ------------------ 2786| 335k| pNum_codes[max_code_size] += pNum_codes[i]; 2787| 223k| for (i = max_code_size; i > 0; i--) ------------------ | Branch (2787:27): [True: 206k, False: 16.9k] ------------------ 2788| 206k| total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i)); 2789| 22.1k| while (total != (1UL << max_code_size)) { ------------------ | Branch (2789:10): [True: 5.21k, False: 16.9k] ------------------ 2790| 5.21k| pNum_codes[max_code_size]--; 2791| 6.72k| for (i = max_code_size - 1; i > 0; i--) ------------------ | Branch (2791:33): [True: 6.72k, False: 0] ------------------ 2792| 6.72k| if (pNum_codes[i]) { ------------------ | Branch (2792:11): [True: 5.21k, False: 1.50k] ------------------ 2793| 5.21k| pNum_codes[i]--; 2794| 5.21k| pNum_codes[i + 1] += 2; 2795| 5.21k| break; 2796| 5.21k| } 2797| 5.21k| total--; 2798| 5.21k| } 2799| 16.9k|} zip.c:tdefl_start_dynamic_block: 2913| 5.95k|static void tdefl_start_dynamic_block(tdefl_compressor *d) { 2914| 5.95k| int num_lit_codes, num_dist_codes, num_bit_lengths; 2915| 5.95k| mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, 2916| 5.95k| rle_repeat_count, packed_code_sizes_index; 2917| 5.95k| mz_uint8 2918| 5.95k| code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], 2919| 5.95k| packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], 2920| 5.95k| prev_code_size = 0xFF; 2921| | 2922| 5.95k| d->m_huff_count[0][256] = 1; 2923| | 2924| 5.95k| tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE); ------------------ | | 718| 5.95k|#define MZ_FALSE (0) ------------------ 2925| 5.95k| tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE); ------------------ | | 718| 5.95k|#define MZ_FALSE (0) ------------------ 2926| | 2927| 122k| for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) ------------------ | Branch (2927:29): [True: 122k, False: 384] ------------------ 2928| 122k| if (d->m_huff_code_sizes[0][num_lit_codes - 1]) ------------------ | Branch (2928:9): [True: 5.57k, False: 116k] ------------------ 2929| 5.57k| break; 2930| 51.0k| for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) ------------------ | Branch (2930:29): [True: 50.4k, False: 584] ------------------ 2931| 50.4k| if (d->m_huff_code_sizes[1][num_dist_codes - 1]) ------------------ | Branch (2931:9): [True: 5.37k, False: 45.0k] ------------------ 2932| 5.37k| break; 2933| | 2934| 5.95k| memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); 2935| 5.95k| memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], 2936| 5.95k| num_dist_codes); 2937| 5.95k| total_code_sizes_to_pack = num_lit_codes + num_dist_codes; 2938| 5.95k| num_packed_code_sizes = 0; 2939| 5.95k| rle_z_count = 0; 2940| 5.95k| rle_repeat_count = 0; 2941| | 2942| 5.95k| memset(&d->m_huff_count[2][0], 0, 2943| 5.95k| sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2); 2944| 1.72M| for (i = 0; i < total_code_sizes_to_pack; i++) { ------------------ | Branch (2944:15): [True: 1.72M, False: 5.95k] ------------------ 2945| 1.72M| mz_uint8 code_size = code_sizes_to_pack[i]; 2946| 1.72M| if (!code_size) { ------------------ | Branch (2946:9): [True: 404k, False: 1.31M] ------------------ 2947| 404k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 2869| 404k| { \ | | 2870| 404k| if (rle_repeat_count) { \ | | ------------------ | | | Branch (2870:9): [True: 15.7k, False: 388k] | | ------------------ | | 2871| 15.7k| if (rle_repeat_count < 3) { \ | | ------------------ | | | Branch (2871:11): [True: 13.4k, False: 2.27k] | | ------------------ | | 2872| 13.4k| d->m_huff_count[2][prev_code_size] = \ | | 2873| 13.4k| (mz_uint16)(d->m_huff_count[2][prev_code_size] + \ | | 2874| 13.4k| rle_repeat_count); \ | | 2875| 29.9k| while (rle_repeat_count--) \ | | ------------------ | | | Branch (2875:16): [True: 16.5k, False: 13.4k] | | ------------------ | | 2876| 16.5k| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 2877| 13.4k| } else { \ | | 2878| 2.27k| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 2879| 2.27k| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 2880| 2.27k| packed_code_sizes[num_packed_code_sizes++] = \ | | 2881| 2.27k| (mz_uint8)(rle_repeat_count - 3); \ | | 2882| 2.27k| } \ | | 2883| 15.7k| rle_repeat_count = 0; \ | | 2884| 15.7k| } \ | | 2885| 404k| } ------------------ 2948| 404k| if (++rle_z_count == 138) { ------------------ | Branch (2948:11): [True: 172, False: 404k] ------------------ 2949| 172| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 2888| 172| { \ | | 2889| 172| if (rle_z_count) { \ | | ------------------ | | | Branch (2889:9): [True: 172, False: 0] | | ------------------ | | 2890| 172| if (rle_z_count < 3) { \ | | ------------------ | | | Branch (2890:11): [True: 0, False: 172] | | ------------------ | | 2891| 0| d->m_huff_count[2][0] = \ | | 2892| 0| (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 2893| 0| while (rle_z_count--) \ | | ------------------ | | | Branch (2893:16): [True: 0, False: 0] | | ------------------ | | 2894| 0| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 2895| 172| } else if (rle_z_count <= 10) { \ | | ------------------ | | | Branch (2895:18): [True: 0, False: 172] | | ------------------ | | 2896| 0| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 2897| 0| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 2898| 0| packed_code_sizes[num_packed_code_sizes++] = \ | | 2899| 0| (mz_uint8)(rle_z_count - 3); \ | | 2900| 172| } else { \ | | 2901| 172| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 2902| 172| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 2903| 172| packed_code_sizes[num_packed_code_sizes++] = \ | | 2904| 172| (mz_uint8)(rle_z_count - 11); \ | | 2905| 172| } \ | | 2906| 172| rle_z_count = 0; \ | | 2907| 172| } \ | | 2908| 172| } ------------------ 2950| 172| } 2951| 1.31M| } else { 2952| 1.31M| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 2888| 1.31M| { \ | | 2889| 1.31M| if (rle_z_count) { \ | | ------------------ | | | Branch (2889:9): [True: 126k, False: 1.18M] | | ------------------ | | 2890| 126k| if (rle_z_count < 3) { \ | | ------------------ | | | Branch (2890:11): [True: 104k, False: 22.3k] | | ------------------ | | 2891| 104k| d->m_huff_count[2][0] = \ | | 2892| 104k| (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 2893| 219k| while (rle_z_count--) \ | | ------------------ | | | Branch (2893:16): [True: 114k, False: 104k] | | ------------------ | | 2894| 114k| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 2895| 104k| } else if (rle_z_count <= 10) { \ | | ------------------ | | | Branch (2895:18): [True: 14.4k, False: 7.92k] | | ------------------ | | 2896| 14.4k| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 2897| 14.4k| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 2898| 14.4k| packed_code_sizes[num_packed_code_sizes++] = \ | | 2899| 14.4k| (mz_uint8)(rle_z_count - 3); \ | | 2900| 14.4k| } else { \ | | 2901| 7.92k| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 2902| 7.92k| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 2903| 7.92k| packed_code_sizes[num_packed_code_sizes++] = \ | | 2904| 7.92k| (mz_uint8)(rle_z_count - 11); \ | | 2905| 7.92k| } \ | | 2906| 126k| rle_z_count = 0; \ | | 2907| 126k| } \ | | 2908| 1.31M| } ------------------ 2953| 1.31M| if (code_size != prev_code_size) { ------------------ | Branch (2953:11): [True: 447k, False: 868k] ------------------ 2954| 447k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 2869| 447k| { \ | | 2870| 447k| if (rle_repeat_count) { \ | | ------------------ | | | Branch (2870:9): [True: 52.4k, False: 395k] | | ------------------ | | 2871| 52.4k| if (rle_repeat_count < 3) { \ | | ------------------ | | | Branch (2871:11): [True: 38.3k, False: 14.0k] | | ------------------ | | 2872| 38.3k| d->m_huff_count[2][prev_code_size] = \ | | 2873| 38.3k| (mz_uint16)(d->m_huff_count[2][prev_code_size] + \ | | 2874| 38.3k| rle_repeat_count); \ | | 2875| 88.2k| while (rle_repeat_count--) \ | | ------------------ | | | Branch (2875:16): [True: 49.8k, False: 38.3k] | | ------------------ | | 2876| 49.8k| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 2877| 38.3k| } else { \ | | 2878| 14.0k| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 2879| 14.0k| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 2880| 14.0k| packed_code_sizes[num_packed_code_sizes++] = \ | | 2881| 14.0k| (mz_uint8)(rle_repeat_count - 3); \ | | 2882| 14.0k| } \ | | 2883| 52.4k| rle_repeat_count = 0; \ | | 2884| 52.4k| } \ | | 2885| 447k| } ------------------ 2955| 447k| d->m_huff_count[2][code_size] = 2956| 447k| (mz_uint16)(d->m_huff_count[2][code_size] + 1); 2957| 447k| packed_code_sizes[num_packed_code_sizes++] = code_size; 2958| 868k| } else if (++rle_repeat_count == 6) { ------------------ | Branch (2958:18): [True: 123k, False: 745k] ------------------ 2959| 123k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 2869| 123k| { \ | | 2870| 123k| if (rle_repeat_count) { \ | | ------------------ | | | Branch (2870:9): [True: 123k, False: 0] | | ------------------ | | 2871| 123k| if (rle_repeat_count < 3) { \ | | ------------------ | | | Branch (2871:11): [True: 0, False: 123k] | | ------------------ | | 2872| 0| d->m_huff_count[2][prev_code_size] = \ | | 2873| 0| (mz_uint16)(d->m_huff_count[2][prev_code_size] + \ | | 2874| 0| rle_repeat_count); \ | | 2875| 0| while (rle_repeat_count--) \ | | ------------------ | | | Branch (2875:16): [True: 0, False: 0] | | ------------------ | | 2876| 0| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 2877| 123k| } else { \ | | 2878| 123k| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 2879| 123k| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 2880| 123k| packed_code_sizes[num_packed_code_sizes++] = \ | | 2881| 123k| (mz_uint8)(rle_repeat_count - 3); \ | | 2882| 123k| } \ | | 2883| 123k| rle_repeat_count = 0; \ | | 2884| 123k| } \ | | 2885| 123k| } ------------------ 2960| 123k| } 2961| 1.31M| } 2962| 1.72M| prev_code_size = code_size; 2963| 1.72M| } 2964| 5.95k| if (rle_repeat_count) { ------------------ | Branch (2964:7): [True: 1.56k, False: 4.39k] ------------------ 2965| 1.56k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 2869| 1.56k| { \ | | 2870| 1.56k| if (rle_repeat_count) { \ | | ------------------ | | | Branch (2870:9): [True: 1.56k, False: 0] | | ------------------ | | 2871| 1.56k| if (rle_repeat_count < 3) { \ | | ------------------ | | | Branch (2871:11): [True: 1.40k, False: 162] | | ------------------ | | 2872| 1.40k| d->m_huff_count[2][prev_code_size] = \ | | 2873| 1.40k| (mz_uint16)(d->m_huff_count[2][prev_code_size] + \ | | 2874| 1.40k| rle_repeat_count); \ | | 2875| 3.09k| while (rle_repeat_count--) \ | | ------------------ | | | Branch (2875:16): [True: 1.69k, False: 1.40k] | | ------------------ | | 2876| 1.69k| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 2877| 1.40k| } else { \ | | 2878| 162| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 2879| 162| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 2880| 162| packed_code_sizes[num_packed_code_sizes++] = \ | | 2881| 162| (mz_uint8)(rle_repeat_count - 3); \ | | 2882| 162| } \ | | 2883| 1.56k| rle_repeat_count = 0; \ | | 2884| 1.56k| } \ | | 2885| 1.56k| } ------------------ 2966| 4.39k| } else { 2967| 4.39k| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 2888| 4.39k| { \ | | 2889| 4.39k| if (rle_z_count) { \ | | ------------------ | | | Branch (2889:9): [True: 384, False: 4.01k] | | ------------------ | | 2890| 384| if (rle_z_count < 3) { \ | | ------------------ | | | Branch (2890:11): [True: 384, False: 0] | | ------------------ | | 2891| 384| d->m_huff_count[2][0] = \ | | 2892| 384| (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 2893| 768| while (rle_z_count--) \ | | ------------------ | | | Branch (2893:16): [True: 384, False: 384] | | ------------------ | | 2894| 384| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 2895| 384| } else if (rle_z_count <= 10) { \ | | ------------------ | | | Branch (2895:18): [True: 0, False: 0] | | ------------------ | | 2896| 0| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 2897| 0| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 2898| 0| packed_code_sizes[num_packed_code_sizes++] = \ | | 2899| 0| (mz_uint8)(rle_z_count - 3); \ | | 2900| 0| } else { \ | | 2901| 0| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 2902| 0| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 2903| 0| packed_code_sizes[num_packed_code_sizes++] = \ | | 2904| 0| (mz_uint8)(rle_z_count - 11); \ | | 2905| 0| } \ | | 2906| 384| rle_z_count = 0; \ | | 2907| 384| } \ | | 2908| 4.39k| } ------------------ 2968| 4.39k| } 2969| | 2970| 5.95k| tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE); ------------------ | | 718| 5.95k|#define MZ_FALSE (0) ------------------ 2971| | 2972| 5.95k| TDEFL_PUT_BITS(2, 2); ------------------ | | 2853| 5.95k| do { \ | | 2854| 5.95k| mz_uint bits = b; \ | | 2855| 5.95k| mz_uint len = l; \ | | 2856| 5.95k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 5.95k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 5.95k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 5.95k| d->m_bits_in += len; \ | | 2859| 6.51k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 556, False: 5.95k] | | ------------------ | | 2860| 556| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 556, False: 0] | | ------------------ | | 2861| 556| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 556| d->m_bit_buffer >>= 8; \ | | 2863| 556| d->m_bits_in -= 8; \ | | 2864| 556| } \ | | 2865| 5.95k| } \ | | 2866| 5.95k| MZ_MACRO_END | | ------------------ | | | | 726| 5.95k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 5.95k] | | | | ------------------ | | ------------------ ------------------ | Branch (2972:3): [True: 0, False: 5.95k] | Branch (2972:3): [True: 5.95k, False: 0] ------------------ 2973| | 2974| 5.95k| TDEFL_PUT_BITS(num_lit_codes - 257, 5); ------------------ | | 2853| 5.95k| do { \ | | 2854| 5.95k| mz_uint bits = b; \ | | 2855| 5.95k| mz_uint len = l; \ | | 2856| 5.95k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 5.95k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 5.95k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 5.95k| d->m_bits_in += len; \ | | 2859| 11.0k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 5.12k, False: 5.95k] | | ------------------ | | 2860| 5.12k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 5.12k, False: 0] | | ------------------ | | 2861| 5.12k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 5.12k| d->m_bit_buffer >>= 8; \ | | 2863| 5.12k| d->m_bits_in -= 8; \ | | 2864| 5.12k| } \ | | 2865| 5.95k| } \ | | 2866| 5.95k| MZ_MACRO_END | | ------------------ | | | | 726| 5.95k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 5.95k] | | | | ------------------ | | ------------------ ------------------ | Branch (2974:3): [True: 0, False: 5.95k] | Branch (2974:3): [True: 5.95k, False: 0] ------------------ 2975| 5.95k| TDEFL_PUT_BITS(num_dist_codes - 1, 5); ------------------ | | 2853| 5.95k| do { \ | | 2854| 5.95k| mz_uint bits = b; \ | | 2855| 5.95k| mz_uint len = l; \ | | 2856| 5.95k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 5.95k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 5.95k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 5.95k| d->m_bits_in += len; \ | | 2859| 7.27k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 1.31k, False: 5.95k] | | ------------------ | | 2860| 1.31k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 1.31k, False: 0] | | ------------------ | | 2861| 1.31k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 1.31k| d->m_bit_buffer >>= 8; \ | | 2863| 1.31k| d->m_bits_in -= 8; \ | | 2864| 1.31k| } \ | | 2865| 5.95k| } \ | | 2866| 5.95k| MZ_MACRO_END | | ------------------ | | | | 726| 5.95k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 5.95k] | | | | ------------------ | | ------------------ ------------------ | Branch (2975:3): [True: 0, False: 5.95k] | Branch (2975:3): [True: 5.95k, False: 0] ------------------ 2976| | 2977| 18.4k| for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) ------------------ | Branch (2977:30): [True: 18.4k, False: 0] ------------------ 2978| 18.4k| if (d->m_huff_code_sizes ------------------ | Branch (2978:9): [True: 5.95k, False: 12.5k] ------------------ 2979| 18.4k| [2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) 2980| 5.95k| break; 2981| 5.95k| num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); ------------------ | | 758| 5.95k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 0, False: 5.95k] | | ------------------ ------------------ 2982| 5.95k| TDEFL_PUT_BITS(num_bit_lengths - 4, 4); ------------------ | | 2853| 5.95k| do { \ | | 2854| 5.95k| mz_uint bits = b; \ | | 2855| 5.95k| mz_uint len = l; \ | | 2856| 5.95k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 5.95k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 5.95k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 5.95k| d->m_bits_in += len; \ | | 2859| 10.8k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 4.92k, False: 5.95k] | | ------------------ | | 2860| 4.92k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 4.92k, False: 0] | | ------------------ | | 2861| 4.92k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 4.92k| d->m_bit_buffer >>= 8; \ | | 2863| 4.92k| d->m_bits_in -= 8; \ | | 2864| 4.92k| } \ | | 2865| 5.95k| } \ | | 2866| 5.95k| MZ_MACRO_END | | ------------------ | | | | 726| 5.95k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 5.95k] | | | | ------------------ | | ------------------ ------------------ | Branch (2982:3): [True: 0, False: 5.95k] | Branch (2982:3): [True: 5.95k, False: 0] ------------------ 2983| 106k| for (i = 0; (int)i < num_bit_lengths; i++) ------------------ | Branch (2983:15): [True: 100k, False: 5.95k] ------------------ 2984| 100k| TDEFL_PUT_BITS( ------------------ | | 2853| 106k| do { \ | | 2854| 100k| mz_uint bits = b; \ | | 2855| 100k| mz_uint len = l; \ | | 2856| 100k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 100k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 100k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 100k| d->m_bits_in += len; \ | | 2859| 137k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 36.6k, False: 100k] | | ------------------ | | 2860| 36.6k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 36.6k, False: 0] | | ------------------ | | 2861| 36.6k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 36.6k| d->m_bit_buffer >>= 8; \ | | 2863| 36.6k| d->m_bits_in -= 8; \ | | 2864| 36.6k| } \ | | 2865| 100k| } \ | | 2866| 106k| MZ_MACRO_END | | ------------------ | | | | 726| 106k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 100k] | | | | ------------------ | | ------------------ ------------------ | Branch (2984:5): [True: 0, False: 100k] | Branch (2984:5): [True: 100k, False: 0] ------------------ 2985| 5.95k| d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); 2986| | 2987| 5.95k| for (packed_code_sizes_index = 0; 2988| 798k| packed_code_sizes_index < num_packed_code_sizes;) { ------------------ | Branch (2988:8): [True: 792k, False: 5.95k] ------------------ 2989| 792k| mz_uint code = packed_code_sizes[packed_code_sizes_index++]; 2990| 792k| MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2); ------------------ | | 746| 792k|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (2990:5): [True: 0, False: 792k] | Branch (2990:5): [True: 792k, False: 0] ------------------ 2991| 792k| TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); ------------------ | | 2853| 792k| do { \ | | 2854| 792k| mz_uint bits = b; \ | | 2855| 792k| mz_uint len = l; \ | | 2856| 792k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 792k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 792k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 792k| d->m_bits_in += len; \ | | 2859| 1.03M| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 240k, False: 792k] | | ------------------ | | 2860| 240k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 240k, False: 0] | | ------------------ | | 2861| 240k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 240k| d->m_bit_buffer >>= 8; \ | | 2863| 240k| d->m_bits_in -= 8; \ | | 2864| 240k| } \ | | 2865| 792k| } \ | | 2866| 792k| MZ_MACRO_END | | ------------------ | | | | 726| 792k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 792k] | | | | ------------------ | | ------------------ ------------------ | Branch (2991:5): [True: 0, False: 792k] | Branch (2991:5): [True: 792k, False: 0] ------------------ 2992| 792k| if (code >= 16) ------------------ | Branch (2992:9): [True: 162k, False: 630k] ------------------ 2993| | TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], ------------------ | | 2853| 162k| do { \ | | 2854| 162k| mz_uint bits = b; \ | | 2855| 162k| mz_uint len = l; \ | | 2856| 162k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 162k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 162k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 162k| d->m_bits_in += len; \ | | 2859| 209k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 47.7k, False: 162k] | | ------------------ | | 2860| 47.7k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 47.7k, False: 0] | | ------------------ | | 2861| 47.7k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 47.7k| d->m_bit_buffer >>= 8; \ | | 2863| 47.7k| d->m_bits_in -= 8; \ | | 2864| 47.7k| } \ | | 2865| 162k| } \ | | 2866| 162k| MZ_MACRO_END | | ------------------ | | | | 726| 162k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 162k] | | | | ------------------ | | ------------------ ------------------ | Branch (2993:7): [True: 0, False: 162k] | Branch (2993:7): [True: 162k, False: 0] ------------------ 2994| 792k| "\02\03\07"[code - 16]); 2995| 792k| } 2996| 5.95k|} zip.c:tdefl_compress_lz_codes: 3120| 6.47k|static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d) { 3121| 6.47k| mz_uint flags; 3122| 6.47k| mz_uint8 *pLZ_codes; 3123| | 3124| 6.47k| flags = 1; 3125| 145M| for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; ------------------ | Branch (3125:38): [True: 145M, False: 6.47k] ------------------ 3126| 145M| flags >>= 1) { 3127| 145M| if (flags == 1) ------------------ | Branch (3127:9): [True: 18.2M, False: 127M] ------------------ 3128| 18.2M| flags = *pLZ_codes++ | 0x100; 3129| 145M| if (flags & 1) { ------------------ | Branch (3129:9): [True: 2.11M, False: 143M] ------------------ 3130| 2.11M| mz_uint sym, num_extra_bits; 3131| 2.11M| mz_uint match_len = pLZ_codes[0], 3132| 2.11M| match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); 3133| 2.11M| pLZ_codes += 3; 3134| | 3135| 2.11M| MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); ------------------ | | 746| 2.11M|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3135:7): [True: 0, False: 2.11M] | Branch (3135:7): [True: 2.11M, False: 0] ------------------ 3136| 2.11M| TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], ------------------ | | 2853| 2.11M| do { \ | | 2854| 2.11M| mz_uint bits = b; \ | | 2855| 2.11M| mz_uint len = l; \ | | 2856| 2.11M| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 2.11M|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 2.11M| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 2.11M| d->m_bits_in += len; \ | | 2859| 3.08M| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 974k, False: 2.11M] | | ------------------ | | 2860| 974k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 974k, False: 0] | | ------------------ | | 2861| 974k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 974k| d->m_bit_buffer >>= 8; \ | | 2863| 974k| d->m_bits_in -= 8; \ | | 2864| 974k| } \ | | 2865| 2.11M| } \ | | 2866| 2.11M| MZ_MACRO_END | | ------------------ | | | | 726| 2.11M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.11M] | | | | ------------------ | | ------------------ ------------------ | Branch (3136:7): [True: 0, False: 2.11M] | Branch (3136:7): [True: 2.11M, False: 0] ------------------ 3137| 2.11M| d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); 3138| 2.11M| TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], ------------------ | | 2853| 2.11M| do { \ | | 2854| 2.11M| mz_uint bits = b; \ | | 2855| 2.11M| mz_uint len = l; \ | | 2856| 2.11M| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 2.11M|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 2.11M| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 2.11M| d->m_bits_in += len; \ | | 2859| 2.15M| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 42.4k, False: 2.11M] | | ------------------ | | 2860| 42.4k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 42.4k, False: 0] | | ------------------ | | 2861| 42.4k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 42.4k| d->m_bit_buffer >>= 8; \ | | 2863| 42.4k| d->m_bits_in -= 8; \ | | 2864| 42.4k| } \ | | 2865| 2.11M| } \ | | 2866| 2.11M| MZ_MACRO_END | | ------------------ | | | | 726| 2.11M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.11M] | | | | ------------------ | | ------------------ ------------------ | Branch (3138:7): [True: 0, False: 2.11M] | Branch (3138:7): [True: 2.11M, False: 0] ------------------ 3139| 2.11M| s_tdefl_len_extra[match_len]); 3140| | 3141| 2.11M| if (match_dist < 512) { ------------------ | Branch (3141:11): [True: 361k, False: 1.75M] ------------------ 3142| 361k| sym = s_tdefl_small_dist_sym[match_dist]; 3143| 361k| num_extra_bits = s_tdefl_small_dist_extra[match_dist]; 3144| 1.75M| } else { 3145| 1.75M| sym = s_tdefl_large_dist_sym[match_dist >> 8]; 3146| 1.75M| num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8]; 3147| 1.75M| } 3148| 2.11M| MZ_ASSERT(d->m_huff_code_sizes[1][sym]); ------------------ | | 746| 2.11M|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3148:7): [True: 0, False: 2.11M] | Branch (3148:7): [True: 2.11M, False: 0] ------------------ 3149| 2.11M| TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); ------------------ | | 2853| 2.11M| do { \ | | 2854| 2.11M| mz_uint bits = b; \ | | 2855| 2.11M| mz_uint len = l; \ | | 2856| 2.11M| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 2.11M|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 2.11M| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 2.11M| d->m_bits_in += len; \ | | 2859| 3.06M| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 949k, False: 2.11M] | | ------------------ | | 2860| 949k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 949k, False: 0] | | ------------------ | | 2861| 949k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 949k| d->m_bit_buffer >>= 8; \ | | 2863| 949k| d->m_bits_in -= 8; \ | | 2864| 949k| } \ | | 2865| 2.11M| } \ | | 2866| 2.11M| MZ_MACRO_END | | ------------------ | | | | 726| 2.11M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.11M] | | | | ------------------ | | ------------------ ------------------ | Branch (3149:7): [True: 0, False: 2.11M] | Branch (3149:7): [True: 2.11M, False: 0] ------------------ 3150| 2.11M| TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); ------------------ | | 2853| 2.11M| do { \ | | 2854| 2.11M| mz_uint bits = b; \ | | 2855| 2.11M| mz_uint len = l; \ | | 2856| 2.11M| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 2.11M|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 2.11M| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 2.11M| d->m_bits_in += len; \ | | 2859| 4.68M| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 2.57M, False: 2.11M] | | ------------------ | | 2860| 2.57M| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 2.57M, False: 0] | | ------------------ | | 2861| 2.57M| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 2.57M| d->m_bit_buffer >>= 8; \ | | 2863| 2.57M| d->m_bits_in -= 8; \ | | 2864| 2.57M| } \ | | 2865| 2.11M| } \ | | 2866| 2.11M| MZ_MACRO_END | | ------------------ | | | | 726| 2.11M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.11M] | | | | ------------------ | | ------------------ ------------------ | Branch (3150:7): [True: 0, False: 2.11M] | Branch (3150:7): [True: 2.11M, False: 0] ------------------ 3151| 143M| } else { 3152| 143M| mz_uint lit = *pLZ_codes++; 3153| 143M| MZ_ASSERT(d->m_huff_code_sizes[0][lit]); ------------------ | | 746| 143M|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (3153:7): [True: 0, False: 143M] | Branch (3153:7): [True: 143M, False: 0] ------------------ 3154| 143M| TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); ------------------ | | 2853| 143M| do { \ | | 2854| 143M| mz_uint bits = b; \ | | 2855| 143M| mz_uint len = l; \ | | 2856| 143M| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 143M|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 143M| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 143M| d->m_bits_in += len; \ | | 2859| 275M| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 132M, False: 143M] | | ------------------ | | 2860| 132M| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 132M, False: 0] | | ------------------ | | 2861| 132M| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 132M| d->m_bit_buffer >>= 8; \ | | 2863| 132M| d->m_bits_in -= 8; \ | | 2864| 132M| } \ | | 2865| 143M| } \ | | 2866| 143M| MZ_MACRO_END | | ------------------ | | | | 726| 143M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 143M] | | | | ------------------ | | ------------------ ------------------ | Branch (3154:7): [True: 0, False: 143M] | Branch (3154:7): [True: 143M, False: 0] ------------------ 3155| 143M| } 3156| 145M| } 3157| | 3158| 6.47k| TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); ------------------ | | 2853| 6.47k| do { \ | | 2854| 6.47k| mz_uint bits = b; \ | | 2855| 6.47k| mz_uint len = l; \ | | 2856| 6.47k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 746| 6.47k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 2857| 6.47k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 2858| 6.47k| d->m_bits_in += len; \ | | 2859| 15.1k| while (d->m_bits_in >= 8) { \ | | ------------------ | | | Branch (2859:12): [True: 8.65k, False: 6.47k] | | ------------------ | | 2860| 8.65k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (2860:11): [True: 8.65k, False: 0] | | ------------------ | | 2861| 8.65k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 2862| 8.65k| d->m_bit_buffer >>= 8; \ | | 2863| 8.65k| d->m_bits_in -= 8; \ | | 2864| 8.65k| } \ | | 2865| 6.47k| } \ | | 2866| 6.47k| MZ_MACRO_END | | ------------------ | | | | 726| 6.47k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 6.47k] | | | | ------------------ | | ------------------ ------------------ | Branch (3158:3): [True: 0, False: 6.47k] | Branch (3158:3): [True: 6.47k, False: 0] ------------------ 3159| | 3160| 6.47k| return (d->m_pOutput_buf < d->m_pOutput_buf_end); 3161| 6.47k|} zip.c:tinfl_clear_tree: 4374| 10.4k|static void tinfl_clear_tree(tinfl_decompressor *r) { 4375| 10.4k| if (r->m_type == 0) ------------------ | Branch (4375:7): [True: 3.57k, False: 6.84k] ------------------ 4376| 3.57k| MZ_CLEAR_ARR(r->m_tree_0); ------------------ | | 761| 3.57k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 4377| 6.84k| else if (r->m_type == 1) ------------------ | Branch (4377:12): [True: 3.57k, False: 3.27k] ------------------ 4378| 3.57k| MZ_CLEAR_ARR(r->m_tree_1); ------------------ | | 761| 3.57k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 4379| 3.27k| else 4380| 3.27k| MZ_CLEAR_ARR(r->m_tree_2); ------------------ | | 761| 3.27k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 4381| 10.4k|} zip.c:mz_zip_reader_end_internal: 6051| 4.51k| mz_bool set_last_error) { 6052| 4.51k| mz_bool status = MZ_TRUE; ------------------ | | 719| 4.51k|#define MZ_TRUE (1) ------------------ 6053| | 6054| 4.51k| if (!pZip) ------------------ | Branch (6054:7): [True: 0, False: 4.51k] ------------------ 6055| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6056| | 6057| 4.51k| if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ------------------ | Branch (6057:7): [True: 2.25k, False: 2.25k] | Branch (6057:28): [True: 0, False: 2.25k] | Branch (6057:49): [True: 0, False: 2.25k] ------------------ 6058| 2.25k| (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) { ------------------ | Branch (6058:7): [True: 0, False: 2.25k] ------------------ 6059| 2.25k| if (set_last_error) ------------------ | Branch (6059:9): [True: 2.25k, False: 0] ------------------ 6060| 2.25k| pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER; 6061| | 6062| 2.25k| return MZ_FALSE; ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 6063| 2.25k| } 6064| | 6065| 2.25k| if (pZip->m_pState) { ------------------ | Branch (6065:7): [True: 2.25k, False: 0] ------------------ 6066| 2.25k| mz_zip_internal_state *pState = pZip->m_pState; 6067| 2.25k| pZip->m_pState = NULL; 6068| | 6069| 2.25k| mz_zip_array_clear(pZip, &pState->m_central_dir); 6070| 2.25k| mz_zip_array_clear(pZip, &pState->m_central_dir_offsets); 6071| 2.25k| mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets); 6072| | 6073| 2.25k|#ifndef MINIZ_NO_STDIO 6074| 2.25k| if (pState->m_pFile) { ------------------ | Branch (6074:9): [True: 0, False: 2.25k] ------------------ 6075| 0| if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) { ------------------ | Branch (6075:11): [True: 0, False: 0] ------------------ 6076| 0| if (MZ_FCLOSE(pState->m_pFile) == EOF) { ------------------ | | 5172| 0|#define MZ_FCLOSE fclose ------------------ | Branch (6076:13): [True: 0, False: 0] ------------------ 6077| 0| if (set_last_error) ------------------ | Branch (6077:15): [True: 0, False: 0] ------------------ 6078| 0| pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED; 6079| 0| status = MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6080| 0| } 6081| 0| } 6082| 0| pState->m_pFile = NULL; 6083| 0| } 6084| 2.25k|#endif /* #ifndef MINIZ_NO_STDIO */ 6085| | 6086| 2.25k| pZip->m_pFree(pZip->m_pAlloc_opaque, pState); 6087| 2.25k| } 6088| 2.25k| pZip->m_zip_mode = MZ_ZIP_MODE_INVALID; 6089| | 6090| 2.25k| return status; 6091| 4.51k|} zip.c:mz_zip_set_error: 5502| 2.25k| mz_zip_error err_num) { 5503| 2.25k| if (pZip) ------------------ | Branch (5503:7): [True: 2.25k, False: 0] ------------------ 5504| 2.25k| pZip->m_last_error = err_num; 5505| 2.25k| return MZ_FALSE; ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 5506| 2.25k|} zip.c:mz_zip_reader_init_internal: 5509| 2.25k| mz_uint flags) { 5510| 2.25k| (void)flags; 5511| 2.25k| if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) ------------------ | Branch (5511:7): [True: 0, False: 2.25k] | Branch (5511:18): [True: 0, False: 2.25k] | Branch (5511:38): [True: 0, False: 2.25k] ------------------ 5512| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 5513| | 5514| 2.25k| if (!pZip->m_pAlloc) ------------------ | Branch (5514:7): [True: 2.25k, False: 0] ------------------ 5515| 2.25k| pZip->m_pAlloc = miniz_def_alloc_func; 5516| 2.25k| if (!pZip->m_pFree) ------------------ | Branch (5516:7): [True: 2.25k, False: 0] ------------------ 5517| 2.25k| pZip->m_pFree = miniz_def_free_func; 5518| 2.25k| if (!pZip->m_pRealloc) ------------------ | Branch (5518:7): [True: 2.25k, False: 0] ------------------ 5519| 2.25k| pZip->m_pRealloc = miniz_def_realloc_func; 5520| | 5521| 2.25k| pZip->m_archive_size = 0; 5522| 2.25k| pZip->m_central_directory_file_ofs = 0; 5523| 2.25k| pZip->m_total_files = 0; 5524| 2.25k| pZip->m_last_error = MZ_ZIP_NO_ERROR; 5525| | 5526| 2.25k| if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc( ------------------ | Branch (5526:7): [True: 0, False: 2.25k] ------------------ 5527| 2.25k| pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) 5528| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 5529| | 5530| 2.25k| memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state)); 5531| 2.25k| MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, ------------------ | | 5341| 2.25k| (array_ptr)->m_element_size = element_size ------------------ 5532| 2.25k| sizeof(mz_uint8)); 5533| 2.25k| MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, ------------------ | | 5341| 2.25k| (array_ptr)->m_element_size = element_size ------------------ 5534| 2.25k| sizeof(mz_uint32)); 5535| 2.25k| MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, ------------------ | | 5341| 2.25k| (array_ptr)->m_element_size = element_size ------------------ 5536| 2.25k| sizeof(mz_uint32)); 5537| 2.25k| pZip->m_pState->m_init_flags = flags; 5538| 2.25k| pZip->m_pState->m_zip64 = MZ_FALSE; ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 5539| 2.25k| pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE; ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 5540| | 5541| 2.25k| pZip->m_zip_mode = MZ_ZIP_MODE_READING; 5542| | 5543| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 5544| 2.25k|} zip.c:mz_zip_reader_read_central_dir: 5704| 2.25k| mz_uint flags) { 5705| 2.25k| mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, 5706| 2.25k| cdir_disk_index = 0; 5707| 2.25k| mz_uint64 cdir_ofs = 0, eocd_ofs = 0, archive_ofs = 0; 5708| 2.25k| mz_int64 cur_file_ofs = 0; 5709| 2.25k| const mz_uint8 *p; 5710| | 5711| 2.25k| mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; 5712| 2.25k| mz_uint8 *pBuf = (mz_uint8 *)buf_u32; 5713| 2.25k| mz_bool sort_central_dir = 5714| 2.25k| ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0); 5715| 2.25k| mz_uint32 zip64_end_of_central_dir_locator_u32 5716| 2.25k| [(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / 5717| 2.25k| sizeof(mz_uint32)]; 5718| 2.25k| mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32; 5719| | 5720| 2.25k| mz_uint32 zip64_end_of_central_dir_header_u32 5721| 2.25k| [(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / 5722| 2.25k| sizeof(mz_uint32)]; 5723| 2.25k| mz_uint8 *pZip64_end_of_central_dir = 5724| 2.25k| (mz_uint8 *)zip64_end_of_central_dir_header_u32; 5725| | 5726| 2.25k| mz_uint64 zip64_end_of_central_dir_ofs = 0; 5727| | 5728| | /* Basic sanity checks - reject files which are too small, and check the first 5729| | * 4 bytes of the file to make sure a local header is there. */ 5730| 2.25k| if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) ------------------ | Branch (5730:7): [True: 0, False: 2.25k] ------------------ 5731| 0| return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); 5732| | 5733| 2.25k| if (!mz_zip_reader_locate_header_sig( ------------------ | Branch (5733:7): [True: 0, False: 2.25k] ------------------ 5734| 2.25k| pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, 5735| 2.25k| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs)) 5736| 0| return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR); 5737| | 5738| 2.25k| eocd_ofs = cur_file_ofs; 5739| | /* Read and verify the end of central directory record. */ 5740| 2.25k| if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, ------------------ | Branch (5740:7): [True: 0, False: 2.25k] ------------------ 5741| 2.25k| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != 5742| 2.25k| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) 5743| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); 5744| | 5745| 2.25k| if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ | Branch (5745:7): [True: 0, False: 2.25k] ------------------ 5746| 2.25k| MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) 5747| 0| return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); 5748| | 5749| 2.25k| if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + ------------------ | Branch (5749:7): [True: 2.25k, False: 0] ------------------ 5750| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) { 5751| 2.25k| if (pZip->m_pRead(pZip->m_pIO_opaque, ------------------ | Branch (5751:9): [True: 2.25k, False: 0] ------------------ 5752| 2.25k| cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, 5753| 2.25k| pZip64_locator, 5754| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == 5755| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) { 5756| 2.25k| if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ | Branch (5756:11): [True: 2.25k, False: 0] ------------------ 5757| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) { 5758| 2.25k| pZip->m_pState->m_zip64 = MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 5759| 2.25k| } 5760| 2.25k| } 5761| 2.25k| } 5762| | 5763| 2.25k| if (pZip->m_pState->m_zip64) { ------------------ | Branch (5763:7): [True: 2.25k, False: 0] ------------------ 5764| | /* Try locating the EOCD64 right before the EOCD64 locator. This works even 5765| | * when the effective start of the zip header is not yet known. */ 5766| 2.25k| if (cur_file_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + ------------------ | Branch (5766:9): [True: 0, False: 2.25k] ------------------ 5767| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) 5768| 0| return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); 5769| | 5770| 2.25k| zip64_end_of_central_dir_ofs = cur_file_ofs - 5771| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE - 5772| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE; 5773| | 5774| 2.25k| if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs, ------------------ | Branch (5774:9): [True: 0, False: 2.25k] ------------------ 5775| 2.25k| pZip64_end_of_central_dir)) { 5776| | /* That failed, try reading where the locator tells us to. */ 5777| 0| zip64_end_of_central_dir_ofs = MZ_READ_LE64( ------------------ | | 779| 0| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 0| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 0| << 32U)) ------------------ 5778| 0| pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS); 5779| | 5780| 0| if (zip64_end_of_central_dir_ofs > ------------------ | Branch (5780:11): [True: 0, False: 0] ------------------ 5781| 0| (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) 5782| 0| return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); 5783| | 5784| 0| if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs, ------------------ | Branch (5784:11): [True: 0, False: 0] ------------------ 5785| 0| pZip64_end_of_central_dir)) 5786| 0| return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); 5787| 0| } 5788| 2.25k| } 5789| | 5790| 2.25k| pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5791| 2.25k| cdir_entries_on_this_disk = 5792| 2.25k| MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5793| 2.25k| num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5794| 2.25k| cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5795| 2.25k| cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS); ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5796| 2.25k| cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS); ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5797| | 5798| 2.25k| if (pZip->m_pState->m_zip64) { ------------------ | Branch (5798:7): [True: 2.25k, False: 0] ------------------ 5799| 2.25k| mz_uint32 zip64_total_num_of_disks = 5800| 2.25k| MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS); ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5801| 2.25k| mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64( ------------------ | | 779| 2.25k| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 2.25k| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 2.25k| << 32U)) ------------------ 5802| 2.25k| pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS); 5803| 2.25k| mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64( ------------------ | | 779| 2.25k| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 2.25k| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 2.25k| << 32U)) ------------------ 5804| 2.25k| pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS); 5805| 2.25k| mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64( ------------------ | | 779| 2.25k| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 2.25k| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 2.25k| << 32U)) ------------------ 5806| 2.25k| pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS); 5807| 2.25k| mz_uint64 zip64_size_of_central_directory = 5808| 2.25k| MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS); ------------------ | | 779| 2.25k| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 2.25k| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 2.25k| << 32U)) ------------------ 5809| | 5810| 2.25k| if (zip64_size_of_end_of_central_dir_record < ------------------ | Branch (5810:9): [True: 0, False: 2.25k] ------------------ 5811| 2.25k| (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12)) 5812| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5813| | 5814| 2.25k| if (zip64_total_num_of_disks != 1U) ------------------ | Branch (5814:9): [True: 0, False: 2.25k] ------------------ 5815| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); 5816| | 5817| | /* Check for miniz's practical limits */ 5818| 2.25k| if (zip64_cdir_total_entries > MZ_UINT32_MAX) ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (5818:9): [True: 0, False: 2.25k] ------------------ 5819| 0| return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); 5820| | 5821| 2.25k| pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries; 5822| | 5823| 2.25k| if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX) ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (5823:9): [True: 0, False: 2.25k] ------------------ 5824| 0| return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); 5825| | 5826| 2.25k| cdir_entries_on_this_disk = 5827| 2.25k| (mz_uint32)zip64_cdir_total_entries_on_this_disk; 5828| | 5829| | /* Check for miniz's current practical limits (sorry, this should be enough 5830| | * for millions of files) */ 5831| 2.25k| if (zip64_size_of_central_directory > MZ_UINT32_MAX) ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (5831:9): [True: 0, False: 2.25k] ------------------ 5832| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); 5833| | 5834| 2.25k| cdir_size = (mz_uint32)zip64_size_of_central_directory; 5835| | 5836| 2.25k| num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5837| 2.25k| MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS); 5838| | 5839| 2.25k| cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5840| 2.25k| MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS); 5841| | 5842| 2.25k| cdir_ofs = 5843| 2.25k| MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS); ------------------ | | 779| 2.25k| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 2.25k| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 2.25k| << 32U)) ------------------ 5844| 2.25k| } 5845| | 5846| 2.25k| if (pZip->m_total_files != cdir_entries_on_this_disk) ------------------ | Branch (5846:7): [True: 0, False: 2.25k] ------------------ 5847| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); 5848| | 5849| 2.25k| if (((num_this_disk | cdir_disk_index) != 0) && ------------------ | Branch (5849:7): [True: 0, False: 2.25k] ------------------ 5850| 0| ((num_this_disk != 1) || (cdir_disk_index != 1))) ------------------ | Branch (5850:8): [True: 0, False: 0] | Branch (5850:32): [True: 0, False: 0] ------------------ 5851| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); 5852| | 5853| 2.25k| if (cdir_size < ------------------ | Branch (5853:7): [True: 0, False: 2.25k] ------------------ 5854| 2.25k| (mz_uint64)pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) 5855| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5856| | 5857| 2.25k| if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size) ------------------ | Branch (5857:7): [True: 0, False: 2.25k] ------------------ 5858| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5859| | 5860| 2.25k| if (eocd_ofs < cdir_ofs + cdir_size) ------------------ | Branch (5860:7): [True: 0, False: 2.25k] ------------------ 5861| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5862| | 5863| | /* The end of central dir follows the central dir, unless the zip file has 5864| | * some trailing data (e.g. it is appended to an executable file). */ 5865| 2.25k| archive_ofs = eocd_ofs - (cdir_ofs + cdir_size); 5866| 2.25k| if (pZip->m_pState->m_zip64) { ------------------ | Branch (5866:7): [True: 2.25k, False: 0] ------------------ 5867| 2.25k| if (archive_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + ------------------ | Branch (5867:9): [True: 0, False: 2.25k] ------------------ 5868| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) 5869| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5870| | 5871| 2.25k| archive_ofs -= MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + 5872| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE; 5873| 2.25k| } 5874| | 5875| | /* Update the archive start position, but only if not specified. */ 5876| 2.25k| if ((pZip->m_zip_type == MZ_ZIP_TYPE_FILE || ------------------ | Branch (5876:8): [True: 0, False: 2.25k] ------------------ 5877| 2.25k| pZip->m_zip_type == MZ_ZIP_TYPE_CFILE || ------------------ | Branch (5877:8): [True: 0, False: 2.25k] ------------------ 5878| 2.25k| pZip->m_zip_type == MZ_ZIP_TYPE_USER) && ------------------ | Branch (5878:8): [True: 0, False: 2.25k] ------------------ 5879| 0| pZip->m_pState->m_file_archive_start_ofs == 0) { ------------------ | Branch (5879:7): [True: 0, False: 0] ------------------ 5880| 0| pZip->m_pState->m_file_archive_start_ofs = archive_ofs; 5881| 0| pZip->m_archive_size -= archive_ofs; 5882| 0| } 5883| | 5884| 2.25k| pZip->m_central_directory_file_ofs = cdir_ofs; 5885| | 5886| 2.25k| if (pZip->m_total_files) { ------------------ | Branch (5886:7): [True: 2.25k, False: 0] ------------------ 5887| 2.25k| mz_uint i, n; 5888| | /* Read the entire central directory into a heap block, and allocate another 5889| | * heap block to hold the unsorted central dir file record offsets, and 5890| | * possibly another to hold the sorted indices. */ 5891| 2.25k| if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, ------------------ | Branch (5891:9): [True: 0, False: 2.25k] ------------------ 5892| 2.25k| MZ_FALSE)) || ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 5893| 2.25k| (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, ------------------ | Branch (5893:9): [True: 0, False: 2.25k] ------------------ 5894| 2.25k| pZip->m_total_files, MZ_FALSE))) ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 5895| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 5896| | 5897| 2.25k| if (sort_central_dir) { ------------------ | Branch (5897:9): [True: 2.25k, False: 0] ------------------ 5898| 2.25k| if (!mz_zip_array_resize(pZip, ------------------ | Branch (5898:11): [True: 0, False: 2.25k] ------------------ 5899| 2.25k| &pZip->m_pState->m_sorted_central_dir_offsets, 5900| 2.25k| pZip->m_total_files, MZ_FALSE)) ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 5901| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 5902| 2.25k| } 5903| | 5904| 2.25k| if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, ------------------ | Branch (5904:9): [True: 0, False: 2.25k] ------------------ 5905| 2.25k| pZip->m_pState->m_central_dir.m_p, 5906| 2.25k| cdir_size) != cdir_size) 5907| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); 5908| | 5909| | /* Now create an index into the central directory file records, do some 5910| | * basic sanity checking on each record */ 5911| 2.25k| p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p; 5912| 4.51k| for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) { ------------------ | Branch (5912:32): [True: 2.25k, False: 2.25k] ------------------ 5913| 2.25k| mz_uint total_header_size, disk_index, bit_flags, filename_size, 5914| 2.25k| ext_data_size; 5915| 2.25k| mz_uint64 comp_size, decomp_size, local_header_ofs; 5916| | 5917| 2.25k| if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || ------------------ | Branch (5917:11): [True: 0, False: 2.25k] ------------------ 5918| 2.25k| (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)) ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ | Branch (5918:11): [True: 0, False: 2.25k] ------------------ 5919| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5920| | 5921| 2.25k| MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, ------------------ | | 5354| 2.25k| ((element_type *)((array_ptr)->m_p))[index] ------------------ 5922| 2.25k| i) = 5923| 2.25k| (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p); 5924| | 5925| 2.25k| if (sort_central_dir) ------------------ | Branch (5925:11): [True: 2.25k, False: 0] ------------------ 5926| 2.25k| MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, ------------------ | | 5354| 2.25k| ((element_type *)((array_ptr)->m_p))[index] ------------------ 5927| 2.25k| mz_uint32, i) = i; 5928| | 5929| 2.25k| comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5930| 2.25k| decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5931| 2.25k| local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS); ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5932| 2.25k| filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5933| 2.25k| ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5934| | 5935| 2.25k| if ((!pZip->m_pState->m_zip64_has_extended_info_fields) && ------------------ | Branch (5935:11): [True: 2.25k, False: 0] ------------------ 5936| 2.25k| (ext_data_size) && ------------------ | Branch (5936:11): [True: 2.25k, False: 0] ------------------ 5937| 2.25k| (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == ------------------ | | 758| 4.51k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 2.25k, False: 0] | | | Branch (758:25): [True: 652, False: 1.60k] | | | Branch (758:38): [True: 652, False: 1.60k] | | ------------------ ------------------ | Branch (5937:11): [True: 0, False: 2.25k] ------------------ 5938| 2.25k| MZ_UINT32_MAX)) { ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ 5939| | /* Attempt to find zip64 extended information field in the entry's extra 5940| | * data */ 5941| 0| mz_uint32 extra_size_remaining = ext_data_size; 5942| | 5943| 0| if (extra_size_remaining) { ------------------ | Branch (5943:13): [True: 0, False: 0] ------------------ 5944| 0| const mz_uint8 *pExtra_data; 5945| 0| void *buf = NULL; 5946| | 5947| 0| if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > ------------------ | Branch (5947:15): [True: 0, False: 0] ------------------ 5948| 0| n) { 5949| 0| buf = MZ_MALLOC(ext_data_size); ------------------ | | 753| 0|#define MZ_MALLOC(x) malloc(x) ------------------ 5950| 0| if (buf == NULL) ------------------ | Branch (5950:17): [True: 0, False: 0] ------------------ 5951| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 5952| | 5953| 0| if (pZip->m_pRead(pZip->m_pIO_opaque, ------------------ | Branch (5953:17): [True: 0, False: 0] ------------------ 5954| 0| cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + 5955| 0| filename_size, 5956| 0| buf, ext_data_size) != ext_data_size) { 5957| 0| MZ_FREE(buf); ------------------ | | 754| 0|#define MZ_FREE(x) free(x) ------------------ 5958| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); 5959| 0| } 5960| | 5961| 0| pExtra_data = (mz_uint8 *)buf; 5962| 0| } else { 5963| 0| pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size; 5964| 0| } 5965| | 5966| 0| do { 5967| 0| mz_uint32 field_id; 5968| 0| mz_uint32 field_data_size; 5969| | 5970| 0| if (extra_size_remaining < (sizeof(mz_uint16) * 2)) { ------------------ | Branch (5970:17): [True: 0, False: 0] ------------------ 5971| 0| MZ_FREE(buf); ------------------ | | 754| 0|#define MZ_FREE(x) free(x) ------------------ 5972| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5973| 0| } 5974| | 5975| 0| field_id = MZ_READ_LE16(pExtra_data); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5976| 0| field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 5977| | 5978| 0| if ((field_data_size + sizeof(mz_uint16) * 2) > ------------------ | Branch (5978:17): [True: 0, False: 0] ------------------ 5979| 0| extra_size_remaining) { 5980| 0| MZ_FREE(buf); ------------------ | | 754| 0|#define MZ_FREE(x) free(x) ------------------ 5981| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 5982| 0| } 5983| | 5984| 0| if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { ------------------ | Branch (5984:17): [True: 0, False: 0] ------------------ 5985| | /* Ok, the archive didn't have any zip64 headers but it uses a 5986| | * zip64 extended information field so mark it as zip64 anyway 5987| | * (this can occur with infozip's zip util when it reads 5988| | * compresses files from stdin). */ 5989| 0| pZip->m_pState->m_zip64 = MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 5990| 0| pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 5991| 0| break; 5992| 0| } 5993| | 5994| 0| pExtra_data += sizeof(mz_uint16) * 2 + field_data_size; 5995| 0| extra_size_remaining = 5996| 0| extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; 5997| 0| } while (extra_size_remaining); ------------------ | Branch (5997:20): [True: 0, False: 0] ------------------ 5998| | 5999| 0| MZ_FREE(buf); ------------------ | | 754| 0|#define MZ_FREE(x) free(x) ------------------ 6000| 0| } 6001| 0| } 6002| | 6003| | /* I've seen archives that aren't marked as zip64 that uses zip64 ext 6004| | * data, argh */ 6005| 2.25k| if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) { ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) { ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (6005:11): [True: 2.25k, False: 0] | Branch (6005:43): [True: 2.25k, False: 0] ------------------ 6006| 2.25k| if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ | Branch (6006:14): [True: 0, False: 2.25k] ------------------ 6007| 0| (decomp_size != comp_size)) || ------------------ | Branch (6007:14): [True: 0, False: 0] ------------------ 6008| 2.25k| (decomp_size && !comp_size)) ------------------ | Branch (6008:14): [True: 2.25k, False: 0] | Branch (6008:29): [True: 0, False: 2.25k] ------------------ 6009| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6010| 2.25k| } 6011| | 6012| 2.25k| disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6013| 2.25k| if ((disk_index == MZ_UINT16_MAX) || ------------------ | | 793| 2.25k|#define MZ_UINT16_MAX (0xFFFFU) ------------------ | Branch (6013:11): [True: 0, False: 2.25k] ------------------ 6014| 2.25k| ((disk_index != num_this_disk) && (disk_index != 1))) ------------------ | Branch (6014:12): [True: 0, False: 2.25k] | Branch (6014:45): [True: 0, False: 0] ------------------ 6015| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); 6016| | 6017| 2.25k| if (comp_size != MZ_UINT32_MAX) { ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (6017:11): [True: 2.25k, False: 0] ------------------ 6018| 2.25k| if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ | Branch (6018:13): [True: 0, False: 2.25k] ------------------ 6019| 2.25k| MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size) 6020| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6021| 2.25k| } 6022| | 6023| 2.25k| bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6024| 2.25k| if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED) ------------------ | Branch (6024:11): [True: 0, False: 2.25k] ------------------ 6025| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); 6026| | 6027| 2.25k| if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + ------------------ | Branch (6027:11): [True: 0, False: 2.25k] ------------------ 6028| 2.25k| MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6029| 2.25k| MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6030| 2.25k| MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6031| 2.25k| n) 6032| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6033| | 6034| 2.25k| n -= total_header_size; 6035| 2.25k| p += total_header_size; 6036| 2.25k| } 6037| 2.25k| } 6038| | 6039| 2.25k| if (sort_central_dir) ------------------ | Branch (6039:7): [True: 2.25k, False: 0] ------------------ 6040| 2.25k| mz_zip_reader_sort_central_dir_offsets_by_filename(pZip); 6041| | 6042| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 6043| 2.25k|} zip.c:mz_zip_reader_locate_header_sig: 5644| 2.25k| mz_int64 *pOfs) { 5645| 2.25k| mz_int64 cur_file_ofs; 5646| 2.25k| mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; 5647| 2.25k| mz_uint8 *pBuf = (mz_uint8 *)buf_u32; 5648| | 5649| | /* Basic sanity checks - reject files which are too small */ 5650| 2.25k| if (pZip->m_archive_size < record_size) ------------------ | Branch (5650:7): [True: 0, False: 2.25k] ------------------ 5651| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 5652| | 5653| | /* Find the record by scanning the file from the end towards the beginning. */ 5654| 2.25k| cur_file_ofs = 5655| 2.25k| MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0); ------------------ | | 758| 2.25k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 750, False: 1.50k] | | ------------------ ------------------ 5656| 2.25k| for (;;) { 5657| 2.25k| int i, 5658| 2.25k| n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs); ------------------ | | 759| 2.25k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 2.25k] | | ------------------ ------------------ 5659| | 5660| 2.25k| if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n) ------------------ | Branch (5660:9): [True: 0, False: 2.25k] ------------------ 5661| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 5662| | 5663| 42.9k| for (i = n - 4; i >= 0; --i) { ------------------ | Branch (5663:21): [True: 42.9k, False: 0] ------------------ 5664| 42.9k| mz_uint s = MZ_READ_LE32(pBuf + i); ------------------ | | 772| 42.9k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 42.9k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 42.9k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 42.9k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 5665| 42.9k| if (s == record_sig) { ------------------ | Branch (5665:11): [True: 2.25k, False: 40.6k] ------------------ 5666| 2.25k| if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size) ------------------ | Branch (5666:13): [True: 2.25k, False: 0] ------------------ 5667| 2.25k| break; 5668| 2.25k| } 5669| 42.9k| } 5670| | 5671| 2.25k| if (i >= 0) { ------------------ | Branch (5671:9): [True: 2.25k, False: 0] ------------------ 5672| 2.25k| cur_file_ofs += i; 5673| 2.25k| break; 5674| 2.25k| } 5675| | 5676| | /* Give up if we've searched the entire file, or we've gone back "too far" 5677| | * (~64kb) */ 5678| 0| if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= ------------------ | Branch (5678:9): [True: 0, False: 0] | Branch (5678:28): [True: 0, False: 0] ------------------ 5679| 0| ((mz_uint64)(MZ_UINT16_MAX) + record_size))) ------------------ | | 793| 0|#define MZ_UINT16_MAX (0xFFFFU) ------------------ 5680| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 5681| | 5682| 0| cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0); ------------------ | | 758| 0|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 0, False: 0] | | ------------------ ------------------ 5683| 0| } 5684| | 5685| 2.25k| *pOfs = cur_file_ofs; 5686| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 5687| 2.25k|} zip.c:mz_zip_reader_eocd64_valid: 5690| 2.25k| uint8_t *buf) { 5691| 2.25k| if (pZip->m_pRead(pZip->m_pIO_opaque, offset, buf, ------------------ | Branch (5691:7): [True: 2.25k, False: 0] ------------------ 5692| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == 5693| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) { 5694| 2.25k| if (MZ_READ_LE32(buf + MZ_ZIP64_ECDH_SIG_OFS) == ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ | Branch (5694:9): [True: 2.25k, False: 0] ------------------ 5695| 2.25k| MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) { 5696| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 5697| 2.25k| } 5698| 2.25k| } 5699| | 5700| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 5701| 2.25k|} zip.c:mz_zip_reader_sort_central_dir_offsets_by_filename: 5585| 2.25k|mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip) { 5586| 2.25k| mz_zip_internal_state *pState = pZip->m_pState; 5587| 2.25k| const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets; 5588| 2.25k| const mz_zip_array *pCentral_dir = &pState->m_central_dir; 5589| 2.25k| mz_uint32 *pIndices; 5590| 2.25k| mz_uint32 start, end; 5591| 2.25k| const mz_uint32 size = pZip->m_total_files; 5592| | 5593| 2.25k| if (size <= 1U) ------------------ | Branch (5593:7): [True: 2.25k, False: 0] ------------------ 5594| 2.25k| return; 5595| | 5596| 0| pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, ------------------ | | 5354| 0| ((element_type *)((array_ptr)->m_p))[index] ------------------ 5597| 0| mz_uint32, 0); 5598| | 5599| 0| start = (size - 2U) >> 1U; 5600| 0| for (;;) { 5601| 0| mz_uint64 child, root = start; 5602| 0| for (;;) { 5603| 0| if ((child = (root << 1U) + 1U) >= size) ------------------ | Branch (5603:11): [True: 0, False: 0] ------------------ 5604| 0| break; 5605| 0| child += (((child + 1U) < size) && ------------------ | Branch (5605:17): [True: 0, False: 0] ------------------ 5606| 0| (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, ------------------ | Branch (5606:17): [True: 0, False: 0] ------------------ 5607| 0| pIndices[child], 5608| 0| pIndices[child + 1U]))); 5609| 0| if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, ------------------ | Branch (5609:11): [True: 0, False: 0] ------------------ 5610| 0| pIndices[root], pIndices[child])) 5611| 0| break; 5612| 0| MZ_SWAP_UINT32(pIndices[root], pIndices[child]); ------------------ | | 5574| 0| do { \ | | 5575| 0| mz_uint32 t = a; \ | | 5576| 0| a = b; \ | | 5577| 0| b = t; \ | | 5578| 0| } \ | | 5579| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 5613| 0| root = child; 5614| 0| } 5615| 0| if (!start) ------------------ | Branch (5615:9): [True: 0, False: 0] ------------------ 5616| 0| break; 5617| 0| start--; 5618| 0| } 5619| | 5620| 0| end = size - 1; 5621| 0| while (end > 0) { ------------------ | Branch (5621:10): [True: 0, False: 0] ------------------ 5622| 0| mz_uint64 child, root = 0; 5623| 0| MZ_SWAP_UINT32(pIndices[end], pIndices[0]); ------------------ | | 5574| 0| do { \ | | 5575| 0| mz_uint32 t = a; \ | | 5576| 0| a = b; \ | | 5577| 0| b = t; \ | | 5578| 0| } \ | | 5579| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 5624| 0| for (;;) { 5625| 0| if ((child = (root << 1U) + 1U) >= end) ------------------ | Branch (5625:11): [True: 0, False: 0] ------------------ 5626| 0| break; 5627| 0| child += 5628| 0| (((child + 1U) < end) && ------------------ | Branch (5628:12): [True: 0, False: 0] ------------------ 5629| 0| mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, ------------------ | Branch (5629:12): [True: 0, False: 0] ------------------ 5630| 0| pIndices[child], pIndices[child + 1U])); 5631| 0| if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, ------------------ | Branch (5631:11): [True: 0, False: 0] ------------------ 5632| 0| pIndices[root], pIndices[child])) 5633| 0| break; 5634| 0| MZ_SWAP_UINT32(pIndices[root], pIndices[child]); ------------------ | | 5574| 0| do { \ | | 5575| 0| mz_uint32 t = a; \ | | 5576| 0| a = b; \ | | 5577| 0| b = t; \ | | 5578| 0| } \ | | 5579| 0| MZ_MACRO_END | | ------------------ | | | | 726| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 5635| 0| root = child; 5636| 0| } 5637| 0| end--; 5638| 0| } 5639| 0|} zip.c:mz_zip_mem_read_func: 6116| 13.5k| void *pBuf, size_t n) { 6117| 13.5k| mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; 6118| 13.5k| size_t s = (file_ofs >= pZip->m_archive_size) ------------------ | Branch (6118:14): [True: 0, False: 13.5k] ------------------ 6119| 13.5k| ? 0 6120| 13.5k| : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n); ------------------ | | 759| 13.5k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 13.5k] | | ------------------ ------------------ 6121| 13.5k| memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s); 6122| 13.5k| return s; 6123| 13.5k|} zip.c:mz_zip_get_cdh: 6274| 20.3k| mz_uint file_index) { 6275| 20.3k| if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) ------------------ | Branch (6275:7): [True: 0, False: 20.3k] | Branch (6275:18): [True: 0, False: 20.3k] | Branch (6275:39): [True: 0, False: 20.3k] ------------------ 6276| 0| return NULL; 6277| 20.3k| return &MZ_ZIP_ARRAY_ELEMENT( ------------------ | | 5354| 20.3k| ((element_type *)((array_ptr)->m_p))[index] ------------------ 6278| 20.3k| &pZip->m_pState->m_central_dir, mz_uint8, 6279| 20.3k| MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, 6280| 20.3k| file_index)); 6281| 20.3k|} zip.c:mz_zip_locate_file_binary_search: 6529| 2.25k| mz_uint32 *pIndex) { 6530| 2.25k| mz_zip_internal_state *pState = pZip->m_pState; 6531| 2.25k| const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets; 6532| 2.25k| const mz_zip_array *pCentral_dir = &pState->m_central_dir; 6533| 2.25k| mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT( ------------------ | | 5354| 2.25k| ((element_type *)((array_ptr)->m_p))[index] ------------------ 6534| 2.25k| &pState->m_sorted_central_dir_offsets, mz_uint32, 0); 6535| 2.25k| const mz_uint32 size = pZip->m_total_files; 6536| 2.25k| const mz_uint filename_len = (mz_uint)strlen(pFilename); 6537| | 6538| 2.25k| if (pIndex) ------------------ | Branch (6538:7): [True: 2.25k, False: 0] ------------------ 6539| 2.25k| *pIndex = 0; 6540| | 6541| 2.25k| if (size) { ------------------ | Branch (6541:7): [True: 2.25k, False: 0] ------------------ 6542| | /* yes I could use uint32_t's, but then we would have to add some special 6543| | * case checks in the loop, argh, and */ 6544| | /* honestly the major expense here on 32-bit CPU's will still be the 6545| | * filename compare */ 6546| 2.25k| mz_int64 l = 0, h = (mz_int64)size - 1; 6547| | 6548| 2.25k| while (l <= h) { ------------------ | Branch (6548:12): [True: 2.25k, False: 0] ------------------ 6549| 2.25k| mz_int64 m = l + ((h - l) >> 1); 6550| 2.25k| mz_uint32 file_index = pIndices[(mz_uint32)m]; 6551| | 6552| 2.25k| int comp = mz_zip_filename_compare(pCentral_dir, pCentral_dir_offsets, 6553| 2.25k| file_index, pFilename, filename_len); 6554| 2.25k| if (!comp) { ------------------ | Branch (6554:11): [True: 2.25k, False: 0] ------------------ 6555| 2.25k| if (pIndex) ------------------ | Branch (6555:13): [True: 2.25k, False: 0] ------------------ 6556| 2.25k| *pIndex = file_index; 6557| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 6558| 2.25k| } else if (comp < 0) ------------------ | Branch (6558:18): [True: 0, False: 0] ------------------ 6559| 0| l = m + 1; 6560| 0| else 6561| 0| h = m - 1; 6562| 2.25k| } 6563| 2.25k| } 6564| | 6565| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND); 6566| 2.25k|} zip.c:mz_zip_filename_compare: 6508| 2.25k| mz_uint l_index, const char *pR, mz_uint r_len) { 6509| 2.25k| const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT( ------------------ | | 5354| 2.25k| ((element_type *)((array_ptr)->m_p))[index] ------------------ 6510| 2.25k| pCentral_dir_array, mz_uint8, 6511| 2.25k| MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, 6512| 2.25k| l_index)), 6513| 2.25k| *pE; 6514| 2.25k| mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6515| 2.25k| mz_uint8 l = 0, r = 0; 6516| 2.25k| pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; 6517| 2.25k| pE = pL + MZ_MIN(l_len, r_len); ------------------ | | 759| 2.25k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 2.25k] | | ------------------ ------------------ 6518| 11.2k| while (pL < pE) { ------------------ | Branch (6518:10): [True: 9.03k, False: 2.25k] ------------------ 6519| 9.03k| if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) ------------------ | | 5214| 9.03k|#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c)) | | ------------------ | | | Branch (5214:25): [True: 9.03k, False: 0] | | | Branch (5214:41): [True: 0, False: 9.03k] | | ------------------ ------------------ if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) ------------------ | | 5214| 9.03k|#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c)) | | ------------------ | | | Branch (5214:25): [True: 9.03k, False: 0] | | | Branch (5214:41): [True: 0, False: 9.03k] | | ------------------ ------------------ | Branch (6519:9): [True: 0, False: 9.03k] ------------------ 6520| 0| break; 6521| 9.03k| pL++; 6522| 9.03k| pR++; 6523| 9.03k| } 6524| 2.25k| return (pL == pE) ? (int)(l_len - r_len) : (l - r); ------------------ | Branch (6524:10): [True: 2.25k, False: 0] ------------------ 6525| 2.25k|} zip.c:mz_zip_reader_extract_to_mem_no_alloc1: 6652| 2.25k| const mz_zip_archive_file_stat *st) { 6653| 2.25k| int status = TINFL_STATUS_DONE; 6654| 2.25k| mz_uint64 needed_size, cur_file_ofs, comp_remaining, 6655| 2.25k| out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail; 6656| 2.25k| mz_zip_archive_file_stat file_stat; 6657| 2.25k| void *pRead_buf; 6658| 2.25k| mz_uint32 6659| 2.25k| local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / 6660| 2.25k| sizeof(mz_uint32)]; 6661| 2.25k| mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; 6662| 2.25k| tinfl_decompressor inflator; 6663| | 6664| 2.25k| if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ------------------ | Branch (6664:7): [True: 0, False: 2.25k] | Branch (6664:18): [True: 0, False: 2.25k] | Branch (6664:40): [True: 2.25k, False: 0] | Branch (6664:54): [True: 0, False: 2.25k] ------------------ 6665| 2.25k| ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) ------------------ | Branch (6665:8): [True: 0, False: 2.25k] | Branch (6665:32): [True: 0, False: 0] | Branch (6665:54): [True: 0, False: 2.25k] ------------------ 6666| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6667| | 6668| 2.25k| if (st) { ------------------ | Branch (6668:7): [True: 2.25k, False: 0] ------------------ 6669| 2.25k| file_stat = *st; 6670| 2.25k| } else if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) ------------------ | Branch (6670:14): [True: 0, False: 0] ------------------ 6671| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6672| | 6673| | /* A directory or zero length file */ 6674| 2.25k| if ((file_stat.m_is_directory) || (!file_stat.m_comp_size)) ------------------ | Branch (6674:7): [True: 0, False: 2.25k] | Branch (6674:37): [True: 0, False: 2.25k] ------------------ 6675| 0| return MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 6676| | 6677| | /* Encryption and patch files are not supported. */ 6678| 2.25k| if (file_stat.m_bit_flag & ------------------ | Branch (6678:7): [True: 0, False: 2.25k] ------------------ 6679| 2.25k| (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | 6680| 2.25k| MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | 6681| 2.25k| MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)) 6682| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); 6683| | 6684| | /* This function only supports decompressing stored and deflate. */ 6685| 2.25k| if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && ------------------ | Branch (6685:7): [True: 2.25k, False: 0] | Branch (6685:51): [True: 2.25k, False: 0] ------------------ 6686| 2.25k| (file_stat.m_method != MZ_DEFLATED)) ------------------ | | 316| 2.25k|#define MZ_DEFLATED 8 ------------------ | Branch (6686:7): [True: 0, False: 2.25k] ------------------ 6687| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); 6688| | 6689| | /* Ensure supplied output buffer is large enough. */ 6690| 2.25k| needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size ------------------ | Branch (6690:17): [True: 0, False: 2.25k] ------------------ 6691| 2.25k| : file_stat.m_uncomp_size; 6692| 2.25k| if (buf_size < needed_size) ------------------ | Branch (6692:7): [True: 0, False: 2.25k] ------------------ 6693| 0| return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL); 6694| | 6695| | /* Read and parse the local directory entry. */ 6696| 2.25k| cur_file_ofs = file_stat.m_local_header_ofs; 6697| 2.25k| if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, ------------------ | Branch (6697:7): [True: 0, False: 2.25k] ------------------ 6698| 2.25k| MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != 6699| 2.25k| MZ_ZIP_LOCAL_DIR_HEADER_SIZE) 6700| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); 6701| | 6702| 2.25k| if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) ------------------ | | 772| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ | Branch (6702:7): [True: 0, False: 2.25k] ------------------ 6703| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6704| | 6705| 2.25k| cur_file_ofs += (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + 6706| 2.25k| MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6707| 2.25k| MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); ------------------ | | 769| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 2.25k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6708| 2.25k| if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size) ------------------ | Branch (6708:7): [True: 0, False: 2.25k] ------------------ 6709| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6710| | 6711| 2.25k| if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) { ------------------ | Branch (6711:7): [True: 0, False: 2.25k] | Branch (6711:48): [True: 0, False: 2.25k] ------------------ 6712| | /* The file is stored or the caller has requested the compressed data. */ 6713| 0| if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, ------------------ | Branch (6713:9): [True: 0, False: 0] ------------------ 6714| 0| (size_t)needed_size) != needed_size) 6715| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); 6716| | 6717| 0|#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 6718| 0| if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0) { ------------------ | Branch (6718:9): [True: 0, False: 0] ------------------ 6719| 0| if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, ------------------ | | 300| 0|#define MZ_CRC32_INIT (0) ------------------ | Branch (6719:11): [True: 0, False: 0] ------------------ 6720| 0| (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) 6721| 0| return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED); 6722| 0| } 6723| 0|#endif 6724| | 6725| 0| return MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 6726| 0| } 6727| | 6728| | /* Decompress the file either directly from memory or from a file input 6729| | * buffer. */ 6730| 2.25k| tinfl_init(&inflator); ------------------ | | 1191| 2.25k| do { \ | | 1192| 2.25k| (r)->m_state = 0; \ | | 1193| 2.25k| } \ | | 1194| 2.25k| MZ_MACRO_END | | ------------------ | | | | 726| 2.25k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (726:29): [Folded, False: 2.25k] | | | | ------------------ | | ------------------ ------------------ 6731| | 6732| 2.25k| if (pZip->m_pState->m_pMem) { ------------------ | Branch (6732:7): [True: 2.25k, False: 0] ------------------ 6733| | /* Read directly from the archive in memory. */ 6734| 2.25k| pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs; 6735| 2.25k| read_buf_size = read_buf_avail = file_stat.m_comp_size; 6736| 2.25k| comp_remaining = 0; 6737| 2.25k| } else if (pUser_read_buf) { ------------------ | Branch (6737:14): [True: 0, False: 0] ------------------ 6738| | /* Use a user provided read buffer. */ 6739| 0| if (!user_read_buf_size) ------------------ | Branch (6739:9): [True: 0, False: 0] ------------------ 6740| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6741| 0| pRead_buf = (mz_uint8 *)pUser_read_buf; 6742| 0| read_buf_size = user_read_buf_size; 6743| 0| read_buf_avail = 0; 6744| 0| comp_remaining = file_stat.m_comp_size; 6745| 0| } else { 6746| | /* Temporarily allocate a read buffer. */ 6747| 0| read_buf_size = 6748| 0| MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE); ------------------ | | 759| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 0] | | ------------------ ------------------ 6749| 0| if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF)) ------------------ | Branch (6749:9): [Folded, False: 0] | Branch (6749:52): [True: 0, False: 0] ------------------ 6750| 0| return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); 6751| | 6752| 0| if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, ------------------ | Branch (6752:9): [True: 0, False: 0] ------------------ 6753| 0| (size_t)read_buf_size))) 6754| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 6755| | 6756| 0| read_buf_avail = 0; 6757| 0| comp_remaining = file_stat.m_comp_size; 6758| 0| } 6759| | 6760| 2.25k| do { 6761| | /* The size_t cast here should be OK because we've verified that the output 6762| | * buffer is >= file_stat.m_uncomp_size above */ 6763| 2.25k| size_t in_buf_size, 6764| 2.25k| out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs); 6765| 2.25k| if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) { ------------------ | Branch (6765:9): [True: 0, False: 2.25k] | Branch (6765:30): [True: 0, False: 0] ------------------ 6766| 0| read_buf_avail = MZ_MIN(read_buf_size, comp_remaining); ------------------ | | 759| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 0] | | ------------------ ------------------ 6767| 0| if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, ------------------ | Branch (6767:11): [True: 0, False: 0] ------------------ 6768| 0| (size_t)read_buf_avail) != read_buf_avail) { 6769| 0| status = TINFL_STATUS_FAILED; 6770| 0| mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED); 6771| 0| break; 6772| 0| } 6773| 0| cur_file_ofs += read_buf_avail; 6774| 0| comp_remaining -= read_buf_avail; 6775| 0| read_buf_ofs = 0; 6776| 0| } 6777| 2.25k| in_buf_size = (size_t)read_buf_avail; 6778| 2.25k| status = tinfl_decompress( 6779| 2.25k| &inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, 6780| 2.25k| (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, 6781| 2.25k| TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | 6782| 2.25k| (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0)); ------------------ | Branch (6782:14): [True: 0, False: 2.25k] ------------------ 6783| 2.25k| read_buf_avail -= in_buf_size; 6784| 2.25k| read_buf_ofs += in_buf_size; 6785| 2.25k| out_buf_ofs += out_buf_size; 6786| 2.25k| } while (status == TINFL_STATUS_NEEDS_MORE_INPUT); ------------------ | Branch (6786:12): [True: 0, False: 2.25k] ------------------ 6787| | 6788| 2.25k| if (status == TINFL_STATUS_DONE) { ------------------ | Branch (6788:7): [True: 2.25k, False: 0] ------------------ 6789| | /* Make sure the entire file was decompressed, and check its CRC. */ 6790| 2.25k| if (out_buf_ofs != file_stat.m_uncomp_size) { ------------------ | Branch (6790:9): [True: 0, False: 2.25k] ------------------ 6791| 0| mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); 6792| 0| status = TINFL_STATUS_FAILED; 6793| 0| } 6794| 2.25k|#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 6795| 2.25k| else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, ------------------ | | 300| 2.25k|#define MZ_CRC32_INIT (0) ------------------ | Branch (6795:14): [True: 0, False: 2.25k] ------------------ 6796| 2.25k| (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) { 6797| 0| mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED); 6798| 0| status = TINFL_STATUS_FAILED; 6799| 0| } 6800| 2.25k|#endif 6801| 2.25k| } 6802| | 6803| 2.25k| if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf)) ------------------ | Branch (6803:7): [True: 0, False: 2.25k] | Branch (6803:36): [True: 0, False: 0] ------------------ 6804| 0| pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); 6805| | 6806| 2.25k| return status == TINFL_STATUS_DONE; 6807| 2.25k|} zip.c:mz_zip_file_stat_internal: 6368| 4.51k| mz_bool *pFound_zip64_extra_data) { 6369| 4.51k| mz_uint n; 6370| 4.51k| const mz_uint8 *p = pCentral_dir_header; 6371| | 6372| 4.51k| if (pFound_zip64_extra_data) ------------------ | Branch (6372:7): [True: 0, False: 4.51k] ------------------ 6373| 0| *pFound_zip64_extra_data = MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 6374| | 6375| 4.51k| if ((!p) || (!pStat)) ------------------ | Branch (6375:7): [True: 0, False: 4.51k] | Branch (6375:15): [True: 0, False: 4.51k] ------------------ 6376| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 6377| | 6378| | /* Extract fields from the central directory record. */ 6379| 4.51k| pStat->m_file_index = file_index; 6380| 4.51k| pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT( ------------------ | | 5354| 4.51k| ((element_type *)((array_ptr)->m_p))[index] ------------------ 6381| 4.51k| &pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index); 6382| 4.51k| pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6383| 4.51k| pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6384| 4.51k| pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6385| 4.51k| pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6386| 4.51k|#ifndef MINIZ_NO_TIME 6387| 4.51k| pStat->m_time = 6388| 4.51k| mz_zip_dos_to_time_t(MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_TIME_OFS), ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6389| 4.51k| MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_DATE_OFS)); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6390| 4.51k|#endif 6391| 4.51k| pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS); ------------------ | | 772| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 6392| 4.51k| pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); ------------------ | | 772| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 6393| 4.51k| pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); ------------------ | | 772| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 6394| 4.51k| pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6395| 4.51k| pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS); ------------------ | | 772| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 6396| 4.51k| pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS); ------------------ | | 772| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 773| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | 774| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | 775| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 6397| | 6398| | /* Copy as much of the filename and comment as possible. */ 6399| 4.51k| n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6400| 4.51k| n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1); ------------------ | | 759| 4.51k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 4.51k, False: 0] | | ------------------ ------------------ 6401| 4.51k| memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n); 6402| 4.51k| pStat->m_filename[n] = '\0'; 6403| | 6404| 4.51k| n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS); ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6405| 4.51k| n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1); ------------------ | | 759| 4.51k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 4.51k, False: 0] | | ------------------ ------------------ 6406| 4.51k| pStat->m_comment_size = n; 6407| 4.51k| memcpy(pStat->m_comment, 6408| 4.51k| p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + 6409| 4.51k| MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6410| 4.51k| MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS), ------------------ | | 769| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 4.51k| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6411| 4.51k| n); 6412| 4.51k| pStat->m_comment[n] = '\0'; 6413| | 6414| | /* Set some flags for convienance */ 6415| 4.51k| pStat->m_is_directory = mz_zip_reader_is_file_a_directory(pZip, file_index); 6416| 4.51k| pStat->m_is_encrypted = mz_zip_reader_is_file_encrypted(pZip, file_index); 6417| 4.51k| pStat->m_is_supported = mz_zip_reader_is_file_supported(pZip, file_index); 6418| | 6419| | /* See if we need to read any zip64 extended information fields. */ 6420| | /* Confusingly, these zip64 fields can be present even on non-zip64 archives 6421| | * (Debian zip on a huge files from stdin piped to stdout creates them). */ 6422| 4.51k| if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size), ------------------ | | 758| 9.03k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 4.51k, False: 0] | | | Branch (758:25): [True: 1.30k, False: 3.21k] | | | Branch (758:38): [True: 1.30k, False: 3.21k] | | ------------------ ------------------ | Branch (6422:7): [True: 0, False: 4.51k] ------------------ 6423| 4.51k| pStat->m_local_header_ofs) == MZ_UINT32_MAX) { ------------------ | | 794| 4.51k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ 6424| | /* Attempt to find zip64 extended information field in the entry's extra 6425| | * data */ 6426| 0| mz_uint32 extra_size_remaining = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6427| | 6428| 0| if (extra_size_remaining) { ------------------ | Branch (6428:9): [True: 0, False: 0] ------------------ 6429| 0| const mz_uint8 *pExtra_data = 6430| 0| p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + 6431| 0| MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6432| | 6433| 0| do { 6434| 0| mz_uint32 field_id; 6435| 0| mz_uint32 field_data_size; 6436| | 6437| 0| if (extra_size_remaining < (sizeof(mz_uint16) * 2)) ------------------ | Branch (6437:13): [True: 0, False: 0] ------------------ 6438| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6439| | 6440| 0| field_id = MZ_READ_LE16(pExtra_data); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6441| 0| field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); ------------------ | | 769| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | 770| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) ------------------ 6442| | 6443| 0| if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining) ------------------ | Branch (6443:13): [True: 0, False: 0] ------------------ 6444| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6445| | 6446| 0| if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { ------------------ | Branch (6446:13): [True: 0, False: 0] ------------------ 6447| 0| const mz_uint8 *pField_data = pExtra_data + sizeof(mz_uint16) * 2; 6448| 0| mz_uint32 field_data_remaining = field_data_size; 6449| | 6450| 0| if (pFound_zip64_extra_data) ------------------ | Branch (6450:15): [True: 0, False: 0] ------------------ 6451| 0| *pFound_zip64_extra_data = MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 6452| | 6453| 0| if (pStat->m_uncomp_size == MZ_UINT32_MAX) { ------------------ | | 794| 0|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (6453:15): [True: 0, False: 0] ------------------ 6454| 0| if (field_data_remaining < sizeof(mz_uint64)) ------------------ | Branch (6454:17): [True: 0, False: 0] ------------------ 6455| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6456| | 6457| 0| pStat->m_uncomp_size = MZ_READ_LE64(pField_data); ------------------ | | 779| 0| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 0| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 0| << 32U)) ------------------ 6458| 0| pField_data += sizeof(mz_uint64); 6459| 0| field_data_remaining -= sizeof(mz_uint64); 6460| 0| } 6461| | 6462| 0| if (pStat->m_comp_size == MZ_UINT32_MAX) { ------------------ | | 794| 0|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (6462:15): [True: 0, False: 0] ------------------ 6463| 0| if (field_data_remaining < sizeof(mz_uint64)) ------------------ | Branch (6463:17): [True: 0, False: 0] ------------------ 6464| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6465| | 6466| 0| pStat->m_comp_size = MZ_READ_LE64(pField_data); ------------------ | | 779| 0| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 0| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 0| << 32U)) ------------------ 6467| 0| pField_data += sizeof(mz_uint64); 6468| 0| field_data_remaining -= sizeof(mz_uint64); 6469| 0| } 6470| | 6471| 0| if (pStat->m_local_header_ofs == MZ_UINT32_MAX) { ------------------ | | 794| 0|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (6471:15): [True: 0, False: 0] ------------------ 6472| 0| if (field_data_remaining < sizeof(mz_uint64)) ------------------ | Branch (6472:17): [True: 0, False: 0] ------------------ 6473| 0| return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); 6474| | 6475| 0| pStat->m_local_header_ofs = MZ_READ_LE64(pField_data); ------------------ | | 779| 0| (((mz_uint64)MZ_READ_LE32(p)) | \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 780| 0| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ | | ------------------ | | | | 772| 0| ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ | | | | 773| 0| ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ | | | | 774| 0| ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ | | | | 775| 0| ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) | | ------------------ | | 781| 0| << 32U)) ------------------ 6476| 0| pField_data += sizeof(mz_uint64); 6477| 0| field_data_remaining -= sizeof(mz_uint64); 6478| 0| } 6479| | 6480| 0| break; 6481| 0| } 6482| | 6483| 0| pExtra_data += sizeof(mz_uint16) * 2 + field_data_size; 6484| 0| extra_size_remaining = 6485| 0| extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; 6486| 0| } while (extra_size_remaining); ------------------ | Branch (6486:16): [True: 0, False: 0] ------------------ 6487| 0| } 6488| 0| } 6489| | 6490| 4.51k| return MZ_TRUE; ------------------ | | 719| 4.51k|#define MZ_TRUE (1) ------------------ 6491| 4.51k|} zip.c:mz_zip_dos_to_time_t: 5434| 4.51k|static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date) { 5435| 4.51k| struct tm tm; 5436| 4.51k| memset(&tm, 0, sizeof(tm)); 5437| 4.51k| tm.tm_isdst = -1; 5438| 4.51k| tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900; 5439| 4.51k| tm.tm_mon = ((dos_date >> 5) & 15) - 1; 5440| 4.51k| tm.tm_mday = dos_date & 31; 5441| 4.51k| tm.tm_hour = (dos_time >> 11) & 31; 5442| 4.51k| tm.tm_min = (dos_time >> 5) & 63; 5443| 4.51k| tm.tm_sec = (dos_time << 1) & 62; 5444| 4.51k| return mktime(&tm); 5445| 4.51k|} zip.c:mz_zip_array_resize: 5405| 20.3k| mz_uint growing) { 5406| 20.3k| if (new_size > pArray->m_capacity) { ------------------ | Branch (5406:7): [True: 11.2k, False: 9.03k] ------------------ 5407| 11.2k| if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) ------------------ | Branch (5407:9): [True: 0, False: 11.2k] ------------------ 5408| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 5409| 11.2k| } 5410| 20.3k| pArray->m_size = new_size; 5411| 20.3k| return MZ_TRUE; ------------------ | | 719| 20.3k|#define MZ_TRUE (1) ------------------ 5412| 20.3k|} zip.c:mz_zip_array_ensure_capacity: 5372| 11.2k| mz_uint growing) { 5373| 11.2k| void *pNew_p; 5374| 11.2k| size_t new_capacity = min_new_capacity; 5375| 11.2k| MZ_ASSERT(pArray->m_element_size); ------------------ | | 746| 11.2k|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (5375:3): [True: 0, False: 11.2k] | Branch (5375:3): [True: 11.2k, False: 0] ------------------ 5376| 11.2k| if (pArray->m_capacity >= min_new_capacity) ------------------ | Branch (5376:7): [True: 0, False: 11.2k] ------------------ 5377| 0| return MZ_TRUE; ------------------ | | 719| 0|#define MZ_TRUE (1) ------------------ 5378| 11.2k| if (growing) { ------------------ | Branch (5378:7): [True: 4.51k, False: 6.77k] ------------------ 5379| 4.51k| new_capacity = MZ_MAX(1, pArray->m_capacity); ------------------ | | 758| 4.51k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 4.51k, False: 0] | | ------------------ ------------------ 5380| 18.0k| while (new_capacity < min_new_capacity) ------------------ | Branch (5380:12): [True: 13.5k, False: 4.51k] ------------------ 5381| 13.5k| new_capacity *= 2; 5382| 4.51k| } 5383| 11.2k| if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, ------------------ | Branch (5383:7): [True: 0, False: 11.2k] ------------------ 5384| 11.2k| pArray->m_element_size, new_capacity))) 5385| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 5386| 11.2k| pArray->m_p = pNew_p; 5387| 11.2k| pArray->m_capacity = new_capacity; 5388| 11.2k| return MZ_TRUE; ------------------ | | 719| 11.2k|#define MZ_TRUE (1) ------------------ 5389| 11.2k|} zip.c:mz_zip_array_clear: 5364| 13.5k| mz_zip_array *pArray) { 5365| 13.5k| pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p); 5366| 13.5k| memset(pArray, 0, sizeof(mz_zip_array)); 5367| 13.5k|} zip.c:mz_zip_heap_write_func: 7905| 24.5k| const void *pBuf, size_t n) { 7906| 24.5k| mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; 7907| 24.5k| mz_zip_internal_state *pState = pZip->m_pState; 7908| 24.5k| mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size); ------------------ | | 758| 24.5k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 24.5k, False: 0] | | ------------------ ------------------ 7909| | 7910| 24.5k| if (!n) ------------------ | Branch (7910:7): [True: 0, False: 24.5k] ------------------ 7911| 0| return 0; 7912| | 7913| | /* An allocation this big is likely to just fail on 32-bit systems, so don't 7914| | * even go there. */ 7915| 24.5k| if ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF)) { ------------------ | Branch (7915:7): [Folded, False: 24.5k] | Branch (7915:48): [True: 0, False: 0] ------------------ 7916| 0| mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); 7917| 0| return 0; 7918| 0| } 7919| | 7920| 24.5k| if (new_size > pState->m_mem_capacity) { ------------------ | Branch (7920:7): [True: 2.27k, False: 22.2k] ------------------ 7921| 2.27k| void *pNew_block; 7922| 2.27k| size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity); ------------------ | | 758| 2.27k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (758:23): [True: 0, False: 2.27k] | | ------------------ ------------------ 7923| | 7924| 7.48k| while (new_capacity < new_size) ------------------ | Branch (7924:12): [True: 5.20k, False: 2.27k] ------------------ 7925| 5.20k| new_capacity *= 2; 7926| | 7927| 2.27k| if (NULL == (pNew_block = pZip->m_pRealloc( ------------------ | Branch (7927:9): [True: 0, False: 2.27k] ------------------ 7928| 2.27k| pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity))) { 7929| 0| mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 7930| 0| return 0; 7931| 0| } 7932| | 7933| 2.27k| pState->m_pMem = pNew_block; 7934| 2.27k| pState->m_mem_capacity = new_capacity; 7935| 2.27k| } 7936| 24.5k| memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n); 7937| 24.5k| pState->m_mem_size = (size_t)new_size; 7938| 24.5k| return n; 7939| 24.5k|} zip.c:mz_zip_writer_end_internal: 7942| 4.51k| mz_bool set_last_error) { 7943| 4.51k| mz_zip_internal_state *pState; 7944| 4.51k| mz_bool status = MZ_TRUE; ------------------ | | 719| 4.51k|#define MZ_TRUE (1) ------------------ 7945| | 7946| 4.51k| if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ------------------ | Branch (7946:7): [True: 0, False: 4.51k] | Branch (7946:18): [True: 0, False: 4.51k] | Branch (7946:39): [True: 0, False: 4.51k] | Branch (7946:60): [True: 0, False: 4.51k] ------------------ 7947| 4.51k| ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && ------------------ | Branch (7947:8): [True: 4.51k, False: 0] ------------------ 7948| 4.51k| (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) { ------------------ | Branch (7948:8): [True: 2.25k, False: 2.25k] ------------------ 7949| 2.25k| if (set_last_error) ------------------ | Branch (7949:9): [True: 2.25k, False: 0] ------------------ 7950| 2.25k| mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); 7951| 2.25k| return MZ_FALSE; ------------------ | | 718| 2.25k|#define MZ_FALSE (0) ------------------ 7952| 2.25k| } 7953| | 7954| 2.25k| pState = pZip->m_pState; 7955| 2.25k| pZip->m_pState = NULL; 7956| 2.25k| mz_zip_array_clear(pZip, &pState->m_central_dir); 7957| 2.25k| mz_zip_array_clear(pZip, &pState->m_central_dir_offsets); 7958| 2.25k| mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets); 7959| | 7960| 2.25k|#ifndef MINIZ_NO_STDIO 7961| 2.25k| if (pState->m_pFile) { ------------------ | Branch (7961:7): [True: 0, False: 2.25k] ------------------ 7962| 0| if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) { ------------------ | Branch (7962:9): [True: 0, False: 0] ------------------ 7963| 0| if (MZ_FCLOSE(pState->m_pFile) == EOF) { ------------------ | | 5172| 0|#define MZ_FCLOSE fclose ------------------ | Branch (7963:11): [True: 0, False: 0] ------------------ 7964| 0| if (set_last_error) ------------------ | Branch (7964:13): [True: 0, False: 0] ------------------ 7965| 0| mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); 7966| 0| status = MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 7967| 0| } 7968| 0| } 7969| | 7970| 0| pState->m_pFile = NULL; 7971| 0| } 7972| 2.25k|#endif /* #ifndef MINIZ_NO_STDIO */ 7973| | 7974| 2.25k| if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem)) { ------------------ | Branch (7974:7): [True: 2.25k, False: 0] | Branch (7974:53): [True: 2.25k, False: 0] ------------------ 7975| 2.25k| pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem); 7976| 2.25k| pState->m_pMem = NULL; 7977| 2.25k| } 7978| | 7979| 2.25k| pZip->m_pFree(pZip->m_pAlloc_opaque, pState); 7980| 2.25k| pZip->m_zip_mode = MZ_ZIP_MODE_INVALID; 7981| 2.25k| return status; 7982| 4.51k|} zip.c:mz_zip_time_t_to_dos_time: 5449| 4.51k| mz_uint16 *pDOS_date) { 5450| |#ifdef _MSC_VER 5451| | struct tm tm_struct; 5452| | struct tm *tm = &tm_struct; 5453| | errno_t err = localtime_s(tm, &time); 5454| | if (err) { 5455| | *pDOS_date = 0; 5456| | *pDOS_time = 0; 5457| | return; 5458| | } 5459| |#else 5460| 4.51k| struct tm *tm = localtime(&time); 5461| 4.51k|#endif /* #ifdef _MSC_VER */ 5462| | 5463| 4.51k| *pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + 5464| 4.51k| ((tm->tm_sec) >> 1)); 5465| 4.51k| *pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + 5466| 4.51k| ((tm->tm_mon + 1) << 5) + tm->tm_mday); 5467| 4.51k|} zip.c:mz_zip_writer_compute_padding_needed_for_file_alignment: 8452| 2.25k|mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip) { 8453| 2.25k| mz_uint32 n; 8454| 2.25k| if (!pZip->m_file_offset_alignment) ------------------ | Branch (8454:7): [True: 2.25k, False: 0] ------------------ 8455| 2.25k| return 0; 8456| 0| n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1)); 8457| 0| return (mz_uint)((pZip->m_file_offset_alignment - n) & 8458| 0| (pZip->m_file_offset_alignment - 1)); 8459| 2.25k|} zip.c:mz_zip_writer_write_zeros: 8462| 2.25k| mz_uint64 cur_file_ofs, mz_uint32 n) { 8463| 2.25k| char buf[4096]; 8464| 2.25k| memset(buf, 0, MZ_MIN(sizeof(buf), n)); ------------------ | | 759| 2.25k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 2.25k] | | ------------------ ------------------ 8465| 2.25k| while (n) { ------------------ | Branch (8465:10): [True: 0, False: 2.25k] ------------------ 8466| 0| mz_uint32 s = MZ_MIN(sizeof(buf), n); ------------------ | | 759| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (759:23): [True: 0, False: 0] | | ------------------ ------------------ 8467| 0| if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s) ------------------ | Branch (8467:9): [True: 0, False: 0] ------------------ 8468| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); 8469| | 8470| 0| cur_file_ofs += s; 8471| 0| n -= s; 8472| 0| } 8473| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 8474| 2.25k|} zip.c:mz_zip_writer_create_zip64_extra_data: 8301| 4.51k| mz_uint64 *pLocal_header_ofs) { 8302| 4.51k| mz_uint8 *pDst = pBuf; 8303| 4.51k| mz_uint32 field_size = 0; 8304| | 8305| 4.51k| MZ_WRITE_LE16(pDst + 0, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID); ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8306| 4.51k| MZ_WRITE_LE16(pDst + 2, 0); ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8307| 4.51k| pDst += sizeof(mz_uint16) * 2; 8308| | 8309| 4.51k| if (pUncomp_size) { ------------------ | Branch (8309:7): [True: 0, False: 4.51k] ------------------ 8310| 0| MZ_WRITE_LE64(pDst, *pUncomp_size); ------------------ | | 7902| 0|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 8311| 0| pDst += sizeof(mz_uint64); 8312| 0| field_size += sizeof(mz_uint64); 8313| 0| } 8314| | 8315| 4.51k| if (pComp_size) { ------------------ | Branch (8315:7): [True: 0, False: 4.51k] ------------------ 8316| 0| MZ_WRITE_LE64(pDst, *pComp_size); ------------------ | | 7902| 0|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 8317| 0| pDst += sizeof(mz_uint64); 8318| 0| field_size += sizeof(mz_uint64); 8319| 0| } 8320| | 8321| 4.51k| if (pLocal_header_ofs) { ------------------ | Branch (8321:7): [True: 0, False: 4.51k] ------------------ 8322| 0| MZ_WRITE_LE64(pDst, *pLocal_header_ofs); ------------------ | | 7902| 0|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 8323| 0| pDst += sizeof(mz_uint64); 8324| 0| field_size += sizeof(mz_uint64); 8325| 0| } 8326| | 8327| 4.51k| MZ_WRITE_LE16(pBuf + 2, field_size); ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8328| | 8329| 4.51k| return (mz_uint32)(pDst - pBuf); 8330| 4.51k|} zip.c:mz_zip_writer_create_local_dir_header: 8336| 2.25k| mz_uint16 dos_time, mz_uint16 dos_date) { 8337| 2.25k| (void)pZip; 8338| 2.25k| memset(pDst, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE); 8339| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_SIG_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 8340| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0); ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) | | ------------------ | | | Branch (7900:72): [True: 2.25k, False: 0] | | ------------------ ------------------ 8341| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_BIT_FLAG_OFS, bit_flags); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8342| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_METHOD_OFS, method); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8343| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_TIME_OFS, dos_time); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8344| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_DATE_OFS, dos_date); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8345| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_CRC32_OFS, uncomp_crc32); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 8346| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, ------------------ | | 7901| 4.51k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 2.25k, False: 0] | | ------------------ ------------------ 8347| 2.25k| MZ_MIN(comp_size, MZ_UINT32_MAX)); 8348| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, ------------------ | | 7901| 4.51k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 2.25k, False: 0] | | ------------------ ------------------ 8349| 2.25k| MZ_MIN(uncomp_size, MZ_UINT32_MAX)); 8350| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILENAME_LEN_OFS, filename_size); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8351| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_EXTRA_LEN_OFS, extra_size); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8352| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 8353| 2.25k|} zip.c:mz_zip_writer_add_put_buf_callback: 8282| 6.47k| void *pUser) { 8283| 6.47k| mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser; 8284| 6.47k| if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, ------------------ | Branch (8284:7): [True: 0, False: 6.47k] ------------------ 8285| 6.47k| pState->m_cur_archive_file_ofs, pBuf, 8286| 6.47k| len) != len) 8287| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 8288| | 8289| 6.47k| pState->m_cur_archive_file_ofs += len; 8290| 6.47k| pState->m_comp_size += len; 8291| 6.47k| return MZ_TRUE; ------------------ | | 719| 6.47k|#define MZ_TRUE (1) ------------------ 8292| 6.47k|} zip.c:mz_write_le32: 7889| 76.8k|static MZ_FORCEINLINE void mz_write_le32(mz_uint8 *p, mz_uint32 v) { 7890| 76.8k| p[0] = (mz_uint8)v; 7891| 76.8k| p[1] = (mz_uint8)(v >> 8); 7892| 76.8k| p[2] = (mz_uint8)(v >> 16); 7893| 76.8k| p[3] = (mz_uint8)(v >> 24); 7894| 76.8k|} zip.c:mz_write_le64: 7895| 18.0k|static MZ_FORCEINLINE void mz_write_le64(mz_uint8 *p, mz_uint64 v) { 7896| 18.0k| mz_write_le32(p, (mz_uint32)v); 7897| 18.0k| mz_write_le32(p + sizeof(mz_uint32), (mz_uint32)(v >> 32)); 7898| 18.0k|} zip.c:mz_zip_writer_add_to_central_dir: 8392| 2.25k| mz_uint user_extra_data_len) { 8393| 2.25k| mz_zip_internal_state *pState = pZip->m_pState; 8394| 2.25k| mz_uint32 central_dir_ofs = (mz_uint32)pState->m_central_dir.m_size; 8395| 2.25k| size_t orig_central_dir_size = pState->m_central_dir.m_size; 8396| 2.25k| mz_uint8 central_dir_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE]; 8397| | 8398| 2.25k| if (!pZip->m_pState->m_zip64) { ------------------ | Branch (8398:7): [True: 0, False: 2.25k] ------------------ 8399| 0| if (local_header_ofs > 0xFFFFFFFF) ------------------ | Branch (8399:9): [True: 0, False: 0] ------------------ 8400| 0| return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); 8401| 0| } 8402| | 8403| | /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */ 8404| 2.25k| if (((mz_uint64)pState->m_central_dir.m_size + ------------------ | Branch (8404:7): [True: 0, False: 2.25k] ------------------ 8405| 2.25k| MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + extra_size + 8406| 2.25k| user_extra_data_len + comment_size) >= MZ_UINT32_MAX) ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ 8407| 0| return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); 8408| | 8409| 2.25k| if (!mz_zip_writer_create_central_dir_header( ------------------ | Branch (8409:7): [True: 0, False: 2.25k] ------------------ 8410| 2.25k| pZip, central_dir_header, filename_size, 8411| 2.25k| (mz_uint16)(extra_size + user_extra_data_len), comment_size, 8412| 2.25k| uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, 8413| 2.25k| dos_date, local_header_ofs, ext_attributes)) 8414| 0| return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); 8415| | 8416| 2.25k| if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, ------------------ | Branch (8416:7): [True: 0, False: 2.25k] ------------------ 8417| 2.25k| MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) || 8418| 2.25k| (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, ------------------ | Branch (8418:7): [True: 0, False: 2.25k] ------------------ 8419| 2.25k| filename_size)) || 8420| 2.25k| (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, ------------------ | Branch (8420:7): [True: 0, False: 2.25k] ------------------ 8421| 2.25k| extra_size)) || 8422| 2.25k| (!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, ------------------ | Branch (8422:7): [True: 0, False: 2.25k] ------------------ 8423| 2.25k| user_extra_data_len)) || 8424| 2.25k| (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, ------------------ | Branch (8424:7): [True: 0, False: 2.25k] ------------------ 8425| 2.25k| comment_size)) || 8426| 2.25k| (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, ------------------ | Branch (8426:7): [True: 0, False: 2.25k] ------------------ 8427| 2.25k| ¢ral_dir_ofs, 1))) { 8428| | /* Try to resize the central directory array back into its original state. 8429| | */ 8430| 0| mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, 8431| 0| MZ_FALSE); ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 8432| 0| return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); 8433| 0| } 8434| | 8435| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 8436| 2.25k|} zip.c:mz_zip_writer_create_central_dir_header: 8360| 2.25k| mz_uint64 local_header_ofs, mz_uint32 ext_attributes) { 8361| 2.25k| (void)pZip; 8362| 2.25k| memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE); 8363| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 8364| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_MADE_BY_OFS, ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) | | ------------------ | | | Branch (7900:72): [True: 0, False: 2.25k] | | ------------------ ------------------ 8365| 2.25k| (ext_attributes >> 16) ? 0x0314 : 0x0014); 8366| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0); ------------------ | | 7900| 4.51k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) | | ------------------ | | | Branch (7900:72): [True: 2.25k, False: 0] | | ------------------ ------------------ 8367| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8368| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8369| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_TIME_OFS, dos_time); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8370| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_DATE_OFS, dos_date); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8371| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_CRC32_OFS, uncomp_crc32); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 8372| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, ------------------ | | 7901| 4.51k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 2.25k, False: 0] | | ------------------ ------------------ 8373| 2.25k| MZ_MIN(comp_size, MZ_UINT32_MAX)); 8374| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, ------------------ | | 7901| 4.51k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 2.25k, False: 0] | | ------------------ ------------------ 8375| 2.25k| MZ_MIN(uncomp_size, MZ_UINT32_MAX)); 8376| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILENAME_LEN_OFS, filename_size); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8377| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_EXTRA_LEN_OFS, extra_size); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8378| 2.25k| MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_COMMENT_LEN_OFS, comment_size); ------------------ | | 7900| 2.25k|#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) ------------------ 8379| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, ext_attributes); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 8380| 2.25k| MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, ------------------ | | 7901| 4.51k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 2.25k, False: 0] | | ------------------ ------------------ 8381| 2.25k| MZ_MIN(local_header_ofs, MZ_UINT32_MAX)); 8382| 2.25k| return MZ_TRUE; ------------------ | | 719| 2.25k|#define MZ_TRUE (1) ------------------ 8383| 2.25k|} zip.c:mz_write_le16: 7885| 58.7k|static MZ_FORCEINLINE void mz_write_le16(mz_uint8 *p, mz_uint16 v) { 7886| 58.7k| p[0] = (mz_uint8)v; 7887| 58.7k| p[1] = (mz_uint8)(v >> 8); 7888| 58.7k|} zip.c:mz_zip_array_push_back: 5423| 13.5k| size_t n) { 5424| 13.5k| size_t orig_size = pArray->m_size; 5425| 13.5k| if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) ------------------ | | 719| 13.5k|#define MZ_TRUE (1) ------------------ | Branch (5425:7): [True: 0, False: 13.5k] ------------------ 5426| 0| return MZ_FALSE; ------------------ | | 718| 0|#define MZ_FALSE (0) ------------------ 5427| 13.5k| if (n > 0) ------------------ | Branch (5427:7): [True: 9.03k, False: 4.51k] ------------------ 5428| 9.03k| memcpy((mz_uint8 *)pArray->m_p + orig_size * pArray->m_element_size, 5429| 9.03k| pElements, n * pArray->m_element_size); 5430| 13.5k| return MZ_TRUE; ------------------ | | 719| 13.5k|#define MZ_TRUE (1) ------------------ 5431| 13.5k|} zip_entry_open: 1704| 4.51k|int zip_entry_open(struct zip_t *zip, const char *entryname) { 1705| 4.51k| return _zip_entry_open(zip, entryname, 0); 1706| 4.51k|} zip_entry_close: 1775| 4.51k|int zip_entry_close(struct zip_t *zip) { 1776| 4.51k| mz_zip_archive *pzip = NULL; 1777| 4.51k| int err = 0; 1778| 4.51k|#if ZIP_ENABLE_DEFLATE 1779| 4.51k| mz_uint level; 1780| 4.51k| tdefl_status done; 1781| 4.51k| mz_uint16 entrylen; 1782| 4.51k| mz_uint16 dos_time = 0, dos_date = 0; 1783| 4.51k| mz_uint8 *pExtra_data = NULL; 1784| 4.51k| mz_uint32 extra_size = 0; 1785| 4.51k| mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE]; 1786| 4.51k| mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64]; 1787| 4.51k| mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64; 1788| 4.51k|#endif 1789| | 1790| 4.51k| if (!zip) { ------------------ | Branch (1790:7): [True: 0, False: 4.51k] ------------------ 1791| | // zip_t handler is not initialized 1792| 0| err = ZIP_ENOINIT; ------------------ | | 93| 0|#define ZIP_ENOINIT -1 // not initialized ------------------ 1793| 0| goto cleanup; 1794| 0| } 1795| | 1796| 4.51k| pzip = &(zip->archive); 1797| 4.51k| if (pzip->m_zip_mode == MZ_ZIP_MODE_READING) { ------------------ | Branch (1797:7): [True: 2.25k, False: 2.25k] ------------------ 1798| 2.25k| goto cleanup; 1799| 2.25k| } 1800| | 1801| |#if !ZIP_ENABLE_DEFLATE 1802| | (void)pzip; 1803| | err = ZIP_EINVMODE; 1804| | goto cleanup; 1805| |#else 1806| 2.25k| level = zip->level & 0xF; 1807| 2.25k| if (level) { ------------------ | Branch (1807:7): [True: 2.25k, False: 0] ------------------ 1808| 2.25k| done = tdefl_compress_buffer(&(zip->entry.comp), "", 0, TDEFL_FINISH); 1809| 2.25k| if (done != TDEFL_STATUS_DONE && done != TDEFL_STATUS_OKAY) { ------------------ | Branch (1809:9): [True: 0, False: 2.25k] | Branch (1809:38): [True: 0, False: 0] ------------------ 1810| 0| err = ZIP_ETDEFLBUF; ------------------ | | 104| 0|#define ZIP_ETDEFLBUF -12 // cannot flush tdefl buffer ------------------ 1811| 0| goto cleanup; 1812| 0| } 1813| 2.25k| zip->entry.comp_size = zip->entry.state.m_comp_size; 1814| 2.25k| if (zip->password) { ------------------ | Branch (1814:9): [True: 0, False: 2.25k] ------------------ 1815| 0| zip->entry.comp_size += ZIP_PKWARE_ENCRYPT_HEADER_SIZE; ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1816| 0| } 1817| 2.25k| zip->entry.dir_offset = zip->entry.state.m_cur_archive_file_ofs; 1818| 2.25k| zip->entry.method = MZ_DEFLATED; ------------------ | | 316| 2.25k|#define MZ_DEFLATED 8 ------------------ 1819| 2.25k| } 1820| | 1821| 2.25k| entrylen = (mz_uint16)strlen(zip->entry.name); 1822| 2.25k|#ifndef MINIZ_NO_TIME 1823| 2.25k| mz_zip_time_t_to_dos_time(zip->entry.m_time, &dos_time, &dos_date); 1824| 2.25k|#endif 1825| | 1826| 2.25k| if (zip->password && zip->entry.enc_header_ofs > 0) { ------------------ | Branch (1826:7): [True: 0, False: 2.25k] | Branch (1826:24): [True: 0, False: 0] ------------------ 1827| 0| struct zip_pkware_keys_t fix_keys, orig_keys; 1828| 0| mz_uint8 enc_header[ZIP_PKWARE_ENCRYPT_HEADER_SIZE]; 1829| 0| mz_uint8 check_byte = (mz_uint8)(zip->entry.uncomp_crc32 >> 24); 1830| 0| mz_uint64 data_ofs, data_size; 1831| 0| mz_zip_internal_state *pState = pzip->m_pState; 1832| 0| size_t i; 1833| | 1834| 0| MZ_WRITE_LE32(zip->entry.header + MZ_ZIP_LDH_CRC32_OFS, ------------------ | | 7901| 0|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 1835| 0| zip->entry.uncomp_crc32); 1836| 0| MZ_WRITE_LE32(zip->entry.header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, ------------------ | | 7901| 0|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 0, False: 0] | | ------------------ ------------------ 1837| 0| MZ_MIN(zip->entry.comp_size, MZ_UINT32_MAX)); 1838| 0| MZ_WRITE_LE32(zip->entry.header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, ------------------ | | 7901| 0|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) | | ------------------ | | | Branch (7901:72): [True: 0, False: 0] | | ------------------ ------------------ 1839| 0| MZ_MIN(zip->entry.uncomp_size, MZ_UINT32_MAX)); 1840| 0| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.header_offset, ------------------ | Branch (1840:9): [True: 0, False: 0] ------------------ 1841| 0| zip->entry.header, sizeof(zip->entry.header)) != 1842| 0| sizeof(zip->entry.header)) { 1843| 0| err = ZIP_EWRTHDR; ------------------ | | 106| 0|#define ZIP_EWRTHDR -14 // cannot write entry header ------------------ 1844| 0| goto cleanup; 1845| 0| } 1846| | 1847| 0| zip_pkware_keys_init_password(&fix_keys, zip->password); 1848| 0| zip_pkware_keys_init_password(&orig_keys, zip->password); 1849| | 1850| 0| if (pState->m_pFile) { ------------------ | Branch (1850:9): [True: 0, False: 0] ------------------ 1851| 0|#ifndef MINIZ_NO_STDIO 1852| 0| if (MZ_FSEEK64(pState->m_pFile, (mz_int64)zip->entry.enc_header_ofs, ------------------ | | 5176| 0|#define MZ_FSEEK64 fseeko ------------------ | Branch (1852:11): [True: 0, False: 0] ------------------ 1853| 0| SEEK_SET)) { 1854| 0| err = ZIP_EFSEEK; ------------------ | | 119| 0|#define ZIP_EFSEEK -27 // fseek error ------------------ 1855| 0| goto cleanup; 1856| 0| } 1857| 0| if (fread(enc_header, 1, ZIP_PKWARE_ENCRYPT_HEADER_SIZE, ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ | Branch (1857:11): [True: 0, False: 0] ------------------ 1858| 0| pState->m_pFile) != ZIP_PKWARE_ENCRYPT_HEADER_SIZE) { ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1859| 0| err = ZIP_EFREAD; ------------------ | | 120| 0|#define ZIP_EFREAD -28 // fread error ------------------ 1860| 0| goto cleanup; 1861| 0| } 1862| |#else 1863| | err = ZIP_ENOFILE; 1864| | goto cleanup; 1865| |#endif /* MINIZ_NO_STDIO */ 1866| 0| } else if (pState->m_pMem) { ------------------ | Branch (1866:16): [True: 0, False: 0] ------------------ 1867| 0| memcpy(enc_header, 1868| 0| (const mz_uint8 *)pState->m_pMem + zip->entry.enc_header_ofs, 1869| 0| ZIP_PKWARE_ENCRYPT_HEADER_SIZE); ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1870| 0| } else { 1871| 0| err = ZIP_EFREAD; ------------------ | | 120| 0|#define ZIP_EFREAD -28 // fread error ------------------ 1872| 0| goto cleanup; 1873| 0| } 1874| | 1875| 0| for (i = 0; i < ZIP_PKWARE_ENCRYPT_HEADER_SIZE; i++) { ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ | Branch (1875:17): [True: 0, False: 0] ------------------ 1876| 0| mz_uint8 plain = zip_pkware_decrypt(&orig_keys, enc_header[i]); 1877| 0| if (i == ZIP_PKWARE_ENCRYPT_HEADER_SIZE - 1) { ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ | Branch (1877:11): [True: 0, False: 0] ------------------ 1878| 0| enc_header[i] = zip_pkware_encrypt_byte(&fix_keys, check_byte); 1879| 0| } else { 1880| 0| enc_header[i] = zip_pkware_encrypt_byte(&fix_keys, plain); 1881| 0| } 1882| 0| } 1883| | 1884| 0| pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.enc_header_ofs, enc_header, 1885| 0| ZIP_PKWARE_ENCRYPT_HEADER_SIZE); ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1886| | 1887| 0| data_ofs = zip->entry.enc_header_ofs + ZIP_PKWARE_ENCRYPT_HEADER_SIZE; ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1888| 0| if (level) { ------------------ | Branch (1888:9): [True: 0, False: 0] ------------------ 1889| 0| data_size = zip->entry.state.m_comp_size; 1890| 0| } else { 1891| 0| data_size = zip->entry.comp_size - ZIP_PKWARE_ENCRYPT_HEADER_SIZE; ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1892| 0| } 1893| | 1894| 0| if (data_size > 0) { ------------------ | Branch (1894:9): [True: 0, False: 0] ------------------ 1895| 0| mz_uint8 re_buf[4096]; 1896| 0| mz_uint64 remaining = data_size; 1897| 0| mz_uint64 ofs = data_ofs; 1898| 0| while (remaining > 0) { ------------------ | Branch (1898:14): [True: 0, False: 0] ------------------ 1899| 0| size_t chunk = 1900| 0| (remaining > sizeof(re_buf)) ? sizeof(re_buf) : (size_t)remaining; ------------------ | Branch (1900:13): [True: 0, False: 0] ------------------ 1901| | 1902| 0| if (pState->m_pFile) { ------------------ | Branch (1902:13): [True: 0, False: 0] ------------------ 1903| 0|#ifndef MINIZ_NO_STDIO 1904| 0| if (MZ_FSEEK64(pState->m_pFile, (mz_int64)ofs, SEEK_SET)) { ------------------ | | 5176| 0|#define MZ_FSEEK64 fseeko ------------------ | Branch (1904:15): [True: 0, False: 0] ------------------ 1905| 0| err = ZIP_EFSEEK; ------------------ | | 119| 0|#define ZIP_EFSEEK -27 // fseek error ------------------ 1906| 0| goto cleanup; 1907| 0| } 1908| 0| if (fread(re_buf, 1, chunk, pState->m_pFile) != chunk) { ------------------ | Branch (1908:15): [True: 0, False: 0] ------------------ 1909| 0| err = ZIP_EFREAD; ------------------ | | 120| 0|#define ZIP_EFREAD -28 // fread error ------------------ 1910| 0| goto cleanup; 1911| 0| } 1912| |#else 1913| | err = ZIP_ENOFILE; 1914| | goto cleanup; 1915| |#endif /* MINIZ_NO_STDIO */ 1916| 0| } else if (pState->m_pMem) { ------------------ | Branch (1916:20): [True: 0, False: 0] ------------------ 1917| 0| memcpy(re_buf, (const mz_uint8 *)pState->m_pMem + ofs, chunk); 1918| 0| } else { 1919| 0| err = ZIP_EFREAD; ------------------ | | 120| 0|#define ZIP_EFREAD -28 // fread error ------------------ 1920| 0| goto cleanup; 1921| 0| } 1922| | 1923| 0| for (i = 0; i < chunk; i++) { ------------------ | Branch (1923:21): [True: 0, False: 0] ------------------ 1924| 0| mz_uint8 plain = zip_pkware_decrypt(&orig_keys, re_buf[i]); 1925| 0| re_buf[i] = zip_pkware_encrypt_byte(&fix_keys, plain); 1926| 0| } 1927| 0| if (pzip->m_pWrite(pzip->m_pIO_opaque, ofs, re_buf, chunk) != chunk) { ------------------ | Branch (1927:13): [True: 0, False: 0] ------------------ 1928| 0| err = ZIP_EFWRITE; ------------------ | | 121| 0|#define ZIP_EFWRITE -29 // fwrite error ------------------ 1929| 0| goto cleanup; 1930| 0| } 1931| 0| ofs += chunk; 1932| 0| remaining -= chunk; 1933| 0| } 1934| 0| } 1935| 2.25k| } else { 1936| 2.25k| MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 1937| 2.25k| MZ_WRITE_LE32(local_dir_footer + 4, zip->entry.uncomp_crc32); ------------------ | | 7901| 2.25k|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) ------------------ 1938| 2.25k| MZ_WRITE_LE64(local_dir_footer + 8, zip->entry.comp_size); ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 1939| 2.25k| MZ_WRITE_LE64(local_dir_footer + 16, zip->entry.uncomp_size); ------------------ | | 7902| 2.25k|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) ------------------ 1940| | 1941| 2.25k| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, ------------------ | Branch (1941:9): [True: 0, False: 2.25k] ------------------ 1942| 2.25k| local_dir_footer, 1943| 2.25k| local_dir_footer_size) != local_dir_footer_size) { 1944| 0| err = ZIP_EWRTHDR; ------------------ | | 106| 0|#define ZIP_EWRTHDR -14 // cannot write entry header ------------------ 1945| 0| goto cleanup; 1946| 0| } 1947| 2.25k| zip->entry.dir_offset += local_dir_footer_size; 1948| 2.25k| } 1949| | 1950| 2.25k| pExtra_data = extra_data; 1951| 2.25k| extra_size = mz_zip_writer_create_zip64_extra_data( 1952| 2.25k| extra_data, 1953| 2.25k| (zip->entry.uncomp_size >= MZ_UINT32_MAX) ? &zip->entry.uncomp_size ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (1953:7): [True: 0, False: 2.25k] ------------------ 1954| 2.25k| : NULL, 1955| 2.25k| (zip->entry.comp_size >= MZ_UINT32_MAX) ? &zip->entry.comp_size : NULL, ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (1955:7): [True: 0, False: 2.25k] ------------------ 1956| 2.25k| (zip->entry.header_offset >= MZ_UINT32_MAX) ? &zip->entry.header_offset ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (1956:7): [True: 0, False: 2.25k] ------------------ 1957| 2.25k| : NULL); 1958| | 1959| 2.25k| if ((entrylen) && ISSLASH(zip->entry.name[entrylen - 1]) && ------------------ | | 65| 4.51k|#define ISSLASH(C) ((C) == '/' || (C) == '\\') | | ------------------ | | | Branch (65:21): [True: 0, False: 2.25k] | | | Branch (65:35): [True: 0, False: 2.25k] | | ------------------ ------------------ | Branch (1959:7): [True: 2.25k, False: 0] ------------------ 1960| 0| !zip->entry.uncomp_size) { ------------------ | Branch (1960:7): [True: 0, False: 0] ------------------ 1961| | /* Set DOS Subdirectory attribute bit. */ 1962| 0| zip->entry.external_attr |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG; 1963| 0| } 1964| | 1965| 2.25k| { 1966| 2.25k| mz_uint16 gen_flags = MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8; 1967| 2.25k| if (zip->password) { ------------------ | Branch (1967:9): [True: 0, False: 2.25k] ------------------ 1968| 0| gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED; 1969| 2.25k| } else { 1970| 2.25k| gen_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR; 1971| 2.25k| } 1972| | 1973| 2.25k| if (!mz_zip_writer_add_to_central_dir( ------------------ | Branch (1973:9): [True: 0, False: 2.25k] ------------------ 1974| 2.25k| pzip, zip->entry.name, entrylen, pExtra_data, (mz_uint16)extra_size, 1975| 2.25k| "", 0, zip->entry.uncomp_size, zip->entry.comp_size, 1976| 2.25k| zip->entry.uncomp_crc32, zip->entry.method, gen_flags, dos_time, 1977| 2.25k| dos_date, zip->entry.header_offset, zip->entry.external_attr, NULL, 1978| 2.25k| 0)) { 1979| 0| err = ZIP_EWRTDIR; ------------------ | | 107| 0|#define ZIP_EWRTDIR -15 // cannot write to central dir ------------------ 1980| 0| goto cleanup; 1981| 0| } 1982| 2.25k| } 1983| | 1984| 2.25k| pzip->m_total_files++; 1985| 2.25k| pzip->m_archive_size = zip->entry.dir_offset; 1986| 2.25k|#endif /* ZIP_ENABLE_DEFLATE */ 1987| | 1988| 4.51k|cleanup: 1989| 4.51k| if (zip) { ------------------ | Branch (1989:7): [True: 4.51k, False: 0] ------------------ 1990| 4.51k| zip->entry.m_time = 0; 1991| 4.51k| zip->entry.index = -1; 1992| | CLEANUP(zip->entry.name); ------------------ | | 69| 4.51k| do { \ | | 70| 4.51k| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 4.51k, False: 0] | | ------------------ | | 71| 4.51k| free((void *)ptr); \ | | 72| 4.51k| ptr = NULL; \ | | 73| 4.51k| } \ | | 74| 4.51k| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 4.51k] | | ------------------ ------------------ 1993| 4.51k| } 1994| 4.51k| return err; 1995| 2.25k|} zip_entry_write: 2063| 2.25k|int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) { 2064| 2.25k| mz_uint level; 2065| 2.25k| mz_zip_archive *pzip = NULL; 2066| 2.25k| tdefl_status status; 2067| | 2068| 2.25k| if (!zip) { ------------------ | Branch (2068:7): [True: 0, False: 2.25k] ------------------ 2069| 0| return ZIP_ENOINIT; ------------------ | | 93| 0|#define ZIP_ENOINIT -1 // not initialized ------------------ 2070| 0| } 2071| | 2072| 2.25k| pzip = &(zip->archive); 2073| 2.25k| if (buf && bufsize > 0) { ------------------ | Branch (2073:7): [True: 2.25k, False: 0] | Branch (2073:14): [True: 2.25k, False: 0] ------------------ 2074| 2.25k| zip->entry.uncomp_size += bufsize; 2075| 2.25k| zip->entry.uncomp_crc32 = (mz_uint32)mz_crc32( 2076| 2.25k| zip->entry.uncomp_crc32, (const mz_uint8 *)buf, bufsize); 2077| | 2078| 2.25k| level = zip->level & 0xF; 2079| 2.25k| if (!level) { ------------------ | Branch (2079:9): [True: 0, False: 2.25k] ------------------ 2080| 0| if (zip->password) { ------------------ | Branch (2080:11): [True: 0, False: 0] ------------------ 2081| 0| mz_uint8 *enc_buf = (mz_uint8 *)malloc(bufsize); 2082| 0| size_t i; 2083| 0| if (!enc_buf) { ------------------ | Branch (2083:13): [True: 0, False: 0] ------------------ 2084| 0| return ZIP_EOOMEM; ------------------ | | 113| 0|#define ZIP_EOOMEM -21 // out of memory ------------------ 2085| 0| } 2086| 0| for (i = 0; i < bufsize; i++) { ------------------ | Branch (2086:21): [True: 0, False: 0] ------------------ 2087| 0| enc_buf[i] = zip_pkware_encrypt_byte(&zip->entry.enc_keys, 2088| 0| ((const mz_uint8 *)buf)[i]); 2089| 0| } 2090| 0| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, enc_buf, ------------------ | Branch (2090:13): [True: 0, False: 0] ------------------ 2091| 0| bufsize) != bufsize) { 2092| 0| free(enc_buf); 2093| 0| return ZIP_EWRTENT; ------------------ | | 100| 0|#define ZIP_EWRTENT -8 // cannot write data to entry ------------------ 2094| 0| } 2095| 0| free(enc_buf); 2096| 0| } else { 2097| 0| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, buf, ------------------ | Branch (2097:13): [True: 0, False: 0] ------------------ 2098| 0| bufsize) != bufsize) { 2099| 0| return ZIP_EWRTENT; ------------------ | | 100| 0|#define ZIP_EWRTENT -8 // cannot write data to entry ------------------ 2100| 0| } 2101| 0| } 2102| 0| zip->entry.dir_offset += bufsize; 2103| 0| zip->entry.comp_size += bufsize; 2104| 2.25k| } else { 2105| 2.25k| status = tdefl_compress_buffer(&(zip->entry.comp), buf, bufsize, 2106| 2.25k| TDEFL_NO_FLUSH); 2107| 2.25k| if (status != TDEFL_STATUS_DONE && status != TDEFL_STATUS_OKAY) { ------------------ | Branch (2107:11): [True: 2.25k, False: 0] | Branch (2107:42): [True: 0, False: 2.25k] ------------------ 2108| 0| return ZIP_ETDEFLBUF; ------------------ | | 104| 0|#define ZIP_ETDEFLBUF -12 // cannot flush tdefl buffer ------------------ 2109| 0| } 2110| 2.25k| } 2111| 2.25k| } 2112| | 2113| 2.25k| return 0; 2114| 2.25k|} zip_entry_read: 2308| 2.25k|ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize) { 2309| 2.25k| mz_zip_archive *pzip = NULL; 2310| 2.25k| mz_uint idx; 2311| 2.25k| size_t size = 0; 2312| | 2313| 2.25k| if (!zip) { ------------------ | Branch (2313:7): [True: 0, False: 2.25k] ------------------ 2314| 0| return (ssize_t)ZIP_ENOINIT; ------------------ | | 93| 0|#define ZIP_ENOINIT -1 // not initialized ------------------ 2315| 0| } 2316| | 2317| 2.25k| pzip = &(zip->archive); 2318| 2.25k| if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || ------------------ | Branch (2318:7): [True: 0, False: 2.25k] ------------------ 2319| 2.25k| zip->entry.index < (ssize_t)0) { ------------------ | Branch (2319:7): [True: 0, False: 2.25k] ------------------ 2320| 0| return (ssize_t)ZIP_ENOENT; ------------------ | | 95| 0|#define ZIP_ENOENT -3 // entry not found ------------------ 2321| 0| } 2322| | 2323| 2.25k| idx = (mz_uint)zip->entry.index; 2324| 2.25k| if (mz_zip_reader_is_file_a_directory(pzip, idx)) { ------------------ | Branch (2324:7): [True: 0, False: 2.25k] ------------------ 2325| 0| return (ssize_t)ZIP_EINVENTTYPE; ------------------ | | 109| 0|#define ZIP_EINVENTTYPE -17 // invalid entry type ------------------ 2326| 0| } 2327| | 2328| 2.25k| if (zip->password) { ------------------ | Branch (2328:7): [True: 0, False: 2.25k] ------------------ 2329| 0| return zip_entry_decrypt_and_read(zip, buf, bufsize); 2330| 0| } 2331| | 2332| 2.25k| *buf = mz_zip_reader_extract_to_heap(pzip, idx, &size, 0); 2333| 2.25k| if (!*buf) { ------------------ | Branch (2333:7): [True: 0, False: 2.25k] ------------------ 2334| 0| return (ssize_t)ZIP_EOOMEM; ------------------ | | 113| 0|#define ZIP_EOOMEM -21 // out of memory ------------------ 2335| 0| } 2336| 2.25k| if (bufsize) { ------------------ | Branch (2336:7): [True: 2.25k, False: 0] ------------------ 2337| 2.25k| *bufsize = size; 2338| 2.25k| } 2339| 2.25k| return (ssize_t)size; 2340| 2.25k|} zip_stream_open: 2683| 4.51k| char mode) { 2684| 4.51k| int errnum = 0; 2685| 4.51k| return zip_stream_openwitherror(stream, size, level, mode, &errnum); 2686| 4.51k|} zip_stream_openwitherror: 2701| 4.51k| int level, char mode, int *errnum) { 2702| 4.51k|#if ZIP_ENABLE_DEFLATE 2703| 4.51k| mz_uint wflags = (mode == 'w') ? MZ_ZIP_FLAG_WRITE_ZIP64 : 0; ------------------ | Branch (2703:20): [True: 2.25k, False: 2.25k] ------------------ 2704| 4.51k|#endif 2705| 4.51k| struct zip_t *zip = (struct zip_t *)calloc((size_t)1, sizeof(struct zip_t)); 2706| |#if !ZIP_ENABLE_INFLATE && !ZIP_ENABLE_DEFLATE 2707| | (void)stream; 2708| | (void)size; 2709| |#endif 2710| 4.51k| if (!zip) { ------------------ | Branch (2710:7): [True: 0, False: 4.51k] ------------------ 2711| | // out of memory 2712| 0| *errnum = ZIP_EOOMEM; ------------------ | | 113| 0|#define ZIP_EOOMEM -21 // out of memory ------------------ 2713| 0| return NULL; 2714| 0| } 2715| | 2716| 4.51k| zip->entry.index = -1; 2717| | 2718| 4.51k| if (level < 0) { ------------------ | Branch (2718:7): [True: 0, False: 4.51k] ------------------ 2719| 0| level = MZ_DEFAULT_LEVEL; 2720| 0| } 2721| 4.51k| if ((level & 0xF) > MZ_UBER_COMPRESSION) { ------------------ | Branch (2721:7): [True: 0, False: 4.51k] ------------------ 2722| | // Wrong compression level 2723| 0| *errnum = ZIP_EINVLVL; ------------------ | | 97| 0|#define ZIP_EINVLVL -5 // invalid compression level ------------------ 2724| 0| goto cleanup; 2725| 0| } 2726| 4.51k| zip->level = (mz_uint)level; 2727| | 2728| 4.51k| switch (mode) { 2729| 0|#if ZIP_ENABLE_INFLATE 2730| 2.25k| case 'r': ------------------ | Branch (2730:3): [True: 2.25k, False: 2.25k] ------------------ 2731| 2.25k| case ('r' - 64): { ------------------ | Branch (2731:3): [True: 0, False: 4.51k] ------------------ 2732| 2.25k| if (stream && size > 0) { ------------------ | Branch (2732:9): [True: 2.25k, False: 0] | Branch (2732:19): [True: 2.25k, False: 0] ------------------ 2733| 2.25k| if (!mz_zip_reader_init_mem(&(zip->archive), stream, size, 0)) { ------------------ | Branch (2733:11): [True: 0, False: 2.25k] ------------------ 2734| 0| *errnum = ZIP_ERINIT; ------------------ | | 122| 0|#define ZIP_ERINIT -30 // cannot initialize reader ------------------ 2735| 0| goto cleanup; 2736| 0| } 2737| 2.25k| } else { 2738| 0| *errnum = ZIP_EINVMODE; ------------------ | | 96| 0|#define ZIP_EINVMODE -4 // invalid zip mode ------------------ 2739| 0| goto cleanup; 2740| 0| } 2741| 2.25k| } break; 2742| 2.25k|#endif 2743| | 2744| 2.25k|#if ZIP_ENABLE_DEFLATE 2745| 2.25k| case 'd': ------------------ | Branch (2745:3): [True: 0, False: 4.51k] ------------------ 2746| 0| case ('d' - 64): { ------------------ | Branch (2746:3): [True: 0, False: 4.51k] ------------------ 2747| 0| if (stream && size > 0) { ------------------ | Branch (2747:9): [True: 0, False: 0] | Branch (2747:19): [True: 0, False: 0] ------------------ 2748| 0| if (!mz_zip_reader_init_mem( ------------------ | Branch (2748:11): [True: 0, False: 0] ------------------ 2749| 0| &(zip->archive), stream, size, 2750| 0| zip->level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) { 2751| 0| *errnum = ZIP_ERINIT; ------------------ | | 122| 0|#define ZIP_ERINIT -30 // cannot initialize reader ------------------ 2752| 0| goto cleanup; 2753| 0| } 2754| 0| if (!mz_zip_writer_init_from_reader_v2(&(zip->archive), NULL, 0)) { ------------------ | Branch (2754:11): [True: 0, False: 0] ------------------ 2755| 0| *errnum = ZIP_EWRINIT; ------------------ | | 124| 0|#define ZIP_EWRINIT -32 // cannot initialize writer from reader ------------------ 2756| 0| mz_zip_reader_end(&(zip->archive)); 2757| 0| goto cleanup; 2758| 0| } 2759| 0| zip->archive.m_pWrite = zip_stream_delete_write_func; 2760| 0| } else { 2761| 0| *errnum = ZIP_EINVMODE; ------------------ | | 96| 0|#define ZIP_EINVMODE -4 // invalid zip mode ------------------ 2762| 0| goto cleanup; 2763| 0| } 2764| 0| } break; 2765| | 2766| 2.25k| case 'w': ------------------ | Branch (2766:3): [True: 2.25k, False: 2.25k] ------------------ 2767| 2.25k| case ('w' - 64): { ------------------ | Branch (2767:3): [True: 0, False: 4.51k] ------------------ 2768| 2.25k| if (stream == NULL && size == 0) { ------------------ | Branch (2768:9): [True: 2.25k, False: 0] | Branch (2768:27): [True: 2.25k, False: 0] ------------------ 2769| 2.25k| if (!mz_zip_writer_init_heap_v2(&(zip->archive), 0, 1024, wflags)) { ------------------ | Branch (2769:11): [True: 0, False: 2.25k] ------------------ 2770| 0| *errnum = ZIP_EWINIT; ------------------ | | 123| 0|#define ZIP_EWINIT -31 // cannot initialize writer ------------------ 2771| 0| goto cleanup; 2772| 0| } 2773| 2.25k| } else { 2774| 0| *errnum = ZIP_EINVMODE; ------------------ | | 96| 0|#define ZIP_EINVMODE -4 // invalid zip mode ------------------ 2775| 0| goto cleanup; 2776| 0| } 2777| 2.25k| } break; 2778| 2.25k|#endif 2779| | 2780| 2.25k| default: ------------------ | Branch (2780:3): [True: 0, False: 4.51k] ------------------ 2781| 0| *errnum = ZIP_EINVMODE; ------------------ | | 96| 0|#define ZIP_EINVMODE -4 // invalid zip mode ------------------ 2782| 0| goto cleanup; 2783| 4.51k| } 2784| | 2785| 4.51k| *errnum = 0; 2786| 4.51k| return zip; 2787| | 2788| 0|cleanup: 2789| 0| CLEANUP(zip); ------------------ | | 69| 0| do { \ | | 70| 0| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 0, False: 0] | | ------------------ | | 71| 0| free((void *)ptr); \ | | 72| 0| ptr = NULL; \ | | 73| 0| } \ | | 74| 0| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 0] | | ------------------ ------------------ 2790| | return NULL; 2791| 4.51k|} zip_stream_copy: 2793| 2.25k|ssize_t zip_stream_copy(struct zip_t *zip, void **buf, size_t *bufsize) { 2794| 2.25k| size_t n; 2795| | 2796| 2.25k| if (!zip || !buf) { ------------------ | Branch (2796:7): [True: 0, False: 2.25k] | Branch (2796:15): [True: 0, False: 2.25k] ------------------ 2797| 0| return (ssize_t)ZIP_ENOINIT; ------------------ | | 93| 0|#define ZIP_ENOINIT -1 // not initialized ------------------ 2798| 0| } 2799| | 2800| 2.25k|#if ZIP_ENABLE_DEFLATE 2801| 2.25k| if (zip->archive.m_zip_mode == MZ_ZIP_MODE_WRITING) { ------------------ | Branch (2801:7): [True: 2.25k, False: 0] ------------------ 2802| 2.25k| zip_archive_finalize(&(zip->archive)); 2803| 2.25k| } 2804| 2.25k|#endif 2805| | 2806| 2.25k| if (!zip->archive.m_pState || !zip->archive.m_pState->m_pMem) { ------------------ | Branch (2806:7): [True: 0, False: 2.25k] | Branch (2806:33): [True: 0, False: 2.25k] ------------------ 2807| 0| return (ssize_t)ZIP_ENOINIT; ------------------ | | 93| 0|#define ZIP_ENOINIT -1 // not initialized ------------------ 2808| 0| } 2809| | 2810| 2.25k| n = (size_t)zip->archive.m_archive_size; 2811| 2.25k| if (bufsize != NULL) { ------------------ | Branch (2811:7): [True: 2.25k, False: 0] ------------------ 2812| 2.25k| *bufsize = n; 2813| 2.25k| } 2814| | 2815| 2.25k| *buf = calloc(n, sizeof(unsigned char)); 2816| 2.25k| if (!*buf) { ------------------ | Branch (2816:7): [True: 0, False: 2.25k] ------------------ 2817| 0| return (ssize_t)ZIP_EOOMEM; ------------------ | | 113| 0|#define ZIP_EOOMEM -21 // out of memory ------------------ 2818| 0| } 2819| 2.25k| memcpy(*buf, zip->archive.m_pState->m_pMem, n); 2820| | 2821| 2.25k| return (ssize_t)n; 2822| 2.25k|} zip_stream_close: 2824| 4.51k|void zip_stream_close(struct zip_t *zip) { 2825| 4.51k| if (zip) { ------------------ | Branch (2825:7): [True: 4.51k, False: 0] ------------------ 2826| 4.51k|#if ZIP_ENABLE_DEFLATE 2827| 4.51k| mz_zip_writer_end(&(zip->archive)); 2828| 4.51k|#endif 2829| 4.51k|#if ZIP_ENABLE_INFLATE 2830| 4.51k| mz_zip_reader_end(&(zip->archive)); 2831| 4.51k|#endif 2832| 4.51k| CLEANUP(zip->password); ------------------ | | 69| 4.51k| do { \ | | 70| 4.51k| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 0, False: 4.51k] | | ------------------ | | 71| 0| free((void *)ptr); \ | | 72| 0| ptr = NULL; \ | | 73| 0| } \ | | 74| 4.51k| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 4.51k] | | ------------------ ------------------ 2833| | CLEANUP(zip); ------------------ | | 69| 4.51k| do { \ | | 70| 4.51k| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 4.51k, False: 0] | | ------------------ | | 71| 4.51k| free((void *)ptr); \ | | 72| 4.51k| ptr = NULL; \ | | 73| 4.51k| } \ | | 74| 4.51k| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 4.51k] | | ------------------ ------------------ 2834| 4.51k| } 2835| 4.51k|} zip.c:zip_archive_truncate: 510| 2.25k|static int zip_archive_truncate(mz_zip_archive *pzip) { 511| 2.25k| mz_zip_internal_state *pState = pzip->m_pState; 512| 2.25k| mz_uint64 file_size = pzip->m_archive_size; 513| 2.25k| if ((pzip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem)) { ------------------ | Branch (513:7): [True: 2.25k, False: 0] | Branch (513:53): [True: 2.25k, False: 0] ------------------ 514| 2.25k| return 0; 515| 2.25k| } 516| 0| if (pzip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED) { ------------------ | Branch (516:7): [True: 0, False: 0] ------------------ 517| 0| if (pState->m_pFile) { ------------------ | Branch (517:9): [True: 0, False: 0] ------------------ 518| 0|#ifndef MINIZ_NO_STDIO 519| 0| int fd = fileno(pState->m_pFile); 520| 0| return ftruncate(fd, pState->m_file_archive_start_ofs + file_size); 521| |#else 522| | (void)file_size; 523| | return ZIP_ENOFILE; 524| |#endif /* MINIZ_NO_STDIO */ 525| 0| } 526| 0| } 527| 0| return 0; 528| 0|} zip.c:_zip_entry_open: 1452| 4.51k| int case_sensitive) { 1453| 4.51k| size_t entrylen = 0; 1454| 4.51k| mz_zip_archive *pzip = NULL; 1455| 4.51k| mz_zip_archive_file_stat stats; 1456| 4.51k|#if ZIP_ENABLE_DEFLATE 1457| 4.51k| int err = 0; 1458| 4.51k| mz_uint num_alignment_padding_bytes, level; 1459| 4.51k| mz_uint16 dos_time = 0, dos_date = 0; 1460| 4.51k| mz_uint32 extra_size = 0; 1461| 4.51k| mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE]; 1462| 4.51k| mz_uint64 local_dir_header_ofs = 0; 1463| 4.51k|#endif 1464| | 1465| 4.51k| if (!zip) { ------------------ | Branch (1465:7): [True: 0, False: 4.51k] ------------------ 1466| 0| return ZIP_ENOINIT; ------------------ | | 93| 0|#define ZIP_ENOINIT -1 // not initialized ------------------ 1467| 0| } 1468| | 1469| 4.51k|#if ZIP_ENABLE_DEFLATE 1470| 4.51k| local_dir_header_ofs = zip->archive.m_archive_size; 1471| 4.51k|#endif 1472| | 1473| 4.51k| if (!entryname) { ------------------ | Branch (1473:7): [True: 0, False: 4.51k] ------------------ 1474| 0| return ZIP_EINVENTNAME; ------------------ | | 94| 0|#define ZIP_EINVENTNAME -2 // invalid entry name ------------------ 1475| 0| } 1476| | 1477| 4.51k| entrylen = strlen(entryname); 1478| 4.51k| if (entrylen == 0) { ------------------ | Branch (1478:7): [True: 0, False: 4.51k] ------------------ 1479| 0| return ZIP_EINVENTNAME; ------------------ | | 94| 0|#define ZIP_EINVENTNAME -2 // invalid entry name ------------------ 1480| 0| } 1481| | 1482| 4.51k| if (zip->entry.name) { ------------------ | Branch (1482:7): [True: 0, False: 4.51k] ------------------ 1483| 0| CLEANUP(zip->entry.name); ------------------ | | 69| 0| do { \ | | 70| 0| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 0, False: 0] | | ------------------ | | 71| 0| free((void *)ptr); \ | | 72| 0| ptr = NULL; \ | | 73| 0| } \ | | 74| 0| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 0] | | ------------------ ------------------ 1484| 0| } 1485| | 1486| 4.51k| pzip = &(zip->archive); 1487| 4.51k| if (pzip->m_zip_mode == MZ_ZIP_MODE_READING) { ------------------ | Branch (1487:7): [True: 2.25k, False: 2.25k] ------------------ 1488| 2.25k| zip->entry.name = zip_strclone(entryname, entrylen); 1489| 2.25k| if (!zip->entry.name) { ------------------ | Branch (1489:9): [True: 0, False: 2.25k] ------------------ 1490| | // Cannot parse zip entry name 1491| 0| return ZIP_EINVENTNAME; ------------------ | | 94| 0|#define ZIP_EINVENTNAME -2 // invalid entry name ------------------ 1492| 0| } 1493| | 1494| 2.25k| zip->entry.index = (ssize_t)mz_zip_reader_locate_file( 1495| 2.25k| pzip, zip->entry.name, NULL, 1496| 2.25k| case_sensitive ? MZ_ZIP_FLAG_CASE_SENSITIVE : 0); ------------------ | Branch (1496:9): [True: 0, False: 2.25k] ------------------ 1497| 2.25k| if (zip->entry.index < (ssize_t)0) { ------------------ | Branch (1497:9): [True: 0, False: 2.25k] ------------------ 1498| 0| CLEANUP(zip->entry.name); ------------------ | | 69| 0| do { \ | | 70| 0| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 0, False: 0] | | ------------------ | | 71| 0| free((void *)ptr); \ | | 72| 0| ptr = NULL; \ | | 73| 0| } \ | | 74| 0| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 0] | | ------------------ ------------------ 1499| 0| return ZIP_ENOENT; ------------------ | | 95| 0|#define ZIP_ENOENT -3 // entry not found ------------------ 1500| 0| } 1501| | 1502| 2.25k| if (!mz_zip_reader_file_stat(pzip, (mz_uint)zip->entry.index, &stats)) { ------------------ | Branch (1502:9): [True: 0, False: 2.25k] ------------------ 1503| 0| CLEANUP(zip->entry.name); ------------------ | | 69| 0| do { \ | | 70| 0| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 0, False: 0] | | ------------------ | | 71| 0| free((void *)ptr); \ | | 72| 0| ptr = NULL; \ | | 73| 0| } \ | | 74| 0| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 0] | | ------------------ ------------------ 1504| 0| return ZIP_ENOENT; ------------------ | | 95| 0|#define ZIP_ENOENT -3 // entry not found ------------------ 1505| 0| } 1506| | 1507| 2.25k| zip->entry.comp_size = stats.m_comp_size; 1508| 2.25k| zip->entry.uncomp_size = stats.m_uncomp_size; 1509| 2.25k| zip->entry.uncomp_crc32 = stats.m_crc32; 1510| 2.25k| zip->entry.dir_offset = stats.m_central_dir_ofs; 1511| 2.25k| zip->entry.header_offset = stats.m_local_header_ofs; 1512| 2.25k| zip->entry.method = stats.m_method; 1513| 2.25k| zip->entry.external_attr = stats.m_external_attr; 1514| 2.25k|#ifndef MINIZ_NO_TIME 1515| 2.25k| zip->entry.m_time = stats.m_time; 1516| 2.25k|#endif 1517| | 1518| 2.25k| return 0; 1519| 2.25k| } 1520| | 1521| |#if !ZIP_ENABLE_DEFLATE 1522| | return ZIP_EINVMODE; 1523| |#else 1524| | /* 1525| | .ZIP File Format Specification Version: 6.3.3 1526| | 1527| | 4.4.17.1 The name of the file, with optional relative path. 1528| | The path stored MUST not contain a drive or 1529| | device letter, or a leading slash. All slashes 1530| | MUST be forward slashes '/' as opposed to 1531| | backwards slashes '\' for compatibility with Amiga 1532| | and UNIX file systems etc. If input came from standard 1533| | input, there is no file name field. 1534| | */ 1535| 2.25k| zip->entry.name = zip_strrpl(entryname, entrylen, '\\', '/'); 1536| 2.25k| if (!zip->entry.name) { ------------------ | Branch (1536:7): [True: 0, False: 2.25k] ------------------ 1537| | // Cannot parse zip entry name 1538| 0| return ZIP_EINVENTNAME; ------------------ | | 94| 0|#define ZIP_EINVENTNAME -2 // invalid entry name ------------------ 1539| 0| } 1540| | 1541| 2.25k| level = zip->level & 0xF; 1542| | 1543| 2.25k| zip->entry.index = (ssize_t)zip->archive.m_total_files; 1544| 2.25k| zip->entry.comp_size = 0; 1545| 2.25k| zip->entry.uncomp_size = 0; 1546| 2.25k| zip->entry.uncomp_crc32 = MZ_CRC32_INIT; ------------------ | | 300| 2.25k|#define MZ_CRC32_INIT (0) ------------------ 1547| 2.25k| zip->entry.dir_offset = zip->archive.m_archive_size; 1548| 2.25k| zip->entry.header_offset = zip->archive.m_archive_size; 1549| 2.25k| memset(zip->entry.header, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8)); 1550| 2.25k| zip->entry.method = level ? MZ_DEFLATED : 0; ------------------ | | 316| 2.25k|#define MZ_DEFLATED 8 ------------------ | Branch (1550:23): [True: 2.25k, False: 0] ------------------ 1551| | 1552| | // UNIX or APPLE 1553| |#if MZ_PLATFORM == 3 || MZ_PLATFORM == 19 1554| | // regular file with rw-r--r-- permissions 1555| | zip->entry.external_attr = (mz_uint32)(0100644) << 16; 1556| |#else 1557| 2.25k| zip->entry.external_attr = 0; 1558| 2.25k|#endif 1559| | 1560| 2.25k| num_alignment_padding_bytes = 1561| 2.25k| mz_zip_writer_compute_padding_needed_for_file_alignment(pzip); 1562| | 1563| 2.25k| if (!pzip->m_pState || (pzip->m_zip_mode != MZ_ZIP_MODE_WRITING)) { ------------------ | Branch (1563:7): [True: 0, False: 2.25k] | Branch (1563:26): [True: 0, False: 2.25k] ------------------ 1564| | // Invalid zip mode 1565| 0| err = ZIP_EINVMODE; ------------------ | | 96| 0|#define ZIP_EINVMODE -4 // invalid zip mode ------------------ 1566| 0| goto cleanup; 1567| 0| } 1568| 2.25k| if (zip->level & MZ_ZIP_FLAG_COMPRESSED_DATA) { ------------------ | Branch (1568:7): [True: 0, False: 2.25k] ------------------ 1569| | // Invalid zip compression level 1570| 0| err = ZIP_EINVLVL; ------------------ | | 97| 0|#define ZIP_EINVLVL -5 // invalid compression level ------------------ 1571| 0| goto cleanup; 1572| 0| } 1573| | 1574| 2.25k| if (!mz_zip_writer_write_zeros(pzip, zip->entry.dir_offset, ------------------ | Branch (1574:7): [True: 0, False: 2.25k] ------------------ 1575| 2.25k| num_alignment_padding_bytes)) { 1576| | // Cannot memset zip entry header 1577| 0| err = ZIP_EMEMSET; ------------------ | | 99| 0|#define ZIP_EMEMSET -7 // memset error ------------------ 1578| 0| goto cleanup; 1579| 0| } 1580| 2.25k| local_dir_header_ofs += num_alignment_padding_bytes; 1581| | 1582| 2.25k| zip->entry.m_time = time(NULL); 1583| 2.25k|#ifndef MINIZ_NO_TIME 1584| 2.25k| mz_zip_time_t_to_dos_time(zip->entry.m_time, &dos_time, &dos_date); 1585| 2.25k|#endif 1586| | 1587| | // ZIP64 header with NULL sizes (sizes will be in the data descriptor, just 1588| | // after file data) 1589| 2.25k| extra_size = mz_zip_writer_create_zip64_extra_data( 1590| 2.25k| extra_data, NULL, NULL, 1591| 2.25k| (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); ------------------ | | 794| 2.25k|#define MZ_UINT32_MAX (0xFFFFFFFFU) ------------------ | Branch (1591:7): [True: 0, False: 2.25k] ------------------ 1592| | 1593| 2.25k| { 1594| 2.25k| mz_uint16 gen_flags = MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8; 1595| 2.25k| if (zip->password) { ------------------ | Branch (1595:9): [True: 0, False: 2.25k] ------------------ 1596| 0| gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED; 1597| 2.25k| } else { 1598| 2.25k| gen_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR; 1599| 2.25k| } 1600| | 1601| 2.25k| if (!mz_zip_writer_create_local_dir_header( ------------------ | Branch (1601:9): [True: 0, False: 2.25k] ------------------ 1602| 2.25k| pzip, zip->entry.header, (mz_uint16)entrylen, (mz_uint16)extra_size, 1603| 2.25k| 0, 0, 0, zip->entry.method, gen_flags, dos_time, dos_date)) { 1604| 0| err = ZIP_EMEMSET; ------------------ | | 99| 0|#define ZIP_EMEMSET -7 // memset error ------------------ 1605| 0| goto cleanup; 1606| 0| } 1607| 2.25k| } 1608| | 1609| 2.25k| zip->entry.header_offset = 1610| 2.25k| zip->entry.dir_offset + num_alignment_padding_bytes; 1611| | 1612| 2.25k| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.header_offset, ------------------ | Branch (1612:7): [True: 0, False: 2.25k] ------------------ 1613| 2.25k| zip->entry.header, 1614| 2.25k| sizeof(zip->entry.header)) != sizeof(zip->entry.header)) { 1615| 0| err = ZIP_EMEMSET; ------------------ | | 99| 0|#define ZIP_EMEMSET -7 // memset error ------------------ 1616| 0| goto cleanup; 1617| 0| } 1618| | 1619| 2.25k| if (pzip->m_file_offset_alignment) { ------------------ | Branch (1619:7): [True: 0, False: 2.25k] ------------------ 1620| 0| MZ_ASSERT( ------------------ | | 746| 0|#define MZ_ASSERT(x) assert(x) ------------------ | Branch (1620:5): [True: 0, False: 0] | Branch (1620:5): [True: 0, False: 0] ------------------ 1621| 0| (zip->entry.header_offset & (pzip->m_file_offset_alignment - 1)) == 0); 1622| 0| } 1623| 2.25k| zip->entry.dir_offset += 1624| 2.25k| num_alignment_padding_bytes + sizeof(zip->entry.header); 1625| | 1626| 2.25k| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, zip->entry.name, ------------------ | Branch (1626:7): [True: 0, False: 2.25k] ------------------ 1627| 2.25k| entrylen) != entrylen) { 1628| 0| err = ZIP_EWRTENT; ------------------ | | 100| 0|#define ZIP_EWRTENT -8 // cannot write data to entry ------------------ 1629| 0| goto cleanup; 1630| 0| } 1631| | 1632| 2.25k| zip->entry.dir_offset += entrylen; 1633| | 1634| 2.25k| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, extra_data, ------------------ | Branch (1634:7): [True: 0, False: 2.25k] ------------------ 1635| 2.25k| extra_size) != extra_size) { 1636| 0| err = ZIP_EWRTENT; ------------------ | | 100| 0|#define ZIP_EWRTENT -8 // cannot write data to entry ------------------ 1637| 0| goto cleanup; 1638| 0| } 1639| 2.25k| zip->entry.dir_offset += extra_size; 1640| | 1641| 2.25k| if (zip->password) { ------------------ | Branch (1641:7): [True: 0, False: 2.25k] ------------------ 1642| 0| mz_uint8 enc_header[ZIP_PKWARE_ENCRYPT_HEADER_SIZE]; 1643| 0| size_t i; 1644| | 1645| 0| zip_pkware_keys_init_password(&zip->entry.enc_keys, zip->password); 1646| | 1647| 0| for (i = 0; i < ZIP_PKWARE_ENCRYPT_HEADER_SIZE - 1; i++) { ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ | Branch (1647:17): [True: 0, False: 0] ------------------ 1648| 0| mz_uint8 rnd = 1649| 0| (mz_uint8)(mz_crc32(MZ_CRC32_INIT, enc_header, i) >> (i & 7)); ------------------ | | 300| 0|#define MZ_CRC32_INIT (0) ------------------ 1650| 0| enc_header[i] = zip_pkware_encrypt_byte(&zip->entry.enc_keys, rnd); 1651| 0| } 1652| 0| enc_header[ZIP_PKWARE_ENCRYPT_HEADER_SIZE - 1] = zip_pkware_encrypt_byte( ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1653| 0| &zip->entry.enc_keys, (mz_uint8)(dos_time >> 8)); 1654| | 1655| 0| zip->entry.enc_header_ofs = zip->entry.dir_offset; 1656| | 1657| 0| if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, enc_header, ------------------ | Branch (1657:9): [True: 0, False: 0] ------------------ 1658| 0| ZIP_PKWARE_ENCRYPT_HEADER_SIZE) != ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1659| 0| ZIP_PKWARE_ENCRYPT_HEADER_SIZE) { ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1660| 0| err = ZIP_EWRTENT; ------------------ | | 100| 0|#define ZIP_EWRTENT -8 // cannot write data to entry ------------------ 1661| 0| goto cleanup; 1662| 0| } 1663| 0| zip->entry.dir_offset += ZIP_PKWARE_ENCRYPT_HEADER_SIZE; ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1664| 0| zip->entry.comp_size += ZIP_PKWARE_ENCRYPT_HEADER_SIZE; ------------------ | | 126| 0|#define ZIP_PKWARE_ENCRYPT_HEADER_SIZE 12 ------------------ 1665| 0| } 1666| | 1667| 2.25k| if (level) { ------------------ | Branch (1667:7): [True: 2.25k, False: 0] ------------------ 1668| 2.25k| zip->entry.state.m_pZip = pzip; 1669| 2.25k| zip->entry.state.m_cur_archive_file_ofs = zip->entry.dir_offset; 1670| 2.25k| zip->entry.state.m_comp_size = 0; 1671| | 1672| 2.25k| if (zip->password) { ------------------ | Branch (1672:9): [True: 0, False: 2.25k] ------------------ 1673| 0| zip->entry.enc_state.inner_state = &(zip->entry.state); 1674| 0| zip->entry.enc_state.keys = &(zip->entry.enc_keys); 1675| | 1676| 0| if (tdefl_init(&(zip->entry.comp), zip_encrypt_put_buf_callback, ------------------ | Branch (1676:11): [True: 0, False: 0] ------------------ 1677| 0| &(zip->entry.enc_state), 1678| 0| (int)tdefl_create_comp_flags_from_zip_params( 1679| 0| (int)level, -15, MZ_DEFAULT_STRATEGY)) != 1680| 0| TDEFL_STATUS_OKAY) { 1681| 0| err = ZIP_ETDEFLINIT; ------------------ | | 101| 0|#define ZIP_ETDEFLINIT -9 // cannot initialize tdefl compressor ------------------ 1682| 0| goto cleanup; 1683| 0| } 1684| 2.25k| } else { 1685| 2.25k| if (tdefl_init(&(zip->entry.comp), mz_zip_writer_add_put_buf_callback, ------------------ | Branch (1685:11): [True: 0, False: 2.25k] ------------------ 1686| 2.25k| &(zip->entry.state), 1687| 2.25k| (int)tdefl_create_comp_flags_from_zip_params( 1688| 2.25k| (int)level, -15, MZ_DEFAULT_STRATEGY)) != 1689| 2.25k| TDEFL_STATUS_OKAY) { 1690| 0| err = ZIP_ETDEFLINIT; ------------------ | | 101| 0|#define ZIP_ETDEFLINIT -9 // cannot initialize tdefl compressor ------------------ 1691| 0| goto cleanup; 1692| 0| } 1693| 2.25k| } 1694| 2.25k| } 1695| | 1696| 2.25k| return 0; 1697| | 1698| 0|cleanup: 1699| | CLEANUP(zip->entry.name); ------------------ | | 69| 0| do { \ | | 70| 0| if (ptr) { \ | | ------------------ | | | Branch (70:9): [True: 0, False: 0] | | ------------------ | | 71| 0| free((void *)ptr); \ | | 72| 0| ptr = NULL; \ | | 73| 0| } \ | | 74| 0| } while (0) | | ------------------ | | | Branch (74:12): [Folded, False: 0] | | ------------------ ------------------ 1700| 0| return err; 1701| 2.25k|#endif /* ZIP_ENABLE_DEFLATE */ 1702| 2.25k|} zip.c:zip_strrpl: 438| 2.25k|static char *zip_strrpl(const char *str, size_t n, char oldchar, char newchar) { 439| 2.25k| char c; 440| 2.25k| size_t i; 441| 2.25k| char *rpl = (char *)calloc((1 + n), sizeof(char)); 442| 2.25k| char *begin = rpl; 443| 2.25k| if (!rpl) { ------------------ | Branch (443:7): [True: 0, False: 2.25k] ------------------ 444| 0| return NULL; 445| 0| } 446| | 447| 11.2k| for (i = 0; (i < n) && (c = *str++); ++i) { ------------------ | Branch (447:15): [True: 9.03k, False: 2.25k] | Branch (447:26): [True: 9.03k, False: 0] ------------------ 448| 9.03k| if (c == oldchar) { ------------------ | Branch (448:9): [True: 0, False: 9.03k] ------------------ 449| 0| c = newchar; 450| 0| } 451| 9.03k| *rpl++ = c; 452| 9.03k| } 453| | 454| 2.25k| return begin; 455| 2.25k|} zip.c:zip_strclone: 421| 2.25k|static char *zip_strclone(const char *str, size_t n) { 422| 2.25k| char c; 423| 2.25k| size_t i; 424| 2.25k| char *rpl = (char *)calloc((1 + n), sizeof(char)); 425| 2.25k| char *begin = rpl; 426| 2.25k| if (!rpl) { ------------------ | Branch (426:7): [True: 0, False: 2.25k] ------------------ 427| 0| return NULL; 428| 0| } 429| | 430| 11.2k| for (i = 0; (i < n) && (c = *str++); ++i) { ------------------ | Branch (430:15): [True: 9.03k, False: 2.25k] | Branch (430:26): [True: 9.03k, False: 0] ------------------ 431| 9.03k| *rpl++ = c; 432| 9.03k| } 433| | 434| 2.25k| return begin; 435| 2.25k|} zip.c:zip_archive_finalize: 675| 2.25k|static inline void zip_archive_finalize(mz_zip_archive *pzip) { 676| 2.25k| mz_zip_writer_finalize_archive(pzip); 677| 2.25k| zip_archive_truncate(pzip); 678| 2.25k|}