private void ConvertToString()
{
PipelineProcessor processor = new PipelineProcessor();
processor.Add(this.command.Context.CreateCommand("out-string", false));
object[] c = (object[]) processor.Execute(this.inputList.ToArray());
this.inputList = new ArrayList(c);
}
public void Dispose()
{
if (this.pp != null)
{
this.pp.Dispose();
this.pp = null;
}
}
internal Array ShutDown()
{
if (this.pp == null)
{
return new object[0];
}
PipelineProcessor pp = this.pp;
this.pp = null;
return pp.Execute();
}
private void DelayedInternalInitialize()
{
this.pp = new PipelineProcessor();
CmdletInfo cmdletInfo = new CmdletInfo(this.commandName, this.commandType, null, null, this.context);
CommandProcessor commandProcessor = new CommandProcessor(cmdletInfo, this.context);
foreach (CommandParameterInternal internal2 in this.commandParameterList)
{
commandProcessor.AddParameter(internal2);
}
this.pp.Add(commandProcessor);
}
internal SteppablePipeline(ExecutionContext context, PipelineProcessor pipeline)
{
if (pipeline == null)
{
throw new ArgumentNullException("pipeline");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
this._pipeline = pipeline;
this._context = context;
}
internal void Push(PipelineProcessor item)
{
if (item == null)
{
throw PSTraceSource.NewArgumentNullException("item");
}
lock (this._syncRoot)
{
if (this._stopping)
{
PipelineStoppedException exception = new PipelineStoppedException();
throw exception;
}
this._stack.Push(item);
}
item.LocalPipeline = this._localPipeline;
}
internal override void Bind(System.Management.Automation.Internal.PipelineProcessor pipelineProcessor, CommandProcessorBase commandProcessor, ExecutionContext context)
{
Pipe redirectionPipe = this.GetRedirectionPipe(context, pipelineProcessor);
switch (base.FromStream)
{
case RedirectionStream.All:
commandProcessor.CommandRuntime.OutputPipe = redirectionPipe;
commandProcessor.CommandRuntime.ErrorOutputPipe = redirectionPipe;
commandProcessor.CommandRuntime.WarningOutputPipe = redirectionPipe;
commandProcessor.CommandRuntime.VerboseOutputPipe = redirectionPipe;
commandProcessor.CommandRuntime.DebugOutputPipe = redirectionPipe;
return;
case RedirectionStream.Output:
commandProcessor.CommandRuntime.OutputPipe = redirectionPipe;
return;
case RedirectionStream.Error:
commandProcessor.CommandRuntime.ErrorOutputPipe = redirectionPipe;
return;
case RedirectionStream.Warning:
commandProcessor.CommandRuntime.WarningOutputPipe = redirectionPipe;
return;
case RedirectionStream.Verbose:
commandProcessor.CommandRuntime.VerboseOutputPipe = redirectionPipe;
return;
case RedirectionStream.Debug:
commandProcessor.CommandRuntime.DebugOutputPipe = redirectionPipe;
break;
case RedirectionStream.Host:
break;
default:
return;
}
}
protected override void BeginProcessing()
{
Collection<PSTraceSource> preconfiguredSources = null;
this.matchingSources = base.ConfigureTraceSource(base.NameInternal, false, out preconfiguredSources);
base.TurnOnTracing(this.matchingSources, false);
base.TurnOnTracing(preconfiguredSources, true);
foreach (PSTraceSource source in preconfiguredSources)
{
this.matchingSources.Add(source);
}
if (base.ParameterSetName == "commandSet")
{
CommandProcessorBase commandProcessor = base.Context.CommandDiscovery.LookupCommandProcessor(this.command, CommandOrigin.Runspace, false);
ParameterBinderController.AddArgumentsToCommandProcessor(commandProcessor, this.ArgumentList);
this.pipeline = new PipelineProcessor();
this.pipeline.Add(commandProcessor);
this.pipeline.ExternalErrorOutput = new TracePipelineWriter(this, true, this.matchingSources);
this.pipeline.ExternalSuccessOutput = new TracePipelineWriter(this, false, this.matchingSources);
}
base.ResetTracing(this.matchingSources);
}
internal Pipe GetRedirectionPipe(ExecutionContext context, System.Management.Automation.Internal.PipelineProcessor parentPipelineProcessor)
{
if (string.IsNullOrWhiteSpace(this.File))
{
return(new Pipe {
NullPipe = true
});
}
CommandProcessorBase commandProcessor = context.CreateCommand("out-file", false);
CommandParameterInternal parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Encoding", "-Encoding:", PositionUtilities.EmptyExtent, "Unicode", false);
commandProcessor.AddParameter(parameter);
if (this.Appending)
{
parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Append", "-Append:", PositionUtilities.EmptyExtent, true, false);
commandProcessor.AddParameter(parameter);
}
parameter = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, "Filepath", "-Filepath:", PositionUtilities.EmptyExtent, this.File, false);
commandProcessor.AddParameter(parameter);
this.PipelineProcessor = new System.Management.Automation.Internal.PipelineProcessor();
this.PipelineProcessor.Add(commandProcessor);
try
{
this.PipelineProcessor.StartStepping(true);
}
catch (RuntimeException exception)
{
if (exception.ErrorRecord.Exception is ArgumentException)
{
throw InterpreterError.NewInterpreterExceptionWithInnerException(null, typeof(RuntimeException), null, "RedirectionFailed", ParserStrings.RedirectionFailed, exception.ErrorRecord.Exception, new object[] { this.File, exception.ErrorRecord.Exception.Message });
}
throw;
}
if (parentPipelineProcessor != null)
{
parentPipelineProcessor.AddRedirectionPipe(this.PipelineProcessor);
}
return(new Pipe(context, this.PipelineProcessor));
}
public void Dispose()
{
if (!this.disposed)
{
this.disposed = true;
base.ResetTracing(this.matchingSources);
base.ClearStoredState();
this.matchingSources = null;
if (this.pipeline != null)
{
this.pipeline.Dispose();
this.pipeline = null;
}
if (base.FileStreams != null)
{
foreach (FileStream stream in base.FileStreams)
{
stream.Flush();
stream.Close();
}
}
GC.SuppressFinalize(this);
}
}
internal override void Bind(PipelineProcessor pipelineProcessor, CommandProcessorBase commandProcessor, ExecutionContext context)
{
Pipe outputPipe = commandProcessor.CommandRuntime.OutputPipe;
switch (base.FromStream)
{
case RedirectionStream.All:
commandProcessor.CommandRuntime.ErrorMergeTo = MshCommandRuntime.MergeDataStream.Output;
commandProcessor.CommandRuntime.WarningOutputPipe = outputPipe;
commandProcessor.CommandRuntime.VerboseOutputPipe = outputPipe;
commandProcessor.CommandRuntime.DebugOutputPipe = outputPipe;
return;
case RedirectionStream.Output:
case RedirectionStream.Host:
break;
case RedirectionStream.Error:
commandProcessor.CommandRuntime.ErrorMergeTo = MshCommandRuntime.MergeDataStream.Output;
return;
case RedirectionStream.Warning:
commandProcessor.CommandRuntime.WarningOutputPipe = outputPipe;
return;
case RedirectionStream.Verbose:
commandProcessor.CommandRuntime.VerboseOutputPipe = outputPipe;
return;
case RedirectionStream.Debug:
commandProcessor.CommandRuntime.DebugOutputPipe = outputPipe;
break;
default:
return;
}
}
internal AllowWrite(InternalCommand permittedToWrite, bool permittedToWriteToPipeline)
{
if (permittedToWrite == null)
{
throw PSTraceSource.NewArgumentNullException("permittedToWrite");
}
MshCommandRuntime commandRuntime = permittedToWrite.commandRuntime as MshCommandRuntime;
if (commandRuntime == null)
{
throw PSTraceSource.NewArgumentNullException("permittedToWrite.CommandRuntime");
}
this._pp = commandRuntime.PipelineProcessor;
if (this._pp == null)
{
throw PSTraceSource.NewArgumentNullException("permittedToWrite.CommandRuntime.PipelineProcessor");
}
this._wasPermittedToWrite = this._pp._permittedToWrite;
this._wasPermittedToWriteToPipeline = this._pp._permittedToWriteToPipeline;
this._wasPermittedToWriteThread = this._pp._permittedToWriteThread;
this._pp._permittedToWrite = permittedToWrite;
this._pp._permittedToWriteToPipeline = permittedToWriteToPipeline;
this._pp._permittedToWriteThread = Thread.CurrentThread;
}
internal static void InvokePipeline (object input, bool ignoreInput, CommandParameterInternal[][] pipeElements, CommandBaseAst[] pipeElementAsts, CommandRedirection[][] commandRedirections, FunctionContext funcContext)
{
PipelineProcessor pipelineProcessor = new PipelineProcessor ();
System.Management.Automation.ExecutionContext context = funcContext._executionContext;
Pipe pipe = funcContext._outputPipe;
try {
if (context.Events != null) {
context.Events.ProcessPendingActions ();
}
if ((input == AutomationNull.Value) && !ignoreInput) {
AddNoopCommandProcessor (pipelineProcessor, context);
}
CommandProcessorBase commandProcessor = null;
CommandRedirection[] redirections = null;
for (int i = 0; i < pipeElements.Length; i++) {
redirections = (commandRedirections != null) ? commandRedirections [i] : null;
commandProcessor = AddCommand (pipelineProcessor, pipeElements [i], pipeElementAsts [i], redirections, context);
}
if ((commandProcessor != null) && !commandProcessor.CommandRuntime.OutputPipe.IsRedirected) {
pipelineProcessor.LinkPipelineSuccessOutput (pipe ?? new Pipe (new ArrayList ()));
if (redirections != null) {
foreach (CommandRedirection redirection in redirections) {
if (redirection is MergingRedirection) {
redirection.Bind (pipelineProcessor, commandProcessor, context);
}
}
}
}
context.PushPipelineProcessor (pipelineProcessor);
try {
pipelineProcessor.SynchronousExecuteEnumerate (input, null, true);
} finally {
context.PopPipelineProcessor (false);
}
}
finally
{
context.QuestionMarkVariableValue = !pipelineProcessor.ExecutionFailed;
pipelineProcessor.Dispose();
}
}
internal abstract void Bind(PipelineProcessor pipelineProcessor, CommandProcessorBase commandProcessor, ExecutionContext context);
private static void AddNoopCommandProcessor(PipelineProcessor pipelineProcessor, System.Management.Automation.ExecutionContext context)
{
CmdletInfo commandInfo = new CmdletInfo("Out-Null", typeof(OutNullCommand));
CommandProcessorBase commandProcessor = context.CommandDiscovery.LookupCommandProcessor(commandInfo, context.EngineSessionState.CurrentScope.ScopeOrigin, false, null);
pipelineProcessor.Add(commandProcessor);
}
internal static SteppablePipeline GetSteppablePipeline(PipelineAst pipelineAst, CommandOrigin commandOrigin)
{
PipelineProcessor pipe = new PipelineProcessor();
System.Management.Automation.ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
foreach (CommandAst ast in pipelineAst.PipelineElements.Cast<CommandAst>())
{
List<CommandParameterInternal> list = new List<CommandParameterInternal>();
foreach (CommandElementAst ast2 in ast.CommandElements)
{
CommandParameterAst commandParameterAst = ast2 as CommandParameterAst;
if (commandParameterAst != null)
{
list.Add(GetCommandParameter(commandParameterAst, executionContextFromTLS));
}
else
{
ExpressionAst expressionAst = (ExpressionAst) ast2;
object obj2 = Compiler.GetExpressionValue(expressionAst, executionContextFromTLS, (IList)null);
bool splatted = (expressionAst is VariableExpressionAst) && ((VariableExpressionAst) expressionAst).Splatted;
list.Add(CommandParameterInternal.CreateArgument(expressionAst.Extent, obj2, splatted));
}
}
List<CommandRedirection> list2 = new List<CommandRedirection>();
foreach (RedirectionAst ast5 in ast.Redirections)
{
list2.Add(GetCommandRedirection(ast5, executionContextFromTLS));
}
CommandProcessorBase base2 = AddCommand(pipe, list.ToArray(), ast, list2.ToArray(), executionContextFromTLS);
base2.Command.CommandOriginInternal = commandOrigin;
base2.CommandScope.ScopeOrigin = commandOrigin;
base2.Command.MyInvocation.CommandOrigin = commandOrigin;
CallStackFrame[] frameArray = executionContextFromTLS.Debugger.GetCallStack().ToArray<CallStackFrame>();
if ((frameArray.Length > 0) && Regex.IsMatch(frameArray[0].Position.Text, "GetSteppablePipeline", RegexOptions.IgnoreCase))
{
InvocationInfo myInvocation = base2.Command.MyInvocation;
myInvocation.InvocationName = frameArray[0].InvocationInfo.InvocationName;
if (frameArray.Length > 1)
{
IScriptExtent position = frameArray[1].Position;
if ((position != null) && (position != PositionUtilities.EmptyExtent))
{
myInvocation.DisplayScriptPosition = position;
}
}
}
if ((executionContextFromTLS.CurrentCommandProcessor != null) && (executionContextFromTLS.CurrentCommandProcessor.CommandRuntime != null))
{
base2.CommandRuntime.SetMergeFromRuntime(executionContextFromTLS.CurrentCommandProcessor.CommandRuntime);
}
}
return new SteppablePipeline(executionContextFromTLS, pipe);
}
/// <summary>
/// Creates a PipelineProcessor object from LocalPipeline object.
/// </summary>
/// <returns>Created PipelineProcessor object</returns>
private PipelineProcessor CreatePipelineProcessor()
{
CommandCollection commands = Commands;
if (commands == null || commands.Count == 0)
{
throw PSTraceSource.NewInvalidOperationException(RunspaceStrings.NoCommandInPipeline);
}
PipelineProcessor pipelineProcessor = new PipelineProcessor();
pipelineProcessor.TopLevel = true;
bool failed = false;
try
{
foreach (Command command in commands)
{
CommandProcessorBase commandProcessorBase;
// If CommandInfo is null, proceed with CommandDiscovery to resolve the command name
if (command.CommandInfo == null)
{
try
{
CommandOrigin commandOrigin = command.CommandOrigin;
if (IsNested)
{
commandOrigin = CommandOrigin.Internal;
}
commandProcessorBase =
command.CreateCommandProcessor
(
LocalRunspace.ExecutionContext,
LocalRunspace.CommandFactory,
AddToHistory,
commandOrigin
);
}
catch
{
// If we had an error creating a command processor and we are logging, then
// log the attempted command invocation anyways.
if (this.Runspace.GetExecutionContext.EngineHostInterface.UI.IsTranscribing)
{
// Don't need to log script commands, as they were already logged during pipeline
// setup
if (!command.IsScript)
{
this.Runspace.ExecutionContext.InternalHost.UI.TranscribeCommand(command.CommandText, null);
}
}
throw;
}
}
else
{
commandProcessorBase = CreateCommandProcessBase(command);
// Set the internal command origin member on the command object at this point...
commandProcessorBase.Command.CommandOriginInternal = CommandOrigin.Internal;
commandProcessorBase.Command.MyInvocation.InvocationName = command.CommandInfo.Name;
if (command.Parameters != null)
{
foreach (CommandParameter publicParameter in command.Parameters)
{
CommandParameterInternal internalParameter = CommandParameter.ToCommandParameterInternal(publicParameter, false);
commandProcessorBase.AddParameter(internalParameter);
}
}
}
commandProcessorBase.RedirectShellErrorOutputPipe = this.RedirectShellErrorOutputPipe;
pipelineProcessor.Add(commandProcessorBase);
}
return pipelineProcessor;
}
catch (RuntimeException)
{
failed = true;
throw;
}
catch (Exception e)
{
failed = true;
CommandProcessorBase.CheckForSevereException(e);
throw new RuntimeException(PipelineStrings.CannotCreatePipeline, e);
}
finally
{
if (failed)
{
this.SetHadErrors(true);
// 2004/02/26-JonN added IDisposable to PipelineProcessor
pipelineProcessor.Dispose();
}
}
}
private static CommandProcessorBase AddCommand(PipelineProcessor pipe, CommandParameterInternal[] commandElements, CommandBaseAst commandBaseAst, CommandRedirection[] redirections, System.Management.Automation.ExecutionContext context)
{
object parameterText;
IScriptExtent parameterExtent;
CommandProcessorBase base2;
InternalCommand command;
string str3;
HelpCategory category;
CommandAst ast = commandBaseAst as CommandAst;
TokenKind kind = (ast != null) ? ast.InvocationOperator : TokenKind.Unknown;
bool dotSource = kind == TokenKind.Dot;
SessionStateInternal sessionState = null;
int index = 0;
PSModuleInfo info = PSObject.Base(commandElements[0].ArgumentValue) as PSModuleInfo;
if (info != null)
{
if ((info.ModuleType == ModuleType.Binary) && (info.SessionState == null))
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInBinaryModule", ParserStrings.CantInvokeInBinaryModule, new object[] { info.Name });
}
if (info.SessionState == null)
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "CantInvokeInNonImportedModule", ParserStrings.CantInvokeInNonImportedModule, new object[] { info.Name });
}
sessionState = info.SessionState.Internal;
index++;
}
CommandParameterInternal internal3 = commandElements[index];
if (internal3.ParameterNameSpecified)
{
parameterText = internal3.ParameterText;
parameterExtent = internal3.ParameterExtent;
if (!internal3.ArgumentSpecified)
{
}
}
else
{
parameterText = PSObject.Base(internal3.ArgumentValue);
parameterExtent = internal3.ArgumentExtent;
}
string str = dotSource ? "." : ((kind == TokenKind.Ampersand) ? "&" : null);
ScriptBlock scriptblock = parameterText as ScriptBlock;
if (scriptblock != null)
{
base2 = CommandDiscovery.CreateCommandProcessorForScript(scriptblock, context, !dotSource, sessionState);
}
else
{
CommandInfo commandInfo = parameterText as CommandInfo;
if (commandInfo != null)
{
base2 = context.CommandDiscovery.LookupCommandProcessor(commandInfo, context.EngineSessionState.CurrentScope.ScopeOrigin, new bool?(!dotSource), sessionState);
}
else
{
string str2 = (parameterText as string) ?? PSObject.ToStringParser(context, parameterText);
str = str ?? str2;
if (string.IsNullOrEmpty(str2))
{
throw InterpreterError.NewInterpreterException(parameterText, typeof(RuntimeException), parameterExtent, "BadExpression", ParserStrings.BadExpression, new object[] { dotSource ? "." : "&" });
}
try
{
if (sessionState != null)
{
SessionStateInternal engineSessionState = context.EngineSessionState;
try
{
context.EngineSessionState = sessionState;
base2 = context.CreateCommand(str2, dotSource);
goto Label_025D;
}
finally
{
context.EngineSessionState = engineSessionState;
}
}
base2 = context.CreateCommand(str2, dotSource);
}
catch (RuntimeException exception)
{
if (exception.ErrorRecord.InvocationInfo == null)
{
InvocationInfo invocationInfo = new InvocationInfo(null, parameterExtent, context) {
InvocationName = str
};
exception.ErrorRecord.SetInvocationInfo(invocationInfo);
}
throw;
}
}
}
Label_025D:
command = base2.Command;
base2.UseLocalScope = !dotSource && ((command is ScriptCommand) || (command is PSScriptCmdlet));
bool flag2 = base2 is NativeCommandProcessor;
for (int i = index + 1; i < commandElements.Length; i++)
{
CommandParameterInternal parameter = commandElements[i];
if ((!parameter.ParameterNameSpecified || !parameter.ParameterName.Equals("-", StringComparison.OrdinalIgnoreCase)) || flag2)
{
if (parameter.ArgumentSplatted)
{
foreach (CommandParameterInternal internal6 in Splat(parameter.ArgumentValue, parameter.ArgumentExtent))
{
base2.AddParameter(internal6);
}
}
else
{
base2.AddParameter(parameter);
}
}
}
if (base2.IsHelpRequested(out str3, out category))
{
base2 = CommandProcessorBase.CreateGetHelpCommandProcessor(context, str3, category);
}
base2.Command.InvocationExtent = commandBaseAst.Extent;
base2.Command.MyInvocation.ScriptPosition = commandBaseAst.Extent;
base2.Command.MyInvocation.InvocationName = str;
pipe.Add(base2);
bool flag3 = false;
bool flag4 = false;
bool flag5 = false;
bool flag6 = false;
if (redirections != null)
{
foreach (CommandRedirection redirection in redirections)
{
redirection.Bind(pipe, base2, context);
switch (redirection.FromStream)
{
case RedirectionStream.All:
flag3 = true;
flag4 = true;
flag5 = true;
flag6 = true;
break;
case RedirectionStream.Error:
flag3 = true;
break;
case RedirectionStream.Warning:
flag4 = true;
break;
case RedirectionStream.Verbose:
flag5 = true;
break;
case RedirectionStream.Debug:
flag6 = true;
break;
}
}
}
if (!flag3)
{
if (context.ShellFunctionErrorOutputPipe != null)
{
base2.CommandRuntime.ErrorOutputPipe = context.ShellFunctionErrorOutputPipe;
}
else
{
base2.CommandRuntime.ErrorOutputPipe.ExternalWriter = context.ExternalErrorOutput;
}
}
if (!flag4 && (context.ExpressionWarningOutputPipe != null))
{
base2.CommandRuntime.WarningOutputPipe = context.ExpressionWarningOutputPipe;
flag4 = true;
}
if (!flag5 && (context.ExpressionVerboseOutputPipe != null))
{
base2.CommandRuntime.VerboseOutputPipe = context.ExpressionVerboseOutputPipe;
flag5 = true;
}
if (!flag6 && (context.ExpressionDebugOutputPipe != null))
{
base2.CommandRuntime.DebugOutputPipe = context.ExpressionDebugOutputPipe;
flag6 = true;
}
if ((context.CurrentCommandProcessor != null) && (context.CurrentCommandProcessor.CommandRuntime != null))
{
if (!flag4 && (context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe != null))
{
base2.CommandRuntime.WarningOutputPipe = context.CurrentCommandProcessor.CommandRuntime.WarningOutputPipe;
}
if (!flag5 && (context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe != null))
{
base2.CommandRuntime.VerboseOutputPipe = context.CurrentCommandProcessor.CommandRuntime.VerboseOutputPipe;
}
if (!flag6 && (context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe != null))
{
base2.CommandRuntime.DebugOutputPipe = context.CurrentCommandProcessor.CommandRuntime.DebugOutputPipe;
}
}
return base2;
}
/// <summary>
/// Resets the TraceSource flags back to their original value and restores
/// the original TraceListeners.
/// </summary>
public void Dispose()
{
if (!_disposed)
{
_disposed = true;
// Reset the flags for the trace switch back to the original value
ResetTracing(_matchingSources);
ClearStoredState();
_matchingSources = null;
if (_pipeline != null)
{
_pipeline.Dispose();
_pipeline = null;
}
// If there are any file streams, close those as well.
if (this.FileStreams != null)
{
foreach (FileStream fileStream in this.FileStreams)
{
fileStream.Flush();
fileStream.Dispose();
}
}
GC.SuppressFinalize(this);
}
} // Dispose
/// <summary>
/// Gets the PSTraceSource instances that match the names specified.
/// </summary>
protected override void BeginProcessing()
{
Collection<PSTraceSource> preconfiguredSources = null;
_matchingSources = ConfigureTraceSource(base.NameInternal, false, out preconfiguredSources);
TurnOnTracing(_matchingSources, false);
TurnOnTracing(preconfiguredSources, true);
// Now that tracing has been configured, move all the sources into a
// single collection
foreach (PSTraceSource preconfiguredSource in preconfiguredSources)
{
_matchingSources.Add(preconfiguredSource);
}
if (ParameterSetName == "commandSet")
{
// Create the CommandProcessor and add it to a pipeline
CommandProcessorBase commandProcessor =
this.Context.CommandDiscovery.LookupCommandProcessor(Command, CommandOrigin.Runspace, false);
// Add the parameters that were specified
ParameterBinderController.AddArgumentsToCommandProcessor(commandProcessor, ArgumentList);
_pipeline = new PipelineProcessor();
_pipeline.Add(commandProcessor);
// Hook up the success and error pipelines to this cmdlet's WriteObject and
// WriteError methods
_pipeline.ExternalErrorOutput = new TracePipelineWriter(this, true, _matchingSources);
_pipeline.ExternalSuccessOutput = new TracePipelineWriter(this, false, _matchingSources);
}
ResetTracing(_matchingSources);
}
/// <summary>
/// This pipe writes into another pipeline processor allowing
/// pipelines to be chained together...
/// </summary>
/// <param name="context">The execution context object for this engine instance</param>
/// <param name="outputPipeline">The pipeline to write into...</param>
internal Pipe(ExecutionContext context, PipelineProcessor outputPipeline)
{
Diagnostics.Assert(outputPipeline != null, "outputPipeline cannot be null");
Diagnostics.Assert(outputPipeline != null, "context cannot be null");
_isRedirected = true;
_context = context;
PipelineProcessor = outputPipeline;
}
private void DelayedInternalInitialize()
{
_pp = new PipelineProcessor();
CmdletInfo cmdletInfo = new CmdletInfo(_commandName, _commandType, null, null, _context);
CommandProcessor cp = new CommandProcessor(cmdletInfo, _context);
foreach (CommandParameterInternal par in _commandParameterList)
{
cp.AddParameter(par);
}
_pp.Add(cp);
}
private PipelineProcessor CreatePipelineProcessor()
{
PipelineProcessor processor2;
CommandCollection commands = base.Commands;
if ((commands == null) || (commands.Count == 0))
{
throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "NoCommandInPipeline", new object[0]);
}
PipelineProcessor processor = new PipelineProcessor {
TopLevel = true
};
bool flag = false;
try
{
foreach (Command command in commands)
{
CommandProcessorBase base2;
if (command.CommandInfo == null)
{
base2 = command.CreateCommandProcessor(this.LocalRunspace.ExecutionContext, this.LocalRunspace.CommandFactory, base.AddToHistory, this.IsNested ? CommandOrigin.Internal : CommandOrigin.Runspace);
}
else
{
CmdletInfo commandInfo = (CmdletInfo) command.CommandInfo;
base2 = new CommandProcessor(commandInfo, this.LocalRunspace.ExecutionContext);
PSSQMAPI.IncrementData(commandInfo.CommandType);
base2.Command.CommandOriginInternal = CommandOrigin.Internal;
base2.Command.MyInvocation.InvocationName = commandInfo.Name;
if (command.Parameters != null)
{
foreach (CommandParameter parameter in command.Parameters)
{
CommandParameterInternal internal2 = CommandParameter.ToCommandParameterInternal(parameter, false);
base2.AddParameter(internal2);
}
}
}
base2.RedirectShellErrorOutputPipe = base.RedirectShellErrorOutputPipe;
processor.Add(base2);
}
processor2 = processor;
}
catch (RuntimeException)
{
flag = true;
throw;
}
catch (Exception exception)
{
flag = true;
CommandProcessorBase.CheckForSevereException(exception);
throw new RuntimeException(PipelineStrings.CannotCreatePipeline, exception);
}
finally
{
if (flag)
{
base.SetHadErrors(true);
processor.Dispose();
}
}
return processor2;
}
/// <summary>
/// Formats the input objects using out-string. Output of out-string
/// is given as input to native command processor.
/// This method is to be called from the pipeline thread and not from the
/// thread which writes input in to process.
/// </summary>
private void ConvertToString()
{
Dbg.Assert(_inputFormat == NativeCommandIOFormat.Text, "InputFormat should be Text");
PipelineProcessor p = new PipelineProcessor();
p.Add(_command.Context.CreateCommand("out-string", false));
object[] result = (object[])p.SynchronousExecuteEnumerate(_inputList.ToArray());
_inputList = new ArrayList(result);
}
internal void AddRedirectionPipe(PipelineProcessor pipelineProcessor)
{
if (pipelineProcessor == null)
{
throw PSTraceSource.NewArgumentNullException("pipelineProcessor");
}
if (this._redirectionPipes == null)
{
this._redirectionPipes = new List<PipelineProcessor>();
}
this._redirectionPipes.Add(pipelineProcessor);
}