public System.Object VisitTrap(System.Management.Automation.Language.TrapStatementAst trapStatementAst)
{
IScriptExtent mappedExtent = MapExtent(trapStatementAst.Extent);
TypeConstraintAst mappedTrapType = (TypeConstraintAst)VisitTypeConstraint(trapStatementAst.TrapType);
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(trapStatementAst.Body);
return(new TrapStatementAst(mappedExtent, mappedTrapType, mappedBody));
}
internal static Dictionary<string, VariableAnalysisDetails> Visit(TrapStatementAst trap)
{
// We disable optimizations for trap because it simplifies what we need to do when invoking
// the trap, and it's assumed that the code inside a trap rarely, if ever, actually creates
// any local variables.
var visitor = new FindAllVariablesVisitor(disableOptimizations: true, scriptCmdlet: false);
trap.Body.InternalVisit(visitor);
return visitor._variables;
}
/// <summary/>
public virtual object VisitTrap(TrapStatementAst trapStatementAst)
{
return _decorated.VisitTrap(trapStatementAst);
}
/// <summary>
/// Visit trap
/// </summary>
/// <param name="trapStatementAst"></param>
/// <returns></returns>
public object VisitTrap(TrapStatementAst trapStatementAst)
{
if (trapStatementAst == null) return null;
trapStatementAst.Body.Visit(this.Decorator);
return null;
}
internal static Tuple<Type, Dictionary<string, int>> AnalyzeTrap(TrapStatementAst trap)
{
return new VariableAnalysis().AnalyzeImpl(trap);
}
public override AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
{
this.ReportError(trapStatementAst, () => ParserStrings.TrapStatementNotSupportedInDataSection, new object[0]);
return AstVisitAction.Continue;
}
private Tuple<Type, Dictionary<string, int>> AnalyzeImpl(TrapStatementAst trap)
{
_variables = FindAllVariablesVisitor.Visit(trap);
// We disable optimizations for trap because it simplifies what we need to do when invoking
// the trap, and it's assumed that the code inside a trap rarely, if ever, actually creates
// any local variables.
_disableOptimizations = true;
Init();
_localsAllocated = SpecialVariables.AutomaticVariables.Length;
_currentBlock = _entryBlock;
trap.Body.Accept(this);
_currentBlock.FlowsTo(_exitBlock);
return FinishAnalysis();
}
public override AstVisitAction VisitTrap(TrapStatementAst ast) { return CheckParent(ast); }
/// <summary/> public virtual AstVisitAction VisitTrap(TrapStatementAst trapStatementAst) => DefaultVisit(trapStatementAst);
public override AstVisitAction VisitTrap(TrapStatementAst ast)
{
return(CheckScriptBlock(ast));
}
public override AstVisitAction VisitTrap(TrapStatementAst ast)
{
return(CheckParent(ast));
}
/// <summary/>
public virtual object VisitTrap(TrapStatementAst trapStatementAst)
{
return(null);
}
private Tuple<Action<FunctionContext>, Type> CompileTrap(TrapStatementAst trap)
{
Compiler compiler = new Compiler(this._sequencePoints) {
_compilingTrap = true
};
string funcName = this._currentFunctionName + "<trap>";
if (trap.TrapType != null)
{
funcName = funcName + "<" + trap.TrapType.TypeName.Name + ">";
}
Tuple<Type, Dictionary<string, int>> tuple = VariableAnalysis.AnalyzeTrap(trap);
compiler.LocalVariablesTupleType = tuple.Item1;
compiler.LocalVariablesParameter = Expression.Variable(compiler.LocalVariablesTupleType, "locals");
Expression<Action<FunctionContext>> expression = compiler.CompileSingleLambda(trap.Body.Statements, trap.Body.Traps, funcName, null, null);
return Tuple.Create<Action<FunctionContext>, Type>(expression.Compile(), compiler.LocalVariablesTupleType);
}
public object VisitTrap(TrapStatementAst trapStatementAst)
{
return null;
}
internal static Dictionary<string, VariableAnalysisDetails> Visit(TrapStatementAst trap)
{
FindAllVariablesVisitor visitor = new FindAllVariablesVisitor(true, false);
trap.Body.InternalVisit(visitor);
return visitor._variables;
}
public override AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
{
return AstVisitAction.SkipChildren;
}
public virtual AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
{
return AstVisitAction.Continue;
}
public object VisitTrap(TrapStatementAst trapStatementAst) { throw new UnexpectedElementException(); }
public object VisitTrap(TrapStatementAst trapStatementAst)
{
Diagnostics.Assert(false, "Traps are not visited directly.");
return null;
}
/// <summary/>
public virtual AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
{
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
{
this.ReportError(trapStatementAst, () => ParserStrings.TrapStatementNotSupportedInDataSection, new object[0]);
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitTrap(TrapStatementAst ast)
{
return this.CheckScriptBlock(ast);
}
private Tuple<Type, Dictionary<string, int>> AnalyzeImpl(TrapStatementAst trap)
{
this._variables = FindAllVariablesVisitor.Visit(trap);
this._disableOptimizations = true;
this.Init();
this._localsAllocated = SpecialVariables.AutomaticVariables.Length;
this._currentBlock = this._entryBlock;
trap.Body.Accept(this);
this._currentBlock.FlowsTo(this._exitBlock);
return this.FinishAnalysis(false);
}
public object VisitTrap(TrapStatementAst trapStatementAst)
{
return(AutomationNull.Value);
}
public object VisitTrap(TrapStatementAst trapStatementAst)
{
trapStatementAst.Body.Accept(this);
return null;
}
public object VisitTrap(TrapStatementAst trapStatementAst)
{
return(false);
}
/// <summary>
/// Visit Trap
/// </summary>
/// <param name="trapStatementAst"></param>
/// <returns></returns>
public override AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
{
// We don't want to discover any variables in traps - they get their own scope.
return AstVisitAction.SkipChildren;
}
public object VisitTrap(TrapStatementAst trapStatementAst)
{
throw PSTraceSource.NewArgumentException("ast");
}
private AstVisitAction VisitTrapBody(TrapStatementAst trapStatement)
{
foreach (StatementAst statement in trapStatement.Body.Statements)
{
try
{
statement.Visit(this);
}
catch (ContinueException)
{
return AstVisitAction.Continue;
}
catch (BreakException)
{
WriteErrorRecord();
return AstVisitAction.SkipChildren;
}
}
WriteErrorRecord();
return AstVisitAction.Continue;
}
public object VisitTrap(TrapStatementAst trapStatementAst) { return AutomationNull.Value; }
private AstVisitAction VisitTrapBody(TrapStatementAst trapStatement)
{
foreach (StatementAst statement in trapStatement.Body.Statements)
{
statement.Visit(this);
if (statement is ContinueStatementAst)
{
return AstVisitAction.Continue;
}
else if (statement is BreakStatementAst)
{
WriteErrorRecord();
return AstVisitAction.SkipChildren;
}
}
WriteErrorRecord();
return AstVisitAction.Continue;
}
public object VisitTrap(TrapStatementAst trapStatementAst) { throw PSTraceSource.NewArgumentException("ast"); }
public override AstVisitAction VisitTrap(TrapStatementAst trapStatementAst)
{
throw new NotImplementedException(); //VisitTrap(trapStatementAst);
}
private Tuple<Action<FunctionContext>, Type> CompileTrap(TrapStatementAst trap)
{
var compiler = new Compiler(_sequencePoints) { _compilingTrap = true };
string funcName = _currentFunctionName + "<trap>";
if (trap.TrapType != null)
{
funcName += "<" + trap.TrapType.TypeName.Name + ">";
}
// We generate code as though we're dotting the trap, but in reality we don't dot it,
// a new scope is always created. The code gen for dotting means we can avoid passing
// around the array of local variable names. We assume traps don't need to perform well,
// and that they rarely if ever actually create any local variables. We still do the
// variable analysis though because we must mark automatic variables like $_.
var analysis = VariableAnalysis.AnalyzeTrap(trap);
compiler.LocalVariablesTupleType = analysis.Item1;
compiler.LocalVariablesParameter = Expression.Variable(compiler.LocalVariablesTupleType, "locals");
var lambda = compiler.CompileSingleLambda(trap.Body.Statements, trap.Body.Traps, funcName, null, null, null);
return Tuple.Create(lambda.Compile(), compiler.LocalVariablesTupleType);
}
public object VisitTrap(TrapStatementAst trapStatementAst)
{
return false;
}
public object VisitTrap(TrapStatementAst trapStatementAst)
{
throw new NotImplementedException();
}
