strategy
if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
(s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
(s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
s->strategy == Z_RLE ? deflate_rle(s, flush) :
if (s->match_length <= 5 && (s->strategy == Z_FILTERED
int windowBits, int memLevel, int strategy,
strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) {
s->strategy = strategy;
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) {
if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
if ((strategy != s->strategy || func != configuration_table[level].func) &&
s->strategy = strategy;
int strategy; /* favor or force Huffman coding*/
int strategy; /* compression strategy */
state->strategy = Z_DEFAULT_STRATEGY;
state->strategy = Z_FILTERED;
state->strategy = Z_HUFFMAN_ONLY;
state->strategy = Z_RLE;
state->strategy = Z_FIXED;
MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
int ZEXPORT gzsetparams(gzFile file, int level, int strategy) {
if (level == state->level && strategy == state->strategy)
deflateParams(strm, level, strategy);
state->strategy = strategy;
if (static_lenb <= opt_lenb || s->strategy == Z_FIXED)
ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy);
int strategy, const char *version,
# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
int strategy);
int windowBits, int memLevel, int strategy,
int deflateParams(z_streamp strm, int level, int strategy)
nuke->strategy = rand_mod(256); /* random direction */
obj->strategy = 0;
char strategy;
curkl->strategy = 0;
curkl->strategy = rand_mod(15)+5;
if (curkl->strategy)
curkl->strategy--;
curkl->vely = curkl->strategy & 3;
curkl->velx = (curkl->strategy >> 2) & 3;
if (nuke->strategy && rand_mod(3)) {
dy = nuke->strategy & 3;
dx = (nuke->strategy >> 2) & 3;
nuke->strategy = rand_mod(256);
if (nuke->strategy && ambsize < 90 && !rand_mod(200-smarts))
if (curkl->strategy) {
if (!--curkl->strategy) { /* clock ran down */
switch (obj->strategy||thru_stars?0:
(massacre || obj->strategy ||
if (obj->strategy) {
obj->strategy = 0;
obj->strategy = 1;
if (thru_stars && obj->strategy < 7)
if (obj->strategy) {
obj->strategy += (!torps && deados > 10);
if (obj->strategy > 4)
if (!torps && obj->strategy > 5) {
obj->strategy = 1;
nuke->strategy = nukey + (nukex << 2);
nuke->strategy = rand_mod(30);
occupant[y][x]->strategy = 0;
occupant[y][x]->strategy = 0;
.strategy = z3rambd_altmem_strategy
writedisklabel(dev_t dev, void (*strategy)(struct buf *), struct disklabel *d,
if ((rwops = sector_init(dev, strategy)) == 0)
readdisklabel(dev_t dev, void (*strategy)(struct buf *), struct disklabel *d,
if ((rwops = sector_init(dev, strategy)) == 0)
rw->strategy(b);
void (*strategy)(struct buf *);
rw->strategy = strat;
rw->strategy(b);
{ "OpenFirmware", strategy, devopen_dummy, devclose, noioctl }
if (strategy(devp, F_READ, blkno, DEV_BSIZE, pme, &nread)
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)
if (strategy(devp, F_READ, poff + 1,
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)
(strategy(&ofdev, F_READ,
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &read)
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &read)
if (strategy(devp, F_READ, poff + LABELSECTOR, DEV_BSIZE,
{ "OpenFirmware", strategy, devopen_dummy, devclose, noioctl }
error = strategy(&ofdev, F_READ, LABELSECTOR,
int strategy(void *, int, daddr_t, size_t, void *, size_t *);
if (strategy(devp, F_READ, blk, DEV_BSIZE, buf, &read)
if (strategy(devp, F_READ, blk * (lp->d_secsize / DEV_BSIZE),
strategy,
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)
if (strategy(devp, F_READ, poff + LABELSECTOR,
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)
if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)
if (strategy(&ofdev, F_READ,
strategy,
if (strategy(devp, F_READ, LABELSECTOR, DEV_BSIZE, buf, &readsize)
if (strategy(&ofdev, F_READ,
#define SADEV(name,strategy,open,close,ioctl) \
(int(*)(void *, int ,daddr_t , size_t, void *, size_t *))strategy, \
db_elf_search_symbol(db_symtab_t *symtab, db_addr_t off, db_strategy_t strategy,
if (strategy == DB_STGY_PROC &&
if (strategy == DB_STGY_ANY &&
db_search_symbol(db_addr_t val, db_strategy_t strategy, db_expr_t *offp)
(NULL, val, strategy, &newdiff);
if (ksyms_getname(&mod, &sym, (vaddr_t)val, strategy) == 0) {
db_symstr(char *buf, size_t buflen, db_expr_t off, db_strategy_t strategy)
cursym = db_search_symbol(off, strategy, &d);
if (strategy == DB_STGY_PROC) {
strategy|KSYMS_CLOSEST) == 0) {
if (strategy & KSYMS_PROC && val == off) {
strategy|KSYMS_CLOSEST) != 0)
if (strategy & KSYMS_PROC) {
db_printsym(db_expr_t off, db_strategy_t strategy,
cursym = db_search_symbol(off, strategy, &d);
if (strategy == DB_STGY_PROC) {
strategy|KSYMS_CLOSEST) == 0) {
if (strategy & KSYMS_PROC && uval == off) {
strategy|KSYMS_CLOSEST) != 0)
if (strategy & KSYMS_PROC) {
sc->sc_memops->strategy(sc->sc_cookie, bp);
void (*strategy)(void *, struct buf *);
table_en->target->strategy(table_en, nestbuf);
int (*strategy)(dm_table_entry_t *, struct buf *);
if (dm_target->strategy == NULL) {
dmt->strategy = &dm_target_linear_strategy;
dmt->strategy = &dm_target_stripe_strategy;
dmt->strategy = &dm_target_error_strategy;
dmt->strategy = &dm_target_zero_strategy;
dmt->strategy = &dm_target_delay_strategy;
dmt->strategy = &dm_target_flakey_strategy;
dmt->strategy = &dm_target_delay_strategy;
dmt->strategy = &dm_target_error_strategy;
dmt->strategy = &dm_target_flakey_strategy;
dmt->strategy = &dm_target_mirror_strategy;
dmt->strategy = &dm_target_snapshot_strategy;
dmt1->strategy = &dm_target_snapshot_orig_strategy;
dmt->strategy = &dm_target_stripe_strategy;
dmt->strategy = &dm_target_zero_strategy;
u32 headroom, int strategy)
switch (strategy) {
u32 headroom, int strategy);
int strategy)
switch (strategy) {
int strategy);
struct udf_strategy *strategy;
struct udf_strategy *strategy = ump->strategy;
KASSERT(strategy);
error = (strategy->create_logvol_dscr)(&args);
struct udf_strategy *strategy = ump->strategy;
KASSERT(strategy);
(strategy->free_logvol_dscr)(&args);
struct udf_strategy *strategy = ump->strategy;
KASSERT(strategy);
error = (strategy->read_logvol_dscr)(&args);
struct udf_strategy *strategy = udf_node->ump->strategy;
KASSERT(strategy);
error = (strategy->write_logvol_dscr)(&args);
struct udf_strategy *strategy = ump->strategy;
KASSERT(strategy);
(strategy->queuebuf)(&args);
struct udf_strategy *strategy = ump->strategy;
KASSERT(strategy);
(strategy->sync_caches)(&args);
struct udf_strategy *strategy = ump->strategy;
KASSERT(strategy);
(strategy->discstrat_init)(&args);
struct udf_strategy *strategy = ump->strategy;
if (strategy) {
(strategy->discstrat_finish)(&args);
ump->strategy = &udf_strat_rmw;
ump->strategy = &udf_strat_sequential;
ump->strategy = &udf_strat_direct;
ump->strategy = &udf_strat_rmw;
ump->strategy = &udf_strat_direct;
(ump->strategy == &udf_strat_direct) ? "Direct" :
(ump->strategy == &udf_strat_sequential) ? "Sequential" :
(ump->strategy == &udf_strat_rmw) ? "RMW" : "UNKNOWN!"));
ump->strategy = &udf_strat_bootstrap;
KASSERT(ump->strategy != &udf_strat_bootstrap);
physio(void (*strategy)(struct buf *), struct buf *obp, dev_t dev, int flags,
(*strategy)(bp);
bufq_alloc(struct bufq_state **bufqp, const char *strategy, int flags)
KASSERT((flags & BUFQ_EXACT) == 0 || strategy != BUFQ_STRAT_ANY);
if (strategy != BUFQ_STRAT_ANY &&
STRAT_MATCH(strategy, (it))) {
if (strategy == BUFQ_STRAT_ANY || found_exact)
strlcat(strategy_module_name, strategy,
if (strategy != BUFQ_STRAT_ANY && !found_exact) {
strategy, bsp->bs_name);
SDT_PROBE3(sdt, bdev, strategy, entry, d, bp->b_dev, bp);
SDT_PROBE3(sdt, bdev, strategy, return, d, bp->b_dev, bp);
SDT_PROBE_DEFINE3(sdt, bdev, strategy, entry,
SDT_PROBE_DEFINE3(sdt, bdev, strategy, return,
#define DEV_STRATEGY(d) ___CONCAT(LIBSA_SINGLE_DEVICE,strategy)
s->strategy = strategy;
if (s->strategy != Z_HUFFMAN_ONLY) {
if (s->strategy != Z_HUFFMAN_ONLY) {
if (s->match_length <= 5 && (s->strategy == Z_FILTERED ||
int strategy; /* favor or force Huffman coding*/
int level, int method, int windowBits, int memLevel, int strategy,
strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
s->strategy = strategy;
int ZEXPORT deflateParams(strm, level, strategy)
int strategy;
if (level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
(strategy), ZLIB_VERSION, sizeof(z_stream))
find_qentry_to_delete(const struct buf_queue_head *head, int strategy,
if (strategy == PURGE_BY_PRIORITY) {
return find_qentry_to_delete(head, strategy, false);
message_queue_purge(struct filed *f, size_t del_entries, int strategy)
f, del_entries, strategy,
(void)find_qentry_to_delete(&f->f_qhead, strategy, true);
qentry = find_qentry_to_delete(&f->f_qhead, strategy, 0);