states
Lex_state states[STATE_BSIZE], *statep;
states[0].ls_state = -1;
states[0].ls_info.base = (Lex_state *) 0;
statep = &states[1];
state_info.base = states;
state_info.end = &states[STATE_BSIZE];
if (statep != &states[1])
const char *states[] = PFUDPS_NAMES;
printf(" %s:%s\n", states[src->state], states[dst->state]);
const char *states[] = PFOTHERS_NAMES;
printf(" %s:%s\n", states[src->state], states[dst->state]);
rule->bytes[1]), rule->states);
PF_RULE_FIELD(states, DC),
printf(" %-25s %14u %14s\n", "current entries", s->states, "");
printf(" ( states %u, connections %u, rate %u.%u/%us )\n", sn->states,
if (sn->states == 0) {
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.__CONCAT(s_,_func_)
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_ei_, _func_) (_ei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
} states;
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
states st; /* current states */
states fresh; /* states for a fresh start */
states tmp; /* temporary */
states empty; /* empty set of states */
static states
states bef, /* states reachable before */
states aft, /* states already known reachable after */
static states step(struct re_guts *g, sopno start, sopno stop, states bef, wint_t ch, states aft, int sflags);
states st,
static void print(struct match *m, const char *caption, states st, int ch, FILE *d);
states st = m->st;
states fresh = m->fresh;
states empty = m->empty;
states tmp = m->tmp;
#define states1 states /* for later use in regexec() decision */
info.states = NULL;
info.states = calloc(info.num_states,
if (info.states == NULL)
printf("%-16s %-8s %s\n", info.states[n].name,
info.states[n].user == true ? "user" : "kernel",
info.states[n].desc);
const int states[] = {
return states[id];
const RF_AccessState_t *states;
const RF_AccessState_t *states; /* array of states to be run */
const RF_AccessState_t *states)
desc->states = states;
numBlocks, lbufPtr, bp, flags, raidPtr->Layout.map->states);
RF_AccessState_t current_state = desc->states[current_state_index];
current_state = desc->states[current_state_index];
const char *states[TSTATE_STATES+1] = {
if (!r->max_states || r->states < r->max_states)
r->states++;
r->states--;
TAILQ_FOREACH(st, &sk->states, next) {
if (cur->states <= 0 && cur->expire <= time_second) {
if (cur->rule.ptr->states <= 0 &&
if (--s->src_node->states <= 0) {
if (--s->nat_src_node->states <= 0) {
if (--cur->rule.ptr->states <= 0 &&
if (--cur->nat_rule.ptr->states <= 0 &&
if (--cur->anchor.ptr->states <= 0)
pf_status.states--;
TAILQ_INSERT_TAIL(&sk->states, s, next);
TAILQ_INSERT_HEAD(&sk->states, s, next);
TAILQ_REMOVE(&sk->states, s, next);
s->rule.ptr->states++; \
TAILQ_INIT(&sk->states);
s->anchor.ptr->states++; \
s->nat_rule.ptr->states++; \
s->nat_rule.ptr->states--; \
s->anchor.ptr->states--; \
s->rule.ptr->states--; \
if (r->max_states && (r->states >= r->max_states)) {
if (sn != NULL && sn->states == 0 && sn->expire == 0) {
if (nsn != sn && nsn != NULL && nsn->states == 0 &&
s->src_node->states++;
s->nat_src_node->states++;
TAILQ_FOREACH(s, &sk->states, next)
ret = TAILQ_FIRST(&sk->states);
TAILQ_FOREACH(s, &sk->states, next)
(*sn)->states >= rule->max_src_states) {
TAILQ_FOREACH(sp, &cur->states, next)
pf_status.states++;
pf_purge_expired_states(1 + (pf_status.states
u_int32_t states;
states = state->rule.ptr->states;
states = pf_status.states;
if (end && states > start && start < end) {
if (states < end)
return (state->expire + timeout * (end - states) /
s->rule.ptr->states++;
rule->states = 0;
newrule->states = 0;
nr = pf_status.states;
n->states = 0;
if (sn->states != 0) {
sn->states = 0;
pf_purge_expired_states(pf_status.states);
node->states = 0;
if (rule->states <= 0) {
if (rule->states > 0 || rule->src_nodes > 0 ||
u_int32_t states;
u_int32_t states;
u_int32_t states;
struct pf_statelist states;
enum states {
struct lua_state_info *states;
if (info->states == NULL) {
states = kmem_alloc(sizeof(*states) * n, KM_SLEEP);
if (copyin(info->states, states, sizeof(*states) * n)
strcpy(states[n].name, s->lua_name);
strcpy(states[n].desc, s->lua_desc);
states[n].user = s->K->ks_user;
copyout(states, info->states,
sizeof(*states) * n);
kmem_free(states, sizeof(*states) * n);
struct lua_state_info *states;
#define LFS_SET_UINO(ip, states) do { \
if (((states) & IN_ACCESSED) && !((ip)->i_state & IN_ACCESSED)) \
if (((states) & IN_CLEANING) && !((ip)->i_state & IN_CLEANING)) \
if (((states) & IN_MODIFIED) && !((ip)->i_state & IN_MODIFIED)) \
(ip)->i_state |= (states); \
#define LFS_CLR_UINO(ip, states) do { \
if (((states) & IN_ACCESSED) && ((ip)->i_state & IN_ACCESSED)) \
if (((states) & IN_CLEANING) && ((ip)->i_state & IN_CLEANING)) \
if (((states) & IN_MODIFIED) && ((ip)->i_state & IN_MODIFIED)) \
(ip)->i_state &= ~(states); \
states[mouse_button_state].s[trans]);
S_DELAYED(states[mouse_button_state].s[trans])) {
states[mouse_button_state].s[A_TIMEOUT];
if (mouse_button_state != states[mouse_button_state].s[trans])
mouse_button_state = states[mouse_button_state].s[trans];
a2->button &= states[mouse_button_state].mask;
a2->button |= states[mouse_button_state].buttons;
if (states[mouse_button_state].timeout)
#define S_DELAYED(st) (states[st].s[A_TIMEOUT] != (st))
} states[10] = {
states->ps_buf = malloc(allocated * sizeof(struct pfsync_state));
if (states->ps_buf == NULL)
if (allocated == (states->ps_len / sizeof(struct pfsync_state))) {
buf = realloc(states->ps_buf, allocated * sizeof(struct pfsync_state));
free(states->ps_buf);
states->ps_buf = buf;
struct pfioc_states* states;
states
| state states { parse_init(); }
extern struct pfioc_states* states;