protected IteratorExpressionImpl(LexicalInfo lexicalInfo, Expression expression, Expression iterator, StatementModifier filter) : base(lexicalInfo)
{
_declarations = new DeclarationCollection(this);
Expression = expression;
Iterator = iterator;
Filter = filter;
}
protected IteratorExpressionImpl(Expression expression, Expression iterator, StatementModifier filter)
{
_declarations = new DeclarationCollection(this);
Expression = expression;
Iterator = iterator;
Filter = filter;
}
public DeclarationsNamespace(INamespace parent, Declaration declaration)
{
_parent = parent;
_declarations = new DeclarationCollection {
declaration
};
}
/// <summary>
/// Constructs a new file parse tree.
/// </summary>
/// <param name="type">The type of the file.</param>
/// <param name="name">The name of the file.</param>
/// <param name="declarations">The declarations in the file.</param>
/// <param name="span">The location of the tree.</param>
public FileTree(FileType type, string name, DeclarationCollection declarations, Span span) : base(TreeType.FileTree, span)
{
SetParent(declarations);
this.FileType = FileType.None;
this.Name = name;
this.Declarations = declarations;
}
public UnpackStatement CreateUnpackStatement(DeclarationCollection declarations, Expression expression)
{
UnpackStatement unpack = new UnpackStatement(expression.LexicalInfo);
unpack.Declarations.Extend(declarations);
unpack.Expression = expression;
return(unpack);
}
/// <summary>
/// Constructs a new parse tree for a custom property declaration.
/// </summary>
/// <param name="attributes">The attributes on the declaration.</param>
/// <param name="modifiers">The modifiers on the declaration.</param>
/// <param name="customLocation">The location of the 'Custom' keyword.</param>
/// <param name="keywordLocation">The location of the keyword.</param>
/// <param name="name">The name of the custom event.</param>
/// <param name="asLocation">The location of the 'As', if any.</param>
/// <param name="resultType">The result type, if any.</param>
/// <param name="implementsList">The implements list.</param>
/// <param name="accessors">The custom event accessors.</param>
/// <param name="endDeclaration">The End Event declaration, if any.</param>
/// <param name="span">The location of the parse tree.</param>
/// <param name="comments">The comments for the parse tree.</param>
public CustomEventDeclaration(AttributeBlockCollection attributes, ModifierCollection modifiers, Location customLocation, Location keywordLocation, SimpleName name, Location asLocation, TypeName resultType, NameCollection implementsList, DeclarationCollection accessors, EndBlockDeclaration endDeclaration,
Span span, IList <Comment> comments) : base(TreeType.CustomEventDeclaration, attributes, modifiers, keywordLocation, name, null, null, asLocation, null, resultType,
span, comments)
{
SetParent(accessors);
SetParent(endDeclaration);
SetParent(implementsList);
_CustomLocation = customLocation;
_ImplementsList = implementsList;
_Accessors = accessors;
_EndDeclaration = endDeclaration;
}
protected PlSqlBlockStatement(SerializationInfo info, StreamingContext context)
: base(info, context)
{
Declarations = new DeclarationCollection();
ExceptionHandlers = new ExceptionHandlerCollection();
var decls = (SqlStatement[])info.GetValue("Declarations", typeof(SqlStatement[]));
foreach (var statement in decls)
{
Declarations.Add(statement);
}
var handlers = (ExceptionHandler[])info.GetValue("ExceptionHandlers", typeof(ExceptionHandler[]));
foreach (var handler in handlers)
{
ExceptionHandlers.Add(handler);
}
}
/// <summary>
/// Constructs a new file parse tree.
/// </summary>
/// <param name="declarations">The declarations in the file.</param>
/// <param name="span">The location of the tree.</param>
public FileTree(DeclarationCollection declarations, Span span) : this(FileType.None, string.Empty, declarations, span)
{
}
/// <summary>
/// Optimize the <c>for item in range()</c> construct
/// </summary>
/// <param name="node">the for statement to check</param>
private void CheckForItemInRangeLoop(ForStatement node)
{
MethodInvocationExpression mi = node.Iterator as MethodInvocationExpression;
if (null == mi)
{
return;
}
if (!IsRangeInvocation(mi))
{
return;
}
DeclarationCollection declarations = node.Declarations;
if (declarations.Count != 1)
{
return;
}
ExpressionCollection args = mi.Arguments;
Block body = new Block(node.LexicalInfo);
Expression min;
Expression max;
Expression step;
if (args.Count == 1)
{
min = CodeBuilder.CreateIntegerLiteral(0);
max = args[0];
step = CodeBuilder.CreateIntegerLiteral(1);
}
else if (args.Count == 2)
{
min = args[0];
max = args[1];
step = CodeBuilder.CreateIntegerLiteral(1);
}
else
{
min = args[0];
max = args[1];
step = args[2];
}
InternalLocal numVar = CodeBuilder.DeclareTempLocal(
_currentMethod,
TypeSystemServices.IntType);
Expression numRef = CodeBuilder.CreateReference(numVar);
// __num = <min>
body.Add(
CodeBuilder.CreateAssignment(
numRef,
min));
Expression endRef;
if (max.NodeType == NodeType.IntegerLiteralExpression)
{
endRef = max;
}
else
{
InternalLocal endVar = CodeBuilder.DeclareTempLocal(
_currentMethod,
TypeSystemServices.IntType);
endRef = CodeBuilder.CreateReference(endVar);
// __end = <end>
body.Add(
CodeBuilder.CreateAssignment(
endRef,
max));
}
if (args.Count == 1)
{
if (max.NodeType == NodeType.IntegerLiteralExpression)
{
if (((IntegerLiteralExpression)max).Value < 0)
{
// raise ArgumentOutOfRangeException("max") (if <max> < 0)
Statement statement = CodeBuilder.RaiseException(
body.LexicalInfo,
TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor),
CodeBuilder.CreateStringLiteral("max"));
body.Add(statement);
}
}
else
{
IfStatement ifStatement = new IfStatement(body.LexicalInfo);
ifStatement.TrueBlock = new Block();
// raise ArgumentOutOfRangeException("max") if __end < 0
Statement statement = CodeBuilder.RaiseException(
body.LexicalInfo,
TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor),
CodeBuilder.CreateStringLiteral("max"));
ifStatement.Condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.LessThan,
endRef,
CodeBuilder.CreateIntegerLiteral(0));
ifStatement.TrueBlock.Add(statement);
body.Add(ifStatement);
}
}
Expression stepRef;
switch (args.Count)
{
case 1:
stepRef = CodeBuilder.CreateIntegerLiteral(1);
break;
case 2:
if ((min.NodeType == NodeType.IntegerLiteralExpression) &&
(max.NodeType == NodeType.IntegerLiteralExpression) &&
(((IntegerLiteralExpression)max).Value < ((IntegerLiteralExpression)min).Value))
{
// __step = -1
stepRef = CodeBuilder.CreateIntegerLiteral(-1);
}
else if ((min.NodeType == NodeType.IntegerLiteralExpression) &&
(max.NodeType == NodeType.IntegerLiteralExpression))
{
// __step = 1
stepRef = CodeBuilder.CreateIntegerLiteral(1);
}
else
{
InternalLocal stepVar = CodeBuilder.DeclareTempLocal(
_currentMethod,
TypeSystemServices.IntType);
stepRef = CodeBuilder.CreateReference(stepVar);
// __step = 1
body.Add(
CodeBuilder.CreateAssignment(
stepRef,
CodeBuilder.CreateIntegerLiteral(1)));
// __step = -1 if __end < __num
IfStatement ifStatement = new IfStatement(node.LexicalInfo);
ifStatement.Condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.LessThan,
endRef,
numRef);
ifStatement.TrueBlock = new Block();
ifStatement.TrueBlock.Add(
CodeBuilder.CreateAssignment(
stepRef,
CodeBuilder.CreateIntegerLiteral(-1)));
body.Add(ifStatement);
}
break;
default:
if (step.NodeType == NodeType.IntegerLiteralExpression)
{
stepRef = step;
}
else
{
InternalLocal stepVar = CodeBuilder.DeclareTempLocal(
_currentMethod,
TypeSystemServices.IntType);
stepRef = CodeBuilder.CreateReference(stepVar);
// __step = <step>
body.Add(
CodeBuilder.CreateAssignment(
stepRef,
step));
}
break;
}
if (args.Count == 3)
{
Expression condition = null;
bool run = false;
if (step.NodeType == NodeType.IntegerLiteralExpression)
{
if (((IntegerLiteralExpression)step).Value < 0)
{
if ((max.NodeType == NodeType.IntegerLiteralExpression) &&
(min.NodeType == NodeType.IntegerLiteralExpression))
{
run = (((IntegerLiteralExpression)max).Value > ((IntegerLiteralExpression)min).Value);
}
else
{
condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.GreaterThan,
endRef,
numRef);
}
}
else
{
if ((max.NodeType == NodeType.IntegerLiteralExpression) &&
(min.NodeType == NodeType.IntegerLiteralExpression))
{
run = (((IntegerLiteralExpression)max).Value < ((IntegerLiteralExpression)min).Value);
}
else
{
condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.LessThan,
endRef,
numRef);
}
}
}
else
{
if ((max.NodeType == NodeType.IntegerLiteralExpression) &&
(min.NodeType == NodeType.IntegerLiteralExpression))
{
if (((IntegerLiteralExpression)max).Value < ((IntegerLiteralExpression)min).Value)
{
condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.GreaterThan,
stepRef,
CodeBuilder.CreateIntegerLiteral(0));
}
else
{
condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.LessThan,
stepRef,
CodeBuilder.CreateIntegerLiteral(0));
}
}
else
{
condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.Or,
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.And,
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.LessThan,
stepRef,
CodeBuilder.CreateIntegerLiteral(0)),
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.GreaterThan,
endRef,
numRef)),
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.And,
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.GreaterThan,
stepRef,
CodeBuilder.CreateIntegerLiteral(0)),
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
BinaryOperatorType.LessThan,
endRef,
numRef)));
}
}
// raise ArgumentOutOfRangeException("step") if (__step < 0 and __end > __begin) or (__step > 0 and __end < __begin)
Statement statement = CodeBuilder.RaiseException(
body.LexicalInfo,
TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor),
CodeBuilder.CreateStringLiteral("step"));
if (condition != null)
{
IfStatement ifStatement = new IfStatement(body.LexicalInfo);
ifStatement.TrueBlock = new Block();
ifStatement.Condition = condition;
ifStatement.TrueBlock.Add(statement);
body.Add(ifStatement);
}
else if (run)
{
body.Add(statement);
}
// __end = __num + __step * cast(int, Math.Ceiling((__end - __num)/cast(double, __step)))
if ((step.NodeType == NodeType.IntegerLiteralExpression) &&
(max.NodeType == NodeType.IntegerLiteralExpression) &&
(min.NodeType == NodeType.IntegerLiteralExpression))
{
int stepVal = (int)((IntegerLiteralExpression)step).Value;
int maxVal = (int)((IntegerLiteralExpression)max).Value;
int minVal = (int)((IntegerLiteralExpression)min).Value;
endRef = CodeBuilder.CreateIntegerLiteral(
minVal + stepVal * (int)System.Math.Ceiling((maxVal - minVal) / ((double)stepVal)));
}
else
{
Expression endBak = endRef;
if (max.NodeType == NodeType.IntegerLiteralExpression)
{
InternalLocal endVar = CodeBuilder.DeclareTempLocal(
_currentMethod,
TypeSystemServices.IntType);
endRef = CodeBuilder.CreateReference(endVar);
}
body.Add(
CodeBuilder.CreateAssignment(
endRef,
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.IntType,
BinaryOperatorType.Addition,
numRef,
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.IntType,
BinaryOperatorType.Multiply,
stepRef,
CodeBuilder.CreateCast(
TypeSystemServices.IntType,
CodeBuilder.CreateMethodInvocation(
TypeSystemServices.Map(System_Math_Ceiling),
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.DoubleType,
BinaryOperatorType.Division,
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.IntType,
BinaryOperatorType.Subtraction,
endBak,
numRef),
CodeBuilder.CreateCast(
TypeSystemServices.DoubleType,
stepRef))))))));
}
}
// while __num != __end:
WhileStatement ws = new WhileStatement(node.LexicalInfo);
BinaryOperatorType op = BinaryOperatorType.Inequality;
if (stepRef.NodeType == NodeType.IntegerLiteralExpression)
{
if (((IntegerLiteralExpression)stepRef).Value > 0)
{
op = BinaryOperatorType.LessThan;
}
else
{
op = BinaryOperatorType.GreaterThan;
}
}
ws.Condition = CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.BoolType,
op,
numRef,
endRef);
ws.Condition.LexicalInfo = node.LexicalInfo;
// item = __num
ws.Block.Add(
CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference((InternalLocal)declarations[0].Entity),
numRef));
Block rawBlock = new Block();
rawBlock["checked"] = false;
// __num += __step
rawBlock.Add(
CodeBuilder.CreateAssignment(
numRef,
CodeBuilder.CreateBoundBinaryExpression(
TypeSystemServices.IntType,
BinaryOperatorType.Addition,
numRef,
stepRef)));
ws.Block.Add(rawBlock as Statement);
// <block>
ws.Block.Add(node.Block);
body.Add(ws);
ReplaceCurrentNode(body);
}
protected IteratorExpressionImpl(LexicalInfo lexicalInfo) : base(lexicalInfo)
{
_declarations = new DeclarationCollection(this);
}
protected ForStatementImpl(LexicalInfo lexicalInfo) : base(lexicalInfo)
{
_declarations = new DeclarationCollection(this);
Block = new Block();
}
public static void UnpackExpression(BooCodeBuilder codeBuilder, Method method, Block block, Expression expression, DeclarationCollection declarations)
{
if (expression.ExpressionType.IsArray)
{
UnpackArray(codeBuilder, method, block, expression, declarations);
}
else
{
UnpackEnumerable(codeBuilder, method, block, expression, declarations);
}
}
public static void UnpackArray(BooCodeBuilder codeBuilder, Method method, Block block, Expression expression, DeclarationCollection declarations)
{
ILocalEntity local = expression.Entity as ILocalEntity;
if (null == local)
{
local = codeBuilder.DeclareTempLocal(method,
expression.ExpressionType);
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(local),
expression));
}
for (int i = 0; i < declarations.Count; ++i)
{
Declaration declaration = declarations[i];
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(
declaration.Entity),
codeBuilder.CreateSlicing(
codeBuilder.CreateReference(local),
i)));
}
}
protected UnpackStatementImpl(LexicalInfo lexicalInfo, Expression expression) : base(lexicalInfo)
{
_declarations = new DeclarationCollection(this);
Expression = expression;
}
override public void LeaveForStatement(ForStatement node)
{
_iteratorNode = node.Iterator;
CurrentEnumeratorType = GetExpressionType(node.Iterator);
if (null == CurrentBestEnumeratorType)
{
return; //error
}
DeclarationCollection declarations = node.Declarations;
Block body = new Block(node.LexicalInfo);
InternalLocal iterator = CodeBuilder.DeclareLocal(_current,
Context.GetUniqueName("iterator"),
CurrentBestEnumeratorType);
if (CurrentBestEnumeratorType == CurrentEnumeratorType)
{
//$iterator = <node.Iterator>
body.Add(
CodeBuilder.CreateAssignment(
node.LexicalInfo,
CodeBuilder.CreateReference(iterator),
node.Iterator));
}
else
{
//$iterator = <node.Iterator>.GetEnumerator()
body.Add(
CodeBuilder.CreateAssignment(
node.LexicalInfo,
CodeBuilder.CreateReference(iterator),
CodeBuilder.CreateMethodInvocation(node.Iterator, CurrentBestGetEnumerator)));
}
// while __iterator.MoveNext():
if (null == CurrentBestMoveNext)
{
return; //error
}
WhileStatement ws = new WhileStatement(node.LexicalInfo);
ws.Condition = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference(iterator),
CurrentBestMoveNext);
if (null == CurrentBestGetCurrent)
{
return; //error
}
Expression current = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference(iterator),
CurrentBestGetCurrent);
if (1 == declarations.Count)
{
// item = __iterator.Current
ws.Block.Add(
CodeBuilder.CreateAssignment(
node.LexicalInfo,
CodeBuilder.CreateReference((InternalLocal)declarations[0].Entity),
current));
}
else
{
UnpackExpression(ws.Block,
CodeBuilder.CreateCast(
CurrentEnumeratorItemType,
current),
node.Declarations);
}
ws.Block.Add(node.Block);
ws.OrBlock = node.OrBlock;
ws.ThenBlock = node.ThenBlock;
// try:
// while...
// ensure:
// d = iterator as IDisposable
// d.Dispose() unless d is null
if (IsAssignableFrom(TypeSystemServices.IDisposableType, CurrentBestEnumeratorType))
{
TryStatement tryStatement = new TryStatement();
tryStatement.ProtectedBlock.Add(ws);
tryStatement.EnsureBlock = new Block();
CastExpression castExpression = new CastExpression();
castExpression.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.IDisposableType);
castExpression.Target = CodeBuilder.CreateReference(iterator);
castExpression.ExpressionType = TypeSystemServices.IDisposableType;
tryStatement.EnsureBlock.Add(
CodeBuilder.CreateMethodInvocation(castExpression, IDisposable_Dispose));
body.Add(tryStatement);
}
else
{
body.Add(ws);
}
ReplaceCurrentNode(body);
}
protected UnpackStatementImpl()
{
_declarations = new DeclarationCollection(this);
}
protected UnpackStatementImpl(Expression expression)
{
_declarations = new DeclarationCollection(this);
Expression = expression;
}
protected IteratorExpressionImpl()
{
_declarations = new DeclarationCollection(this);
}
public DeclarationsNamespace(INamespace parent, TypeSystemServices tagManager, Declaration declaration)
{
_parent = parent;
_declarations = new DeclarationCollection();
_declarations.Add(declaration);
}
public DeclarationsNamespace(INamespace parent, TypeSystemServices tagManager, DeclarationCollection declarations)
{
_parent = parent;
_declarations = declarations;
}
/// <summary>
/// Unpacks an expression onto a list of declarations.
/// </summary>
/// <param name="block">Block this takes place in</param>
/// <param name="expression">expression to explode</param>
/// <param name="declarations">list of declarations to set</param>
void UnpackExpression(Block block, Expression expression, DeclarationCollection declarations)
{
NormalizeIterationStatements.UnpackExpression(CodeBuilder, _currentMethod, block, expression, declarations);
}
protected ForStatementImpl(LexicalInfo lexicalInfo, Expression iterator) : base(lexicalInfo)
{
_declarations = new DeclarationCollection(this);
Block = new Block();
Iterator = iterator;
}
override public void LeaveForStatement(ForStatement node)
{
IType enumeratorType = GetExpressionType(node.Iterator);
IType enumeratorItemType = TypeSystemServices.GetEnumeratorItemType(enumeratorType);
DeclarationCollection declarations = node.Declarations;
Block body = new Block(node.LexicalInfo);
InternalLocal iterator = CodeBuilder.DeclareLocal(
_current,
"___iterator" + _context.AllocIndex(),
TypeSystemServices.IEnumeratorType);
if (TypeSystemServices.IEnumeratorType.IsAssignableFrom(enumeratorType))
{
body.Add(
CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference(iterator),
node.Iterator));
}
else
{
// ___iterator = <node.Iterator>.GetEnumerator()
body.Add(
CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference(iterator),
CodeBuilder.CreateMethodInvocation(
node.Iterator,
IEnumerable_GetEnumerator)));
}
// while __iterator.MoveNext():
WhileStatement ws = new WhileStatement(node.LexicalInfo);
ws.Condition = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference(iterator),
IEnumerator_MoveNext);
Expression current = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference(iterator),
IEnumerator_get_Current);
if (1 == declarations.Count)
{
// item = __iterator.Current
ws.Block.Add(
CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference((InternalLocal)declarations[0].Entity),
current));
}
else
{
UnpackExpression(ws.Block,
CodeBuilder.CreateCast(
enumeratorItemType,
current),
node.Declarations);
}
ws.Block.Add(node.Block);
body.Add(ws);
ReplaceCurrentNode(body);
}
public DeclarationsNamespace(BindingManager bindingManager, DeclarationCollection declarations)
{
_bindingManager = bindingManager;
_declarations = declarations;
}
void UnpackExpression(Block block, Expression expression, DeclarationCollection declarations)
{
UnpackExpression(CodeBuilder, _current, block, expression, declarations);
}
public DeclarationsNamespace(BindingManager bindingManager, Declaration declaration)
{
_bindingManager = bindingManager;
_declarations = new DeclarationCollection();
_declarations.Add(declaration);
}
public static void UnpackEnumerable(BooCodeBuilder codeBuilder, Method method, Block block, Expression expression, DeclarationCollection declarations)
{
TypeSystemServices tss = codeBuilder.TypeSystemServices;
InternalLocal local = codeBuilder.DeclareTempLocal(method,
tss.IEnumeratorType);
IType expressionType = expression.ExpressionType;
if (expressionType.IsSubclassOf(codeBuilder.TypeSystemServices.IEnumeratorType))
{
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(local),
expression));
}
else
{
if (!expressionType.IsSubclassOf(codeBuilder.TypeSystemServices.IEnumerableType))
{
expression = codeBuilder.CreateMethodInvocation(
RuntimeServices_GetEnumerable, expression);
}
block.Add(
codeBuilder.CreateAssignment(
block.LexicalInfo,
codeBuilder.CreateReference(local),
codeBuilder.CreateMethodInvocation(
expression, IEnumerable_GetEnumerator)));
}
for (int i = 0; i < declarations.Count; ++i)
{
Declaration declaration = declarations[i];
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(declaration.Entity),
codeBuilder.CreateMethodInvocation(RuntimeServices_MoveNext,
codeBuilder.CreateReference(local))));
}
}
private void CreateMoveNext()
{
BooMethodBuilder method = _enumerator.AddVirtualMethod("MoveNext", TypeSystemServices.BoolType);
Expression moveNext = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference((InternalField)_enumeratorField.Entity),
TypeSystemServices.Map(Methods.InstanceFunctionOf <IEnumerator, bool>(e => e.MoveNext)));
Expression current = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference((InternalField)_enumeratorField.Entity),
((IProperty)GetMember(_sourceEnumeratorType, "Current", EntityType.Property)).GetGetMethod());
Statement filter = null;
Statement stmt;
Block outerBlock;
Block innerBlock;
if (null == _generator.Filter)
{
IfStatement istmt = new IfStatement(moveNext, new Block(), null);
outerBlock = innerBlock = istmt.TrueBlock;
stmt = istmt;
}
else
{
WhileStatement wstmt = new WhileStatement(moveNext);
outerBlock = wstmt.Block;
if (StatementModifierType.If == _generator.Filter.Type)
{
IfStatement ifstmt = new IfStatement(_generator.Filter.Condition, new Block(), null);
innerBlock = ifstmt.TrueBlock;
filter = ifstmt;
}
else
{
UnlessStatement ustmt = new UnlessStatement(_generator.Filter.Condition);
innerBlock = ustmt.Block;
filter = ustmt;
}
stmt = wstmt;
}
DeclarationCollection declarations = _generator.Declarations;
if (declarations.Count > 1)
{
NormalizeIterationStatements.UnpackExpression(CodeBuilder,
method.Method,
outerBlock,
current,
declarations);
foreach (Declaration declaration in declarations)
{
method.Locals.Add(((InternalLocal)declaration.Entity).Local);
}
}
else
{
InternalLocal local = (InternalLocal)declarations[0].Entity;
method.Locals.Add(local.Local);
outerBlock.Add(CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference(local),
current));
}
if (null != filter)
{
outerBlock.Add(filter);
}
innerBlock.Add(CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference((InternalField)_current.Entity),
_generator.Expression));
innerBlock.Add(new ReturnStatement(new BoolLiteralExpression(true)));
method.Body.Add(stmt);
method.Body.Add(new ReturnStatement(new BoolLiteralExpression(false)));
}
protected UnpackStatementImpl(LexicalInfo lexicalInfo) : base(lexicalInfo)
{
_declarations = new DeclarationCollection(this);
}
public DeclarationsNamespace(INamespace parent, DeclarationCollection declarations)
{
_parent = parent;
_declarations = declarations;
}
