;
91 # pragma message("Assembler code may have bugs -- use at your own risk")
92 voidmatch_init
OF((
void));
111 # define TOO_FAR 4096 155 #define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0)) 163 #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) 177 #define INSERT_STRING(s, str, match_head) \ 178 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ 179 match_head = s->head[s->ins_h], \ 180 s->head[s->ins_h] = (Pos)(str)) 182 #define INSERT_STRING(s, str, match_head) \ 183 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ 184 match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ 185 s->head[s->ins_h] = (Pos)(str)) 192 #define CLEAR_HASH(s) \ 194 s->head[s->hash_size-1] = NIL; \ 195 zmemzero((Bytef *)s->head, \ 196 (unsigned)(s->hash_size-1)*sizeof(*s->head)); \ 209 uIntwsize = s->w_size;
215*p = (
Pos)(m >= wsize ? m - wsize :
NIL);
222*p = (
Pos)(m >= wsize ? m - wsize :
NIL);
259stream_size !=
sizeof(
z_stream)) {
270strm->opaque = (
voidpf)0;
281 if(level != 0) level = 1;
286 if(windowBits < 0) {
288windowBits = -windowBits;
291 else if(windowBits > 15) {
297windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
298strategy < 0 || strategy >
Z_FIXED|| (windowBits == 8 && wrap != 1)) {
301 if(windowBits == 8) windowBits = 9;
418 const Bytef*dictionary;
440 if(dictLength >= s->
w_size) {
447dictionary += dictLength - s->
w_size;
501 if(dictLength !=
Z_NULL)
592 if(bits < 0 || bits > 16 ||
625 if(level < 0 || level > 9 || strategy < 0 || strategy >
Z_FIXED) {
698 uLongcomplen, wraplen;
701complen = sourceLen +
702((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
715wraplen = 6 + (s->
strstart? 4 : 0);
745 returncomplen + wraplen;
748 returnsourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
749(sourceLen >> 25) + 13 - 6 + wraplen;
780 if(
len== 0)
return;
796 #define HCRC_UPDATE(beg) \ 798 if (s->gzhead->hcrc && s->pending > (beg)) \ 799 strm->adler = crc32(strm->adler, s->pending_buf + (beg), \ 800 s->pending - (beg)); \ 864 else if(s->
level< 6)
866 else if(s->
level== 6)
870header |= (level_flags << 6);
872header += 31 - (header % 31);
1008}
while(
val!= 0);
1067}
else if(flush !=
Z_BLOCK) {
1094 if(s->
wrap== 2) {
1212 if(
len== 0)
return0;
1249s->block_start = 0L;
1252s->match_length = s->prev_length =
MIN_MATCH-1;
1253s->match_available = 0;
1281 register Bytef*scan = s->window + s->strstart;
1284 intbest_len = (
int)s->prev_length;
1292 uIntwmask = s->w_mask;
1298 register Bytef*strend = s->window + s->strstart +
MAX_MATCH- 1;
1299 register ushscan_start = *(
ushf*)scan;
1300 register ushscan_end = *(
ushf*)(scan+best_len-1);
1303 register Bytescan_end1 = scan[best_len-1];
1304 register Bytescan_end = scan[best_len];
1313 if(s->prev_length >= s->good_match) {
1325 match= s->window + cur_match;
1335 #if (defined(UNALIGNED_OK) && MAX_MATCH == 258) 1339 if(*(
ushf*)(
match+best_len-1) != scan_end ||
1340*(
ushf*)
match!= scan_start)
continue;
1362 Assert(scan <= s->
window+(
unsigned)(s->window_size-1),
"wild scan");
1363 if(*scan == *
match) scan++;
1370 if(
match[best_len] != scan_end ||
1371 match[best_len-1] != scan_end1 ||
1373*++
match!= scan[1])
continue;
1381scan += 2,
match++;
1388}
while(*++scan == *++
match&& *++scan == *++
match&&
1389*++scan == *++
match&& *++scan == *++
match&&
1390*++scan == *++
match&& *++scan == *++
match&&
1391*++scan == *++
match&& *++scan == *++
match&&
1394 Assert(scan <= s->
window+(
unsigned)(s->window_size-1),
"wild scan");
1401 if(
len> best_len) {
1402s->match_start = cur_match;
1406scan_end = *(
ushf*)(scan+best_len-1);
1408scan_end1 = scan[best_len-1];
1409scan_end = scan[best_len];
1412}
while((cur_match =
prev[cur_match & wmask]) > limit
1413&& --chain_length != 0);
1415 if((
uInt)best_len <= s->lookahead)
return(
uInt)best_len;
1416 returns->lookahead;
1443 match= s->window + cur_match;
1455scan += 2,
match+= 2;
1462}
while(*++scan == *++
match&& *++scan == *++
match&&
1463*++scan == *++
match&& *++scan == *++
match&&
1464*++scan == *++
match&& *++scan == *++
match&&
1465*++scan == *++
match&& *++scan == *++
match&&
1468 Assert(scan <= s->
window+(
unsigned)(s->window_size-1),
"wild scan");
1474s->match_start = cur_match;
1475 return(
uInt)
len<= s->lookahead ? (
uInt)
len: s->lookahead;
1495s->window + start, length) !=
EQUAL) {
1496fprintf(stderr,
" start %u, match %u, length %d\n",
1497start,
match, length);
1499fprintf(stderr,
"%c%c", s->window[
match++], s->window[start++]);
1500}
while(--length != 0);
1501z_error(
"invalid match");
1503 if(z_verbose > 1) {
1504fprintf(stderr,
"\\[%d,%d]", start-
match, length);
1505 do{ putc(s->window[start++], stderr); }
while(--length != 0);
1509 # define check_match(s, start, match, length) 1527 uIntwsize = s->w_size;
1532more = (unsigned)(s->window_size -(
ulg)s->lookahead -(
ulg)s->strstart);
1535 if(
sizeof(
int) <= 2) {
1536 if(more == 0 && s->strstart == 0 && s->lookahead == 0) {
1539}
else if(more == (
unsigned)(-1)) {
1550 if(s->strstart >= wsize+
MAX_DIST(s)) {
1552 zmemcpy(s->window, s->window+wsize, (
unsigned)wsize - more);
1553s->match_start -= wsize;
1554s->strstart -= wsize;
1555s->block_start -= (long) wsize;
1556 if(s->insert > s->strstart)
1557s->insert = s->strstart;
1561 if(s->strm->avail_in == 0)
break;
1574 Assert(more >= 2,
"more < 2");
1576 n=
read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
1580 if(s->lookahead + s->insert >=
MIN_MATCH) {
1581 uInt str= s->strstart - s->insert;
1582s->ins_h = s->window[
str];
1590s->prev[
str& s->w_mask] = s->head[s->ins_h];
1592s->head[s->ins_h] = (
Pos)
str;
1595 if(s->lookahead + s->insert <
MIN_MATCH)
1603}
while(s->lookahead <
MIN_LOOKAHEAD&& s->strm->avail_in != 0);
1612 if(s->high_water < s->window_size) {
1613 ulgcurr = s->strstart + (
ulg)(s->lookahead);
1616 if(s->high_water < curr) {
1620 init= s->window_size - curr;
1624s->high_water = curr +
init;
1626 else if(s->high_water < (
ulg)curr +
WIN_INIT) {
1632 if(
init> s->window_size - s->high_water)
1633 init= s->window_size - s->high_water;
1634 zmemzero(s->window + s->high_water, (
unsigned)
init);
1635s->high_water +=
init;
1640 "not enough room for search");
1647 #define FLUSH_BLOCK_ONLY(s, last) { \ 1648 _tr_flush_block(s, (s->block_start >= 0L ? \ 1649 (charf *)&s->window[(unsigned)s->block_start] : \ 1651 (ulg)((long)s->strstart - s->block_start), \ 1653 s->block_start = s->strstart; \ 1654 flush_pending(s->strm); \ 1655 Tracev((stderr,"[FLUSH]")); \
1659 #define FLUSH_BLOCK(s, last) { \ 1660 FLUSH_BLOCK_ONLY(s, last); \ 1661 if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ 1665 #define MAX_STORED 65535 1668 #define MIN(a, b) ((a) > (b) ? (b) : (a)) 1693 unsignedmin_block =
MIN(s->pending_buf_size - 5, s->w_size);
1699 unsigned len, left, have,
last= 0;
1700 unsignedused = s->strm->avail_in;
1707have = (s->bi_valid + 42) >> 3;
1708 if(s->strm->avail_out < have)
1711have = s->strm->avail_out - have;
1712left = s->strstart - s->block_start;
1713 if(
len> (
ulg)left + s->strm->avail_in)
1714 len= left + s->strm->avail_in;
1725 len!= left + s->strm->avail_in))
1735s->pending_buf[s->pending - 4] =
len;
1736s->pending_buf[s->pending - 3] =
len>> 8;
1737s->pending_buf[s->pending - 2] = ~
len;
1738s->pending_buf[s->pending - 1] = ~
len>> 8;
1745s->compressed_len +=
len<< 3;
1746s->bits_sent +=
len<< 3;
1753 zmemcpy(s->strm->next_out, s->window + s->block_start, left);
1754s->strm->next_out += left;
1755s->strm->avail_out -= left;
1756s->strm->total_out += left;
1757s->block_start += left;
1766s->strm->next_out +=
len;
1767s->strm->avail_out -=
len;
1768s->strm->total_out +=
len;
1770}
while(
last== 0);
1778used -= s->strm->avail_in;
1783 if(used >= s->w_size) {
1785 zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
1786s->strstart = s->w_size;
1787s->insert = s->strstart;
1790 if(s->window_size - s->strstart <= used) {
1792s->strstart -= s->w_size;
1793 zmemcpy(s->window, s->window + s->w_size, s->strstart);
1796 if(s->insert > s->strstart)
1797s->insert = s->strstart;
1799 zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
1800s->strstart += used;
1801s->insert +=
MIN(used, s->w_size - s->insert);
1803s->block_start = s->strstart;
1805 if(s->high_water < s->strstart)
1806s->high_water = s->strstart;
1814s->strm->avail_in == 0 && (
long)s->strstart == s->block_start)
1818have = s->window_size - s->strstart;
1819 if(s->strm->avail_in > have && s->block_start >= (
long)s->w_size) {
1821s->block_start -= s->w_size;
1822s->strstart -= s->w_size;
1823 zmemcpy(s->window, s->window + s->w_size, s->strstart);
1827 if(s->insert > s->strstart)
1828s->insert = s->strstart;
1830 if(have > s->strm->avail_in)
1831have = s->strm->avail_in;
1833 read_buf(s->strm, s->window + s->strstart, have);
1834s->strstart += have;
1835s->insert +=
MIN(have, s->w_size - s->insert);
1837 if(s->high_water < s->strstart)
1838s->high_water = s->strstart;
1845have = (s->bi_valid + 42) >> 3;
1848min_block =
MIN(have, s->w_size);
1849left = s->strstart - s->block_start;
1850 if(left >= min_block ||
1852s->strm->avail_in == 0 && left <= have)) {
1855 len== left ? 1 : 0;
1857s->block_start +=
len;
1890 if(s->lookahead == 0)
break;
1904 if(hash_head !=
NIL&& s->strstart - hash_head <=
MAX_DIST(s)) {
1913 check_match(s, s->strstart, s->match_start, s->match_length);
1918s->lookahead -= s->match_length;
1924 if(s->match_length <= s->max_insert_length &&
1933}
while(--s->match_length != 0);
1938s->strstart += s->match_length;
1939s->match_length = 0;
1940s->ins_h = s->window[s->strstart];
1941 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1951 Tracevv((stderr,
"%c", s->window[s->strstart]));
1993 if(s->lookahead == 0)
break;
2006s->prev_length = s->match_length, s->prev_match = s->match_start;
2009 if(hash_head !=
NIL&& s->prev_length < s->max_lazy_match &&
2010s->strstart - hash_head <=
MAX_DIST(s)) {
2018 if(s->match_length <= 5 && (s->strategy ==
Z_FILTERED 2021s->strstart - s->match_start >
TOO_FAR)
2034 if(s->prev_length >=
MIN_MATCH&& s->match_length <= s->prev_length) {
2038 check_match(s, s->strstart-1, s->prev_match, s->prev_length);
2048s->lookahead -= s->prev_length-1;
2049s->prev_length -= 2;
2051 if(++s->strstart <= max_insert) {
2054}
while(--s->prev_length != 0);
2055s->match_available = 0;
2061}
else if(s->match_available) {
2066 Tracevv((stderr,
"%c", s->window[s->strstart-1]));
2073 if(s->strm->avail_out == 0)
return need_more;
2078s->match_available = 1;
2084 if(s->match_available) {
2085 Tracevv((stderr,
"%c", s->window[s->strstart-1]));
2087s->match_available = 0;
2111 Bytef*scan, *strend;
2123 if(s->lookahead == 0)
break;
2127s->match_length = 0;
2128 if(s->lookahead >=
MIN_MATCH&& s->strstart > 0) {
2129scan = s->window + s->strstart - 1;
2131 if(
prev== *++scan &&
prev== *++scan &&
prev== *++scan) {
2132strend = s->window + s->strstart +
MAX_MATCH;
2134}
while(
prev== *++scan &&
prev== *++scan &&
2135 prev== *++scan &&
prev== *++scan &&
2136 prev== *++scan &&
prev== *++scan &&
2137 prev== *++scan &&
prev== *++scan &&
2140 if(s->match_length > s->lookahead)
2141s->match_length = s->lookahead;
2148 check_match(s, s->strstart, s->strstart - 1, s->match_length);
2152s->lookahead -= s->match_length;
2153s->strstart += s->match_length;
2154s->match_length = 0;
2157 Tracevv((stderr,
"%c", s->window[s->strstart]));
2186 if(s->lookahead == 0) {
2188 if(s->lookahead == 0) {
2196s->match_length = 0;
2197 Tracevv((stderr,
"%c", s->window[s->strstart]));
static void DLIST_NAME() init(DLIST_LIST_TYPE *list)
static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)
static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)
static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)
static const char * str(char *buf, int n)
strategy
Block allocation strategies.
unsigned int
A callback function used to compare two keys in a database.
while(yy_chk[yy_base[yy_current_state]+yy_c] !=yy_current_state)
if(yy_accept[yy_current_state])
const string version
version string
const struct ncbi::grid::netcache::search::fields::SIZE size
const GenericPointer< typename T::ValueType > T2 value
const CharType(& source)[N]
void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)
static int match(PCRE2_SPTR start_eptr, PCRE2_SPTR start_ecode, uint16_t top_bracket, PCRE2_SIZE frame_size, pcre2_match_data *match_data, match_block *mb)
struct tree_desc_s l_desc
struct ct_data_s dyn_dtree[2 *30+1]
struct ct_data_s bl_tree[2 *19+1]
struct tree_desc_s bl_desc
struct tree_desc_s d_desc
struct ct_data_s dyn_ltree[(2 *(256+1+29)+1)]
struct internal_state * state
const config configuration_table[10]
int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head)
block_state deflate_fast(deflate_state *s, int flush)
int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version, int stream_size)
#define FLUSH_BLOCK_ONLY(s, last)
void lm_init(deflate_state *s)
int ZEXPORT deflatePending(z_streamp strm, unsigned *pending, int *bits)
#define check_match(s, start, match, length)
void putShortMSB(deflate_state *s, uInt b)
#define UPDATE_HASH(s, h, c)
int ZEXPORT deflateCopy(z_streamp dest, z_streamp source)
int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
int ZEXPORT deflateReset(z_streamp strm)
#define INSERT_STRING(s, str, match_head)
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
block_state deflate_stored(deflate_state *s, int flush)
uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen)
unsigned read_buf(z_streamp strm, Bytef *buf, unsigned size)
const char deflate_copyright[]
void fill_window(deflate_state *s)
block_state deflate_rle(deflate_state *s, int flush)
int deflateStateCheck(z_streamp strm)
#define FLUSH_BLOCK(s, last)
int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain)
uInt longest_match(deflate_state *s, IPos cur_match)
block_state compress_func OF((deflate_state *s, int flush))
block_state deflate_huff(deflate_state *s, int flush)
int ZEXPORT deflatePrime(z_streamp strm, int bits, int value)
int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef *dictionary, uInt *dictLength)
block_state deflate_slow(deflate_state *s, int flush)
void flush_pending(z_streamp strm)
int ZEXPORT deflateResetKeep(z_streamp strm)
int ZEXPORT deflateEnd(z_streamp strm)
int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size)
int ZEXPORT deflate(z_streamp strm, int flush)
void slide_hash(deflate_state *s)
#define _tr_tally_dist(s, distance, length, flush)
#define _tr_tally_lit(s, c, flush)
#define Z_DEFAULT_STRATEGY
#define Z_DEFAULT_COMPRESSION
block_state(* compress_func)(deflate_state *s, int flush)
#define ERR_RETURN(strm, err)
#define ZALLOC(strm, items, size)
#define Assert(cond, msg)
#define ZFREE(strm, addr)
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4