public PSModuleInfo(ScriptBlock scriptBlock)
{
this._context = LocalPipeline.GetExecutionContextFromTLS();
if (this._context == null)
{
throw new InvalidOperationException(nameof(PSModuleInfo));
}
PSModuleInfo.SetDefaultDynamicNameAndPath(this);
this._sessionState = new SessionState(this._context.EngineSessionState, true, true);
this._sessionState.Internal.Module = this;
SessionStateInternal engineSessionState = this._context.EngineSessionState;
try
{
ArrayList resultList = (ArrayList)null;
this._context.EngineSessionState = this._sessionState.Internal;
this._context.EngineSessionState.SetVariableValue("PSScriptRoot", (object)this._path);
scriptBlock = scriptBlock.Clone(true);
scriptBlock.SessionState = this._sessionState;
if (scriptBlock == null)
{
throw PSModuleInfo.tracer.NewInvalidOperationException();
}
scriptBlock.InvokeWithPipe(false, true, (object)AutomationNull.Value, (object)AutomationNull.Value, (object)AutomationNull.Value, (Pipe)null, ref resultList);
}
finally
{
this._context.EngineSessionState = engineSessionState;
}
}
public Collection <PSObject> InvokeScript(SessionState sessionState, ScriptBlock scriptBlock, params object[] args)
{
Collection <PSObject> collection;
if (scriptBlock == null)
{
throw PSTraceSource.NewArgumentNullException("scriptBlock");
}
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
SessionStateInternal engineSessionState = this._context.EngineSessionState;
try
{
this._context.EngineSessionState = sessionState.Internal;
collection = this.InvokeScript(scriptBlock, false, PipelineResultTypes.None, null, args);
}
finally
{
this._context.EngineSessionState = engineSessionState;
}
return(collection);
}
private void InitializeCommon(AutomationEngine engine, PSHost hostInterface)
{
this._engine = engine;
if (!_assemblyEventHandlerSet)
{
lock (lockObject)
{
if (!_assemblyEventHandlerSet)
{
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(ExecutionContext.PowerShellAssemblyResolveHandler);
_assemblyEventHandlerSet = true;
}
}
}
this._debugger = new System.Management.Automation.Debugger(this);
this.eventManager = new PSLocalEventManager(this);
this.transactionManager = new PSTransactionManager();
this.myHostInterface = hostInterface as System.Management.Automation.Internal.Host.InternalHost;
if (this.myHostInterface == null)
{
this.myHostInterface = new System.Management.Automation.Internal.Host.InternalHost(hostInterface, this);
}
this._assemblyCache = new Dictionary <string, Assembly>();
this._topLevelSessionState = this._engineSessionState = new SessionStateInternal(this);
if (this._authorizationManager == null)
{
this._authorizationManager = new System.Management.Automation.AuthorizationManager(null);
}
this._modules = new ModuleIntrinsics(this);
}
internal static PSReference GetVariableAsRef(VariablePath variablePath, ExecutionContext executionContext, Type staticType)
{
Diagnostics.Assert(variablePath.IsVariable, "calller to verify varpath is a variable.");
SessionStateInternal sessionState = executionContext.EngineSessionState;
CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin;
SessionStateScope scope;
PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin);
if (var == null)
{
throw InterpreterError.NewInterpreterException(variablePath, typeof(RuntimeException), null,
"NonExistingVariableReference",
ParserStrings.NonExistingVariableReference);
}
object value = var.Value;
if (staticType == null && value != null)
{
value = PSObject.Base(value);
if (value != null)
{
staticType = value.GetType();
}
}
if (staticType == null)
{
var declaredType = var.Attributes.OfType <ArgumentTypeConverterAttribute>().FirstOrDefault();
staticType = declaredType != null ? declaredType.TargetType : typeof(LanguagePrimitives.Null);
}
return(PSReference.CreateInstance(var, staticType));
}
/// <summary>
/// </summary>
/// <param name="sessionState"></param>
/// <param name="scriptBlock"></param>
/// <param name="args"></param>
/// <returns></returns>
public Collection <PSObject> InvokeScript(
SessionState sessionState, ScriptBlock scriptBlock, params object[] args)
{
if (scriptBlock == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(scriptBlock));
}
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(sessionState));
}
SessionStateInternal _oldSessionState = _context.EngineSessionState;
try
{
_context.EngineSessionState = sessionState.Internal;
return(InvokeScript(
sb: scriptBlock,
useNewScope: false,
writeToPipeline: PipelineResultTypes.None,
input: null,
args: args));
}
finally
{
_context.EngineSessionState = _oldSessionState;
}
}
public FunctionScopeItemSearcher(
SessionStateInternal sessionState,
VariablePath lookupPath,
CommandOrigin origin) : base(sessionState, lookupPath)
{
_origin = origin;
}
internal static object GetVariableValue(VariablePath variablePath, ExecutionContext executionContext, VariableExpressionAst varAst)
{
if (!variablePath.IsVariable)
{
CmdletProviderContext contextOut;
SessionStateScope scopeOut;
SessionStateInternal ss = executionContext.EngineSessionState;
return(ss.GetVariableValueFromProvider(variablePath, out contextOut, out scopeOut, ss.CurrentScope.ScopeOrigin));
}
SessionStateInternal sessionState = executionContext.EngineSessionState;
CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin;
SessionStateScope scope;
PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin);
if (var != null)
{
return(var.Value);
}
if (sessionState.ExecutionContext._debuggingMode > 0)
{
sessionState.ExecutionContext.Debugger.CheckVariableRead(variablePath.UnqualifiedPath);
}
if (ThrowStrictModeUndefinedVariable(executionContext, varAst))
{
throw InterpreterError.NewInterpreterException(variablePath.UserPath, typeof(RuntimeException),
varAst.Extent, "VariableIsUndefined", ParserStrings.VariableIsUndefined, variablePath.UserPath);
}
return(null);
}
private void InvokeAction(EventAction nextAction)
{
lock (this.actionProcessingLock)
{
this.processingAction = nextAction;
SessionStateInternal engineSessionState = this.context.EngineSessionState;
this.context.EngineSessionState = nextAction.Sender.Action.ScriptBlock.SessionStateInternal;
Runspace defaultRunspace = Runspace.DefaultRunspace;
try
{
Runspace.DefaultRunspace = this.context.CurrentRunspace;
nextAction.Sender.Action.Invoke(nextAction.Sender, nextAction.Args);
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
if (!(ex is PipelineStoppedException))
{
return;
}
this.AddAction(nextAction);
}
finally
{
Runspace.DefaultRunspace = defaultRunspace;
this.context.EngineSessionState = engineSessionState;
this.processingAction = (EventAction)null;
}
}
}
private static PSReference GetVariableAsRef(VariablePath variablePath, ExecutionContext executionContext, Type staticType)
{
SessionStateScope scope;
SessionStateInternal engineSessionState = executionContext.EngineSessionState;
CommandOrigin scopeOrigin = engineSessionState.CurrentScope.ScopeOrigin;
PSVariable variable = engineSessionState.GetVariableItem(variablePath, out scope, scopeOrigin);
if (variable == null)
{
throw InterpreterError.NewInterpreterException(variablePath, typeof(RuntimeException), null, "NonExistingVariableReference", ParserStrings.NonExistingVariableReference, new object[0]);
}
object obj2 = variable.Value;
if ((staticType == null) && (obj2 != null))
{
obj2 = PSObject.Base(obj2);
if (obj2 != null)
{
staticType = obj2.GetType();
}
}
if (staticType == null)
{
ArgumentTypeConverterAttribute attribute = variable.Attributes.OfType <ArgumentTypeConverterAttribute>().FirstOrDefault <ArgumentTypeConverterAttribute>();
staticType = (attribute != null) ? attribute.TargetType : typeof(LanguagePrimitives.Null);
}
return(PSReference.CreateInstance(variable, staticType));
}
internal SecurityDescriptorCmdletProviderIntrinsics(Cmdlet cmdlet)
{
using (SecurityDescriptorCmdletProviderIntrinsics.tracer.TraceConstructor((object)this))
{
this.cmdlet = cmdlet != null ? cmdlet : throw SecurityDescriptorCmdletProviderIntrinsics.tracer.NewArgumentNullException(nameof(cmdlet));
this.sessionState = cmdlet.Context.EngineSessionState;
}
}
internal DriveManagementIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.sessionState = sessionState;
}
protected ScriptCommandProcessorBase(ScriptBlock scriptBlock, ExecutionContext context, bool useLocalScope, CommandOrigin origin, SessionStateInternal sessionState)
{
this._dontUseScopeCommandOrigin = false;
base.CommandInfo = new ScriptInfo(string.Empty, scriptBlock, context);
base._fromScriptFile = false;
this.CommonInitialization(scriptBlock, context, useLocalScope, sessionState);
base.Command.CommandOriginInternal = origin;
}
internal SecurityDescriptorCmdletProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.sessionState = sessionState;
}
internal ChildItemCmdletProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.sessionState = sessionState;
}
internal ItemCmdletProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.sessionState = sessionState;
}
internal PathIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.sessionState = sessionState;
}
internal SessionState(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.sessionState = sessionState;
}
internal PSVariableIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentException("sessionState");
}
this.sessionState = sessionState;
}
/// <summary>
/// This is the constructor for script as cmdlet.
/// </summary>
/// <param name="scriptCommandInfo">
/// The information about the cmdlet.
/// </param>
/// <param name="context">
/// PowerShell engine execution context for this command.
/// </param>
/// <param name="useLocalScope"></param>
/// <param name="sessionState"></param>
/// <param name="fromScriptFile">True when the script to be executed came from a file (as opposed to a function, or interactive input)</param>
internal CommandProcessor(IScriptCommandInfo scriptCommandInfo, ExecutionContext context, bool useLocalScope, bool fromScriptFile, SessionStateInternal sessionState)
: base(scriptCommandInfo as CommandInfo)
{
this._context = context;
this._useLocalScope = useLocalScope;
this._fromScriptFile = fromScriptFile;
this.CommandSessionState = sessionState;
Init(scriptCommandInfo);
}
/// <summary>
/// Constructs a Drive management facade.
/// </summary>
/// <param name="sessionState">
/// The instance of session state that facade wraps.
/// </param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
internal DriveManagementIntrinsics(SessionStateInternal sessionState)
{
if (sessionState is null)
{
throw PSTraceSource.NewArgumentNullException(nameof(sessionState));
}
_sessionState = sessionState;
}
private ScriptBlock CreateBoundScriptBlock(ScriptBlock scriptAction)
{
ScriptBlock block = this.context.Modules.CreateBoundScriptBlock(this.context, scriptAction, true);
PSVariable variable = new PSVariable("script:Error", new ArrayList(), ScopedItemOptions.Constant);
SessionStateInternal sessionStateInternal = block.SessionStateInternal;
sessionStateInternal.GetScopeByID("script").SetVariable(variable.Name, variable, false, true, sessionStateInternal, CommandOrigin.Internal, false);
return(block);
}
/// <summary>
/// Constructs a facade over the "real" session state API.
/// </summary>
/// <param name="sessionState">
/// An instance of the sessionState.
/// </param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
internal ContentCmdletProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState is null)
{
throw PSTraceSource.NewArgumentNullException(nameof(sessionState));
}
_sessionState = sessionState;
}
/// <summary>
/// The internal constructor for this object. It should be the only one that gets called.
/// </summary>
/// <param name="sessionState">
/// An instance of SessionState that the APIs should work against.
/// </param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
internal SessionState(SessionStateInternal sessionState)
{
if (sessionState is null)
{
throw PSTraceSource.NewArgumentNullException(nameof(sessionState));
}
_sessionState = sessionState;
}
/// <summary>
/// Constructs a facade for the specified session.
/// </summary>
/// <param name="sessionState">
/// The session for which the facade wraps.
/// </param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
internal PSVariableIntrinsics(SessionStateInternal sessionState)
{
if (sessionState is null)
{
throw PSTraceSource.NewArgumentException(nameof(sessionState));
}
_sessionState = sessionState;
}
} // DriveManagementIntrinsics private
/// <summary>
/// Constructs a Drive management facade
/// </summary>
///
/// <param name="sessionState">
/// The instance of session state that facade wraps.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
///
internal DriveManagementIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
_sessionState = sessionState;
} // DriveManagementIntrinsics internal
internal ItemCmdletProviderIntrinsics(Cmdlet cmdlet)
{
if (cmdlet == null)
{
throw PSTraceSource.NewArgumentNullException("cmdlet");
}
this.cmdlet = cmdlet;
this.sessionState = cmdlet.Context.EngineSessionState;
}
} // PSVariableInterfaces private
/// <summary>
/// Constructs a facade for the specified session.
/// </summary>
///
/// <param name="sessionState">
/// The session for which the facade wraps.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
///
internal PSVariableIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentException("sessionState");
}
_sessionState = sessionState;
} // PSVariableInterfaces internal
} // ContentCmdletProviderIntrinsics internal
/// <summary>
/// Constructs a facade over the "real" session state API
/// </summary>
///
/// <param name="sessionState">
/// An instance of the sessionState.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
///
internal ContentCmdletProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
_sessionState = sessionState;
} // ContentCmdletProviderIntrinsics internal
/// <summary>
/// The facade for managing providers.
/// </summary>
/// <param name="sessionState">
/// The session to which this is a facade.
/// </param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
internal CmdletProviderManagementIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
_sessionState = sessionState;
}
internal ChildItemCmdletProviderIntrinsics(Cmdlet cmdlet)
{
if (cmdlet == null)
{
throw PSTraceSource.NewArgumentNullException("cmdlet");
}
this.cmdlet = cmdlet;
this.sessionState = cmdlet.Context.EngineSessionState;
}
/// <summary>
/// Initializes a new instance of the SecurityDescriptorCmdletProviderIntrinsics
/// class, using the sessionState parameter to obtain access to the SessionState APIs.
/// </summary>
/// <param name="sessionState">
/// An instance of the real session state class.
/// </param>
internal SecurityDescriptorCmdletProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(sessionState));
}
_sessionState = sessionState;
}
public SessionState()
{
ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
if (executionContextFromTLS == null)
{
throw new InvalidOperationException("ExecutionContext");
}
this.sessionState = new SessionStateInternal(executionContextFromTLS);
this.sessionState.PublicSessionState = this;
}
protected ScriptCommandProcessorBase(IScriptCommandInfo commandInfo, ExecutionContext context, bool useLocalScope, SessionStateInternal sessionState)
: base((CommandInfo)commandInfo)
{
Diagnostics.Assert(commandInfo != null, "commandInfo cannot be null");
Diagnostics.Assert(commandInfo.ScriptBlock != null, "scriptblock cannot be null");
this._fromScriptFile = (this.CommandInfo is ExternalScriptInfo || this.CommandInfo is ScriptInfo);
this._dontUseScopeCommandOrigin = true;
CommonInitialization(commandInfo.ScriptBlock, context, useLocalScope, CommandOrigin.Internal, sessionState);
}
internal SessionState(SessionStateInternal parent, bool createAsChild, bool linkToGlobal)
{
ExecutionContext executionContextFromTls = LocalPipeline.GetExecutionContextFromTLS();
if (executionContextFromTls == null)
{
throw new InvalidOperationException("ExecutionContext");
}
this.sessionState = !createAsChild ? new SessionStateInternal(executionContextFromTls) : new SessionStateInternal(parent, linkToGlobal, executionContextFromTls);
this.sessionState.PublicSessionState = this;
}
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);
}
}
private ProviderInfo GetProvider()
{
ExecutionContext executionContext = GetExecutionContext();
SessionStateInternal sessionState = new SessionStateInternal(executionContext);
SessionStateProviderEntry providerEntry = new SessionStateProviderEntry("FileSystem",typeof(FileSystemProvider), null);
sessionState.AddSessionStateEntry(providerEntry);
ProviderInfo matchingProvider = sessionState.ProviderList.ToList()[0];
return matchingProvider;
}
public SessionState()
{
ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
if (executionContextFromTLS == null)
{
throw new InvalidOperationException("ExecutionContext");
}
this.sessionState = new SessionStateInternal(executionContextFromTLS);
this.sessionState.PublicSessionState = this;
}
internal ProviderIntrinsics(SessionStateInternal sessionState)
{
using (ProviderIntrinsics.tracer.TraceConstructor((object)this))
{
this.item = sessionState != null ? new ItemCmdletProviderIntrinsics(sessionState) : throw ProviderIntrinsics.tracer.NewArgumentNullException(nameof(sessionState));
this.childItem = new ChildItemCmdletProviderIntrinsics(sessionState);
this.content = new ContentCmdletProviderIntrinsics(sessionState);
this.property = new PropertyCmdletProviderIntrinsics(sessionState);
this.securityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(sessionState);
}
}
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 ProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.item = new ItemCmdletProviderIntrinsics(sessionState);
this.childItem = new ChildItemCmdletProviderIntrinsics(sessionState);
this.content = new ContentCmdletProviderIntrinsics(sessionState);
this.property = new PropertyCmdletProviderIntrinsics(sessionState);
this.securityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(sessionState);
}
internal ProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
this.item = new ItemCmdletProviderIntrinsics(sessionState);
this.childItem = new ChildItemCmdletProviderIntrinsics(sessionState);
this.content = new ContentCmdletProviderIntrinsics(sessionState);
this.property = new PropertyCmdletProviderIntrinsics(sessionState);
this.securityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(sessionState);
}
private static object SetVariableValue(VariablePath variablePath, object value, ExecutionContext executionContext, AttributeBaseAst[] attributeAsts)
{
SessionStateScope scope;
SessionStateInternal engineSessionState = executionContext.EngineSessionState;
CommandOrigin scopeOrigin = engineSessionState.CurrentScope.ScopeOrigin;
if (!variablePath.IsVariable)
{
engineSessionState.SetVariable(variablePath, value, true, scopeOrigin);
return(value);
}
if (executionContext.PSDebugTraceLevel > 0)
{
executionContext.Debugger.TraceVariableSet(variablePath.UnqualifiedPath, value);
}
if (variablePath.IsUnscopedVariable)
{
variablePath = variablePath.CloneAndSetLocal();
}
PSVariable newValue = engineSessionState.GetVariableItem(variablePath, out scope, scopeOrigin);
if (newValue == null)
{
Collection <Attribute> attributes = (attributeAsts == null) ? new Collection <Attribute>() : GetAttributeCollection(attributeAsts);
newValue = new PSVariable(variablePath.UnqualifiedPath, value, ScopedItemOptions.None, attributes);
engineSessionState.SetVariable(variablePath, newValue, false, scopeOrigin);
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
}
return(value);
}
if (attributeAsts != null)
{
newValue.Attributes.Clear();
Collection <Attribute> attributeCollection = GetAttributeCollection(attributeAsts);
value = PSVariable.TransformValue(attributeCollection, value);
if (!PSVariable.IsValidValue(attributeCollection, value))
{
ValidationMetadataException exception = new ValidationMetadataException("ValidateSetFailure", null, Metadata.InvalidValueFailure, new object[] { newValue.Name, (value != null) ? value.ToString() : "" });
throw exception;
}
newValue.SetValueRaw(value, true);
newValue.AddParameterAttributesNoChecks(attributeCollection);
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
}
return(value);
}
newValue.Value = value;
return(value);
}
public void TestDrives()
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
PSHost hostInterface = new DefaultHost(currentCulture,currentCulture);
RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create();
InitialSessionState iss = InitialSessionState.CreateDefault2();
AutomationEngine engine = new AutomationEngine(hostInterface, runspaceConfiguration, iss);
ExecutionContext executionContext = new ExecutionContext(engine, hostInterface, iss);
SessionStateInternal sessionState = new SessionStateInternal(executionContext);
Collection<PSDriveInfo> drives = sessionState.Drives(null);
Assert.NotNull(drives);
}
/// <summary>
/// Constructs a facade over the "real" session state API.
/// </summary>
/// <param name="sessionState">
/// An instance of the cmdlet.
/// </param>
internal ProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(sessionState));
}
Item = new ItemCmdletProviderIntrinsics(sessionState);
ChildItem = new ChildItemCmdletProviderIntrinsics(sessionState);
Content = new ContentCmdletProviderIntrinsics(sessionState);
Property = new PropertyCmdletProviderIntrinsics(sessionState);
SecurityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(sessionState);
}
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>
/// The internal constructor for this object. It should be the only one that gets called.
/// </summary>
///
/// <param name="sessionState">
/// An instance of SessionState that the APIs should work against.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="sessionState"/> is null.
/// </exception>
///
internal SessionState(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
_sessionState = sessionState;
#if RELATIONSHIP_SUPPORTED
// 2004/11/24-JeffJon - Relationships have been removed from the Exchange release
this.relationship = new RelationshipProviderManagementIntrinsics (sessionState);
#endif
} // SessionState
} // SessionState
/// <summary>
/// The internal constructor for this object. It should be the only one that gets called.
/// </summary>
///
/// <param name="context">
/// An instance of ExecutionContext whose EngineSessionState represents the parent session state.
/// </param>
/// <param name="createAsChild">
/// True if the session state should be created as a child session state.
/// </param>
/// <param name="linkToGlobal">
/// True if the session state should be linked to the global scope.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="context"/> is null.
/// </exception>
internal SessionState(ExecutionContext context, bool createAsChild, bool linkToGlobal)
{
if (context == null)
throw new InvalidOperationException("ExecutionContext");
if (createAsChild)
{
_sessionState = new SessionStateInternal(context.EngineSessionState, linkToGlobal, context);
}
else
{
_sessionState = new SessionStateInternal(context);
}
_sessionState.PublicSessionState = this;
} // SessionState
protected void CommonInitialization(ScriptBlock scriptBlock, ExecutionContext context, bool useLocalScope, SessionStateInternal sessionState)
{
base.CommandSessionState = sessionState;
base._context = context;
this._rethrowExitException = base.Context.ScriptCommandProcessorShouldRethrowExit;
base._context.ScriptCommandProcessorShouldRethrowExit = false;
ScriptCommand thisCommand = new ScriptCommand {
CommandInfo = base.CommandInfo
};
base.Command = thisCommand;
base.Command.commandRuntime = base.commandRuntime = new MshCommandRuntime(base.Context, base.CommandInfo, thisCommand);
base.CommandScope = useLocalScope ? base.CommandSessionState.NewScope(base.FromScriptFile) : base.CommandSessionState.CurrentScope;
base.UseLocalScope = useLocalScope;
this._scriptBlock = scriptBlock;
if (!base.UseLocalScope && !this._rethrowExitException)
{
CommandProcessorBase.ValidateCompatibleLanguageMode(this._scriptBlock, context.LanguageMode, base.Command.MyInvocation);
}
}
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);
}
}
} // ProviderIntrinsics internal
/// <summary>
/// Constructs a facade over the "real" session state API
/// </summary>
///
/// <param name="sessionState">
/// An instance of the cmdlet.
/// </param>
///
internal ProviderIntrinsics(SessionStateInternal sessionState)
{
if (sessionState == null)
{
throw PSTraceSource.NewArgumentNullException("sessionState");
}
Item = new ItemCmdletProviderIntrinsics(sessionState);
ChildItem = new ChildItemCmdletProviderIntrinsics(sessionState);
Content = new ContentCmdletProviderIntrinsics(sessionState);
Property = new PropertyCmdletProviderIntrinsics(sessionState);
#if SUPPORTS_IMULTIVALUEPROPERTYCMDLETPROVIDER
this.propertyValue = new PropertyValueCmdletProviderIntrinsics(sessionState);
#endif
SecurityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(sessionState);
#if RELATIONSHIP_SUPPORTED
// 2004/11/24-JeffJon - Relationships have been removed from the Exchange release
this.relationship = new RelationshipProviderIntrinsics(sessionState);
#endif
} // ProviderIntrinsics internal
private static CommandProcessorBase CreateCommandProcessorForScript(ScriptInfo scriptInfo, ExecutionContext context, bool useNewScope, SessionStateInternal sessionState)
{
sessionState = sessionState ?? (scriptInfo.ScriptBlock.SessionStateInternal ?? context.EngineSessionState);
CommandProcessorBase base2 = GetScriptAsCmdletProcessor(scriptInfo, context, useNewScope, true, sessionState);
if (base2 != null)
{
return base2;
}
return new DlrScriptCommandProcessor(scriptInfo, context, useNewScope, sessionState);
}
internal DlrScriptCommandProcessor(ScriptBlock scriptBlock, ExecutionContext context, bool useNewScope, CommandOrigin origin, SessionStateInternal sessionState) : base(scriptBlock, context, useNewScope, origin, sessionState)
{
this._input = new ArrayList();
this.Init();
}
internal PSVariable SetVariable(string name, object value, bool asValue, bool force, SessionStateInternal sessionState, CommandOrigin origin = CommandOrigin.Internal, bool fastPath = false)
{
PSVariable variable;
PSVariable variable2 = value as PSVariable;
if (fastPath)
{
if (this.Parent != null)
{
throw new NotImplementedException("fastPath");
}
variable = new PSVariable(name, variable2.Value, variable2.Options, variable2.Attributes) {
Description = variable2.Description
};
this.GetPrivateVariables()[name] = variable;
return variable;
}
bool flag = this.TryGetVariable(name, origin, true, out variable);
if (!asValue && (variable2 != null))
{
if (flag)
{
if (((variable == null) || variable.IsConstant) || (!force && variable.IsReadOnly))
{
SessionStateUnauthorizedAccessException exception = new SessionStateUnauthorizedAccessException(name, SessionStateCategory.Variable, "VariableNotWritable", SessionStateStrings.VariableNotWritable);
throw exception;
}
if ((variable is LocalVariable) && (variable2.Attributes.Any<Attribute>() || (variable2.Options != variable.Options)))
{
SessionStateUnauthorizedAccessException exception2 = new SessionStateUnauthorizedAccessException(name, SessionStateCategory.Variable, "VariableNotWritableRare", SessionStateStrings.VariableNotWritableRare);
throw exception2;
}
if (variable.IsReadOnly && force)
{
this._variables.Remove(name);
flag = false;
variable = new PSVariable(name, variable2.Value, variable2.Options, variable2.Attributes) {
Description = variable2.Description
};
}
else
{
variable.Attributes.Clear();
variable.Value = variable2.Value;
variable.Options = variable2.Options;
variable.Description = variable2.Description;
foreach (Attribute attribute in variable2.Attributes)
{
variable.Attributes.Add(attribute);
}
}
}
else
{
variable = variable2;
}
}
else if (variable != null)
{
variable.Value = value;
}
else
{
variable = (this.LocalsTuple != null) ? (this.LocalsTuple.TrySetVariable(name, value)) ?? new PSVariable(name, value) : new PSVariable(name, value);
}
if (!flag && (this._variables.Count > (this.VariableCapacity.FastValue - 1)))
{
SessionStateOverflowException exception3 = new SessionStateOverflowException(name, SessionStateCategory.Variable, "VariableOverflow", SessionStateStrings.VariableOverflow, new object[] { this.VariableCapacity.FastValue });
throw exception3;
}
if (System.Management.Automation.ExecutionContext.HasEverUsedConstrainedLanguage)
{
System.Management.Automation.ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
if (((executionContextFromTLS != null) && (executionContextFromTLS.LanguageMode == PSLanguageMode.ConstrainedLanguage)) && ((variable.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.AllScope))
{
/* TODO: Review how to get around this: */ /* throw new PSNotSupportedException(); */
}
}
this._variables[name] = variable;
variable.SessionState = sessionState;
return variable;
}
internal PSVariable NewVariable(PSVariable newVariable, bool force, SessionStateInternal sessionState)
{
PSVariable variable;
bool flag = this.TryGetVariable(newVariable.Name, this.ScopeOrigin, true, out variable);
if (flag)
{
if (((variable == null) || variable.IsConstant) || (!force && variable.IsReadOnly))
{
SessionStateUnauthorizedAccessException exception = new SessionStateUnauthorizedAccessException(newVariable.Name, SessionStateCategory.Variable, "VariableNotWritable", SessionStateStrings.VariableNotWritable);
throw exception;
}
if (variable is LocalVariable)
{
SessionStateUnauthorizedAccessException exception2 = new SessionStateUnauthorizedAccessException(newVariable.Name, SessionStateCategory.Variable, "VariableNotWritableRare", SessionStateStrings.VariableNotWritableRare);
throw exception2;
}
if (!object.ReferenceEquals(newVariable, variable))
{
variable.WasRemoved = true;
variable = newVariable;
}
}
else
{
variable = newVariable;
}
if (!flag && (this._variables.Count > (this.VariableCapacity.FastValue - 1)))
{
SessionStateOverflowException exception3 = new SessionStateOverflowException(newVariable.Name, SessionStateCategory.Variable, "VariableOverflow", SessionStateStrings.VariableOverflow, new object[] { this.VariableCapacity.FastValue });
throw exception3;
}
if (System.Management.Automation.ExecutionContext.HasEverUsedConstrainedLanguage)
{
System.Management.Automation.ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
if (((executionContextFromTLS != null) && (executionContextFromTLS.LanguageMode == PSLanguageMode.ConstrainedLanguage)) && ((variable.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.AllScope))
{
throw new PSNotSupportedException();
}
}
this._variables[variable.Name] = variable;
variable.SessionState = sessionState;
return variable;
}
internal CommandProcessorBase LookupCommandProcessor(CommandInfo commandInfo, CommandOrigin commandOrigin, bool? useLocalScope, SessionStateInternal sessionState)
{
CommandProcessorBase base2 = null;
FunctionInfo info3;
CommandNotFoundException exception6;
HashSet<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
while (((commandInfo.CommandType == CommandTypes.Alias) && !set.Contains(commandInfo.Name)) && ((commandOrigin == CommandOrigin.Internal) || (commandInfo.Visibility == SessionStateEntryVisibility.Public)))
{
set.Add(commandInfo.Name);
AliasInfo info = (AliasInfo) commandInfo;
commandInfo = info.ResolvedCommand;
if (commandInfo == null)
{
commandInfo = LookupCommandInfo(info.Definition, commandOrigin, this._context);
}
if (commandInfo == null)
{
CommandNotFoundException exception = new CommandNotFoundException(info.Name, null, "AliasNotResolvedException", DiscoveryExceptions.AliasNotResolvedException, new object[] { info.UnresolvedCommandName });
throw exception;
}
PSSQMAPI.IncrementData(CommandTypes.Alias);
}
ShouldRun(this._context, this._context.EngineHostInterface, commandInfo, commandOrigin);
CommandTypes commandType = commandInfo.CommandType;
if (commandType <= CommandTypes.ExternalScript)
{
switch (commandType)
{
case CommandTypes.Function:
case CommandTypes.Filter:
goto Label_01E3;
case CommandTypes.Cmdlet:
base2 = new CommandProcessor((CmdletInfo) commandInfo, this._context);
goto Label_0260;
case CommandTypes.ExternalScript:
{
ExternalScriptInfo scriptInfo = (ExternalScriptInfo) commandInfo;
scriptInfo.SignatureChecked = true;
try
{
if (!this._context.IsSingleShell)
{
bool? nullable = useLocalScope;
base2 = this.CreateScriptProcessorForMiniShell(scriptInfo, nullable.HasValue ? nullable.GetValueOrDefault() : true, sessionState);
}
else
{
bool? nullable2 = useLocalScope;
base2 = this.CreateScriptProcessorForSingleShell(scriptInfo, this._context, nullable2.HasValue ? nullable2.GetValueOrDefault() : true, sessionState);
}
goto Label_0260;
}
catch (ScriptRequiresSyntaxException exception2)
{
CommandNotFoundException exception3 = new CommandNotFoundException(exception2.Message, exception2);
throw exception3;
}
catch (PSArgumentException exception4)
{
CommandNotFoundException exception5 = new CommandNotFoundException(commandInfo.Name, exception4, "ScriptRequiresInvalidFormat", DiscoveryExceptions.ScriptRequiresInvalidFormat, new object[0]);
throw exception5;
}
goto Label_01E3;
}
}
goto Label_023F;
}
if (commandType != CommandTypes.Application)
{
if (commandType == CommandTypes.Script)
{
bool? nullable4 = useLocalScope;
base2 = CreateCommandProcessorForScript((ScriptInfo) commandInfo, this._context, nullable4.HasValue ? nullable4.GetValueOrDefault() : true, sessionState);
goto Label_0260;
}
if (commandType == CommandTypes.Workflow)
{
goto Label_01E3;
}
goto Label_023F;
}
base2 = new NativeCommandProcessor((ApplicationInfo) commandInfo, this._context);
goto Label_0260;
Label_01E3:
info3 = (FunctionInfo) commandInfo;
bool? nullable3 = useLocalScope;
base2 = CreateCommandProcessorForScript(info3, this._context, nullable3.HasValue ? nullable3.GetValueOrDefault() : true, sessionState);
goto Label_0260;
Label_023F:
exception6 = new CommandNotFoundException(commandInfo.Name, null, "CommandNotFoundException", DiscoveryExceptions.CommandNotFoundException, new object[0]);
throw exception6;
Label_0260:
PSSQMAPI.IncrementData(commandInfo.CommandType);
base2.Command.CommandOriginInternal = commandOrigin;
base2.Command.MyInvocation.InvocationName = commandInfo.Name;
return base2;
}
private static CommandProcessorBase GetScriptAsCmdletProcessor(IScriptCommandInfo scriptCommandInfo, ExecutionContext context, bool useNewScope, bool fromScriptFile, SessionStateInternal sessionState)
{
if ((scriptCommandInfo.ScriptBlock == null) || !scriptCommandInfo.ScriptBlock.UsesCmdletBinding)
{
return null;
}
sessionState = sessionState ?? (scriptCommandInfo.ScriptBlock.SessionStateInternal ?? context.EngineSessionState);
return new CommandProcessor(scriptCommandInfo, context, useNewScope, fromScriptFile, sessionState);
}
private CommandProcessorBase CreateScriptProcessorForSingleShell(ExternalScriptInfo scriptInfo, ExecutionContext context, bool useLocalScope, SessionStateInternal sessionState)
{
VerifyPSVersion(scriptInfo);
this.VerifyRequiredModules(scriptInfo);
IEnumerable<PSSnapInSpecification> requiresPSSnapIns = scriptInfo.RequiresPSSnapIns;
if ((requiresPSSnapIns != null) && requiresPSSnapIns.Any<PSSnapInSpecification>())
{
Collection<string> requiresMissingPSSnapIns = null;
VerifyRequiredSnapins(requiresPSSnapIns, context, out requiresMissingPSSnapIns);
if (requiresMissingPSSnapIns != null)
{
ScriptRequiresException exception = new ScriptRequiresException(scriptInfo.Name, requiresMissingPSSnapIns, "ScriptRequiresMissingPSSnapIns", true);
throw exception;
}
}
else if (!string.IsNullOrEmpty(scriptInfo.RequiresApplicationID))
{
GetShellPathFromRegistry(scriptInfo.RequiresApplicationID);
ScriptRequiresException exception2 = new ScriptRequiresException(scriptInfo.Name, string.Empty, string.Empty, "RequiresShellIDInvalidForSingleShell");
throw exception2;
}
return CreateCommandProcessorForScript(scriptInfo, this._context, useLocalScope, sessionState);
}
internal CommandProcessorBase CreateScriptProcessorForMiniShell(ExternalScriptInfo scriptInfo, bool useLocalScope, SessionStateInternal sessionState)
{
VerifyPSVersion(scriptInfo);
this.VerifyRequiredModules(scriptInfo);
if (string.IsNullOrEmpty(scriptInfo.RequiresApplicationID))
{
if ((scriptInfo.RequiresPSSnapIns != null) && scriptInfo.RequiresPSSnapIns.Any<PSSnapInSpecification>())
{
Collection<string> pSSnapinNames = GetPSSnapinNames(scriptInfo.RequiresPSSnapIns);
ScriptRequiresException exception = new ScriptRequiresException(scriptInfo.Name, pSSnapinNames, "ScriptRequiresMissingPSSnapIns", true);
throw exception;
}
return CreateCommandProcessorForScript(scriptInfo, this._context, useLocalScope, sessionState);
}
if (string.Equals(this._context.ShellID, scriptInfo.RequiresApplicationID, StringComparison.OrdinalIgnoreCase))
{
return CreateCommandProcessorForScript(scriptInfo, this._context, useLocalScope, sessionState);
}
string shellPathFromRegistry = GetShellPathFromRegistry(scriptInfo.RequiresApplicationID);
ScriptRequiresException exception2 = new ScriptRequiresException(scriptInfo.Name, scriptInfo.RequiresApplicationID, shellPathFromRegistry, "ScriptRequiresUnmatchedShellId");
throw exception2;
}
internal DlrScriptCommandProcessor(ScriptInfo scriptInfo, ExecutionContext context, bool useNewScope, SessionStateInternal sessionState) : base(scriptInfo, context, useNewScope, sessionState)
{
this._input = new ArrayList();
this.Init();
}
internal static CommandProcessorBase CreateCommandProcessorForScript(ScriptBlock scriptblock, ExecutionContext context, bool useNewScope, SessionStateInternal sessionState)
{
sessionState = sessionState ?? (scriptblock.SessionStateInternal ?? context.EngineSessionState);
if (scriptblock.UsesCmdletBinding)
{
FunctionInfo scriptCommandInfo = new FunctionInfo("", scriptblock, context);
return GetScriptAsCmdletProcessor(scriptCommandInfo, context, useNewScope, false, sessionState);
}
return new DlrScriptCommandProcessor(scriptblock, context, useNewScope, CommandOrigin.Internal, sessionState);
}