static size_t browscap_compute_contains(
zend_string *pattern, size_t start_pos,
uint16_t *contains_start, uint8_t *contains_len) {
size_t i = start_pos;
/* Find first non-placeholder character after prefix */
for (; i < ZSTR_LEN(pattern); i++) {
if (!is_placeholder(ZSTR_VAL(pattern)[i])) {
/* Skip the case of a single non-placeholder character.
* Let's try to find something longer instead. */
if (i + 1 < ZSTR_LEN(pattern) &&
!is_placeholder(ZSTR_VAL(pattern)[i + 1])) {
break;
}
}
}
*contains_start = i;
/* Find first placeholder character after that */
for (; i < ZSTR_LEN(pattern); i++) {
if (is_placeholder(ZSTR_VAL(pattern)[i])) {
break;
}
}
*contains_len = MIN(i - *contains_start, UINT8_MAX);
return i;
}
bool has_placeholder(level const & l) {
bool r = false;
for_each(l, [&](level const & e) {
if (is_placeholder(e) || is_one_placeholder(e))
r = true;
return !r;
});
return r;
}
/* Length of prefix not containing any wildcards */
static uint8_t browscap_compute_prefix_len(zend_string *pattern) {
size_t i;
for (i = 0; i < ZSTR_LEN(pattern); i++) {
if (is_placeholder(ZSTR_VAL(pattern)[i])) {
break;
}
}
return MIN(i, UINT8_MAX);
}
bool func_quote(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
cell_t res = { .size = 2, .ptr = {ref(c->arg[0])} };
store_reduced(cp, &res);
return true;
}
cell_t *build_quote(cell_t *x) {
return build11(func_quote, x);
}
bool func_popr(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
cell_t *d = c->arg[1];
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, T_LIST)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
if(list_size(p) == 0) goto fail;
if(is_placeholder(p->ptr[0])) {
++p->size;
cell_t *h = expand_inplace_dep(p->ptr[0], 1); // *** no shift here
p->ptr[0] = h->arg[closure_in(h)] = dep(ref(h));
p->ptr[1] = h;
}
if(d) {
drop(c);
d->func = func_id;
d->arg[0] = ref(p->ptr[0]);
d->arg[1] = (cell_t *)alt_set_ref(alt_set);
c->arg[1] = p->ptr[0];
}
/* drop the right list element */
cell_t *res = closure_alloc(closure_args(p)-1);
int elems = list_size(res);
res->type = T_LIST;
int i;
for(i = 0; i < elems; ++i)
res->ptr[i] = ref(p->ptr[i+1]);
res->alt_set = alt_set_ref(alt_set);
res->alt = c->alt;
store_reduced(cp, res);
return true;
fail:
if(d) {
drop(c);
store_fail(d, d->alt);
}
c->arg[1] = 0;
fail(cp);
return false;
}
bool has_placeholder(expr const & e) {
return (bool) find(e, [](expr const & e, unsigned) { // NOLINT
if (is_placeholder(e))
return true;
else if (is_sort(e))
return has_placeholder(sort_level(e));
else if (is_constant(e))
return std::any_of(const_levels(e).begin(), const_levels(e).end(), [](level const & l) { return has_placeholder(l); });
else
return false;
});
}
void polyself(boolean forcecontrol)
{
char buf[BUFSZ];
int old_light, new_light;
int mntmp = NON_PM;
int tries=0;
boolean draconian = (uarm &&
uarm->otyp >= GRAY_DRAGON_SCALE_MAIL &&
uarm->otyp <= YELLOW_DRAGON_SCALES);
boolean iswere = (u.ulycn >= LOW_PM || is_were(youmonst.data));
boolean isvamp = (youmonst.data->mlet == S_VAMPIRE || u.umonnum == PM_VAMPIRE_BAT);
boolean was_floating = (Levitation || Flying);
if (!Polymorph_control && !forcecontrol && !draconian && !iswere && !isvamp) {
if (rn2(20) > ACURR(A_CON)) {
pline("You shudder for a moment.");
losehp(rnd(30), "system shock", KILLED_BY_AN);
exercise(A_CON, FALSE);
return;
}
}
old_light = Upolyd ? emits_light(youmonst.data) : 0;
if (Polymorph_control || forcecontrol) {
do {
getlin("Become what kind of monster? [type the name]",
buf);
mntmp = name_to_mon(buf);
if (mntmp < LOW_PM)
pline("I've never heard of such monsters.");
/* Note: humans are illegal as monsters, but an
* illegal monster forces newman(), which is what we
* want if they specified a human.... */
else if (!polyok(&mons[mntmp]) && !your_race(&mons[mntmp]))
pline("You cannot polymorph into that.");
else break;
} while (++tries < 5);
if (tries==5) pline("That's enough tries!");
/* allow skin merging, even when polymorph is controlled */
if (draconian &&
(mntmp == armor_to_dragon(uarm->otyp) || tries == 5))
goto do_merge;
} else if (draconian || iswere || isvamp) {
/* special changes that don't require polyok() */
if (draconian) {
do_merge:
mntmp = armor_to_dragon(uarm->otyp);
if (!(mvitals[mntmp].mvflags & G_GENOD)) {
/* allow G_EXTINCT */
pline("You merge with your scaly armor.");
uskin = uarm;
uarm = NULL;
/* save/restore hack */
uskin->owornmask |= I_SPECIAL;
}
} else if (iswere) {
if (is_were(youmonst.data))
mntmp = PM_HUMAN; /* Illegal; force newman() */
else
mntmp = u.ulycn;
} else {
if (youmonst.data->mlet == S_VAMPIRE)
mntmp = PM_VAMPIRE_BAT;
else
mntmp = PM_VAMPIRE;
}
/* if polymon fails, "you feel" message has been given
so don't follow up with another polymon or newman */
if (mntmp == PM_HUMAN) newman(); /* werecritter */
else polymon(mntmp);
goto made_change; /* maybe not, but this is right anyway */
}
if (mntmp < LOW_PM) {
tries = 0;
do {
/* randomly pick an "ordinary" monster */
mntmp = rn1(SPECIAL_PM - LOW_PM, LOW_PM);
} while ((!polyok(&mons[mntmp]) || is_placeholder(&mons[mntmp]))
&& tries++ < 200);
}
/* The below polyok() fails either if everything is genocided, or if
* we deliberately chose something illegal to force newman().
*/
if (!polyok(&mons[mntmp]) || !rn2(5) || your_race(&mons[mntmp]))
newman();
else if (!polymon(mntmp)) return;
if (!uarmg) selftouch("No longer petrify-resistant, you");
made_change:
new_light = Upolyd ? emits_light(youmonst.data) : 0;
if (old_light != new_light) {
if (old_light)
del_light_source(level, LS_MONSTER, &youmonst);
if (new_light == 1) ++new_light; /* otherwise it's undetectable */
if (new_light)
new_light_source(level, u.ux, u.uy, new_light,
LS_MONSTER, &youmonst);
}
if (is_pool(level, u.ux,u.uy) && was_floating && !(Levitation || Flying) &&
!breathless(youmonst.data) && !amphibious(youmonst.data) &&
!Swimming) drown();
}
optional<expr> placeholder_type(expr const & e) {
if (is_local(e) && is_placeholder(e))
return some_expr(mlocal_type(e));
else
return none_expr();
}
bool is_placeholder(expr const & e) {
return (is_constant(e) && is_placeholder(const_name(e))) || (is_local(e) && is_placeholder(mlocal_name(e)));
}
bool is_placeholder(level const & e) { return is_global(e) && is_placeholder(global_id(e)); }
bool Type::can_be_container() const {
return is_any() or is_placeholder() or std::any_of(begin(_types), end(_types), [](auto& type) {
return type->is_container();
});
}
static int is_placeholder(lua_State * L) {
if (is_expr(L, 1))
return push_boolean(L, is_placeholder(to_expr(L, 1)));
else
return push_boolean(L, is_placeholder(to_level(L, 1)));
}
