protected override bool GetScopeItem(SessionStateScope scope, VariablePath path, out FunctionInfo script) { bool flag = true; this.name = path.IsFunction ? path.UnqualifiedPath : path.QualifiedName; script = scope.GetFunction(this.name); if (script != null) { bool flag2; FilterInfo info = script as FilterInfo; if (info != null) { flag2 = (info.Options & ScopedItemOptions.Private) != ScopedItemOptions.None; } else { flag2 = (script.Options & ScopedItemOptions.Private) != ScopedItemOptions.None; } if (flag2 && (scope != base.sessionState.CurrentScope)) { return(false); } SessionState.ThrowIfNotVisible(this._origin, script); return(flag); } return(false); }
/// <summary> /// Derived classes override this method to return their /// particular type of scoped item. /// </summary> /// <param name="scope"> /// The scope to look the item up in. /// </param> /// <param name="path"> /// The name of the item to retrieve. /// </param> /// <param name="script"> /// The scope item that the derived class should return. /// </param> /// <returns> /// True if the scope item was found or false otherwise. /// </returns> protected override bool GetScopeItem( SessionStateScope scope, VariablePath path, out FunctionInfo script) { Diagnostics.Assert(path is FunctionLookupPath, "name was scanned incorrect if we get here and it is not a FunctionLookupPath"); bool result = true; _name = path.IsFunction ? path.UnqualifiedPath : path.QualifiedName; script = scope.GetFunction(_name); if (script != null) { bool isPrivate; FilterInfo filterInfo = script as FilterInfo; if (filterInfo != null) { isPrivate = (filterInfo.Options & ScopedItemOptions.Private) != 0; } else { isPrivate = (script.Options & ScopedItemOptions.Private) != 0; } // If the function is private and the lookup scope // isn't the current scope, claim that the function // doesn't exist so that the lookup continues. if (isPrivate && scope != sessionState.CurrentScope) { result = false; } else { // Now check the visibility of the variable... SessionState.ThrowIfNotVisible(_origin, script); } } else { result = false; } return(result); }
/// <summary> /// Set a function in the current scope of session state. /// </summary> /// <param name="name"> /// The name of the function to set. /// </param> /// <param name="function"> /// The new value of the function being set. /// </param> /// <param name="originalFunction"> /// The original function (if any) from which the ScriptBlock is derived. /// </param> /// <param name="force"> /// If true, the function will be set even if its ReadOnly. /// </param> /// <param name="origin"> /// The origin of the caller /// </param> /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is null or empty. /// or /// If <paramref name="function"/> is not a <see cref="FilterInfo">FilterInfo</see> /// or <see cref="FunctionInfo">FunctionInfo</see> /// </exception> /// <exception cref="ArgumentNullException"> /// If <paramref name="function"/> is null. /// </exception> /// <exception cref="SessionStateUnauthorizedAccessException"> /// If the function is read-only or constant. /// </exception> internal FunctionInfo SetFunction( string name, ScriptBlock function, FunctionInfo originalFunction, bool force, CommandOrigin origin) { if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } if (function == null) { throw PSTraceSource.NewArgumentNullException("function"); } string originalName = name; FunctionLookupPath path = new FunctionLookupPath(name); name = path.UnqualifiedPath; if (string.IsNullOrEmpty(name)) { SessionStateException exception = new SessionStateException( originalName, SessionStateCategory.Function, "ScopedFunctionMustHaveName", SessionStateStrings.ScopedFunctionMustHaveName, ErrorCategory.InvalidArgument); throw exception; } ScopedItemOptions options = ScopedItemOptions.None; if (path.IsPrivate) { options |= ScopedItemOptions.Private; } FunctionScopeItemSearcher searcher = new FunctionScopeItemSearcher( this, path, origin); FunctionInfo result = null; SessionStateScope scope = searcher.InitialScope; if (searcher.MoveNext()) { scope = searcher.CurrentLookupScope; name = searcher.Name; if (path.IsPrivate) { // Need to add the Private flag FunctionInfo existingFunction = scope.GetFunction(name); options |= existingFunction.Options; result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext); } else { result = scope.SetFunction(name, function, force, origin, ExecutionContext); } } else { if (path.IsPrivate) { result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext); } else { result = scope.SetFunction(name, function, force, origin, ExecutionContext); } } return(result); }