internal void Invoke(PSEventSubscriber eventSubscriber, PSEventArgs eventArgs)
{
if (!base.IsFinishedState(base.JobStateInfo.State))
{
base.SetJobState(JobState.Running);
SessionState publicSessionState = this.action.SessionStateInternal.PublicSessionState;
publicSessionState.PSVariable.Set("eventSubscriber", eventSubscriber);
publicSessionState.PSVariable.Set("event", eventArgs);
publicSessionState.PSVariable.Set("sender", eventArgs.Sender);
publicSessionState.PSVariable.Set("eventArgs", eventArgs.SourceEventArgs);
ArrayList resultList = new ArrayList();
try
{
Pipe outputPipe = new Pipe(resultList);
this.action.InvokeWithPipe(false, System.Management.Automation.ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe, AutomationNull.Value, AutomationNull.Value, AutomationNull.Value, outputPipe, null, eventArgs.SourceArgs);
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
if (!(exception is PipelineStoppedException))
{
this.LogErrorsAndOutput(resultList, publicSessionState);
base.SetJobState(JobState.Failed);
}
throw;
}
this.LogErrorsAndOutput(resultList, publicSessionState);
this.moreData = true;
}
}
protected override void ProcessRecord()
{
this.stopWatch.Start();
Pipe outputPipe = new Pipe {
NullPipe = true
};
this.script.InvokeWithPipe(false, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, this.InputObject, new object[0], AutomationNull.Value, outputPipe, null, new object[0]);
this.stopWatch.Stop();
}
internal Pipe[] BindForExpression(FunctionContext funcContext)
{
ExecutionContext context = funcContext._executionContext;
Pipe redirectionPipe = this.GetRedirectionPipe(context, null);
Pipe[] pipeArray = new Pipe[7];
switch (base.FromStream)
{
case RedirectionStream.All:
pipeArray[1] = funcContext._outputPipe;
pipeArray[2] = context.ShellFunctionErrorOutputPipe;
pipeArray[3] = context.ExpressionWarningOutputPipe;
pipeArray[4] = context.ExpressionVerboseOutputPipe;
pipeArray[5] = context.ExpressionDebugOutputPipe;
funcContext._outputPipe = redirectionPipe;
context.ShellFunctionErrorOutputPipe = redirectionPipe;
context.ExpressionWarningOutputPipe = redirectionPipe;
context.ExpressionVerboseOutputPipe = redirectionPipe;
context.ExpressionDebugOutputPipe = redirectionPipe;
return pipeArray;
case RedirectionStream.Output:
pipeArray[1] = funcContext._outputPipe;
funcContext._outputPipe = redirectionPipe;
return pipeArray;
case RedirectionStream.Error:
pipeArray[(int) base.FromStream] = context.ShellFunctionErrorOutputPipe;
context.ShellFunctionErrorOutputPipe = redirectionPipe;
return pipeArray;
case RedirectionStream.Warning:
pipeArray[(int) base.FromStream] = context.ExpressionWarningOutputPipe;
context.ExpressionWarningOutputPipe = redirectionPipe;
return pipeArray;
case RedirectionStream.Verbose:
pipeArray[(int) base.FromStream] = context.ExpressionVerboseOutputPipe;
context.ExpressionVerboseOutputPipe = redirectionPipe;
return pipeArray;
case RedirectionStream.Debug:
pipeArray[(int) base.FromStream] = context.ExpressionDebugOutputPipe;
context.ExpressionDebugOutputPipe = redirectionPipe;
return pipeArray;
case RedirectionStream.Host:
return pipeArray;
}
return pipeArray;
}
internal ScriptBlockInvocationEventArgs(System.Management.Automation.ScriptBlock scriptBlock, bool useLocalScope, System.Management.Automation.ScriptBlock.ErrorHandlingBehavior errorHandlingBehavior, object dollarUnder, object input, object scriptThis, Pipe outputPipe, System.Management.Automation.InvocationInfo invocationInfo, params object[] args)
{
if (scriptBlock == null)
{
throw PSTraceSource.NewArgumentNullException("scriptBlock");
}
this.ScriptBlock = scriptBlock;
this.OutputPipe = outputPipe;
this.UseLocalScope = useLocalScope;
this.ErrorHandlingBehavior = errorHandlingBehavior;
this.DollarUnder = dollarUnder;
this.Input = input;
this.ScriptThis = scriptThis;
this.InvocationInfo = invocationInfo;
this.Args = args;
}
internal void UnbindForExpression(FunctionContext funcContext, Pipe[] pipes)
{
if (pipes != null)
{
ExecutionContext context = funcContext._executionContext;
switch (this.FromStream)
{
case RedirectionStream.All:
funcContext._outputPipe = pipes[1];
context.ShellFunctionErrorOutputPipe = pipes[2];
context.ExpressionWarningOutputPipe = pipes[3];
context.ExpressionVerboseOutputPipe = pipes[4];
context.ExpressionDebugOutputPipe = pipes[5];
return;
case RedirectionStream.Output:
funcContext._outputPipe = pipes[1];
return;
case RedirectionStream.Error:
context.ShellFunctionErrorOutputPipe = pipes[(int) this.FromStream];
return;
case RedirectionStream.Warning:
context.ExpressionWarningOutputPipe = pipes[(int) this.FromStream];
return;
case RedirectionStream.Verbose:
context.ExpressionVerboseOutputPipe = pipes[(int) this.FromStream];
return;
case RedirectionStream.Debug:
context.ExpressionDebugOutputPipe = pipes[(int) this.FromStream];
return;
case RedirectionStream.Host:
return;
}
}
}
private void CopyVariableToTempPipe(VariableStreamKind streamKind, List<IList> variableList, Pipe tempPipe)
{
if (variableList != null && variableList.Count > 0)
{
for (int i = 0; i < variableList.Count; i++)
{
tempPipe.AddVariableList(streamKind, variableList[i]);
}
}
}
/// <summary>
/// When a temporary pipe is used in the middle of execution, then we need to pass along
/// the error and warning variable list to hold the errors and warnings get written out
/// while the temporary pipe is being used.
///
/// We don't need to pass along the out variable list because we don't care about the output
/// generated in the middle of execution.
/// </summary>
internal void SetVariableListForTemporaryPipe(Pipe tempPipe)
{
CopyVariableToTempPipe(VariableStreamKind.Error, _errorVariableList, tempPipe);
CopyVariableToTempPipe(VariableStreamKind.Warning, _warningVariableList, tempPipe);
CopyVariableToTempPipe(VariableStreamKind.Information, _informationVariableList, tempPipe);
}
internal void LinkPipelineSuccessOutput(Pipe pipeToUse)
{
CommandProcessorBase base2 = this._commands[this._commands.Count - 1];
if ((base2 == null) || (base2.CommandRuntime == null))
{
throw PSTraceSource.NewInvalidOperationException();
}
base2.CommandRuntime.OutputPipe = pipeToUse;
this._linkedSuccessOutput = true;
}
internal void LinkPipelineErrorOutput(Pipe pipeToUse)
{
for (int i = 0; i < this._commands.Count; i++)
{
CommandProcessorBase base2 = this._commands[i];
if ((base2 == null) || (base2.CommandRuntime == null))
{
throw PSTraceSource.NewInvalidOperationException();
}
Pipe errorOutputPipe = base2.CommandRuntime.ErrorOutputPipe;
if (base2.CommandRuntime.ErrorOutputPipe.DownstreamCmdlet == null)
{
base2.CommandRuntime.ErrorOutputPipe = pipeToUse;
}
}
this._linkedErrorOutput = true;
}
internal static void SetErrorVariables(IScriptExtent extent, RuntimeException rte, ExecutionContext context, Pipe outputPipe)
{
string newValue = null;
Exception innerException = rte;
int num = 0;
while ((innerException != null) && (num++ < 10))
{
if (!string.IsNullOrEmpty(innerException.StackTrace))
{
newValue = innerException.StackTrace;
}
innerException = innerException.InnerException;
}
context.SetVariable(SpecialVariables.StackTraceVarPath, newValue);
InterpreterError.UpdateExceptionErrorRecordPosition(rte, extent);
ErrorRecord record = rte.ErrorRecord.WrapException(rte);
if (!(rte is PipelineStoppedException))
{
if (outputPipe != null)
{
outputPipe.AppendVariableList(VariableStreamKind.Error, record);
}
context.AppendDollarError(record);
}
}
private static object GetExpressionValue(ExpressionAst expressionAst, System.Management.Automation.ExecutionContext context, SessionStateInternal sessionStateInternal, IList usingValues, ref Func<FunctionContext, object> lambda, ref IScriptExtent[] sequencePoints, ref Type localsTupleType)
{
object obj2;
object obj4;
if (IsConstantValueVisitor.IsConstant(expressionAst, out obj2, false, false))
{
return obj2;
}
VariableExpressionAst varAst = expressionAst as VariableExpressionAst;
if (varAst != null)
{
return VariableOps.GetVariableValue(varAst.VariablePath, context, varAst);
}
if (lambda == null)
{
lambda = new Compiler().CompileSingleExpression(expressionAst, out sequencePoints, out localsTupleType);
}
SessionStateInternal engineSessionState = context.EngineSessionState;
try
{
if ((sessionStateInternal != null) && (context.EngineSessionState != sessionStateInternal))
{
context.EngineSessionState = sessionStateInternal;
}
ArrayList resultList = new ArrayList();
Pipe pipe = new Pipe(resultList);
try
{
FunctionContext arg = new FunctionContext {
_sequencePoints = sequencePoints,
_executionContext = context,
_outputPipe = pipe,
_localsTuple = MutableTuple.MakeTuple(localsTupleType, DottedLocalsNameIndexMap)
};
if (usingValues != null)
{
PSBoundParametersDictionary dictionary = new PSBoundParametersDictionary {
ImplicitUsingParameters = usingValues
};
arg._localsTuple.SetAutomaticVariable(AutomaticVariable.PSBoundParameters, dictionary, context);
}
object obj3 = lambda(arg);
if (obj3 == AutomationNull.Value)
{
return ((resultList.Count == 0) ? null : PipelineOps.PipelineResult(resultList));
}
obj4 = obj3;
}
catch (TargetInvocationException exception)
{
throw exception.InnerException;
}
}
catch (TerminateException)
{
throw;
}
catch (FlowControlException)
{
obj4 = null;
}
finally
{
context.EngineSessionState = engineSessionState;
}
return obj4;
}
} // private void SetResultPipe
internal void LinkPipelineErrorOutput(Pipe pipeToUse)
{
Dbg.Assert(pipeToUse != null, "Caller should verify pipeToUse != null");
for (int i = 0; i < _commands.Count; i++)
{
CommandProcessorBase commandProcessor = _commands[i];
if (null == commandProcessor
|| null == commandProcessor.CommandRuntime)
{
// "null command or request or ErrorOutputPipe " + i
throw PSTraceSource.NewInvalidOperationException();
}
if (commandProcessor.CommandRuntime.ErrorOutputPipe.DownstreamCmdlet == null)
{
commandProcessor.CommandRuntime.ErrorOutputPipe = pipeToUse;
}
}
_linkedErrorOutput = true;
}
private bool IsDownstreamOutDefault(Pipe downstreamPipe)
{
Diagnostics.Assert(downstreamPipe != null, "Caller makes sure the passed-in parameter is not null.");
// Check if the downstream cmdlet is Out-Default, which is the default outputter.
CommandProcessorBase outputProcessor = downstreamPipe.DownstreamCmdlet;
if (outputProcessor != null)
{
// We have the test 'utscript\Engine\TestOutDefaultRedirection.ps1' to check that a user defined
// Out-Default function should not cause a native command to be redirected. So here we should only
// compare the command name to avoid breaking change.
if (String.Equals(outputProcessor.CommandInfo.Name, "Out-Default", StringComparison.OrdinalIgnoreCase))
{
// Verify that this isn't an Out-Default added for transcribing
if (!outputProcessor.Command.MyInvocation.BoundParameters.ContainsKey("Transcript"))
{
return true;
}
}
}
return false;
}
} // private Array RetrieveResults
/// <summary>
/// Links this pipeline to a pre-existing Pipe object. This allows nested pipes
/// to write into the parent pipeline. It does this by resetting the terminal
/// pipeline object.
/// </summary>
/// <param name="pipeToUse">The pipeline to write success objects to</param>
internal void LinkPipelineSuccessOutput(Pipe pipeToUse)
{
Dbg.Assert(pipeToUse != null, "Caller should verify pipeToUse != null");
CommandProcessorBase LastCommandProcessor = _commands[_commands.Count - 1];
if (null == LastCommandProcessor
|| null == LastCommandProcessor.CommandRuntime)
{
// "PipelineProcessor.RetrieveResults(): LastCommandProcessor == null"
throw PSTraceSource.NewInvalidOperationException();
}
LastCommandProcessor.CommandRuntime.OutputPipe = pipeToUse;
_linkedSuccessOutput = true;
} // private void SetResultPipe
internal void InvokeWithPipeImpl(bool createLocalScope,
Dictionary<string, ScriptBlock> functionsToDefine,
List<PSVariable> variablesToDefine,
ErrorHandlingBehavior errorHandlingBehavior,
object dollarUnder,
object input,
object scriptThis,
Pipe outputPipe,
InvocationInfo invocationInfo,
params object[] args)
{
InvokeWithPipeImpl(ScriptBlockClauseToInvoke.ProcessBlockOnly, createLocalScope,
functionsToDefine,
variablesToDefine,
errorHandlingBehavior,
dollarUnder,
input,
scriptThis,
outputPipe,
invocationInfo,
args);
}
internal void InvokeWithPipeImpl(ScriptBlockClauseToInvoke clauseToInvoke,
bool createLocalScope,
Dictionary<string, ScriptBlock> functionsToDefine,
List<PSVariable> variablesToDefine,
ErrorHandlingBehavior errorHandlingBehavior,
object dollarUnder,
object input,
object scriptThis,
Pipe outputPipe,
InvocationInfo invocationInfo,
params object[] args)
{
if (clauseToInvoke == ScriptBlockClauseToInvoke.Begin && !HasBeginBlock)
{
return;
}
else if (clauseToInvoke == ScriptBlockClauseToInvoke.Process && !HasProcessBlock)
{
return;
}
else if (clauseToInvoke == ScriptBlockClauseToInvoke.End && !HasEndBlock)
{
return;
}
ExecutionContext context = GetContextFromTLS();
Diagnostics.Assert(SessionStateInternal == null || SessionStateInternal.ExecutionContext == context,
"The scriptblock is being invoked in a runspace different than the one where it was created");
if (context.CurrentPipelineStopping)
{
throw new PipelineStoppedException();
}
// Validate at the arguments are consistent. The only public API that gets you here never sets createLocalScope to false...
Diagnostics.Assert(createLocalScope == true || functionsToDefine == null, "When calling ScriptBlock.InvokeWithContext(), if 'functionsToDefine' != null then 'createLocalScope' must be true");
Diagnostics.Assert(createLocalScope == true || variablesToDefine == null, "When calling ScriptBlock.InvokeWithContext(), if 'variablesToDefine' != null then 'createLocalScope' must be true");
if (args == null)
{
args = Utils.EmptyArray<object>();
}
bool runOptimized = context._debuggingMode > 0 ? false : createLocalScope;
var codeToInvoke = GetCodeToInvoke(ref runOptimized, clauseToInvoke);
if (codeToInvoke == null)
return;
if (outputPipe == null)
{
// If we don't have a pipe to write to, we need to discard all results.
outputPipe = new Pipe { NullPipe = true };
}
var locals = MakeLocalsTuple(runOptimized);
if (dollarUnder != AutomationNull.Value)
{
locals.SetAutomaticVariable(AutomaticVariable.Underbar, dollarUnder, context);
}
if (input != AutomationNull.Value)
{
locals.SetAutomaticVariable(AutomaticVariable.Input, input, context);
}
if (scriptThis != AutomationNull.Value)
{
locals.SetAutomaticVariable(AutomaticVariable.This, scriptThis, context);
}
SetPSScriptRootAndPSCommandPath(locals, context);
var oldShellFunctionErrorOutputPipe = context.ShellFunctionErrorOutputPipe;
var oldExternalErrorOutput = context.ExternalErrorOutput;
var oldScopeOrigin = context.EngineSessionState.CurrentScope.ScopeOrigin;
var oldSessionState = context.EngineSessionState;
// If the script block has a different language mode than the current,
// change the language mode.
PSLanguageMode? oldLanguageMode = null;
PSLanguageMode? newLanguageMode = null;
if ((this.LanguageMode.HasValue) &&
(this.LanguageMode != context.LanguageMode))
{
oldLanguageMode = context.LanguageMode;
newLanguageMode = this.LanguageMode;
}
Dictionary<string, PSVariable> backupWhenDotting = null;
try
{
var myInvocationInfo = invocationInfo;
if (myInvocationInfo == null)
{
var callerFrame = context.Debugger.GetCallStack().LastOrDefault();
var extent = (callerFrame != null)
? callerFrame.FunctionContext.CurrentPosition
: Ast.Extent;
myInvocationInfo = new InvocationInfo(null, extent, context);
}
locals.SetAutomaticVariable(AutomaticVariable.MyInvocation, myInvocationInfo, context);
if (SessionStateInternal != null)
context.EngineSessionState = SessionStateInternal;
// If we don't want errors written, hide the error pipe.
switch (errorHandlingBehavior)
{
case ErrorHandlingBehavior.WriteToCurrentErrorPipe:
// no need to do anything
break;
case ErrorHandlingBehavior.WriteToExternalErrorPipe:
context.ShellFunctionErrorOutputPipe = null;
break;
case ErrorHandlingBehavior.SwallowErrors:
context.ShellFunctionErrorOutputPipe = null;
context.ExternalErrorOutput = new DiscardingPipelineWriter();
break;
}
if (createLocalScope)
{
var newScope = context.EngineSessionState.NewScope(false);
context.EngineSessionState.CurrentScope = newScope;
newScope.LocalsTuple = locals;
// Inject passed in functions into the scope
if (functionsToDefine != null)
{
foreach (var def in functionsToDefine)
{
if (string.IsNullOrWhiteSpace(def.Key))
{
PSInvalidOperationException e = PSTraceSource.NewInvalidOperationException(
ParserStrings.EmptyFunctionNameInFunctionDefinitionDictionary);
e.SetErrorId("EmptyFunctionNameInFunctionDefinitionDictionary");
throw e;
}
if (def.Value == null)
{
PSInvalidOperationException e = PSTraceSource.NewInvalidOperationException(
ParserStrings.NullFunctionBodyInFunctionDefinitionDictionary, def.Key);
e.SetErrorId("NullFunctionBodyInFunctionDefinitionDictionary");
throw e;
}
newScope.FunctionTable.Add(def.Key, new FunctionInfo(def.Key, def.Value, context));
}
}
// Inject passed in variables into the scope
if (variablesToDefine != null)
{
int index = 0;
foreach (var psvar in variablesToDefine)
{
// Check for null entries.
if (psvar == null)
{
PSInvalidOperationException e = PSTraceSource.NewInvalidOperationException(
ParserStrings.NullEntryInVariablesDefinitionList, index);
e.SetErrorId("NullEntryInVariablesDefinitionList");
throw e;
}
string name = psvar.Name;
Diagnostics.Assert(!(string.Equals(name, "this") || string.Equals(name, "_") || string.Equals(name, "input")),
"The list of variables to set in the scriptblock's scope cannot contain 'this', '_' or 'input'. These variables should be removed before passing the collection to this routine.");
index++;
newScope.Variables.Add(name, psvar);
}
}
}
else
{
if (context.EngineSessionState.CurrentScope.LocalsTuple == null)
{
// If the locals tuple is, that means either:
// * we're invoking a script block for a module
// * something unexpected
context.EngineSessionState.CurrentScope.LocalsTuple = locals;
}
else
{
context.EngineSessionState.CurrentScope.DottedScopes.Push(locals);
backupWhenDotting = new Dictionary<string, PSVariable>();
}
}
// Set the language mode
if (newLanguageMode.HasValue)
{
context.LanguageMode = newLanguageMode.Value;
}
args = BindArgumentsForScriptblockInvoke(
(RuntimeDefinedParameter[])RuntimeDefinedParameters.Data,
args, context, !createLocalScope, backupWhenDotting, locals);
locals.SetAutomaticVariable(AutomaticVariable.Args, args, context);
context.EngineSessionState.CurrentScope.ScopeOrigin = CommandOrigin.Internal;
var functionContext = new FunctionContext
{
_executionContext = context,
_outputPipe = outputPipe,
_localsTuple = locals,
_scriptBlock = this,
_file = this.File,
_debuggerHidden = this.DebuggerHidden,
_debuggerStepThrough = this.DebuggerStepThrough,
_sequencePoints = SequencePoints,
};
ScriptBlock.LogScriptBlockStart(this, context.CurrentRunspace.InstanceId);
try
{
codeToInvoke(functionContext);
}
finally
{
ScriptBlock.LogScriptBlockEnd(this, context.CurrentRunspace.InstanceId);
}
}
catch (TargetInvocationException tie)
{
// DynamicInvoke always wraps, so unwrap here.
throw tie.InnerException;
}
finally
{
// Restore the language mode
if (oldLanguageMode.HasValue)
{
context.LanguageMode = oldLanguageMode.Value;
}
// Now restore the output pipe...
context.ShellFunctionErrorOutputPipe = oldShellFunctionErrorOutputPipe;
context.ExternalErrorOutput = oldExternalErrorOutput;
// Restore the interactive command state...
context.EngineSessionState.CurrentScope.ScopeOrigin = oldScopeOrigin;
if (createLocalScope)
{
context.EngineSessionState.RemoveScope(context.EngineSessionState.CurrentScope);
}
else if (backupWhenDotting != null)
{
context.EngineSessionState.CurrentScope.DottedScopes.Pop();
Diagnostics.Assert(backupWhenDotting != null, "when dotting, this dictionary isn't null");
foreach (var pair in backupWhenDotting)
{
if (pair.Value != null)
{
context.EngineSessionState.SetVariable(pair.Value, false, CommandOrigin.Internal);
}
else
{
context.EngineSessionState.RemoveVariable(pair.Key);
}
}
}
// Restore session state...
context.EngineSessionState = oldSessionState;
}
}
internal void InvokeWithPipeImpl(bool createLocalScope, ScriptBlock.ErrorHandlingBehavior errorHandlingBehavior, object dollarUnder, object input, object scriptThis, Pipe outputPipe, InvocationInfo invocationInfo, object[] args)
{
bool flag;
bool hasValue;
ExecutionContext contextFromTLS = this.GetContextFromTLS();
if (!contextFromTLS.CurrentPipelineStopping)
{
if (args == null)
{
args = new object[0];
}
if (contextFromTLS._debuggingMode > 0)
{
flag = false;
}
else
{
flag = createLocalScope;
}
bool flag1 = flag;
Action<FunctionContext> codeToInvoke = this.GetCodeToInvoke(ref flag1);
if (codeToInvoke != null)
{
if (outputPipe == null)
{
Pipe pipe = new Pipe();
pipe.NullPipe = true;
outputPipe = pipe;
}
MutableTuple mutableTuple = this.MakeLocalsTuple(flag1);
if (dollarUnder != AutomationNull.Value)
{
mutableTuple.SetAutomaticVariable(AutomaticVariable.Underbar, dollarUnder, contextFromTLS);
}
if (input != AutomationNull.Value)
{
mutableTuple.SetAutomaticVariable(AutomaticVariable.Input, input, contextFromTLS);
}
if (scriptThis != AutomationNull.Value)
{
mutableTuple.SetAutomaticVariable(AutomaticVariable.This, scriptThis, contextFromTLS);
}
this.SetPSScriptRootAndPSCommandPath(mutableTuple, contextFromTLS);
Pipe shellFunctionErrorOutputPipe = contextFromTLS.ShellFunctionErrorOutputPipe;
PipelineWriter externalErrorOutput = contextFromTLS.ExternalErrorOutput;
CommandOrigin scopeOrigin = contextFromTLS.EngineSessionState.CurrentScope.ScopeOrigin;
SessionStateInternal engineSessionState = contextFromTLS.EngineSessionState;
PSLanguageMode? nullable = null;
PSLanguageMode? languageMode = null;
PSLanguageMode? languageMode1 = this.LanguageMode;
if (languageMode1.HasValue)
{
PSLanguageMode? nullable1 = this.LanguageMode;
PSLanguageMode pSLanguageMode = contextFromTLS.LanguageMode;
if (nullable1.GetValueOrDefault() != pSLanguageMode)
{
hasValue = true;
}
else
{
hasValue = !nullable1.HasValue;
}
if (hasValue)
{
nullable = new PSLanguageMode?(contextFromTLS.LanguageMode);
languageMode = this.LanguageMode;
}
}
Dictionary<string, PSVariable> strs = null;
try
{
try
{
InvocationInfo invocationInfo1 = invocationInfo;
if (invocationInfo1 == null)
{
invocationInfo1 = new InvocationInfo(null, ((Ast)this._ast).Extent, contextFromTLS);
}
mutableTuple.SetAutomaticVariable(AutomaticVariable.MyInvocation, invocationInfo1, contextFromTLS);
if (this.SessionStateInternal != null)
{
contextFromTLS.EngineSessionState = this.SessionStateInternal;
}
ScriptBlock.ErrorHandlingBehavior errorHandlingBehavior1 = errorHandlingBehavior;
switch (errorHandlingBehavior1)
{
case ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe:
{
WriteToCurrentErrorPipe(createLocalScope, outputPipe, ref args, contextFromTLS, codeToInvoke, mutableTuple, languageMode, ref strs);
break;
}
case ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe:
{
contextFromTLS.ShellFunctionErrorOutputPipe = null;
WriteToCurrentErrorPipe(createLocalScope, outputPipe, ref args, contextFromTLS, codeToInvoke, mutableTuple, languageMode, ref strs);
break;
}
case ScriptBlock.ErrorHandlingBehavior.SwallowErrors:
{
contextFromTLS.ShellFunctionErrorOutputPipe = null;
contextFromTLS.ExternalErrorOutput = new DiscardingPipelineWriter();
WriteToCurrentErrorPipe(createLocalScope, outputPipe, ref args, contextFromTLS, codeToInvoke, mutableTuple, languageMode, ref strs);
break;
}
default:
{
WriteToCurrentErrorPipe(createLocalScope, outputPipe, ref args, contextFromTLS, codeToInvoke, mutableTuple, languageMode, ref strs);
break;
}
}
}
catch (TargetInvocationException targetInvocationException1)
{
TargetInvocationException targetInvocationException = targetInvocationException1;
throw targetInvocationException.InnerException;
}
}
catch(Exception ex)
{
var msg = ex.Message;
}
finally
{
if (nullable.HasValue)
{
contextFromTLS.LanguageMode = nullable.Value;
}
contextFromTLS.ShellFunctionErrorOutputPipe = shellFunctionErrorOutputPipe;
contextFromTLS.ExternalErrorOutput = externalErrorOutput;
contextFromTLS.EngineSessionState.CurrentScope.ScopeOrigin = scopeOrigin;
if (!createLocalScope)
{
if (strs != null)
{
contextFromTLS.EngineSessionState.CurrentScope.DottedScopes.Pop();
foreach (KeyValuePair<string, PSVariable> str in strs)
{
if (str.Value == null)
{
contextFromTLS.EngineSessionState.RemoveVariable(str.Key);
}
else
{
contextFromTLS.EngineSessionState.SetVariable(str.Value, false, CommandOrigin.Internal);
}
}
}
}
else
{
contextFromTLS.EngineSessionState.RemoveScope(contextFromTLS.EngineSessionState.CurrentScope);
}
contextFromTLS.EngineSessionState = engineSessionState;
}
return;
}
else
{
return;
}
}
else
{
throw new PipelineStoppedException();
}
}
public PSModuleInfo(ScriptBlock scriptBlock)
{
this._name = string.Empty;
this._path = string.Empty;
this._description = string.Empty;
this._version = new System.Version(0, 0);
this._detectedFunctionExports = new List<string>();
this._detectedWorkflowExports = new List<string>();
this._detectedCmdletExports = new List<string>();
this._compiledExports = new List<CmdletInfo>();
this._fileList = new List<string>();
this._moduleList = new Collection<object>();
this._nestedModules = new List<PSModuleInfo>();
this._scripts = new List<string>();
this._requiredAssemblies = new Collection<string>();
this._requiredModules = new List<PSModuleInfo>();
this._requiredModulesSpecification = new List<ModuleSpecification>();
this._detectedAliasExports = new Dictionary<string, string>();
this._exportedFormatFiles = new ReadOnlyCollection<string>(new List<string>());
this._exportedTypeFiles = new ReadOnlyCollection<string>(new List<string>());
if (scriptBlock == null)
{
throw PSTraceSource.NewArgumentException("scriptBlock");
}
ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
if (executionContextFromTLS == null)
{
throw new InvalidOperationException("PSModuleInfo");
}
SetDefaultDynamicNameAndPath(this);
this._sessionState = new System.Management.Automation.SessionState(executionContextFromTLS, true, true);
this._sessionState.Internal.Module = this;
SessionStateInternal engineSessionState = executionContextFromTLS.EngineSessionState;
try
{
executionContextFromTLS.EngineSessionState = this._sessionState.Internal;
executionContextFromTLS.SetVariable(SpecialVariables.PSScriptRootVarPath, this._path);
scriptBlock = scriptBlock.Clone(true);
scriptBlock.SessionState = this._sessionState;
Pipe outputPipe = new Pipe {
NullPipe = true
};
scriptBlock.InvokeWithPipe(false, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, AutomationNull.Value, AutomationNull.Value, AutomationNull.Value, outputPipe, null, new object[0]);
}
finally
{
executionContextFromTLS.EngineSessionState = engineSessionState;
}
}
internal object InvokeAsDelegateHelper(object dollarUnder, object dollarThis, object[] args)
{
ExecutionContext contextFromTLS = this.GetContextFromTLS();
ArrayList arrayLists = new ArrayList();
Pipe pipe = new Pipe(arrayLists);
this.InvokeWithPipe(true, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, dollarUnder, null, dollarThis, pipe, null, args);
return ScriptBlock.GetRawResult(arrayLists);
}
internal void InvokeWithPipe(bool useLocalScope, ScriptBlock.ErrorHandlingBehavior errorHandlingBehavior, object dollarUnder, object input, object scriptThis, Pipe outputPipe, InvocationInfo invocationInfo, object[] args)
{
bool flag;
Action action = null;
ExecutionContext contextFromTLS = this.GetContextFromTLS();
if (this.SessionStateInternal == null || this.SessionStateInternal.ExecutionContext == contextFromTLS)
{
RunspaceBase currentRunspace = (RunspaceBase)contextFromTLS.CurrentRunspace;
RunspaceBase runspaceBase = currentRunspace;
if (action == null)
{
action = () => this.InvokeWithPipeImpl(useLocalScope, errorHandlingBehavior, dollarUnder, input, scriptThis, outputPipe, invocationInfo, args);
}
flag = !runspaceBase.RunActionIfNoRunningPipelinesWithThreadCheck(action);
}
else
{
contextFromTLS = this.SessionStateInternal.ExecutionContext;
flag = true;
}
if (flag)
{
contextFromTLS.Events.SubscribeEvent(null, "PowerShell.OnScriptBlockInvoke", "PowerShell.OnScriptBlockInvoke", null, new PSEventReceivedEventHandler(ScriptBlock.OnScriptBlockInvokeEventHandler), true, false, true, 1);
ScriptBlockInvocationEventArgs scriptBlockInvocationEventArg = new ScriptBlockInvocationEventArgs(this, useLocalScope, errorHandlingBehavior, dollarUnder, input, scriptThis, outputPipe, invocationInfo, args);
object[] objArray = new object[1];
objArray[0] = scriptBlockInvocationEventArg;
contextFromTLS.Events.GenerateEvent("PowerShell.OnScriptBlockInvoke", null, objArray, null, true, true);
if (scriptBlockInvocationEventArg.Exception != null)
{
throw scriptBlockInvocationEventArg.Exception;
}
}
}
internal object DoInvokeReturnAsIs(bool useLocalScope, ScriptBlock.ErrorHandlingBehavior errorHandlingBehavior, object dollarUnder, object input, object scriptThis, object[] args)
{
ArrayList arrayLists = new ArrayList();
Pipe pipe = new Pipe(arrayLists);
this.InvokeWithPipe(useLocalScope, errorHandlingBehavior, dollarUnder, input, scriptThis, pipe, null, args);
return ScriptBlock.GetRawResult(arrayLists);
}
internal Collection<PSObject> DoInvoke(object dollarUnder, object input, object[] args)
{
ArrayList arrayLists = new ArrayList();
Pipe pipe = new Pipe(arrayLists);
this.InvokeWithPipe(true, ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe, dollarUnder, input, AutomationNull.Value, pipe, null, args);
return ScriptBlock.GetWrappedResult(arrayLists);
}
private void WriteToCurrentErrorPipe(bool createLocalScope, Pipe outputPipe, ref object[] args, ExecutionContext contextFromTLS, Action<FunctionContext> codeToInvoke, MutableTuple mutableTuple, PSLanguageMode? languageMode, ref Dictionary<string, PSVariable> strs)
{
if (!createLocalScope)
{
if (contextFromTLS.EngineSessionState.CurrentScope.LocalsTuple != null)
{
contextFromTLS.EngineSessionState.CurrentScope.DottedScopes.Push(mutableTuple);
strs = new Dictionary<string, PSVariable>();
}
else
{
contextFromTLS.EngineSessionState.CurrentScope.LocalsTuple = mutableTuple;
}
}
else
{
SessionStateScope sessionStateScope = contextFromTLS.EngineSessionState.NewScope(false);
contextFromTLS.EngineSessionState.CurrentScope = sessionStateScope;
sessionStateScope.LocalsTuple = mutableTuple;
}
if (languageMode.HasValue)
{
contextFromTLS.LanguageMode = languageMode.Value;
}
args = ScriptBlock.BindArgumentsForScripblockInvoke((RuntimeDefinedParameter[])this.RuntimeDefinedParameters.Data, args, contextFromTLS, !createLocalScope, strs, mutableTuple);
mutableTuple.SetAutomaticVariable(AutomaticVariable.Args, args, contextFromTLS);
contextFromTLS.EngineSessionState.CurrentScope.ScopeOrigin = CommandOrigin.Internal;
FunctionContext functionContext = new FunctionContext();
functionContext._executionContext = contextFromTLS;
functionContext._outputPipe = outputPipe;
functionContext._localsTuple = mutableTuple;
functionContext._scriptBlock = this;
functionContext._sequencePoints = this.SequencePoints;
FunctionContext functionContext1 = functionContext;
codeToInvoke(functionContext1);
}
internal static void FlushPipe(Pipe oldPipe, ArrayList arrayList)
{
foreach (object obj2 in arrayList)
{
oldPipe.Add(obj2);
}
}
private static object GetExpressionValue(ExpressionAst expressionAst,
bool isTrustedInput,
ExecutionContext context,
SessionStateInternal sessionStateInternal,
IDictionary usingValues,
ref Func<FunctionContext, object> lambda,
ref IScriptExtent[] sequencePoints,
ref Type localsTupleType)
{
object constantValue;
if (IsConstantValueVisitor.IsConstant(expressionAst, out constantValue))
{
return constantValue;
}
// If this isn't trusted input, then just return.
if (!isTrustedInput)
{
return null;
}
// Can't be exposed to untrusted input - exposing private variable names / etc. could be
// information disclosure.
var variableAst = expressionAst as VariableExpressionAst;
if (variableAst != null)
{
// We can avoid creating a lambda for the common case of a simple variable expression.
return VariableOps.GetVariableValue(variableAst.VariablePath, context, variableAst);
}
// Can't be exposed to untrusted input - invoking arbitrary code could result in remote code
// execution.
if (lambda == null)
{
lambda = (new Compiler()).CompileSingleExpression(expressionAst, out sequencePoints, out localsTupleType);
}
SessionStateInternal oldSessionState = context.EngineSessionState;
try
{
if (sessionStateInternal != null && context.EngineSessionState != sessionStateInternal)
{
// If we're running a function from a module, we need to evaluate the initializers in the
// module context, not the callers context...
context.EngineSessionState = sessionStateInternal;
}
var resultList = new List<object>();
var pipe = new Pipe(resultList);
try
{
var functionContext = new FunctionContext
{
_sequencePoints = sequencePoints,
_executionContext = context,
_file = expressionAst.Extent.File,
_outputPipe = pipe,
_localsTuple = MutableTuple.MakeTuple(localsTupleType, DottedLocalsNameIndexMap)
};
if (usingValues != null)
{
var boundParameters = new PSBoundParametersDictionary { ImplicitUsingParameters = usingValues };
functionContext._localsTuple.SetAutomaticVariable(AutomaticVariable.PSBoundParameters, boundParameters, context);
}
var result = lambda(functionContext);
if (result == AutomationNull.Value)
{
return resultList.Count == 0 ? null : PipelineOps.PipelineResult(resultList);
}
return result;
}
catch (TargetInvocationException tie)
{
throw tie.InnerException;
}
}
catch (TerminateException)
{
// the debugger is terminating the execution; bubble up the exception
throw;
}
catch (FlowControlException)
{
// ignore break, continue and return exceptions
return null;
}
finally
{
context.EngineSessionState = oldSessionState;
}
}