private object GetCommandName(
out bool createScope,
out int index,
out SessionStateInternal commandSessionState,
out bool forceSessionState,
ExecutionContext context)
{
createScope = true;
index = 0;
forceSessionState = false;
commandSessionState = context.EngineSessionState;
if (this._elements.Count == 0)
{
return((object)null);
}
Token element = (Token)this._elements[index++];
if (element.Is(TokenId.DotToken))
{
createScope = false;
}
else if (!element.Is(TokenId.AmpersandToken))
{
return((object)element.TokenText);
}
for (int index1 = 0; index1 < 2; ++index1)
{
ParseTreeNode parseTreeNode = (ParseTreeNode)null;
if (index < this._elements.Count)
{
parseTreeNode = this._elements[index++] as ParseTreeNode;
}
object obj = parseTreeNode != null?PSObject.Base(parseTreeNode.Execute(context)) : throw InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), element, "MissingExpression", (object)element.TokenText);
if (!(obj is PSModuleInfo psModuleInfo))
{
return(obj);
}
if (psModuleInfo.ModuleType == ModuleType.Binary && psModuleInfo.SessionState == null)
{
throw InterpreterError.NewInterpreterException((object)null, typeof(RuntimeException), element, "CantInvokeInBinaryModule", (object)psModuleInfo.Name);
}
commandSessionState = psModuleInfo.SessionState.Internal;
forceSessionState = true;
}
return((object)null);
}
internal object Execute(ParseTreeNode ptn, Array input)
{
object obj = (object)AutomationNull.Value;
ActivationRecordBuilder activationRecordBuilder = new ActivationRecordBuilder();
ptn.Accept((ParseTreeVisitor)activationRecordBuilder);
ActivationRecord activationRecord = this._context.EngineSessionState.CurrentActivationRecord;
try
{
this._context.EngineSessionState.CurrentActivationRecord = new ActivationRecord(activationRecordBuilder.PipelineSlots, activationRecordBuilder.VariableSlots, this._context.EngineSessionState.CurrentScope);
obj = ptn.Execute(input, this._context);
}
catch (FlowControlException ex)
{
}
finally
{
this._context.EngineSessionState.CurrentActivationRecord = activationRecord;
}
return(obj);
}
internal override object Execute(Array input, Pipe outputPipe, ExecutionContext context)
{
this.CheckForInterrupts(context);
if (this._expressions == null || this._expressions.Count == 0)
{
return((object)new object[0]);
}
object[] objArray = new object[this._expressions.Count];
for (int index = 0; index < this._expressions.Count; ++index)
{
ParseTreeNode expression = this._expressions[index];
objArray[index] = expression == null ? (object)this._expressions[index] : expression.Execute(input, (Pipe)null, context);
if (objArray[index] == AutomationNull.Value)
{
objArray[index] = (object)null;
}
}
return((object)objArray);
}
private void ExecuteStatement(
ParseTreeNode statement,
Array input,
Pipe outputPipe,
ref ArrayList resultList,
ExecutionContext context)
{
ScriptTrace.TraceLine(context, statement);
Exception e = (Exception)null;
try
{
try
{
if (statement.IsVoidable)
{
statement.Execute(input, (Pipe)null, context);
}
else
{
statement.Execute(input, outputPipe, ref resultList, context);
}
ParseTreeNode parseTreeNode = statement;
while (parseTreeNode is AssignmentStatementNode assignmentStatementNode)
{
parseTreeNode = assignmentStatementNode.RightHandSide;
}
if (parseTreeNode.IsExpression)
{
context.QuestionMarkVariableValue = true;
}
else if (parseTreeNode is PipelineNode pipelineNode)
{
context.QuestionMarkVariableValue = !pipelineNode.ExecutionFailed(context);
}
}
catch (COMException ex)
{
throw InterpreterError.NewInterpreterExceptionWithInnerException((object)null, typeof(RuntimeException), statement.NodeToken, "COMException", (Exception)ex, (object)ex.Message);
}
catch (InvalidComObjectException ex)
{
throw InterpreterError.NewInterpreterExceptionWithInnerException((object)null, typeof(RuntimeException), statement.NodeToken, "InvalidComObjectException", (Exception)ex, (object)ex.Message);
}
}
catch (ReturnException ex)
{
if (resultList == null || resultList.Count == 0)
{
e = (Exception)ex;
}
else
{
ParseTreeNode.AppendResult(context, ex.Argument, (Pipe)null, ref resultList);
ex.SetArgument((object)resultList.ToArray());
resultList = (ArrayList)null;
e = (Exception)ex;
}
}
catch (RuntimeException ex)
{
e = this.HandleException(statement.NodeToken, ex, outputPipe, ref resultList, context);
}
if (e != null)
{
RuntimeException.LockStackTrace(e);
throw e;
}
}
private object ExecuteWithCatch(ParseTreeNode ptn, Array inputToProcess)
{
object newValue = (object)null;
CommandOrigin scopeOrigin = this.Context.EngineSessionState.currentScope.ScopeOrigin;
if (string.IsNullOrEmpty(this.CommandInfo.Name))
{
if (!this._fromPipeline)
{
goto label_3;
}
}
newValue = this.Context.GetVariable("MyInvocation");
this.Context.SetVariable("MyInvocation", (object)this.Command.MyInvocation);
label_3:
try
{
if (this._dontUseScopeCommandOrigin)
{
this.Context.EngineSessionState.currentScope.ScopeOrigin = CommandOrigin.Internal;
}
else
{
this.Context.EngineSessionState.currentScope.ScopeOrigin = this.Command.CommandOrigin;
}
return(ptn.Execute(inputToProcess, this.commandRuntime.OutputPipe, this.Context));
}
catch (ExitException ex)
{
if (!this.FromScriptFile || this._rethrowExitException)
{
throw;
}
else
{
this._exitWasCalled = true;
int num = (int)ex.Argument;
this.Command.Context.SetVariable("global:LASTEXITCODE", (object)num);
if (num != 0)
{
this.commandRuntime.PipelineProcessor.ExecutionFailed = true;
}
return((object)AutomationNull.Value);
}
}
catch (TerminateException ex)
{
throw;
}
catch (ReturnException ex)
{
return(ex.Argument);
}
catch (RuntimeException ex)
{
this.ManageScriptException(ex);
throw;
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
ScriptCommandProcessor.tracer.TraceException(ex);
throw this.ManageInvocationException(ex);
}
finally
{
this.Context.EngineSessionState.currentScope.ScopeOrigin = scopeOrigin;
if (!string.IsNullOrEmpty(this.CommandInfo.Name) || this._fromPipeline)
{
this.Context.SetVariable("MyInvocation", newValue);
}
}
}
