scope
scope = LDAP_SCOPE_SUBTREE;
res = ldap_search_ext_s(ld, basedn, scope,
int scope = LDAP_SCOPE_ONE;
scope = LDAP_SCOPE_SUBTREE;
res = ldap_search_ext_s(ld, basedn, scope,
int scope = LDAP_SCOPE_ONE;
const char *cp, *scope;
scope = cp + 1;
if (ip6_str2scopeid(scope, sin6, &scopeid) == -1) {
ip6_str2scopeid(const char *scope, struct sockaddr_in6 *sin6, uint32_t *scopeid)
_DIAGASSERT(scope != NULL);
if (*scope == '\0')
*scopeid = if_nametoindex(scope);
lscopeid = strtoul(scope, &ep, 10);
uint16_t scope;
memcpy(&scope, &sin6->sin6_addr.s6_addr[2], sizeof(scope));
sin6->sin6_scope_id = ntohs(scope);
uint16_t scope = htons(sin6->sin6_scope_id);
memcpy(&sin6->sin6_addr.s6_addr[2], &scope, sizeof(scope));
pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
*scope = PTHREAD_SCOPE_SYSTEM;
*scope = PTHREAD_SCOPE_PROCESS;
pthread_attr_setscope(pthread_attr_t *attr, int scope)
switch (scope) {
int scope, cache;
scope = SCARG(uap, scope);
if (scope < LINUX_FLUSH_SCOPE_LINE || scope > LINUX_FLUSH_SCOPE_ALL
if (scope == LINUX_FLUSH_SCOPE_ALL) {
syscallarg(int) scope;
dump_scope(scope_t *scope)
emit_patch(scope, 0);
cur_scope = TAILQ_FIRST(&scope->inner_scope);
emit_patch(scope, 1);
emit_patch(scope_t *scope, int patch)
pinfo = &scope->patches[patch];
new_patch->patch_func = scope->func_num;
new_patch->begin = scope->begin_addr;
new_patch->begin = scope->end_addr;
process_scope(scope_t *scope)
cur_scope = TAILQ_LAST(&scope->inner_scope, scope_tailq);
scope->inner_scope_patches += skip_patch_count;
static void dump_scope(scope_t *scope);
static void emit_patch(scope_t *scope, int patch);
struct scope *scope_alloc(void);
void process_scope(struct scope *);
SLIST_ENTRY(scope) scope_stack_links;
TAILQ_ENTRY(scope) scope_links;
TAILQ_HEAD(, scope) inner_scope;
SLIST_HEAD(scope_list, scope);
TAILQ_HEAD(scope_tailq, scope);
kauth_authorize_action(kauth_scope_t scope, kauth_cred_t cred,
r = kauth_authorize_action_internal(scope, cred, action, arg0, arg1,
kauth_scope_t scope; /* scope backpointer */
kauth_scope_t scope;
scope = NULL;
SIMPLEQ_FOREACH(scope, &scope_list, next_scope) {
if (strcmp(scope->id, id) == 0)
return (scope);
kauth_scope_t scope;
scope = kmem_alloc(sizeof(*scope), KM_SLEEP);
kmem_free(scope, sizeof(*scope));
scope->id = id;
scope->cookie = cookie;
scope->nlisteners = 1;
SIMPLEQ_INIT(&scope->listenq);
listener->scope = scope;
SIMPLEQ_INSERT_HEAD(&scope->listenq, listener, listener_next);
SIMPLEQ_INSERT_TAIL(&scope_list, scope, next_scope);
return (scope);
kauth_deregister_scope(kauth_scope_t scope)
if (scope != NULL) {
SIMPLEQ_REMOVE(&scope_list, scope, kauth_scope, next_scope);
kmem_free(scope, sizeof(*scope));
kauth_scope_t scope;
scope = kauth_ifindscope(id);
if (scope == NULL) {
SIMPLEQ_INSERT_TAIL(&scope->listenq, listener, listener_next);
scope->nlisteners++;
listener->scope = scope;
SIMPLEQ_REMOVE(&listener->scope->listenq, listener,
listener->scope->nlisteners--;
kauth_authorize_action_internal(kauth_scope_t scope, kauth_cred_t cred,
KASSERT(scope != NULL);
SIMPLEQ_FOREACH(listener, &scope->listenq, listener_next) {
error = listener->func(cred, action, scope->cookie, arg0,
switch (args->scope) {
switch (args->scope) {
switch (args->scope) {
int scope;
scope = addr->s6_addr[1] & 0xc0;
switch (scope) {
scope = addr->s6_addr[1] & 0x0f;
switch (scope) {
int scope;
scope = in6_addrscope(in6);
switch (scope) {
int scope;
int scope;
int scope;
Arch_ParseArchive(char **pp, GNodeList *gns, GNode *scope)
result = Var_Parse(&nested_p, scope,
Var_Expand(&lib, scope, VARE_EVAL_DEFINED);
result = Var_Parse(&nested_p, scope,
Var_Expand(&mem, scope, VARE_EVAL_DEFINED);
} else if (!Arch_ParseArchive(&p, gns, scope)) {
void Var_DeleteAll(GNode *scope);
VarCheckSyntax(VarAssignOp op, const char *uvalue, GNode *scope)
scope, VARE_PARSE);
VarAssign_EvalSubst(GNode *scope, const char *name, const char *uvalue,
if (!Var_ExistsExpand(scope, name))
Var_SetExpand(scope, name, "");
evalue = Var_Subst(uvalue, scope,
Var_SetExpand(scope, name, evalue);
VarAssign_EvalShell(const char *name, const char *uvalue, GNode *scope,
Var_SetExpand(scope, name, output);
GNode *scope, FStr *out_true_avalue)
Var_AppendExpand(scope, name, uvalue);
VarAssign_EvalSubst(scope, name, uvalue, &avalue);
VarAssign_EvalShell(name, uvalue, scope, &avalue);
if (op == VAR_DEFAULT && Var_ExistsExpand(scope, name))
Var_SetExpand(scope, name, uvalue);
Parse_Var(VarAssign *var, GNode *scope)
VarCheckSyntax(var->op, var->value, scope);
if (VarAssign_Eval(var->varname, var->op, var->value, scope, &avalue)) {
Parse_VarAssign(const char *line, bool finishDependencyGroup, GNode *scope)
Parse_Var(&var, scope);
Var_SetWithFlags(GNode *scope, const char *name, const char *val,
scope->name, name, val);
if (scope == SCOPE_GLOBAL
scope->name, name, val);
v = VarFind(name, scope, false);
if (scope == SCOPE_CMDLINE && !(flags & VAR_SET_NO_EXPORT)) {
scope->name, name, val);
scope->name, name, val);
v = VarAdd(name, val, scope, flags);
scope->name, name, val);
scope->name, name, val, ValueDescription(val));
ExportVar(name, scope, VEM_PLAIN);
if (scope == SCOPE_CMDLINE) {
Var_Set(GNode *scope, const char *name, const char *val)
Var_SetWithFlags(scope, name, val, VAR_SET_NONE);
Var_SetExpand(GNode *scope, const char *name, const char *val)
Var_Expand(&varname, scope, VARE_EVAL);
scope->name, varname.str, val, name);
Var_SetWithFlags(scope, varname.str, val, VAR_SET_NONE);
Var_Append(GNode *scope, const char *name, const char *val)
v = VarFind(name, scope, scope == SCOPE_GLOBAL);
Var_SetWithFlags(scope, name, val, VAR_SET_NONE);
scope->name, name, val);
} else if (scope == SCOPE_CMDLINE || !v->fromCmd) {
DEBUG3(VAR, "%s: %s = %s\n", scope->name, name, v->val.data);
HashTable_CreateEntry(&scope->vars, name, NULL);
Var_AppendExpand(GNode *scope, const char *name, const char *val)
Var_Expand(&xname, scope, VARE_EVAL);
scope->name, xname.str, val, name);
Var_Append(scope, xname.str, val);
Var_Exists(GNode *scope, const char *name)
Var *v = VarFind(name, scope, true);
Var_ExistsExpand(GNode *scope, const char *name)
Var_Expand(&varname, scope, VARE_EVAL);
exists = Var_Exists(scope, varname.str);
Var_Value(GNode *scope, const char *name)
Var *v = VarFind(name, scope, true);
GNode *scope;
Var_Expand(&rhs, args->scope, VARE_EVAL);
GNode *scope;
Var_SetWithFlags(args->scope, args->var, word.start,
s = Var_Subst(args->body, args->scope, args->emode);
GNode *const_member scope;
FStr nested_val = Var_Parse(&p, ch->expr->scope,
args.scope = expr->scope;
Var_Delete(expr->scope, args.var);
FStr val = Var_Parse(&p, ch->expr->scope,
pattern = Var_Subst(pattern, expr->scope, expr->emode);
GNode *scope;
scope = expr->scope; /* scope where v belongs */
if (expr->defined == DEF_REGULAR && expr->scope != SCOPE_GLOBAL
&& VarFind(expr->name, expr->scope, false) == NULL)
scope = SCOPE_GLOBAL;
Var_Append(scope, expr->name, val.str);
Var_Set(scope, expr->name, output);
Var_Set(scope, expr->name, val.str);
args.scope = expr->scope;
FStr mods = Var_Parse(&p, expr->scope, expr->emode);
UndefinedShortVarValue(char varname, const GNode *scope)
if (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL) {
GNode *scope, VarEvalMode emode,
FStr nested_val = Var_Parse(&p, scope, emode);
ParseVarnameShort(char varname, const char **pp, GNode *scope,
v = VarFind(name, scope, true);
val = UndefinedShortVarValue(varname, scope);
FindLocalLegacyVar(Substring varname, GNode *scope,
if (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL)
scope, false);
GNode *scope,
ParseVarname(&p, startc, endc, scope, nested_emode, &varname);
v = VarFindSubstring(name, scope, true);
v = FindLocalLegacyVar(name, scope, out_true_extraModifiers);
(scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL);
#define Expr_Init(name, value, emode, scope, defined) \
(Expr) { name, value, emode, scope, defined }
VarEvalMode emode, GNode *scope, ExprDefined defined)
expr.scope = scope;
Var_Parse(const char **pp, GNode *scope, VarEvalMode emode)
scope, DEF_REGULAR);
if (!ParseVarnameShort(startc, pp, scope, emode, &val.str, &v))
if (!ParseVarnameLong(&p, startc, scope, emode, expr.emode,
expanded = Var_Subst(Expr_Str(&expr), scope, expr.emode);
GNode_FindVar(GNode *scope, Substring varname, unsigned hash)
return HashTable_FindValueBySubstringHash(&scope->vars, varname, hash);
VarSubstExpr(const char **pp, Buffer *buf, GNode *scope, VarEvalMode emode)
FStr val = Var_Parse(&nested_p, scope, emode);
Var_Subst(const char *str, GNode *scope, VarEvalMode emode)
VarSubstExpr(&p, &res, scope, emode);
Var_SubstInTarget(const char *str, GNode *scope)
EvalStack_Push(VSK_TARGET, scope->name, NULL);
res = Var_Subst(str, scope, VARE_EVAL);
Var_Expand(FStr *str, GNode *scope, VarEvalMode emode)
expanded = Var_Subst(str->str, scope, emode);
Var_Dump(GNode *scope)
HashIter_Init(&hi, &scope->vars);
VarFindSubstring(Substring name, GNode *scope, bool elsewhere)
const Var *var = HashTable_FindValue(&scope->vars, varname);
var = GNode_FindVar(scope, name, nameHash);
if (var == NULL && scope != SCOPE_CMDLINE)
if (!opts.checkEnvFirst && var == NULL && scope != SCOPE_GLOBAL) {
if (var == NULL && scope != SCOPE_INTERNAL) {
if (opts.checkEnvFirst && scope != SCOPE_GLOBAL) {
if (var == NULL && scope != SCOPE_INTERNAL)
VarFind(const char *name, GNode *scope, bool elsewhere)
return VarFindSubstring(Substring_InitStr(name), scope, elsewhere);
VarAdd(const char *name, const char *value, GNode *scope, VarSetFlags flags)
HashEntry *he = HashTable_CreateEntry(&scope->vars, name, NULL);
scope->name, name, value, ValueDescription(value));
Var_Delete(GNode *scope, const char *varname)
HashEntry *he = HashTable_FindEntry(&scope->vars, varname);
scope->name, varname);
scope->name, varname);
DEBUG2(VAR, "%s: delete %s\n", scope->name, varname);
HashTable_DeleteEntry(&scope->vars, he);
Var_DeleteAll(GNode *scope)
HashIter_Init(&hi, &scope->vars);
ExportVarEnv(Var *v, GNode *scope)
val = Var_Subst(expr, scope, VARE_EVAL);
if (scope != SCOPE_GLOBAL) {
ExportVar(const char *name, GNode *scope, VarExportMode mode)
v = VarFind(name, scope, false);
if (v == NULL && scope != SCOPE_GLOBAL)
return ExportVarEnv(v, scope);
Var_ReexportVars(GNode *scope)
ExportVar(var->name.str, scope, VEM_ENV);
ExportVar(varnames.words[i], scope, VEM_ENV);