public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
if (((switchStatementAst.Flags & SwitchFlags.Parallel) == SwitchFlags.Parallel) && !switchStatementAst.IsInWorkflow())
{
this._parser.ReportError(switchStatementAst.Extent, ParserStrings.ParallelNotSupported, new object[0]);
}
return(AstVisitAction.Continue);
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
VariableAnalysisDetails details = this._variables["switch"];
if ((details.LocalTupleIndex == -1) && !this._disableOptimizations)
{
details.LocalTupleIndex = this._localsAllocated++;
}
Action generateCondition = delegate {
switchStatementAst.Condition.Accept(this);
this._currentBlock.AddAst(new AssignmentTarget("switch", typeof(IEnumerator)));
};
Action generateLoopBody = delegate {
bool flag = switchStatementAst.Default != null;
Block next = new Block();
int count = switchStatementAst.Clauses.Count;
for (int j = 0; j < count; j++)
{
Tuple <ExpressionAst, StatementBlockAst> tuple = switchStatementAst.Clauses[j];
Block block2 = new Block();
bool flag2 = (j == (count - 1)) && !flag;
Block block3 = flag2 ? next : new Block();
tuple.Item1.Accept(this);
this._currentBlock.FlowsTo(block3);
this._currentBlock.FlowsTo(block2);
this._currentBlock = block2;
tuple.Item2.Accept(this);
if (!flag2)
{
this._currentBlock.FlowsTo(block3);
this._currentBlock = block3;
}
}
if (flag)
{
this._currentBlock.FlowsTo(next);
switchStatementAst.Default.Accept(this);
}
this._currentBlock.FlowsTo(next);
this._currentBlock = next;
};
this.GenerateWhileLoop(switchStatementAst.Label, generateCondition, generateLoopBody, null);
return(null);
}
public System.Object VisitSwitchStatement(System.Management.Automation.Language.SwitchStatementAst switchStatementAst)
{
IScriptExtent mappedExtent = MapExtent(switchStatementAst.Extent);
PipelineBaseAst mappedCondition = _VisitPipelineBase(switchStatementAst.Condition);
LinkedList <Tuple <ExpressionAst, StatementBlockAst> > mappedClauses = new LinkedList <Tuple <ExpressionAst, StatementBlockAst> >();
foreach (Tuple <ExpressionAst, StatementBlockAst> c in switchStatementAst.Clauses)
{
mappedClauses.AddLast(
new Tuple <ExpressionAst, StatementBlockAst>(
_VisitExpression(c.Item1),
(StatementBlockAst)VisitStatementBlock(c.Item2)
)
);
}
StatementBlockAst mappedDefault = switchStatementAst.Default == null ? null : (StatementBlockAst)VisitStatementBlock(switchStatementAst.Default);
return(new SwitchStatementAst(mappedExtent, switchStatementAst.Label, mappedCondition, switchStatementAst.Flags, mappedClauses, mappedDefault));
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
throw PSTraceSource.NewArgumentException("ast");
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
return(false);
}
/// <summary/>
public virtual object VisitSwitchStatement(SwitchStatementAst switchStatementAst) { return null; }
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst ast)
{
return(Check(ast));
}
/// <summary/>
public virtual object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
return _decorated.VisitSwitchStatement(switchStatementAst);
}
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
if (((switchStatementAst.Flags & SwitchFlags.Parallel) == SwitchFlags.Parallel) && !switchStatementAst.IsInWorkflow())
{
this._parser.ReportError(switchStatementAst.Extent, ParserStrings.ParallelNotSupported, new object[0]);
}
return AstVisitAction.Continue;
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst) { throw new UnexpectedElementException(); }
/// <summary>
/// Visit switch statement
/// </summary>
/// <param name="switchStatementAst"></param>
/// <returns></returns>
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
if (switchStatementAst == null) return null;
Action generateCondition = () =>
{
switchStatementAst.Condition.Visit(this.Decorator);
// $switch is set after evaluating the condition.
_currentBlock.AddAst(new AssignmentTarget(SpecialVars.@switch, typeof(IEnumerator)));
};
Action switchBodyGenerator = () =>
{
bool hasDefault = (switchStatementAst.Default != null);
Block afterStmt = new Block();
int clauseCount = switchStatementAst.Clauses.Count;
for (int i = 0; i < clauseCount; i++)
{
var clause = switchStatementAst.Clauses[i];
Block clauseBlock = new Block();
bool isLastClause = (i == (clauseCount - 1) && !hasDefault);
Block nextBlock = isLastClause ? afterStmt : new Block();
clause.Item1.Visit(this.Decorator);
_currentBlock.FlowsTo(nextBlock);
_currentBlock.FlowsTo(clauseBlock);
_currentBlock = clauseBlock;
clause.Item2.Visit(this.Decorator);
if (!isLastClause)
{
_currentBlock.FlowsTo(nextBlock);
_currentBlock = nextBlock;
}
}
if (hasDefault)
{
// If any clause was executed, we skip the default, so there is always a branch over the default.
_currentBlock.FlowsTo(afterStmt);
switchStatementAst.Default.Visit(this.Decorator);
}
_currentBlock.FlowsTo(afterStmt);
_currentBlock = afterStmt;
};
GenerateWhileLoop(switchStatementAst.Label, generateCondition, switchBodyGenerator);
return null;
}
/// <summary/> public virtual AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst) => DefaultVisit(switchStatementAst);
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
// Parallel flag not allowed
if ((switchStatementAst.Flags & SwitchFlags.Parallel) == SwitchFlags.Parallel)
{
bool reportError = !switchStatementAst.IsInWorkflow();
if (reportError)
{
_parser.ReportError(switchStatementAst.Extent, () => ParserStrings.ParallelNotSupported);
}
}
return AstVisitAction.Continue;
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
AutomaticVarSaver avs = new AutomaticVarSaver(this, SpecialVariables.UnderbarVarPath, 0);
List<ParameterExpression> first = new List<ParameterExpression>();
ParameterExpression item = null;
if (switchStatementAst.Default != null)
{
item = this.NewTemp(typeof(bool), "skipDefault");
first.Add(item);
}
Action<List<Expression>, Expression> switchBodyGenerator = this.GetSwitchBodyGenerator(switchStatementAst, avs, item);
if ((switchStatementAst.Flags & SwitchFlags.File) != SwitchFlags.None)
{
List<Expression> expressions = new List<Expression>();
ParameterExpression expression2 = this.NewTemp(typeof(string), "path");
first.Add(expression2);
expressions.Add(this.UpdatePosition(switchStatementAst.Condition));
DynamicExpression expression3 = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), this.CaptureStatementResults(switchStatementAst.Condition, CaptureAstContext.Assignment, null), _executionContextParameter);
expressions.Add(Expression.Assign(expression2, Expression.Call(CachedReflectionInfo.SwitchOps_ResolveFilePath, Expression.Constant(switchStatementAst.Condition.Extent), expression3, _executionContextParameter)));
List<Expression> list3 = new List<Expression>();
ParameterExpression expression4 = this.NewTemp(typeof(StreamReader), "streamReader");
ParameterExpression line = this.NewTemp(typeof(string), "line");
first.Add(expression4);
first.Add(line);
list3.Add(Expression.Assign(expression4, Expression.New(CachedReflectionInfo.StreamReader_ctor, new Expression[] { expression2 })));
BinaryExpression loopTest = Expression.NotEqual(Expression.Assign(line, Expression.Call(expression4, CachedReflectionInfo.StreamReader_ReadLine)).Cast(typeof(object)), ExpressionCache.NullConstant);
list3.Add(avs.SaveAutomaticVar());
list3.Add(this.GenerateWhileLoop(switchStatementAst.Label, () => loopTest, delegate (List<Expression> loopBody, LabelTarget breakTarget, LabelTarget continueTarget) {
switchBodyGenerator(loopBody, line);
}, null));
BlockExpression body = Expression.Block(list3);
BlockExpression @finally = Expression.Block(Expression.IfThen(Expression.NotEqual(expression4, ExpressionCache.NullConstant), Expression.Call(expression4.Cast(typeof(IDisposable)), CachedReflectionInfo.IDisposable_Dispose)), avs.RestoreAutomaticVar());
ParameterExpression expression7 = this.NewTemp(typeof(Exception), "exception");
BlockExpression expression8 = Expression.Block(body.Type, new Expression[] { Expression.Call(CachedReflectionInfo.CommandProcessorBase_CheckForSevereException, expression7), ThrowRuntimeErrorWithInnerException("FileReadError", ParserStrings.FileReadError, expression7, new Expression[] { Expression.Property(expression7, CachedReflectionInfo.Exception_Message) }) });
expressions.Add(Expression.TryCatchFinally(body, @finally, new CatchBlock[] { Expression.Catch(typeof(FlowControlException), Expression.Rethrow(body.Type)), Expression.Catch(expression7, expression8) }));
return Expression.Block(first.Concat<ParameterExpression>(avs.GetTemps()), expressions);
}
TryExpression expression9 = Expression.TryFinally(Expression.Block(avs.SaveAutomaticVar(), this.GenerateIteratorStatement(SpecialVariables.switchVarPath, () => this.UpdatePosition(switchStatementAst.Condition), this._switchTupleIndex, switchStatementAst, switchBodyGenerator)), avs.RestoreAutomaticVar());
return Expression.Block(first.Concat<ParameterExpression>(avs.GetTemps()), new Expression[] { expression9 });
}
private Action<List<Expression>, Expression> GetSwitchBodyGenerator(SwitchStatementAst switchStatementAst, AutomaticVarSaver avs, ParameterExpression skipDefault)
{
return delegate (List<Expression> exprs, Expression newValue) {
PSSwitchClauseEvalBinder binder = PSSwitchClauseEvalBinder.Get(switchStatementAst.Flags);
exprs.Add(avs.SetNewValue(newValue));
if (skipDefault != null)
{
exprs.Add(Expression.Assign(skipDefault, ExpressionCache.Constant(false)));
}
IsConstantValueVisitor visitor = new IsConstantValueVisitor();
ConstantValueVisitor visitor2 = new ConstantValueVisitor();
int count = switchStatementAst.Clauses.Count;
for (int j = 0; j < count; j++)
{
Expression expression;
Tuple<ExpressionAst, StatementBlockAst> tuple = switchStatementAst.Clauses[j];
object obj2 = ((bool) tuple.Item1.Accept(visitor)) ? tuple.Item1.Accept(visitor2) : null;
if (obj2 is ScriptBlock)
{
MethodCallExpression expression2 = Expression.Call(Expression.Constant(obj2), CachedReflectionInfo.ScriptBlock_DoInvokeReturnAsIs, new Expression[] { ExpressionCache.Constant(true), Expression.Constant(ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe), this.GetLocal(0).Convert(typeof(object)), ExpressionCache.AutomationNullConstant, ExpressionCache.AutomationNullConstant, ExpressionCache.NullObjectArray });
expression = Expression.Dynamic(PSConvertBinder.Get(typeof(bool)), typeof(bool), expression2);
}
else if (obj2 != null)
{
SwitchFlags flags = switchStatementAst.Flags;
Expression expression3 = Expression.Constant(((obj2 is Regex) || (obj2 is WildcardPattern)) ? obj2 : obj2.ToString());
Expression expression4 = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), this.GetLocal(0), _executionContextParameter);
if (((flags & SwitchFlags.Regex) != SwitchFlags.None) || (obj2 is Regex))
{
expression = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedRegex, ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != SwitchFlags.None), expression3, Expression.Constant(tuple.Item1.Extent), expression4, _executionContextParameter);
}
else if (((flags & SwitchFlags.Wildcard) != SwitchFlags.None) || (obj2 is WildcardPattern))
{
expression = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedWildcard, ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != SwitchFlags.None), expression3, expression4, _executionContextParameter);
}
else
{
expression = CallStringEquals(expression3, expression4, (flags & SwitchFlags.CaseSensitive) == SwitchFlags.None);
}
}
else
{
Expression expression5 = this.Compile(tuple.Item1);
expression = Expression.Dynamic(binder, typeof(bool), expression5, this.GetLocal(0), _executionContextParameter);
}
exprs.Add(this.UpdatePosition(tuple.Item1));
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(expression, Expression.Block(this.Compile(tuple.Item2), Expression.Assign(skipDefault, ExpressionCache.Constant(true)))));
}
else
{
exprs.Add(Expression.IfThen(expression, this.Compile(tuple.Item2)));
}
}
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(Expression.Not(skipDefault), this.Compile(switchStatementAst.Default)));
}
};
}
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst) { return AstVisitAction.SkipChildren; }
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst ast) { return CheckParent(ast); }
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
this.ReportError(switchStatementAst, () => ParserStrings.SwitchStatementNotSupportedInDataSection, new object[0]);
return(AstVisitAction.Continue);
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
VariableAnalysisDetails details = this._variables["switch"];
if ((details.LocalTupleIndex == -1) && !this._disableOptimizations)
{
details.LocalTupleIndex = this._localsAllocated++;
}
Action generateCondition = delegate {
switchStatementAst.Condition.Accept(this);
this._currentBlock.AddAst(new AssignmentTarget("switch", typeof(IEnumerator)));
};
Action generateLoopBody = delegate {
bool flag = switchStatementAst.Default != null;
Block next = new Block();
int count = switchStatementAst.Clauses.Count;
for (int j = 0; j < count; j++)
{
Tuple<ExpressionAst, StatementBlockAst> tuple = switchStatementAst.Clauses[j];
Block block2 = new Block();
bool flag2 = (j == (count - 1)) && !flag;
Block block3 = flag2 ? next : new Block();
tuple.Item1.Accept(this);
this._currentBlock.FlowsTo(block3);
this._currentBlock.FlowsTo(block2);
this._currentBlock = block2;
tuple.Item2.Accept(this);
if (!flag2)
{
this._currentBlock.FlowsTo(block3);
this._currentBlock = block3;
}
}
if (flag)
{
this._currentBlock.FlowsTo(next);
switchStatementAst.Default.Accept(this);
}
this._currentBlock.FlowsTo(next);
this._currentBlock = next;
};
this.GenerateWhileLoop(switchStatementAst.Label, generateCondition, generateLoopBody, null);
return null;
}
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
throw new NotImplementedException(); //VisitSwitchStatement(switchStatementAst);
}
/// <summary>
/// Visit SwitchStatement
/// </summary>
/// <param name="switchStatementAst"></param>
/// <returns></returns>
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
NoteVariable(SpecialVars.@switch, typeof(IEnumerator));
return AstVisitAction.Continue;
}
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
this.NoteVariable("switch", -1, typeof(IEnumerator), false, false);
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst ast)
{
return this.Check(ast);
}
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
this.NoteVariable("switch", -1, typeof(IEnumerator), false, false);
return AstVisitAction.Continue;
}
public virtual AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
return AstVisitAction.Continue;
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst) { return AutomationNull.Value; }
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst) { throw PSTraceSource.NewArgumentException("ast"); }
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
var avs = new AutomaticVarSaver(this, SpecialVariables.UnderbarVarPath, (int)AutomaticVariable.Underbar);
var temps = new List<ParameterExpression>();
ParameterExpression skipDefault = null;
if (switchStatementAst.Default != null)
{
skipDefault = NewTemp(typeof(bool), "skipDefault");
temps.Add(skipDefault);
}
var switchBodyGenerator = GetSwitchBodyGenerator(switchStatementAst, avs, skipDefault);
if ((switchStatementAst.Flags & SwitchFlags.File) != 0)
{
// Generate:
//
// string path = SwitchOps.ResolveFilePath(cond.Extent, cond, context);
// StreamReader sr = null;
// try
// {
// sr = new StreamReader(path);
// string line;
// while ((line = sr.ReadLine()) != null)
// {
// $_ = line
// test clauses
// }
// }
// catch (FlowControlException) { throw; }
// catch (Exception exception)
// {
// CommandProcessorBase.CheckForSevereException(exception);
// // "The file could not be read:" + fne.Message
// throw InterpreterError.NewInterpreterExceptionWithInnerException(path, typeof(RuntimeException),
// cond.Extent, "FileReadError", ParserStrings.FileReadError, exception, exception.Message);
// }
// finally
// {
// if (sr != null) sr.Dispose();
// }
var exprs = new List<Expression>();
var path = NewTemp(typeof(string), "path");
temps.Add(path);
exprs.Add(UpdatePosition(switchStatementAst.Condition));
// We should not preserve the partial output if exception is thrown when evaluating the condition.
var cond = DynamicExpression.Dynamic(PSToStringBinder.Get(), typeof(string),
CaptureStatementResults(switchStatementAst.Condition, CaptureAstContext.AssignmentWithoutResultPreservation),
_executionContextParameter);
exprs.Add(
Expression.Assign(
path,
Expression.Call(CachedReflectionInfo.SwitchOps_ResolveFilePath,
Expression.Constant(switchStatementAst.Condition.Extent),
cond,
_executionContextParameter)));
var tryBodyExprs = new List<Expression>();
var streamReader = NewTemp(typeof(StreamReader), "streamReader");
var line = NewTemp(typeof(string), "line");
temps.Add(streamReader);
temps.Add(line);
tryBodyExprs.Add(
Expression.Assign(streamReader,
Expression.New(CachedReflectionInfo.StreamReader_ctor, path)));
var loopTest =
Expression.NotEqual(
Expression.Assign(line,
Expression.Call(streamReader, CachedReflectionInfo.StreamReader_ReadLine)).Cast(typeof(object)),
ExpressionCache.NullConstant);
tryBodyExprs.Add(avs.SaveAutomaticVar());
tryBodyExprs.Add(GenerateWhileLoop(switchStatementAst.Label,
() => loopTest,
(loopBody, breakTarget, continueTarget) => switchBodyGenerator(loopBody, line)));
var tryBlock = Expression.Block(tryBodyExprs);
var finallyBlock = Expression.Block(
Expression.IfThen(
Expression.NotEqual(streamReader, ExpressionCache.NullConstant),
Expression.Call(streamReader.Cast(typeof(IDisposable)), CachedReflectionInfo.IDisposable_Dispose)),
avs.RestoreAutomaticVar());
var exception = NewTemp(typeof(Exception), "exception");
var catchAllBlock = Expression.Block(
tryBlock.Type,
Expression.Call(CachedReflectionInfo.CommandProcessorBase_CheckForSevereException, exception),
ThrowRuntimeErrorWithInnerException("FileReadError",
ParserStrings.FileReadError,
exception,
Expression.Property(exception, CachedReflectionInfo.Exception_Message)));
exprs.Add(Expression.TryCatchFinally(
tryBlock, finallyBlock,
new[]
{
Expression.Catch(typeof(FlowControlException), Expression.Rethrow(tryBlock.Type)),
Expression.Catch(exception, catchAllBlock)
}));
return Expression.Block(temps.Concat(avs.GetTemps()), exprs);
}
// We convert:
// switch ($enumerable) {}
// Into:
// $switch = GetEnumerator $enumerable
// if ($switch == $null)
// {
// $switch = (new object[] { $enumerable }).GetEnumerator()
// }
// REVIEW: should we consider this form of switch a loop for the purposes of deciding
// to compile or not? I have a feeling the loop form is uncommon and compiling isn't worth it.
var tryStmt = Expression.TryFinally(
Expression.Block(
avs.SaveAutomaticVar(),
GenerateIteratorStatement(SpecialVariables.switchVarPath, () => UpdatePosition(switchStatementAst.Condition), _switchTupleIndex,
switchStatementAst, switchBodyGenerator)
),
avs.RestoreAutomaticVar());
return Expression.Block(temps.Concat(avs.GetTemps()), tryStmt);
}
/// <summary/>
public virtual object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
return(null);
}
private Action<List<Expression>, Expression> GetSwitchBodyGenerator(SwitchStatementAst switchStatementAst, AutomaticVarSaver avs, ParameterExpression skipDefault)
{
return (exprs, newValue) =>
{
var clauseEvalBinder = PSSwitchClauseEvalBinder.Get(switchStatementAst.Flags);
exprs.Add(avs.SetNewValue(newValue));
if (skipDefault != null)
{
exprs.Add(Expression.Assign(skipDefault, ExpressionCache.Constant(false)));
}
IsConstantValueVisitor iscvv = new IsConstantValueVisitor();
ConstantValueVisitor cvv = new ConstantValueVisitor();
int clauseCount = switchStatementAst.Clauses.Count;
for (int i = 0; i < clauseCount; i++)
{
var clause = switchStatementAst.Clauses[i];
Expression test;
object constValue = ((bool)clause.Item1.Accept(iscvv)) ? clause.Item1.Accept(cvv) : null;
if (constValue is ScriptBlock)
{
var call = Expression.Call(Expression.Constant(constValue),
CachedReflectionInfo.ScriptBlock_DoInvokeReturnAsIs,
/*useLocalScope=*/ ExpressionCache.Constant(true),
/*errorHandlingBehavior=*/ Expression.Constant(ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe),
/*dollarUnder=*/ GetLocal((int)AutomaticVariable.Underbar).Convert(typeof(object)),
/*input=*/ ExpressionCache.AutomationNullConstant,
/*scriptThis=*/ ExpressionCache.AutomationNullConstant,
/*args=*/ ExpressionCache.NullObjectArray);
test = DynamicExpression.Dynamic(PSConvertBinder.Get(typeof(bool)), typeof(bool), call);
}
else if (constValue != null)
{
SwitchFlags flags = switchStatementAst.Flags;
Expression conditionExpr = constValue is Regex || constValue is WildcardPattern
? (Expression)Expression.Constant(constValue)
: DynamicExpression.Dynamic(PSToStringBinder.Get(), typeof(string),
(constValue is Type)
? Expression.Constant(constValue, typeof(Type))
: Expression.Constant(constValue),
_executionContextParameter);
Expression currentAsString =
DynamicExpression.Dynamic(PSToStringBinder.Get(), typeof(string), GetLocal((int)AutomaticVariable.Underbar),
_executionContextParameter);
if ((flags & SwitchFlags.Regex) != 0 || constValue is Regex)
{
test = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedRegex,
/*caseSensitive=*/ ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != 0),
/*condition=*/ conditionExpr,
/*errorPosition=*/ Expression.Constant(clause.Item1.Extent),
/*str=*/ currentAsString,
/*context=*/ _executionContextParameter);
}
else if ((flags & SwitchFlags.Wildcard) != 0 || constValue is WildcardPattern)
{
// It would be a little better to just build the wildcard at compile time, but
// the runtime method must exist when variable cases are involved.
test = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedWildcard,
/*caseSensitive=*/ ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != 0),
/*condition=*/ conditionExpr,
/*str=*/ currentAsString,
/*context=*/ _executionContextParameter);
}
else
{
test = CallStringEquals(conditionExpr, currentAsString,
((flags & SwitchFlags.CaseSensitive) == 0));
}
}
else
{
var cond = Compile(clause.Item1);
test = DynamicExpression.Dynamic(clauseEvalBinder, typeof(bool),
cond, GetLocal((int)AutomaticVariable.Underbar), _executionContextParameter);
}
exprs.Add(UpdatePosition(clause.Item1));
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(
test,
Expression.Block(Compile(clause.Item2),
Expression.Assign(skipDefault, ExpressionCache.Constant(true)))));
}
else
{
exprs.Add(Expression.IfThen(test, Compile(clause.Item2)));
}
}
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(Expression.Not(skipDefault), Compile(switchStatementAst.Default)));
}
};
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
return false;
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
var details = _variables[SpecialVariables.@switch];
if (details.LocalTupleIndex == VariableAnalysis.Unanalyzed && !_disableOptimizations)
{
details.LocalTupleIndex = _localsAllocated++;
}
Action generateCondition = () =>
{
switchStatementAst.Condition.Accept(this);
// $switch is set after evaluating the condition.
_currentBlock.AddAst(new AssignmentTarget(SpecialVariables.@switch, typeof(IEnumerator)));
};
Action switchBodyGenerator = () =>
{
bool hasDefault = (switchStatementAst.Default != null);
Block afterStmt = new Block();
int clauseCount = switchStatementAst.Clauses.Count;
for (int i = 0; i < clauseCount; i++)
{
var clause = switchStatementAst.Clauses[i];
Block clauseBlock = new Block();
bool isLastClause = (i == (clauseCount - 1) && !hasDefault);
Block nextBlock = isLastClause ? afterStmt : new Block();
clause.Item1.Accept(this);
_currentBlock.FlowsTo(nextBlock);
_currentBlock.FlowsTo(clauseBlock);
_currentBlock = clauseBlock;
clause.Item2.Accept(this);
if (!isLastClause)
{
_currentBlock.FlowsTo(nextBlock);
_currentBlock = nextBlock;
}
}
if (hasDefault)
{
// If any clause was executed, we skip the default, so there is always a branch over the default.
_currentBlock.FlowsTo(afterStmt);
switchStatementAst.Default.Accept(this);
}
_currentBlock.FlowsTo(afterStmt);
_currentBlock = afterStmt;
};
GenerateWhileLoop(switchStatementAst.Label, generateCondition, switchBodyGenerator);
return null;
}
/// <summary/>
public virtual AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
this.ReportError(switchStatementAst, () => ParserStrings.SwitchStatementNotSupportedInDataSection, new object[0]);
return AstVisitAction.Continue;
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
return(AutomationNull.Value);
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
throw new NotImplementedException();
}