protected override bool GetScopeItem(SessionStateScope scope, VariablePath name, out AliasInfo alias)
{
bool flag = true;
alias = scope.GetAlias(name.QualifiedName);
return(((alias != null) && (((alias.Options & ScopedItemOptions.Private) == ScopedItemOptions.None) || (scope == base.sessionState.CurrentScope))) && flag);
}
/// <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="name">
/// The name of the item to retrieve.
/// </param>
/// <param name="variable">
/// 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 name,
out PSVariable variable)
{
Diagnostics.Assert(!(name is FunctionLookupPath),
"name was scanned incorrect if we get here and it is a FunctionLookupPath");
bool result = true;
variable = scope.GetVariable(name.QualifiedName, _origin);
// If the variable is private and the lookup scope
// isn't the current scope, claim that the variable
// doesn't exist so that the lookup continues.
if (variable == null ||
(variable.IsPrivate &&
scope != sessionState.CurrentScope))
{
result = false;
}
return(result);
}
private static object GetUsingValue(MutableTuple tuple, int index, ExecutionContext context)
{
UsingResult usingValueFromTuple = GetUsingValueFromTuple(tuple, index);
if (usingValueFromTuple != null)
{
return(usingValueFromTuple.Value);
}
for (SessionStateScope scope = context.EngineSessionState.CurrentScope; scope != null; scope = scope.Parent)
{
usingValueFromTuple = GetUsingValueFromTuple(scope.LocalsTuple, index);
if (usingValueFromTuple != null)
{
return(usingValueFromTuple.Value);
}
foreach (MutableTuple tuple2 in scope.DottedScopes)
{
usingValueFromTuple = GetUsingValueFromTuple(tuple2, index);
if (usingValueFromTuple != null)
{
return(usingValueFromTuple.Value);
}
}
}
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "UsingWithoutInvokeCommand", ParserStrings.UsingWithoutInvokeCommand, new object[0]);
}
public bool MoveNext()
{
bool flag = true;
if (!this.isInitialized)
{
this.InitializeScopeEnumerator();
}
while (this.scopeEnumerable.MoveNext())
{
T newCurrentItem = default(T);
if (this.TryGetNewScopeItem(((IEnumerator <SessionStateScope>) this.scopeEnumerable).Current, out newCurrentItem))
{
this.currentScope = ((IEnumerator <SessionStateScope>) this.scopeEnumerable).Current;
this.current = newCurrentItem;
flag = true;
break;
}
flag = false;
if (this.isSingleScopeLookup)
{
flag = false;
break;
}
}
return(flag);
}
public void Set(string name, ScriptBlock function, string description = "")
{
var qualName = new SessionStateScope<FunctionInfo>.QualifiedName(name);
var info = new FunctionInfo(qualName.UnqualifiedName, function);
info.Description = description;
_scope.Set(name, info, true, true);
}
/// <summary>
/// Removes a function from the function table.
/// </summary>
/// <param name="name">
/// The name of the function to remove.
/// </param>
/// <param name="origin">
/// THe origin of the caller of this API
/// </param>
/// <param name="force">
/// If true, the function is removed even if it is ReadOnly.
/// </param>
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// </exception>
/// <exception cref="SessionStateUnauthorizedAccessException">
/// If the function is constant.
/// </exception>
internal void RemoveFunction(string name, bool force, CommandOrigin origin)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
// Use the scope enumerator to find an existing function
SessionStateScope scope = _currentScope;
FunctionLookupPath path = new FunctionLookupPath(name);
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
if (searcher.MoveNext())
{
scope = searcher.CurrentLookupScope;
}
scope.RemoveFunction(name, force);
}
/// <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="name">
/// The name of the item to retrieve.
/// </param>
/// <param name="alias">
/// 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 name,
out AliasInfo alias)
{
Diagnostics.Assert(!(name is FunctionLookupPath),
"name was scanned incorrect if we get here and it is a FunctionLookupPath");
bool result = true;
alias = scope.GetAlias(name.QualifiedName);
// If the alias is private and the lookup scope
// isn't the current scope, claim that the alias
// doesn't exist so that the lookup continues.
if (alias == null ||
((alias.Options & ScopedItemOptions.Private) != 0 &&
scope != sessionState.CurrentScope))
{
result = false;
}
return(result);
}
//actual constructor work, but hidden to not be used accidently in a stupid way
private SessionState(SessionStateGlobal sessionStateGlobal, SessionState parent)
{
SessionStateGlobal = sessionStateGlobal;
var parentAliasScope = parent == null ? null : parent._aliasScope;
var parentFunctionScope = parent == null ? null : parent._functionScope;
var parentVariableScope = parent == null ? null : parent._variableScope;
var parentDriveScope = parent == null ? null : parent._driveScope;
var parentModuleScope = parent == null ? null : parent._moduleScope;
var parentCmdletScope = parent == null ? null : parent._cmdletScope;
_aliasScope = new SessionStateScope <AliasInfo>(this, parentAliasScope, SessionStateCategory.Alias);
_functionScope = new SessionStateScope <FunctionInfo>(this, parentFunctionScope, SessionStateCategory.Function);
_variableScope = new SessionStateScope <PSVariable>(this, parentVariableScope, SessionStateCategory.Variable);
_driveScope = new SessionStateScope <PSDriveInfo>(this, parentDriveScope, SessionStateCategory.Drive);
_moduleScope = new SessionStateScope <PSModuleInfo>(this, parentModuleScope, SessionStateCategory.Module);
_cmdletScope = new SessionStateScope <CmdletInfo>(this, parentCmdletScope, SessionStateCategory.Cmdlet);
IsScriptScope = false;
Function = new FunctionIntrinsics(_functionScope);
Alias = new AliasIntrinsics(_aliasScope);
Drive = new DriveManagementIntrinsics(_driveScope);
Path = new PathIntrinsics(this);
PSVariable = new PSVariableIntrinsics(_variableScope);
LoadedModules = new ModuleIntrinsics(_moduleScope);
Cmdlet = new CmdletIntrinsics(_cmdletScope);
}
protected override bool GetScopeItem(SessionStateScope scope, VariablePath name, out PSVariable variable)
{
bool flag = true;
variable = scope.GetVariable(name.QualifiedName, this._origin);
return(((variable != null) && (!variable.IsPrivate || (scope == base.sessionState.CurrentScope))) && flag);
}
/// <summary>
/// Gets an IEnumerable for the cmdlet table for a given scope.
/// </summary>
/// <param name="scopeID">
/// A scope identifier that is either one of the "special" scopes like
/// "global", "script", "local", or "private, or a numeric ID of a relative scope
/// to the current scope.
/// </param>
/// <exception cref="ArgumentException">
/// If <paramref name="scopeID"/> is less than zero, or not
/// a number and not "script", "global", "local", or "private"
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// If <paramref name="scopeID"/> is less than zero or greater than the number of currently
/// active scopes.
/// </exception>
internal IDictionary <string, List <CmdletInfo> > GetCmdletTableAtScope(string scopeID)
{
Dictionary <string, List <CmdletInfo> > result =
new Dictionary <string, List <CmdletInfo> >(StringComparer.OrdinalIgnoreCase);
SessionStateScope scope = GetScopeByID(scopeID);
foreach (KeyValuePair <string, List <CmdletInfo> > entry in scope.CmdletTable)
{
// Make sure the alias isn't private or if it is that the current
// scope is the same scope the alias was retrieved from.
List <CmdletInfo> toBeAdded = new List <CmdletInfo>();
foreach (CmdletInfo cmdletInfo in entry.Value)
{
if ((cmdletInfo.Options & ScopedItemOptions.Private) == 0 ||
scope == _currentScope)
{
toBeAdded.Add(cmdletInfo);
}
}
result.Add(entry.Key, toBeAdded);
}
return(result);
}
internal PSVariable GetVariable(ExecutionContext context)
{
if (this._useConstantValue)
{
return((PSVariable)null);
}
SessionStateInternal engineSessionState = context.EngineSessionState;
CommandOrigin scopeOrigin = engineSessionState.currentScope.ScopeOrigin;
if (!this._variablePath.IsScopedItem)
{
SessionStateScope scope = (SessionStateScope)null;
return(engineSessionState.GetVariableItem(this._variablePath, out scope, scopeOrigin));
}
PSVariable variable = engineSessionState.CurrentActivationRecord.GetVariable(this._activationRecordSlot, scopeOrigin);
if (variable == null)
{
SessionStateScope scope;
variable = engineSessionState.GetVariableItem(this._variablePath, out scope, scopeOrigin);
if (variable != null)
{
engineSessionState.CurrentActivationRecord.SetVariable(variable, scope, this._activationRecordSlot);
}
else if ((context.IsStrictVersion(2) || !this._inExpandableString && context.IsStrictVersion(1)) && !this.IsInternalCode)
{
throw InterpreterError.NewInterpreterException((object)this.NodeToken, typeof(RuntimeException), this.NodeToken, "VariableIsUndefined", (object)this.NodeToken);
}
}
return(variable);
}
/// <summary>
/// Gets the value of the specified cmdlet from the cmdlet table.
/// </summary>
/// <param name="cmdletName">
/// The name of the cmdlet value to retrieve.
/// </param>
/// <param name="scopeID">
/// A scope identifier that is either one of the "special" scopes like
/// "global", "script", "local", or "private, or a numeric ID of a relative scope
/// to the current scope.
/// </param>
/// <returns>
/// The CmdletInfo representing the cmdlet.
/// </returns>
/// <exception cref="ArgumentException">
/// If <paramref name="scopeID"/> is less than zero, or not
/// a number and not "script", "global", "local", or "private"
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// If <paramref name="scopeID"/> is less than zero or greater than the number of currently
/// active scopes.
/// </exception>
internal CmdletInfo GetCmdletAtScope(string cmdletName, string scopeID)
{
CmdletInfo result = null;
if (string.IsNullOrEmpty(cmdletName))
{
return(null);
}
SessionStateScope scope = GetScopeByID(scopeID);
result = scope.GetCmdlet(cmdletName);
// Make sure the alias isn't private or if it is that the current
// scope is the same scope the alias was retrieved from.
if (result != null &&
(result.Options & ScopedItemOptions.Private) != 0 &&
scope != _currentScope)
{
result = null;
}
return(result);
}
public bool MoveNext()
{
bool flag = true;
if (!this.isInitialized)
{
this.InitializeScopeEnumerator();
}
while (this.scopeEnumerable.MoveNext())
{
T local;
if (this.TryGetNewScopeItem(this.scopeEnumerable.Current, out local))
{
this.currentScope = this.scopeEnumerable.Current;
this.current = local;
return(true);
}
flag = false;
if (this.isSingleScopeLookup)
{
return(flag);
}
}
return(flag);
}
private void InitializeScopeEnumerator()
{
// Define the lookup scope and if we have to do single
// level or dynamic lookup based on the lookup variable
_initialScope = sessionState.CurrentScope;
if (_lookupPath.IsGlobal)
{
_initialScope = sessionState.GlobalScope;
_isSingleScopeLookup = true;
}
else if (_lookupPath.IsLocal ||
_lookupPath.IsPrivate)
{
_initialScope = sessionState.CurrentScope;
_isSingleScopeLookup = true;
}
else if (_lookupPath.IsScript)
{
_initialScope = sessionState.ScriptScope;
_isSingleScopeLookup = true;
}
_scopeEnumerable =
new SessionStateScopeEnumerator(_initialScope);
_isInitialized = true;
}
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);
}
public void PrepareForBinding(SessionStateScope scope, CommandLineParameters commandLineParameters)
{
if (this._useLocalScope && (scope.LocalsTuple == null))
{
scope.LocalsTuple = this._localsTuple;
}
this._localsTuple.SetAutomaticVariable(AutomaticVariable.PSBoundParameters, commandLineParameters.GetValueToBindToPSBoundParameters(), base.Context);
this._localsTuple.SetAutomaticVariable(AutomaticVariable.MyInvocation, base.MyInvocation, base.Context);
}
private static CommandCompletion CompleteInputImpl(Ast ast, Token[] tokens, IScriptPosition positionOfCursor, Hashtable options)
{
PowerShell powershell = PowerShell.Create(RunspaceMode.CurrentRunspace);
int replacementIndex = -1;
int replacementLength = -1;
List <CompletionResult> list = null;
if (NeedToInvokeLegacyTabExpansion(powershell))
{
Tuple <string, int, int> inputAndCursorFromAst = GetInputAndCursorFromAst(positionOfCursor);
list = InvokeLegacyTabExpansion(powershell, inputAndCursorFromAst.Item1, inputAndCursorFromAst.Item2, false, out replacementIndex, out replacementLength);
replacementIndex += inputAndCursorFromAst.Item3;
}
if ((list == null) || (list.Count == 0))
{
ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
MutableTuple tuple2 = null;
foreach (CallStackFrame frame in executionContextFromTLS.Debugger.GetCallStack())
{
dynamic obj2 = PSObject.AsPSObject(frame);
var site1 = CallSite <Func <CallSite, object, bool> > .Create(Binder.UnaryOperation(CSharpBinderFlags.None, ExpressionType.IsTrue, typeof(CommandCompletion), new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }));
if (site1.Target(site1, obj2.Command.Equals("TabExpansion2", StringComparison.OrdinalIgnoreCase)))
{
tuple2 = frame.FunctionContext._localsTuple;
break;
}
}
SessionStateScope currentScope = null;
if (tuple2 != null)
{
currentScope = executionContextFromTLS.EngineSessionState.CurrentScope;
SessionStateScope parent = executionContextFromTLS.EngineSessionState.CurrentScope;
while ((parent != null) && (parent.LocalsTuple != tuple2))
{
parent = parent.Parent;
}
if (parent != null)
{
executionContextFromTLS.EngineSessionState.CurrentScope = parent.Parent;
}
}
try
{
list = new CompletionAnalysis(ast, tokens, positionOfCursor, options).GetResults(powershell, out replacementIndex, out replacementLength);
}
finally
{
if (currentScope != null)
{
executionContextFromTLS.EngineSessionState.CurrentScope = currentScope;
}
}
}
return(new CommandCompletion(new Collection <CompletionResult>(list ?? EmptyCompletionResult), -1, replacementIndex, replacementLength));
}
private bool TryGetNewScopeItem(
SessionStateScope lookupScope,
out T newCurrentItem)
{
bool result = GetScopeItem(
lookupScope,
_lookupPath,
out newCurrentItem);
return(result);
}
internal SessionStateInternal(SessionStateInternal parent, bool linkToGlobal, ExecutionContext context)
{
if (context == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(context));
}
ExecutionContext = context;
// Create the working directory stack. This
// is used for the pushd and popd commands
_workingLocationStack = new Dictionary <string, Stack <PathInfo> >(StringComparer.OrdinalIgnoreCase);
// Conservative choice to limit the Set-Location history in order to limit memory impact in case of a regression.
const int locationHistoryLimit = 20;
_setLocationHistory = new HistoryStack <PathInfo>(locationHistoryLimit);
GlobalScope = new SessionStateScope(null);
ModuleScope = GlobalScope;
_currentScope = GlobalScope;
InitializeSessionStateInternalSpecialVariables(false);
// Create the push the global scope on as
// the starting script scope. That way, if you dot-source a script
// that uses variables qualified by script: it works.
GlobalScope.ScriptScope = GlobalScope;
if (parent != null)
{
GlobalScope.Parent = parent.GlobalScope;
// Copy the drives and providers from the parent...
CopyProviders(parent);
// During loading of core modules, providers are not populated.
// We set the drive information later
if (Providers != null && Providers.Count > 0)
{
CurrentDrive = parent.CurrentDrive;
}
// Link it to the global scope...
if (linkToGlobal)
{
GlobalScope = parent.GlobalScope;
}
}
else
{
_currentScope.LocalsTuple = MutableTuple.MakeTuple(Compiler.DottedLocalsTupleType, Compiler.DottedLocalsNameIndexMap);
}
}
protected override bool GetScopeItem(SessionStateScope scope, VariablePath name, out PSDriveInfo drive)
{
bool flag = true;
drive = scope.GetDrive(name.DriveName);
if (drive == null)
{
flag = false;
}
return(flag);
}
/// <summary>
/// Constructs a ScriptParameterBinder with the specified context
/// </summary>
///
/// <param name="script">
/// The script block representing the code being run
/// </param>
///
/// <param name="invocationInfo">
/// The invocation information about the code that is being run.
/// </param>
///
/// <param name="context">
/// The context under which the shell function is executing.
/// </param>
///
/// <param name="command">
/// The command instance that represents the script in a pipeline. May be null.
/// </param>
///
/// <param name="localScope">
/// If binding in a new local scope, the scope to set variables in. If dotting, the value is null.
/// </param>
internal ScriptParameterBinder(
ScriptBlock script,
InvocationInfo invocationInfo,
ExecutionContext context,
InternalCommand command,
SessionStateScope localScope) : base(invocationInfo, context, command)
{
Diagnostics.Assert(script != null, "caller to verify script is not null.");
this.Script = script;
this.LocalScope = localScope;
}
internal void SetCurrentScopeToExecutionScope()
{
if (this._commandSessionState == null)
{
this._commandSessionState = this.Context.EngineSessionState;
}
this._previousScope = this._commandSessionState.CurrentScope;
this._previousCommandSessionState = this.Context.EngineSessionState;
this.Context.EngineSessionState = this._commandSessionState;
this._commandSessionState.CurrentScope = this.CommandScope;
this.OnSetCurrentScope();
}
/// <summary>
/// Constructs a ScriptParameterBinder with the specified context.
/// </summary>
/// <param name="script">
/// The script block representing the code being run
/// </param>
/// <param name="invocationInfo">
/// The invocation information about the code that is being run.
/// </param>
/// <param name="context">
/// The context under which the shell function is executing.
/// </param>
/// <param name="command">
/// The command instance that represents the script in a pipeline. May be null.
/// </param>
/// <param name="localScope">
/// If binding in a new local scope, the scope to set variables in. If dotting, the value is null.
/// </param>
internal ScriptParameterBinder(
ScriptBlock script,
InvocationInfo invocationInfo,
ExecutionContext context,
InternalCommand command,
SessionStateScope localScope) : base(invocationInfo, context, command)
{
Diagnostics.Assert(script != null, "caller to verify script is not null.");
this.Script = script;
this.LocalScope = localScope;
}
internal ScriptParameterBinderController(ScriptBlock script, InvocationInfo invocationInfo, ExecutionContext context, InternalCommand command, SessionStateScope localScope) : base(invocationInfo, context, new ScriptParameterBinder(script, invocationInfo, context, command, localScope))
{
this.DollarArgs = new List<object>();
if (script.HasDynamicParameters)
{
base.UnboundParameters = base.BindableParameters.ReplaceMetadata(script.ParameterMetadata);
}
else
{
base._bindableParameters = script.ParameterMetadata;
base.UnboundParameters = new List<MergedCompiledCommandParameter>(base._bindableParameters.BindableParameters.Values);
}
}
internal SessionStateScope(SessionStateScope parentScope)
{
this.ScopeOrigin = CommandOrigin.Internal;
this.Parent = parentScope;
if (parentScope != null)
{
this._scriptScope = parentScope.ScriptScope;
}
else
{
this._scriptScope = this;
}
}
internal SessionStateScope(SessionStateScope parentScope)
{
this.ScopeOrigin = CommandOrigin.Internal;
this.Parent = parentScope;
if (parentScope != null)
{
this._scriptScope = parentScope.ScriptScope;
}
else
{
this._scriptScope = this;
}
}
internal SessionStateInternal(SessionStateInternal parent, bool linkToGlobal, ExecutionContext context)
{
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
ExecutionContext = context;
// Create the working directory stack. This
// is used for the pushd and popd commands
_workingLocationStack = new Dictionary<String, Stack<PathInfo>>(StringComparer.OrdinalIgnoreCase);
GlobalScope = new SessionStateScope(null);
ModuleScope = GlobalScope;
_currentScope = GlobalScope;
InitializeSessionStateInternalSpecialVariables(false);
// Create the push the global scope on as
// the starting script scope. That way, if you dot-source a script
// that uses variables qualified by script: it works.
GlobalScope.ScriptScope = GlobalScope;
if (parent != null)
{
GlobalScope.Parent = parent.GlobalScope;
// Copy the drives and providers from the parent...
CopyProviders(parent);
// During loading of core modules, providers are not populated.
// We set the drive information later
if (Providers != null && Providers.Count > 0)
{
CurrentDrive = parent.CurrentDrive;
}
// Link it to the global scope...
if (linkToGlobal)
{
GlobalScope = parent.GlobalScope;
}
}
else
{
_currentScope.LocalsTuple = MutableTuple.MakeTuple(Compiler.DottedLocalsTupleType, Compiler.DottedLocalsNameIndexMap);
}
}
/// <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>
/// Constructor for a session state scope.
/// </summary>
///
/// <param name="parentScope">
/// The parent of this scope. It can be null for the global scope.
/// </param>
///
internal SessionStateScope(SessionStateScope parentScope)
{
ScopeOrigin = CommandOrigin.Internal;
Parent = parentScope;
if (parentScope != null)
{
// Now copy the script: scope stack from the parent
_scriptScope = parentScope.ScriptScope;
}
else
{
_scriptScope = this;
}
} // SessionStateScope constructor
internal bool IsStrictVersion(int majorVersion)
{
for (SessionStateScope scope = this.EngineSessionState.CurrentScope; scope != null; scope = scope.Parent)
{
if (scope.StrictModeVersion != null)
{
return(scope.StrictModeVersion.Major >= majorVersion);
}
if (scope == this.EngineSessionState.ModuleScope)
{
break;
}
}
return(false);
}
internal SessionStateScope(SessionStateScope parentScope)
{
using (SessionStateScope.tracer.TraceConstructor((object)this))
{
this.parent = parentScope;
if (parentScope != null)
{
parentScope.Children.Add(this);
this.scriptScope = parentScope.ScriptScope;
}
else
{
this.scriptScope = this;
}
}
}
/// <summary>
/// Creates a new scope in the scope tree and assigns the parent
/// and child scopes appropriately.
/// </summary>
/// <param name="isScriptScope">
/// If true, the new scope is pushed on to the script scope stack and
/// can be referenced using $script:
/// </param>
/// <returns>
/// A new SessionStateScope which is a child of the current scope.
/// </returns>
internal SessionStateScope NewScope(bool isScriptScope)
{
Diagnostics.Assert(
_currentScope != null,
"The currentScope should always be set.");
// Create the new child scope.
SessionStateScope newScope = new SessionStateScope(_currentScope);
if (isScriptScope)
{
newScope.ScriptScope = newScope;
}
return(newScope);
} // NewScope
internal T GetEnumPreference <T>(VariablePath preferenceVariablePath, T defaultPref, out bool defaultUsed)
{
CmdletProviderContext context = null;
SessionStateScope scope = null;
object obj2 = this.EngineSessionState.GetVariableValue(preferenceVariablePath, out context, out scope);
if (obj2 is T)
{
if (obj2 is ActionPreference)
{
ActionPreference o = (ActionPreference)obj2;
if (o == ActionPreference.Ignore)
{
this.EngineSessionState.SetVariableValue(preferenceVariablePath.UserPath, defaultPref);
throw new NotSupportedException(StringUtil.Format(ErrorPackage.UnsupportedPreferenceError, o));
}
}
T local = (T)obj2;
defaultUsed = false;
return(local);
}
defaultUsed = true;
T local2 = defaultPref;
if (obj2 != null)
{
try
{
string str2 = obj2 as string;
if (str2 != null)
{
local2 = (T)Enum.Parse(typeof(T), str2, true);
defaultUsed = false;
return(local2);
}
local2 = (T)obj2;
defaultUsed = false;
}
catch (InvalidCastException)
{
}
catch (ArgumentException)
{
}
}
return(local2);
}
/// <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="name">
/// The name of the item to retrieve.
/// </param>
///
/// <param name="drive">
/// 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 name,
out PSDriveInfo drive)
{
Diagnostics.Assert(!(name is FunctionLookupPath),
"name was scanned incorrect if we get here and it is a FunctionLookupPath");
bool result = true;
drive = scope.GetDrive(name.DriveName);
if (drive == null)
{
result = false;
}
return(result);
}
internal SessionStateInternal(SessionStateInternal parent, bool linkToGlobal, System.Management.Automation.ExecutionContext context)
{
this.ModuleTableKeys = new List<string>();
this._moduleTable = new Dictionary<string, PSModuleInfo>(StringComparer.OrdinalIgnoreCase);
this._scripts = new List<string>(new string[] { "*" });
this._applications = new List<string>(new string[] { "*" });
this._exportedCmdlets = new List<CmdletInfo>();
this._exportedAliases = new List<AliasInfo>();
this._exportedFunctions = new List<FunctionInfo>();
this._exportedWorkflows = new List<WorkflowInfo>();
this.defaultStackName = "default";
this._providers = new Dictionary<string, List<ProviderInfo>>(100, StringComparer.OrdinalIgnoreCase);
this._providersCurrentWorkingDrive = new Dictionary<ProviderInfo, PSDriveInfo>();
this._exportedVariables = new List<PSVariable>();
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
this._context = context;
this.workingLocationStack = new Dictionary<string, Stack<PathInfo>>(StringComparer.OrdinalIgnoreCase);
this._globalScope = new SessionStateScope(null);
this._moduleScope = this._globalScope;
this.currentScope = this._globalScope;
this.InitializeSessionStateInternalSpecialVariables(false);
this._globalScope.ScriptScope = this._globalScope;
if (parent != null)
{
this._globalScope.Parent = parent.GlobalScope;
this.CopyProviders(parent);
if ((this.Providers != null) && (this.Providers.Count > 0))
{
this.CurrentDrive = parent.CurrentDrive;
}
if (linkToGlobal)
{
this._globalScope = parent.GlobalScope;
}
}
else
{
this.currentScope.LocalsTuple = MutableTuple.MakeTuple(Compiler.DottedLocalsTupleType, Compiler.DottedLocalsNameIndexMap);
}
}
public void Set(string name, object value)
{
var qualName = new SessionStateScope <PSVariable> .QualifiedName(name);
// check for existing one. if it's not a scope qualified name, make sure to check only local scope
// because we won't override a parent scope variable with the same name
var variable = qualName.ScopeSpecifier.Length == 0 ? _intrinsics.Scope.GetLocal(name)
: _intrinsics.Scope.Get(name, true);
if (variable == null) // doesn't exist, yet. create
{
_intrinsics.Scope.Set(name, new PSVariable(qualName.UnqualifiedName, value), true, true);
return;
}
// make sure it's not read only
CheckVariableCanBeChanged(variable);
// only modify the value of the old one
variable.Value = value;
}
//actual constructor work, but hidden to not be used accidently in a stupid way
private SessionState(SessionStateGlobal sessionStateGlobal, SessionStateScope <FunctionInfo> functions,
SessionStateScope <PSVariable> variables, SessionStateScope <PSDriveInfo> drives,
SessionStateScope <AliasInfo> aliases)
{
SessionStateGlobal = sessionStateGlobal;
_aliasScope = new SessionStateScope <AliasInfo>(aliases, SessionStateCategory.Alias);
_functionScope = new SessionStateScope <FunctionInfo>(functions, SessionStateCategory.Function);
_variableScope = new SessionStateScope <PSVariable>(variables, SessionStateCategory.Variable);
_driveScope = new SessionStateScope <PSDriveInfo>(drives, SessionStateCategory.Drive);
IsScriptScope = false;
Function = new FunctionIntrinsics(this, _functionScope);
Alias = new AliasIntrinsics(this, _aliasScope);
Drive = new DriveManagementIntrinsics(this, _driveScope);
Path = new PathIntrinsics(SessionStateGlobal);
Provider = new CmdletProviderManagementIntrinsics(SessionStateGlobal);
PSVariable = new PSVariableIntrinsics(this, _variableScope);
}
//actual constructor work, but hidden to not be used accidently in a stupid way
private SessionState(SessionStateGlobal sessionStateGlobal, SessionStateScope<FunctionInfo> functions,
SessionStateScope<PSVariable> variables, SessionStateScope<PSDriveInfo> drives,
SessionStateScope<AliasInfo> aliases)
{
SessionStateGlobal = sessionStateGlobal;
_aliasScope = new SessionStateScope<AliasInfo>(aliases, SessionStateCategory.Alias);
_functionScope = new SessionStateScope<FunctionInfo>(functions, SessionStateCategory.Function);
_variableScope = new SessionStateScope<PSVariable>(variables, SessionStateCategory.Variable);
_driveScope = new SessionStateScope<PSDriveInfo>(drives, SessionStateCategory.Drive);
IsScriptScope = false;
Function = new FunctionIntrinsics(this, _functionScope);
Alias = new AliasIntrinsics(this, _aliasScope);
Drive = new DriveManagementIntrinsics(this, _driveScope);
Path = new PathIntrinsics(SessionStateGlobal);
Provider = new CmdletProviderManagementIntrinsics(SessionStateGlobal);
PSVariable = new PSVariableIntrinsics(this, _variableScope);
}
/// <summary>
/// Initializes the cmdlet parameter binder controller for
/// the specified cmdlet and engine context
/// </summary>
///
/// <param name="script">
/// The script that contains the parameter metadata.
/// </param>
/// <param name="invocationInfo">
/// The invocation information about the code being run.
/// </param>
/// <param name="context">
/// The engine context the cmdlet is run in.
/// </param>
/// <param name="command">
/// The command that the parameters will be bound to.
/// </param>
/// <param name="localScope">
/// The scope that the parameter binder will use to set parameters.
/// </param>
internal ScriptParameterBinderController(
ScriptBlock script,
InvocationInfo invocationInfo,
ExecutionContext context,
InternalCommand command,
SessionStateScope localScope)
: base(invocationInfo, context, new ScriptParameterBinder(script, invocationInfo, context, command, localScope))
{
this.DollarArgs = new List<object>();
// Add the script parameter metadata to the bindable parameters
// And add them to the unbound parameters list
if (script.HasDynamicParameters)
{
UnboundParameters = this.BindableParameters.ReplaceMetadata(script.ParameterMetadata);
}
else
{
_bindableParameters = script.ParameterMetadata;
UnboundParameters = new List<MergedCompiledCommandParameter>(_bindableParameters.BindableParameters.Values);
}
}
internal void NewDrive(PSDriveInfo drive, string scopeID, CmdletProviderContext context)
{
if (drive == null)
{
throw PSTraceSource.NewArgumentNullException("drive");
}
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
if (!IsValidDriveName(drive.Name))
{
throw PSTraceSource.NewArgumentException("drive.Name", "SessionStateStrings", "DriveNameIllegalCharacters", new object[0]);
}
PSDriveInfo newDrive = this.ValidateDriveWithProvider(drive, context, true);
if (newDrive != null)
{
if (string.Compare(newDrive.Name, drive.Name, true, Thread.CurrentThread.CurrentCulture) != 0)
{
throw this.NewProviderInvocationException("NewDriveProviderFailed", SessionStateStrings.NewDriveProviderFailed, drive.Provider, drive.Root, PSTraceSource.NewArgumentException("root"));
}
try
{
SessionStateScope currentScope = this.currentScope;
if (!string.IsNullOrEmpty(scopeID))
{
currentScope = this.GetScopeByID(scopeID);
}
currentScope.NewDrive(newDrive);
}
catch (ArgumentException exception2)
{
context.WriteError(new ErrorRecord(exception2, "NewDriveError", ErrorCategory.InvalidArgument, newDrive));
return;
}
catch (SessionStateException)
{
throw;
}
if (this.ProvidersCurrentWorkingDrive[drive.Provider] == null)
{
this.ProvidersCurrentWorkingDrive[drive.Provider] = drive;
}
context.WriteObject(newDrive);
}
}
internal SessionStateScope NewScope(bool isScriptScope)
{
SessionStateScope scope = new SessionStateScope(this.currentScope);
if (isScriptScope)
{
scope.ScriptScope = scope;
}
return scope;
}
} // NewScope
/// <summary>
/// Removes the current scope from the scope tree and
/// changes the current scope to the parent scope.
/// </summary>
///
/// <param name="scope">
/// The scope to cleanup and remove.
/// </param>
///
/// <exception cref="SessionStateUnauthorizedAccessException">
/// The global scope cannot be removed.
/// </exception>
///
internal void RemoveScope(SessionStateScope scope)
{
Diagnostics.Assert(
_currentScope != null,
"The currentScope should always be set.");
if (scope == GlobalScope)
{
SessionStateUnauthorizedAccessException e =
new SessionStateUnauthorizedAccessException(
StringLiterals.Global,
SessionStateCategory.Scope,
"GlobalScopeCannotRemove",
SessionStateStrings.GlobalScopeCannotRemove);
throw e;
}
// Give the provider a chance to cleanup the drive data associated
// with drives in this scope
foreach (PSDriveInfo drive in scope.Drives)
{
if (drive == null)
{
continue;
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
// Call CanRemoveDrive to give the provider a chance to cleanup
// but ignore the return value and exceptions
try
{
CanRemoveDrive(drive, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception e) // Catch-all OK, 3rd party callout.
{
CommandProcessorBase.CheckForSevereException(e);
// Ignore all exceptions from the provider as we are
// going to force the removal anyway
}
} // foreach drive
scope.RemoveAllDrives();
// If the scope being removed is the current scope,
// then it must be removed from the tree.
if (scope == _currentScope && _currentScope.Parent != null)
{
_currentScope = _currentScope.Parent;
}
scope.Parent = null;
} // RemoveScope
public void QualifiedNameTest(string name, string specifier, string unqualifiedName)
{
var qualName = new SessionStateScope<PSVariable>.QualifiedName(name);
Assert.AreEqual(specifier, qualName.ScopeSpecifier);
Assert.AreEqual(unqualifiedName, qualName.UnqualifiedName);
}
internal PSVariable GetVariableItem(VariablePath variablePath, out SessionStateScope scope, CommandOrigin origin)
{
scope = null;
if (variablePath == null)
{
throw PSTraceSource.NewArgumentNullException("variablePath");
}
VariableScopeItemSearcher searcher = new VariableScopeItemSearcher(this, variablePath, origin);
PSVariable current = null;
if (searcher.MoveNext())
{
current = (PSVariable)searcher.Current;
scope = searcher.CurrentLookupScope;
}
return current;
}
private void GetScopeVariableTable(SessionStateScope scope, Dictionary<string, PSVariable> result, bool includePrivate)
{
foreach (KeyValuePair<string, PSVariable> pair in scope.Variables)
{
if (!result.ContainsKey(pair.Key))
{
PSVariable variable = pair.Value;
if (!variable.IsPrivate || includePrivate)
{
result.Add(pair.Key, variable);
}
}
}
foreach (MutableTuple tuple in scope.DottedScopes)
{
tuple.GetVariableTable(result, includePrivate);
}
if (scope.LocalsTuple != null)
{
scope.LocalsTuple.GetVariableTable(result, includePrivate);
}
}
internal void SetCurrentScopeToExecutionScope()
{
if (this._commandSessionState == null)
{
this._commandSessionState = this.Context.EngineSessionState;
}
this._previousScope = this._commandSessionState.CurrentScope;
this._previousCommandSessionState = this.Context.EngineSessionState;
this.Context.EngineSessionState = this._commandSessionState;
this._commandSessionState.CurrentScope = this.CommandScope;
this.OnSetCurrentScope();
}
internal object SetVariable(VariablePath variablePath, object newValue, bool asValue, bool force, CommandOrigin origin)
{
if (variablePath == null)
{
throw PSTraceSource.NewArgumentNullException("variablePath");
}
CmdletProviderContext context = null;
SessionStateScope currentScope = null;
if (variablePath.IsVariable)
{
if (variablePath.IsLocal || variablePath.IsUnscopedVariable)
{
currentScope = this.currentScope;
}
else if (variablePath.IsScript)
{
currentScope = this.currentScope.ScriptScope;
}
else if (variablePath.IsGlobal)
{
currentScope = this._globalScope;
}
else if (variablePath.IsPrivate)
{
currentScope = this.currentScope;
}
PSVariable variable = currentScope.SetVariable(variablePath.QualifiedName, newValue, asValue, force, this, origin, false);
if (variablePath.IsPrivate && (variable != null))
{
variable.Options |= ScopedItemOptions.Private;
}
return variable;
}
this.GetVariableValue(variablePath, out context, out currentScope);
Collection<IContentWriter> contentWriter = null;
try
{
if (context != null)
{
try
{
CmdletProviderContext context2 = new CmdletProviderContext(context);
this.ClearContent(new string[] { variablePath.QualifiedName }, context2);
}
catch (NotSupportedException)
{
}
catch (ItemNotFoundException)
{
}
contentWriter = this.GetContentWriter(new string[] { variablePath.QualifiedName }, context);
context.ThrowFirstErrorOrDoNothing(true);
}
else
{
try
{
this.ClearContent(new string[] { variablePath.QualifiedName }, false, false);
}
catch (NotSupportedException)
{
}
catch (ItemNotFoundException)
{
}
contentWriter = this.GetContentWriter(new string[] { variablePath.QualifiedName }, false, false);
}
}
catch (NotImplementedException exception)
{
ProviderInfo provider = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out provider);
throw this.NewProviderInvocationException("ProviderCannotBeUsedAsVariable", SessionStateStrings.ProviderCannotBeUsedAsVariable, provider, variablePath.QualifiedName, exception, false);
}
catch (NotSupportedException exception2)
{
ProviderInfo info2 = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out info2);
throw this.NewProviderInvocationException("ProviderCannotBeUsedAsVariable", SessionStateStrings.ProviderCannotBeUsedAsVariable, info2, variablePath.QualifiedName, exception2, false);
}
if ((contentWriter == null) || (contentWriter.Count == 0))
{
ItemNotFoundException exception3 = new ItemNotFoundException(variablePath.QualifiedName, "PathNotFound", SessionStateStrings.PathNotFound);
throw exception3;
}
if (contentWriter.Count > 1)
{
foreach (IContentWriter writer in contentWriter)
{
writer.Close();
}
PSArgumentException e = PSTraceSource.NewArgumentException("path", "SessionStateStrings", "VariablePathResolvedToMultiple", new object[] { variablePath.QualifiedName });
ProviderInfo info3 = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out info3);
throw this.NewProviderInvocationException("ProviderVariableSyntaxInvalid", SessionStateStrings.ProviderVariableSyntaxInvalid, info3, variablePath.QualifiedName, e);
}
IContentWriter writer2 = contentWriter[0];
IList content = newValue as IList;
if (content == null)
{
content = new object[] { newValue };
}
try
{
writer2.Write(content);
}
catch (Exception exception5)
{
ProviderInfo info4 = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out info4);
CommandProcessorBase.CheckForSevereException(exception5);
ProviderInvocationException exception6 = new ProviderInvocationException("ProviderContentWriteError", SessionStateStrings.ProviderContentWriteError, info4, variablePath.QualifiedName, exception5);
throw exception6;
}
finally
{
writer2.Close();
}
return null;
}
internal bool IsShellVirtualDrive(string driveName, out SessionStateScope scope)
{
if (driveName == null)
{
throw PSTraceSource.NewArgumentNullException("driveName");
}
bool flag = false;
if (string.Compare(driveName, "GLOBAL", StringComparison.OrdinalIgnoreCase) == 0)
{
tracer.WriteLine("match found: {0}", new object[] { "GLOBAL" });
flag = true;
scope = this.sessionState.Internal.GlobalScope;
}
else if (string.Compare(driveName, "LOCAL", StringComparison.OrdinalIgnoreCase) == 0)
{
tracer.WriteLine("match found: {0}", new object[] { driveName });
flag = true;
scope = this.sessionState.Internal.CurrentScope;
}
else
{
scope = null;
}
tracer.WriteLine("result = {0}", new object[] { flag });
return flag;
}
private bool ValidateOrRemoveAutoMountedDrive(PSDriveInfo drive, SessionStateScope scope)
{
bool flag = true;
try
{
DriveInfo info = new DriveInfo(drive.Name);
flag = info.DriveType != DriveType.NoRootDirectory;
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
flag = false;
}
if (!flag)
{
DriveCmdletProvider driveProviderInstance = null;
try
{
driveProviderInstance = this.GetDriveProviderInstance(this.ExecutionContext.ProviderNames.FileSystem);
}
catch (NotSupportedException)
{
}
catch (ProviderNotFoundException)
{
}
if (driveProviderInstance == null)
{
return flag;
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
try
{
driveProviderInstance.RemoveDrive(drive, context);
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
}
scope.RemoveDrive(drive);
}
return flag;
}
internal object GetVariableValueFromProvider(VariablePath variablePath, out CmdletProviderContext context, out SessionStateScope scope, CommandOrigin origin)
{
scope = null;
if (variablePath == null)
{
throw PSTraceSource.NewArgumentNullException("variablePath");
}
context = null;
DriveScopeItemSearcher searcher = new DriveScopeItemSearcher(this, variablePath);
object obj2 = null;
if (searcher.MoveNext())
{
PSDriveInfo current = (PSDriveInfo)searcher.Current;
if (current == null)
{
return obj2;
}
context = new CmdletProviderContext(this.ExecutionContext, origin);
context.Drive = current;
Collection<IContentReader> contentReader = null;
try
{
contentReader = this.GetContentReader(new string[] { variablePath.QualifiedName }, context);
}
catch (ItemNotFoundException)
{
return obj2;
}
catch (System.Management.Automation.DriveNotFoundException)
{
return obj2;
}
catch (ProviderNotFoundException)
{
return obj2;
}
catch (NotImplementedException exception)
{
ProviderInfo provider = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out provider);
throw this.NewProviderInvocationException("ProviderCannotBeUsedAsVariable", SessionStateStrings.ProviderCannotBeUsedAsVariable, provider, variablePath.QualifiedName, exception, false);
}
catch (NotSupportedException exception2)
{
ProviderInfo info3 = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out info3);
throw this.NewProviderInvocationException("ProviderCannotBeUsedAsVariable", SessionStateStrings.ProviderCannotBeUsedAsVariable, info3, variablePath.QualifiedName, exception2, false);
}
if ((contentReader == null) || (contentReader.Count == 0))
{
return obj2;
}
if (contentReader.Count > 1)
{
foreach (IContentReader reader in contentReader)
{
reader.Close();
}
PSArgumentException e = PSTraceSource.NewArgumentException("path", "SessionStateStrings", "VariablePathResolvedToMultiple", new object[] { variablePath.QualifiedName });
ProviderInfo info4 = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out info4);
throw this.NewProviderInvocationException("ProviderVariableSyntaxInvalid", SessionStateStrings.ProviderVariableSyntaxInvalid, info4, variablePath.QualifiedName, e);
}
IContentReader reader2 = contentReader[0];
try
{
IList list = reader2.Read(-1L);
if (list == null)
{
return obj2;
}
if (list.Count == 0)
{
return null;
}
if (list.Count == 1)
{
return list[0];
}
return list;
}
catch (Exception exception4)
{
ProviderInfo info5 = null;
this.Globber.GetProviderPath(variablePath.QualifiedName, out info5);
CommandProcessorBase.CheckForSevereException(exception4);
ProviderInvocationException exception5 = new ProviderInvocationException("ProviderContentReadError", SessionStateStrings.ProviderContentReadError, info5, variablePath.QualifiedName, exception4);
throw exception5;
}
finally
{
reader2.Close();
}
}
return obj2;
}
internal object GetVariableValue(VariablePath variablePath, out CmdletProviderContext context, out SessionStateScope scope)
{
context = null;
scope = null;
object obj2 = null;
if (variablePath.IsVariable)
{
PSVariable variableItem = this.GetVariableItem(variablePath, out scope);
if (variableItem != null)
{
obj2 = variableItem.Value;
}
return obj2;
}
return this.GetVariableValueFromProvider(variablePath, out context, out scope, this.currentScope.ScopeOrigin);
}
internal SessionStateScope GetScopeByID(int scopeID)
{
SessionStateScope currentScope = this.currentScope;
int actualValue = scopeID;
while ((scopeID > 0) && (currentScope != null))
{
currentScope = currentScope.Parent;
scopeID--;
}
if ((currentScope == null) && (scopeID >= 0))
{
throw PSTraceSource.NewArgumentOutOfRangeException("scopeID", actualValue, "SessionStateStrings", "ScopeIDExceedsAvailableScopes", new object[] { actualValue });
}
return currentScope;
}
internal PSVariable GetVariableItem(VariablePath variablePath, out SessionStateScope scope)
{
return this.GetVariableItem(variablePath, out scope, CommandOrigin.Internal);
}
/// <summary>
/// Creates a new scope in the scope tree and assigns the parent
/// and child scopes appropriately.
/// </summary>
///
/// <param name="isScriptScope">
/// If true, the new scope is pushed on to the script scope stack and
/// can be referenced using $script:
/// </param>
///
/// <returns>
/// A new SessionStateScope which is a child of the current scope.
/// </returns>
///
internal SessionStateScope NewScope(bool isScriptScope)
{
Diagnostics.Assert(
_currentScope != null,
"The currentScope should always be set.");
// Create the new child scope.
SessionStateScope newScope = new SessionStateScope(_currentScope);
if (isScriptScope)
{
newScope.ScriptScope = newScope;
}
return newScope;
} // NewScope
internal SessionStateScope GetScopeByID(string scopeID)
{
SessionStateScope currentScope = this.currentScope;
if (!string.IsNullOrEmpty(scopeID))
{
if (string.Equals(scopeID, "GLOBAL", StringComparison.OrdinalIgnoreCase))
{
return this._globalScope;
}
if (string.Equals(scopeID, "LOCAL", StringComparison.OrdinalIgnoreCase))
{
return this.currentScope;
}
if (string.Equals(scopeID, "PRIVATE", StringComparison.OrdinalIgnoreCase))
{
return this.currentScope;
}
if (string.Equals(scopeID, "SCRIPT", StringComparison.OrdinalIgnoreCase))
{
return this.currentScope.ScriptScope;
}
try
{
int num = int.Parse(scopeID, Thread.CurrentThread.CurrentCulture);
if (num < 0)
{
throw PSTraceSource.NewArgumentOutOfRangeException("scopeID", scopeID);
}
currentScope = this.GetScopeByID(num) ?? this.currentScope;
}
catch (FormatException)
{
throw PSTraceSource.NewArgumentException("scopeID");
}
catch (OverflowException)
{
throw PSTraceSource.NewArgumentOutOfRangeException("scopeID", scopeID);
}
}
return currentScope;
}
internal void RemoveScope(SessionStateScope scope)
{
if (scope == this._globalScope)
{
SessionStateUnauthorizedAccessException exception = new SessionStateUnauthorizedAccessException("GLOBAL", SessionStateCategory.Scope, "GlobalScopeCannotRemove", SessionStateStrings.GlobalScopeCannotRemove);
throw exception;
}
foreach (PSDriveInfo info in scope.Drives)
{
if (info != null)
{
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
try
{
this.CanRemoveDrive(info, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
}
}
}
scope.RemoveAllDrives();
if ((scope == this.currentScope) && (this.currentScope.Parent != null))
{
this.currentScope = this.currentScope.Parent;
}
scope.Parent = null;
}
internal void RemoveFunction(string name, bool force, CommandOrigin origin)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
SessionStateScope currentScope = this.currentScope;
FunctionLookupPath lookupPath = new FunctionLookupPath(name);
FunctionScopeItemSearcher searcher = new FunctionScopeItemSearcher(this, lookupPath, origin);
if (searcher.MoveNext())
{
currentScope = searcher.CurrentLookupScope;
}
currentScope.RemoveFunction(name, force);
}
public void PrepareForBinding(SessionStateScope scope, CommandLineParameters commandLineParameters)
{
if (_useLocalScope && scope.LocalsTuple == null)
{
scope.LocalsTuple = _localsTuple;
}
_localsTuple.SetAutomaticVariable(AutomaticVariable.PSBoundParameters,
commandLineParameters.GetValueToBindToPSBoundParameters(), this.Context);
_localsTuple.SetAutomaticVariable(AutomaticVariable.MyInvocation, MyInvocation, this.Context);
}
} // RemoveGlobEscaping
#region Path manipulation methods
/// <summary>
/// Determines if the given drive name is a "special" name defined
/// by the shell. For instance, "default", "current", "global", and "scope[##]" are scopes
/// for variables and are considered shell virtual drives.
/// </summary>
///
/// <param name="driveName">
/// The name of the drive to check to see if it is a shell virtual drive.
/// </param>
///
/// <param name="scope">
/// This out parameter is filled with the scope that the drive name represents.
/// It will be null if the driveName does not represent a scope.
/// </param>
///
/// <returns>
/// true, if the drive name is a shell virtual drive like "Default" or "global",
/// false otherwise.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="driveName" /> is null.
/// </exception>
///
/// <remarks>
/// The comparison is done using a case-insensitive comparison using the
/// Invariant culture.
///
/// This is internal so that it is accessible to SessionState.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="driveName"/> is null.
/// </exception>
///
internal bool IsShellVirtualDrive(string driveName, out SessionStateScope scope)
{
if (driveName == null)
{
throw PSTraceSource.NewArgumentNullException("driveName");
}
bool result = false;
// Is it the global scope?
if (String.Compare(
driveName,
StringLiterals.Global,
StringComparison.OrdinalIgnoreCase) == 0)
{
s_tracer.WriteLine("match found: {0}", StringLiterals.Global);
result = true;
scope = _sessionState.Internal.GlobalScope;
} // globalScope
// Is it the local scope?
else if (String.Compare(
driveName,
StringLiterals.Local,
StringComparison.OrdinalIgnoreCase) == 0)
{
s_tracer.WriteLine("match found: {0}", driveName);
result = true;
scope = _sessionState.Internal.CurrentScope;
} // currentScope
else
{
scope = null;
}
return result;
} // IsShellVirtualDrive
internal ScriptParameterBinder(ScriptBlock script, InvocationInfo invocationInfo, ExecutionContext context, InternalCommand command, SessionStateScope localScope) : base(invocationInfo, context, command)
{
this._copyMutableValueSite = CallSite<Func<CallSite, object, object>>.Create(PSVariableAssignmentBinder.Get());
this.Script = script;
this.LocalScope = localScope;
}