internal xfor(For f)
{
initializer = parser(f.initializer);
condition = parser(f.condition);
incrementer = parser(f.incrementer);
body = parser(f.body);
}
protected override object VisitFor(For F)
{
target.PushScope();
// Generate the loop header code.
Visit(F.Init);
string name = target.LabelName();
LinqExprs.LabelTarget begin = LinqExpr.Label("for_" + name + "_begin");
LinqExprs.LabelTarget end = LinqExpr.Label("for_" + name + "_end");
loops.Push(new Loop(LinqExpr.Goto(end), LinqExpr.Goto(begin)));
// Check the condition, exit if necessary.
target.Add(LinqExpr.Label(begin));
target.Add(LinqExpr.IfThen(LinqExpr.Not(target.Compile(F.Condition)), LinqExpr.Goto(end)));
// Generate the body code.
Visit(F.Body);
// Generate the step code.
Visit(F.Step);
target.Add(LinqExpr.Goto(begin));
// Exit point.
target.Add(LinqExpr.Label(end));
loops.Pop();
target.PopScope();
return(null);
}
public static Instruction[] ConvertFunction(MethodBody funcMethod, For forLoop)
{
var size = funcMethod.Instructions.Count - 1;
var result = new Instruction[size];
var instructions = funcMethod.Instructions;
for (var i = 0; i < size; i++)
{
ref var res = ref result[i];
var instruction = instructions[i];
var opCode = instruction.OpCode;
if (opCode == OpCodes.Ldarg_1 || opCode == OpCodes.Ldarga_S)
{
res = LdLoc(forLoop.LocalDefinition);
continue;
}
if (opCode == OpCodes.Ret)
{
continue;
}
res = instruction;
}
public void MultipleInstancesYieldsSingleActualInvocationPerDistinctInvocation()
{
var instance1 = new ForTestingPurposes();
var instance2 = new ForTestingPurposes();
var adapter = new PerInstanceAdapter <IForTestingPurposes>(For.Ever());
var proxy1 = adapter.Adapt(instance1);
var proxy2 = adapter.Adapt(instance2);
proxy1.MethodCall(0, "zero");
proxy1.MethodCall(0, "zero");
proxy1.MethodCall(1, "zero");
proxy1.MethodCall(1, "zero");
proxy1.MethodCall(2, "zero");
proxy1.MethodCall(2, "zero");
proxy2.MethodCall(0, "zero");
proxy2.MethodCall(0, "zero");
proxy2.MethodCall(1, "zero");
proxy2.MethodCall(1, "zero");
proxy2.MethodCall(2, "zero");
proxy2.MethodCall(2, "zero");
Assert.Equal <uint>(3, instance1.MethodCallInvocationCount);
Assert.Equal <uint>(0, instance2.MethodCallInvocationCount);
}
public Node For()
{
var idToken = Expect(TokenCategory.FOR);
var identifier = new Identifier()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
};
Expect(TokenCategory.IN);
var expr = Expression();
Expect(TokenCategory.DO);
var stmtList = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
stmtList.Add(Statement());
}
Expect(TokenCategory.END);
Expect(TokenCategory.ENDLINE);
var result = new For()
{
identifier, expr, stmtList
};
result.AnchorToken = idToken;
return(result);
//Si nos estamos refiriendo a FormatException?
}
public override void VisitFor(For p)
{
var continueLabel = IL.DefineLabel();
VisitStatement(p.Initializer);
EmitLoopSkeleton(continueLabel, (breakLabel) =>
{
var dofor = IL.DefineLabel();
IL.MarkLabel(continueLabel);
VisitExpression(p.Test);
IL.Emit(OpCodes.Stloc, E);
IL.Emit(OpCodes.Ldloca, E);
IL.Emit(OpCodes.Call, isReal);
IL.Emit(OpCodes.Brtrue, dofor);
IL.Emit(OpCodes.Ldsfld, typeof(Error).GetField("ExpectedExpression"));
IL.Emit(OpCodes.Newobj, typeof(ProgramError).GetConstructor(new[] { typeof(Error) }));
IL.Emit(OpCodes.Throw);
IL.MarkLabel(dofor);
IL.Emit(OpCodes.Ldloc, E);
EmitImplicitConversion(typeof(bool));
IL.Emit(OpCodes.Brfalse, breakLabel);
VisitStatement(p.Body);
VisitStatement(p.Iterator);
IL.Emit(OpCodes.Br, continueLabel);
});
}
public void ShouldBeAbleToCancelSchedule(WorkType workType)
{
var output = new List <string>();
var interval = TimeSpan.FromMilliseconds(100);
var task = default(Task);
switch (workType)
{
case WorkType.Sync:
task = _scheduler.Schedule(() => output.Add("one"), interval);
break;
case WorkType.Async:
task = _scheduler.Schedule(async() =>
{
output.Add("one");
await Task.Yield();
}, interval);
break;
default:
throw new Exception($"Unhandled test case {workType}.");
}
Within.FiveSeconds(() => output.Should().Equal(Enumerable.Repeat("one", 1)));
_scheduler.CancelCurrent();
Within.FiveSeconds(() => task.IsCanceled.Should().BeTrue());
var marker = output.Count;
For.OneSecond(() => output.Count.Should().Be(marker));
}
public object VisitFor(For node)
{
EnterScope(node);
Visit(node.Init);
object result = null;
while ((bool)Visit(node.Condition))
{
try
{
result = Visit(node.Body);
}
catch (LoopBreakException)
{
break;
}
catch (LoopContinueException)
{
}
Visit(node.Update);
}
ExitScope();
return(result);
}
public void VisitFor(For statement)
{
var finish = Instruction.Create(OpCodes.Nop);
var start = Instruction.Create(OpCodes.Nop);
if (statement.Initializer != null)
{
CompileForStatement(statement.Initializer);
}
cil.Append(start);
if (statement.Condition != null)
{
var conditionType = CompileExpression(statement.Condition);
if (conditionType == types.Bool)
{
cil.Emit(OpCodes.Brfalse, finish);
}
else
{
throw WrongType(statement.Condition, conditionType, types.Bool);
}
}
CompileBlock(statement.Body);
CompileForStatement(statement.Iterator);
cil.Emit(OpCodes.Br, start);
cil.Append(finish);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "div";
output.TagMode = TagMode.StartTagAndEndTag;
output.Attributes.Add("class", "form-group");
var required = "";
if (For.Metadata.IsRequired)
{
required = " <span class='required'>*</span>";
}
var labeTag = new TagBuilder("label");
labeTag.Attributes.Add("for", For.GetFullHtmlName(ViewContext));
var displayName = For.Metadata?.DisplayName ?? For.Name;
displayName += required;
labeTag.InnerHtml.AppendHtml(displayName);
var input = GetInputTag();
var validationTag = GetValidationTag();
output.PreContent.AppendHtml(labeTag);
output.PreContent.AppendHtml(input);
output.PreContent.AppendHtml(validationTag);
base.Process(context, output);
}
public void WhenDefineNaturalIdThenRegister()
{
var inspector = new ExplicitlyDeclaredModel();
var mapper = new ModelMapper(inspector);
mapper.Class <MyClass>(map =>
{
map.Id(x => x.Id, idmap => { });
map.NaturalId(nidm =>
{
nidm.Property(x => x.Name);
nidm.ManyToOne(x => x.Related);
nidm.Component(x => x.MyComponent, cmap =>
{
cmap.Property(y => y.FirstName);
});
nidm.Any(x => x.Any, typeof(int), anymap => { });
});
});
Assert.That(inspector.IsMemberOfNaturalId(For <MyClass> .Property(x => x.Name)), Is.True);
Assert.That(inspector.IsMemberOfNaturalId(For <MyClass> .Property(x => x.Related)), Is.True);
Assert.That(inspector.IsMemberOfNaturalId(For <MyClass> .Property(x => x.MyComponent)), Is.True);
Assert.That(inspector.IsMemberOfNaturalId(For <MyClass> .Property(x => x.Any)), Is.True);
}
public Node For()
{
var result = new For()
{
AnchorToken = Expect(TokenCategory.FOR)
};
result.Add(new Identifier()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
});
Expect(TokenCategory.IN);
result.Add(Expression());
var dostatement = new Do()
{
AnchorToken = Expect(TokenCategory.DO)
};
while (firstOfStatement.Contains(CurrentToken))
{
dostatement.Add(Statement());
}
Expect(TokenCategory.END);
Expect(TokenCategory.SEMICOL);
result.Add(dostatement);
return(result);
}
public void WhenSetSyncWithNullThenDoesNotThrows()
{
var mapdoc = new HbmMapping();
var rc = new ClassMapper(typeof(EntitySimple), mapdoc, For <EntitySimple> .Property(x => x.Id));
rc.Executing(x => x.Synchronize(null)).NotThrows();
}
public void WhenMapExternalMemberAsComponentIdThenThrows()
{
var mapdoc = new HbmMapping();
var mapper = new ClassMapper(typeof(Person), mapdoc, For <Person> .Property(x => x.Id));
mapper.Executing(m => m.ComponentAsId(For <User> .Property(x => x.Id), map => map.Access(Accessor.Field))).Throws <ArgumentOutOfRangeException>();
}
public void ForNextLoopWithNoVariableAndIntermediateGosubThrowsErrorTest()
{
SetupSut();
var forCmd = new For(_runEnvironment, _mockExpressionEvaluator.Object, _variableRepository);
var nextCmd = new Next(_runEnvironment, _variableRepository);
_mockExpressionEvaluator.SetupSequence(mee => mee.GetExpression())
.Returns(new Accumulator(1.0))
.Returns(new Accumulator(4.0));
var line10 = new ProgramLine(10, new List <IToken> {
new Token("A"), _equalToken, _toToken, _colonToken
});
var line30 = new ProgramLine(30, new List <IToken> {
new Token("2")
});
// Execute for
_runEnvironment.CurrentLine = line10;
forCmd.Execute();
// Pretend we've done a gosub
_runEnvironment.ProgramStack.Push(new StackEntry());
line30.CurrentToken = 0;
_runEnvironment.CurrentLine = line30;
Test.Throws <NextWithoutForException>(nextCmd.Execute);
}
public void WhenSetSyncWithNullThenDoesNotThrows()
{
var mapdoc = new HbmMapping();
var rc = new ClassMapper(typeof(EntitySimple), mapdoc, For <EntitySimple> .Property(x => x.Id));
Assert.That(() => rc.Synchronize(null), Throws.Nothing);
}
public void ForNextLoopWithoutVariableTest()
{
SetupSut();
var forCmd = new For(_runEnvironment, _mockExpressionEvaluator.Object, _variableRepository);
var nextCmd = new Next(_runEnvironment, _variableRepository);
_mockExpressionEvaluator.SetupSequence(mee => mee.GetExpression())
.Returns(new Accumulator(1.0))
.Returns(new Accumulator(3.0));
var line10 = new ProgramLine(10, new List <IToken> {
new Token("A"), _equalToken, _toToken, _colonToken
});
var line20 = new ProgramLine(20, new List <IToken> {
new Token("1")
});
_runEnvironment.CurrentLine = line10;
forCmd.Execute();
Assert.AreEqual(1.0, _variableRepository.GetOrCreateVariable("A", new short[] { }).GetValue().ValueAsDouble());
Assert.AreEqual(1, _runEnvironment.ProgramStack.Count);
var loopBackToken = _runEnvironment.CurrentLine.CurrentToken;
// Execute next,
line20.CurrentToken = 0;
_runEnvironment.CurrentLine = line20;
nextCmd.Execute();
// variable should be 2
Assert.AreEqual(2.0, _variableRepository.GetOrCreateVariable("A", new short[] { }).GetValue().ValueAsDouble());
// Should be back to just after for loop.
Assert.AreEqual(10, _runEnvironment.CurrentLine.LineNumber.Value);
Assert.AreEqual(loopBackToken, _runEnvironment.CurrentLine.CurrentToken);
// Execute next, variable should be 3
line20.CurrentToken = 0;
_runEnvironment.CurrentLine = line20;
nextCmd.Execute();
Assert.AreEqual(3.0, _variableRepository.GetOrCreateVariable("A", new short[] { }).GetValue().ValueAsDouble());
Assert.AreEqual(10, _runEnvironment.CurrentLine.LineNumber.Value);
Assert.AreEqual(loopBackToken, _runEnvironment.CurrentLine.CurrentToken);
// Execute next
line20.CurrentToken = 0;
_runEnvironment.CurrentLine = line20;
nextCmd.Execute();
// So we have exited the loop
Assert.AreEqual(20, _runEnvironment.CurrentLine.LineNumber.Value);
// Did we leave behind the token.
var token = _runEnvironment.CurrentLine.NextToken();
Assert.AreEqual("1", token.Text);
// Variable should be 4.0
Assert.AreEqual(4.0, _variableRepository.GetOrCreateVariable("A", new short[] { }).GetValue().ValueAsDouble());
Assert.AreEqual(0, _runEnvironment.ProgramStack.Count);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var labelTag = new TagBuilder("label");
labelTag.InnerHtml.Append(For.Metadata.Description);
labelTag.AddCssClass("control-label");
var pTag = new TagBuilder("p");
pTag.AddCssClass("form-control-static form-tag-dd");
if (Pipe == null || Pipe.Length <= 0)
{
pTag.InnerHtml.Append("{{" + For.AngularName() + "}}");
}
else
{
pTag.InnerHtml.Append("{{" + For.AngularName() + "|" + Pipe + "}}");
}
output.TagName = "div";
output.Attributes.Add("class", "form-group");
output.Content.AppendHtml(labelTag);
output.Content.AppendHtml(pTag);
}
/// <summary>
/// Generates a for block with the specified loop conditions and body.
/// </summary>
/// <param name="init">The optional init statement.</param>
/// <param name="condition">The optional condition statement.</param>
/// <param name="post">The optional post statement.</param>
/// <param name="body">The body of the for loop.</param>
/// <returns>The root node of the for block AST.</returns>
public static Node Generate(Node init, Node condition, Node post, IReadOnlyList <Node> body)
{
if (init != null || condition != null || post != null)
{
throw new NotImplementedException("init, condition and post are NYI");
}
if (body == null || body.Count == 0)
{
throw new ArgumentException(nameof(body));
}
var forBlock = new For();
var openBrace = new OpenDelimiter(BinaryDelimiterType.Brace);
foreach (var node in body)
{
openBrace.AddChild(node);
}
openBrace.AddClosingDelimiter();
forBlock.AddChild(openBrace);
return(forBlock);
}
public void WhenTwoInterfacesThenReturnMemberInfoOfEachInterface()
{
var members = For <Person> .Property(x => x.Something).GetPropertyFromInterfaces();
Assert.That(members, Contains.Item(For <IEntity> .Property(x => x.Something)));
Assert.That(members, Contains.Item(For <IHasSomething> .Property(x => x.Something)));
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var pipe = string.IsNullOrEmpty(Pipe) ? string.Empty : Pipe;
var labelTag = new TagBuilder("label");
labelTag.InnerHtml.Append(For.Metadata.Description);
labelTag.AddCssClass("control-label");
var pTag = new TagBuilder("p");
pTag.AddCssClass("form-control-static");
var dataBindExpression = ((DefaultModelMetadata)For.Metadata).DataTypeName == "Password"
? "******"
: "{{" + For.CamelizedName() + pipe + "}}";
pTag.InnerHtml.Append(dataBindExpression);
output.TagName = "div";
output.Attributes.Add("class", "form-group");
output.Content.AppendHtml(labelTag);
output.Content.AppendHtml(pTag);
}
public void WhenTwoInterfacesThenReturnMemberInfoOfEachInterface()
{
var members = For <Person> .Property(x => x.Something).GetPropertyFromInterfaces();
members.Should().Contain(For <IEntity> .Property(x => x.Something));
members.Should().Contain(For <IHasSomething> .Property(x => x.Something));
}
public override string ToString()
{
string source = string.Empty;
if (!From.Equals(string.Empty))
{
source += " from " + From + "\r\n ";
}
if (!By.Equals(string.Empty))
{
source += " by " + By + "\r\n ";
}
if (!With.Equals(string.Empty))
{
source += " with " + With + "\r\n ";
}
if (!For.Equals(string.Empty))
{
source += " for " + For + "\r\n ";
}
if (!Via.Equals(string.Empty))
{
source += " via " + Via + "\r\n ";
}
if (!Id.Equals(string.Empty))
{
source += " id " + Id + "\r\n ";
}
if (string.IsNullOrEmpty(source))
{
return("");
}
return(source.Remove(0, source.Length - 3) + ";" + Date.ToString("r"));
}
public void WhenSplittedPropertiesThenRegister()
{
var inspector = new ExplicitlyDeclaredModel();
var mapper = new ModelMapper(inspector);
mapper.Subclass <Inherited>(map =>
{
map.Join("MyClassSplit1", mj =>
{
mj.Property(x => x.SomethingA1);
mj.Property(x => x.SomethingA2);
});
map.Join("MyClassSplit2", mj =>
{
mj.Property(x => x.SomethingB1);
mj.Property(x => x.SomethingB2);
});
map.Property(x => x.Something0);
});
inspector.IsTablePerClassSplit(typeof(MyClass), "MyClassSplit1", For <Inherited> .Property(x => x.Something0)).Should().Be.False();
inspector.IsTablePerClassSplit(typeof(MyClass), "MyClassSplit2", For <Inherited> .Property(x => x.Something0)).Should().Be.False();
inspector.IsTablePerClassSplit(typeof(MyClass), "MyClassSplit1", For <Inherited> .Property(x => x.SomethingA1)).Should().Be.True();
inspector.IsTablePerClassSplit(typeof(MyClass), "MyClassSplit1", For <Inherited> .Property(x => x.SomethingA2)).Should().Be.True();
inspector.IsTablePerClassSplit(typeof(MyClass), "MyClassSplit2", For <Inherited> .Property(x => x.SomethingB1)).Should().Be.True();
inspector.IsTablePerClassSplit(typeof(MyClass), "MyClassSplit2", For <Inherited> .Property(x => x.SomethingB2)).Should().Be.True();
}
public Grid(int[,] map, float squareSize)
{
var nodeCountX = map.GetLength(0);
var nodeCountY = map.GetLength(1);
Width = nodeCountX - 1;
Height = nodeCountY - 1;
var mapWidth = nodeCountX * squareSize;
var mapHeight = nodeCountY * squareSize;
var controlNodes = new ControlNode[nodeCountX, nodeCountY];
For.Xy(nodeCountX, nodeCountY, (x, y) =>
{
var position = new Vector3(-mapWidth / 2 + x * squareSize + squareSize / 2, 0, -mapHeight / 2 + y * squareSize + squareSize / 2);
controlNodes[x, y] = new ControlNode(position, map[x, y] == 1, squareSize);
});
_squares = new Square[Width, Height];
For.Xy(Width, Height, (x, y) =>
{
_squares[x, y] = new Square(
controlNodes[x, y + 1],
controlNodes[x + 1, y + 1],
controlNodes[x + 1, y],
controlNodes[x, y]
);
});
}
public Node For()
{
var result = new For()
{
AnchorToken = Expect(TokenCategory.FOR)
};
result.Add(new Identifier()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
});
Expect(TokenCategory.IN);
result.Add(Expression());
Expect(TokenCategory.DO);
var statementList = new StatementList();
if (firstOfStatement.Contains(CurrentToken))
{
while (firstOfStatement.Contains(CurrentToken))
{
statementList.Add(Statement());
}
}
result.Add(statementList);
Expect(TokenCategory.END);
Expect(TokenCategory.SEMICOLON);
return(result);
}
public void AllKernelOfPixel()
{
var config = new Config(6, 6, 3, 3);
var position = new Position(config, 2, 3);
var answer = new[]
{
// new [] { -1, 0 },
new [] { 0, 0 },
new [] { 1, 0 },
new [] { 2, 0 },
// new [] { -1, 1 },
new [] { 0, 1 },
new [] { 1, 1 },
new [] { 2, 1 },
//new [] { -1, 2 },
new [] { 0, 2 },
new [] { 1, 2 },
new [] { 2, 2 },
};
int counter = 0;
For.AllKernelOfPixel(config, position, (c, k) => {
Assert.AreEqual(k.x, answer[counter][0]);
Assert.AreEqual(k.y, answer[counter][1]);
counter++;
});
Assert.AreEqual(counter, answer.Length);
}
public static DataTable DataOutPut(For @for)
{
Dek TB;
if (FileEx(FilePath))
{
TB = DataLoadSave.LoadXML(FilePath);
DataSet Ds = new DataSet("Students");
//DataTable DekDataTable = new DataTable("DekDataTable");
DataTable StudentT = InitealDTStudent();
DataTable GroupeT = InitealDTSGrope();
DataTable RoomT = InitealDTRoom();
DataTable HostelT = InitealDTSHostel();
Ds.Tables.Add(StudentT);
Ds.Tables.Add(GroupeT);
Ds.Tables.Add(RoomT);
Ds.Tables.Add(HostelT);
switch (@for)
{
case For.Student:
foreach (StudentsTable S in TB.Students)
{
StudentT.Rows.Add(new object[] { S.ID, S.ThirdName_1 + " " + S.Name_2 + " " + S.SurnameName_3,
GetGroupeNameByID(TB, S.GroupeID), GetRoomNumberByRoomID(TB, S.RoomID), S.TicetNumber, S.FormStudy, S.ContractBudget, S.Description });
}
return(StudentT);
case For.Groupe:
foreach (GroupeTable G in TB.Groupes)
{
GroupeT.Rows.Add(new object[] { G.ID, G.GroupeNumber, G.StudentsInGroupe, G.Description });
}
return(GroupeT);
case For.Room:
foreach (RoomTable R in TB.Roomes)
{
RoomT.Rows.Add(new object[] { R.ID, GetHostelNameByID(TB, R.HostelID), R.RoomNumber, R.AllPlace, R.FreePlase, R.Description });
}
return(RoomT);
case For.Hostel:
foreach (HostelNewTable H in TB.HostelsN)
{
HostelT.Rows.Add(new object[] { H.ID, H.Frame, H.RoomsCount, H.Decription });
}
return(HostelT);
default: return(null);
}
}
else
{
return(null);
}
}
public void CanSetPersister()
{
var mapdoc = new HbmMapping();
var rc = new ClassMapper(typeof(EntitySimple), mapdoc, For <EntitySimple> .Property(x => x.Id));
rc.Persister <SingleTableEntityPersister>();
Assert.That(mapdoc.RootClasses[0].Persister, Does.Contain("SingleTableEntityPersister"));
}
public void WhenSetMoreSyncThenAddAll()
{
var mapdoc = new HbmMapping();
var rc = new ClassMapper(typeof(EntitySimple), mapdoc, For <EntitySimple> .Property(x => x.Id));
rc.Synchronize("T1", "T2", "T3", null);
Assert.That(mapdoc.RootClasses[0].Synchronize.Select(x => x.table), Is.EquivalentTo(new [] { "T1", "T2", "T3" }));
}
public ForUI([NotNull] UserDTO u, For f)
: this(u.UserId.ToString())
{
Init(f, () =>
{
Caption = u.UserFio;
ToolTip = string.Format("{0} ({1})", u.Login, u.UserId);
},
() => { Caption = string.Format("{0}", u.UserFio); });
}
public ForUI([NotNull] UserRoleDTO ur, For f)
: this(ur.UserRoleId)
{
Init(f, () =>
{
Caption = ur.Name;
ToolTip = ur.Description.TrimOrNullIfEmpty();
ForeColor = ur.Color();
},
() =>
{
string desc = ur.Description.TrimOrNullIfEmpty();
Caption = string.Format("{0}{1}", ur.Name, string.IsNullOrEmpty(desc) ? "" : " (" + desc + ")");
});
}
public override void VisitFor(For p)
{
var continueLabel = IL.DefineLabel();
VisitStatement(p.Initializer);
EmitLoopSkeleton(continueLabel, (breakLabel) =>
{
var dofor = IL.DefineLabel();
IL.MarkLabel(continueLabel);
VisitExpression(p.Test);
IL.Emit(OpCodes.Stloc, E);
IL.Emit(OpCodes.Ldloca, E);
IL.Emit(OpCodes.Call, isReal);
IL.Emit(OpCodes.Brtrue, dofor);
IL.Emit(OpCodes.Ldsfld, typeof(Error).GetField("ExpectedExpression"));
IL.Emit(OpCodes.Newobj, typeof(ProgramError).GetConstructor(new[] { typeof(Error) }));
IL.Emit(OpCodes.Throw);
IL.MarkLabel(dofor);
IL.Emit(OpCodes.Ldloc, E);
EmitImplicitConversion(typeof(bool));
IL.Emit(OpCodes.Brfalse, breakLabel);
VisitStatement(p.Body);
VisitStatement(p.Iterator);
IL.Emit(OpCodes.Br, continueLabel);
});
}
public virtual Differences VisitFor(For for1, For for2){
Differences differences = new Differences(for1, for2);
if (for1 == null || for2 == null){
if (for1 != for2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
For changes = (For)for2.Clone();
For deletions = (For)for2.Clone();
For insertions = (For)for2.Clone();
Differences diff = this.VisitBlock(for1.Body, for2.Body);
if (diff == null){Debug.Assert(false); return differences;}
changes.Body = diff.Changes as Block;
deletions.Body = diff.Deletions as Block;
insertions.Body = diff.Insertions as Block;
Debug.Assert(diff.Changes == changes.Body && diff.Deletions == deletions.Body && diff.Insertions == insertions.Body);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
diff = this.VisitExpressionList(for1.Invariants, for2.Invariants, out changes.Invariants, out deletions.Invariants, out insertions.Invariants);
if (diff == null){Debug.Assert(false); return differences;}
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
diff = this.VisitExpression(for1.Condition, for2.Condition);
if (diff == null){Debug.Assert(false); return differences;}
changes.Condition = diff.Changes as Expression;
deletions.Condition = diff.Deletions as Expression;
insertions.Condition = diff.Insertions as Expression;
Debug.Assert(diff.Changes == changes.Condition && diff.Deletions == deletions.Condition && diff.Insertions == insertions.Condition);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
StatementList statChanges, statDeletions, statInsertions;
diff = this.VisitStatementList(for1.Incrementer, for2.Incrementer, out statChanges, out statDeletions, out statInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.Initializer = statChanges;
deletions.Initializer = statDeletions;
insertions.Initializer = statInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
diff = this.VisitStatementList(for1.Initializer, for2.Initializer, out statChanges, out statDeletions, out statInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.Initializer = statChanges;
deletions.Initializer = statDeletions;
insertions.Initializer = statInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Statement VisitFor(For For){
if (For == null) return null;
For.Initializer = this.VisitStatementList(For.Initializer);
For.Invariants = this.VisitLoopInvariantList(For.Invariants);
For.Condition = this.VisitExpression(For.Condition);
For.Incrementer = this.VisitStatementList(For.Incrementer);
For.Body = this.VisitBlock(For.Body);
return For;
}
public virtual object Visit (For forStatement)
{
return null;
}
public override object Visit (For forStatement)
{
var result = new ForStatement ();
var location = LocationsBag.GetLocations (forStatement);
result.AddChild (new CSharpTokenNode (Convert (forStatement.loc), ForStatement.ForKeywordRole), ForStatement.ForKeywordRole);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location [0]), Roles.LPar), Roles.LPar);
AddStatementOrList (result, forStatement.Initializer, ForStatement.InitializerRole);
if (location != null && location.Count > 1)
result.AddChild (new CSharpTokenNode (Convert (location [1]), Roles.Semicolon), Roles.Semicolon);
if (forStatement.Condition != null)
result.AddChild ((Expression)forStatement.Condition.Accept (this), Roles.Condition);
if (location != null && location.Count >= 3)
result.AddChild (new CSharpTokenNode (Convert (location [2]), Roles.Semicolon), Roles.Semicolon);
AddStatementOrList (result, forStatement.Iterator, ForStatement.IteratorRole);
if (location != null && location.Count >= 4)
result.AddChild (new CSharpTokenNode (Convert (location [3]), Roles.RPar), Roles.RPar);
if (forStatement.Statement != null)
result.AddChild ((Statement)forStatement.Statement.Accept (this), Roles.EmbeddedStatement);
return result;
}
public override Statement VisitFor(For For) {
if (For == null) return null;
this.loopCount++;
For.Initializer = this.VisitStatementList(For.Initializer);
For.Invariants = this.VisitLoopInvariantList(For.Invariants);
For.Condition = this.VisitBooleanExpression(For.Condition);
For.Incrementer = this.VisitStatementList(For.Incrementer);
For.Body = this.VisitBlock(For.Body);
this.loopCount--;
return For;
}
public override Statement VisitFor(For For){
if (For == null) return null;
StatementList statements = new StatementList(6);
Block forBlock = new Block(statements);
forBlock.SourceContext = For.SourceContext;
int n = For.Incrementer.Count;
StatementList incrStatements = new StatementList(n);
Block incrBlock = new Block(incrStatements);
this.continueTargets.Add(incrBlock);
Block endOfLoop = new Block(null);
this.exitTargets.Add(endOfLoop);
this.VisitStatementList(For.Initializer);
Statement forCondition = null;
if (For.Condition != null)
forCondition = this.VisitAndInvertBranchCondition(For.Condition, endOfLoop, For.Condition.SourceContext);
For.Incrementer = this.VisitStatementList(For.Incrementer);
this.VisitBlock(For.Body);
statements.Add(new Block(For.Initializer));
StatementList conditionStatements = new StatementList(1);
Block condition = new Block(conditionStatements);
statements.Add(condition);
ExpressionList invariants = For.Invariants;
if (invariants != null && invariants.Count > 0)
conditionStatements.Add(VisitLoopInvariants(invariants));
if (forCondition != null) conditionStatements.Add(forCondition);
statements.Add(For.Body);
for (int i = 0; i < n; i++) incrStatements.Add(For.Incrementer[i]);
statements.Add(incrBlock);
statements.Add(new Branch(null, condition));
statements.Add(endOfLoop);
this.continueTargets.Count--;
this.exitTargets.Count--;
return forBlock;
}
// TODO: Handle default values in the comprehension
// Q{U i in enumerable, P(i); T(i)}
public override Expression VisitQuantifier(Quantifier quantifier) {
if (quantifier == null) return null;
Comprehension comprehension = quantifier.Comprehension;
if (comprehension == null) return null;
Block block = new Block(new StatementList());
block.HasLocals = true;
#region Create local to act as accumulator for the quantifier
Local b = null;
switch (quantifier.QuantifierType){
case NodeType.Forall:
b = new Local(Identifier.Empty,SystemTypes.Boolean,block);
break;
case NodeType.Exists:
b = new Local(Identifier.Empty,SystemTypes.Boolean,block);
break;
case NodeType.ExistsUnique:
case NodeType.Count:
case NodeType.Max:
case NodeType.Min:
case NodeType.Product:
case NodeType.Sum:
b = new Local(Identifier.Empty,SystemTypes.Int32,block);
break;
default:
Debug.Assert(false);
return null;
}
#endregion Create local to act as accumulator for the quantifier
if (comprehension.IsDisplay){
#region Display: Generate a separate if-statement for each element
Block endBlock = new Block(new StatementList());
for(int i = 0, n = comprehension.Elements == null ? 0 : comprehension.Elements.Count; i < n; i++){
#region assign the value of the term to b
Statement updateB = null;
switch (quantifier.QuantifierType){
case NodeType.Forall:
updateB = new AssignmentStatement(b,comprehension.Elements[i]);
break;
case NodeType.Exists:
updateB = new AssignmentStatement(b,comprehension.Elements[i]);
break;
case NodeType.ExistsUnique:
case NodeType.Count:
// b := b + (T(i) ? 1 : 0)
updateB = new AssignmentStatement(b,
new BinaryExpression(b,
new TernaryExpression(comprehension.Elements[i], Literal.Int32One, Literal.Int32Zero, NodeType.Conditional, SystemTypes.Int32),
NodeType.Add));
break;
case NodeType.Product:
// b := b * T(i)
updateB = new AssignmentStatement(b, new BinaryExpression(b, comprehension.Elements[i], NodeType.Mul));
break;
case NodeType.Sum:
// b := b + T(i)
updateB = new AssignmentStatement(b, new BinaryExpression(b, comprehension.Elements[i], NodeType.Add));
break;
case NodeType.Max:
// b := b < T(i) ? T(i) : b
updateB = new AssignmentStatement(b,
new TernaryExpression(new BinaryExpression(b, comprehension.Elements[i], NodeType.Lt, SystemTypes.Boolean),
comprehension.Elements[i], b, NodeType.Conditional, SystemTypes.Int32));
break;
case NodeType.Min:
// b := b > T(i) ? T(i) : b
updateB = new AssignmentStatement(b,
new TernaryExpression(new BinaryExpression(b, comprehension.Elements[i], NodeType.Gt, SystemTypes.Boolean),
comprehension.Elements[i], b, NodeType.Conditional, SystemTypes.Int32));
break;
default:
Debug.Assert(false);
return null;
}
block.Statements.Add(updateB);
#endregion assign the value of the term to b
#region Test to see if loop should terminate early
Expression condition = null;
switch (quantifier.QuantifierType){
case NodeType.Forall:
condition = new UnaryExpression(b, NodeType.LogicalNot, SystemTypes.Boolean);
block.Statements.Add(new Branch(condition, endBlock));
break;
case NodeType.Exists:
condition = b;
block.Statements.Add(new Branch(condition, endBlock));
break;
case NodeType.ExistsUnique:
condition = new BinaryExpression(b,Literal.Int32One,NodeType.Gt,SystemTypes.Boolean);
break;
case NodeType.Count:
case NodeType.Max:
case NodeType.Min:
case NodeType.Product:
case NodeType.Sum:
condition = Literal.False; // no short-circuit!! Need to evaluate all of the terms!
break;
default:
Debug.Assert(false);
return null;
}
#endregion Test to see if loop should terminate early
}
block.Statements.Add(endBlock);
#endregion Display: Generate a separate if-statement for each element
}else {
#region "True" comprehension
#region assign the value of the term to the accumulator
Statement updateB = null;
switch (quantifier.QuantifierType){
case NodeType.Forall:
// b := T(i);
updateB = new AssignmentStatement(b,comprehension.Elements[0]);
break;
case NodeType.Exists:
// b := T(i);
updateB = new AssignmentStatement(b,comprehension.Elements[0]);
break;
case NodeType.ExistsUnique:
case NodeType.Count:
// b := b + T(i) ? 1 : 0; // TODO: is it better to try and generate "b += ..."?
updateB = new AssignmentStatement(b,
new BinaryExpression(b,
new TernaryExpression(comprehension.Elements[0],Literal.Int32One,Literal.Int32Zero,NodeType.Conditional,SystemTypes.Int32),
NodeType.Add));
break;
case NodeType.Product:
// b := b * T(i)
updateB = new AssignmentStatement(b,
new BinaryExpression(b, comprehension.Elements[0], NodeType.Mul));
break;
case NodeType.Sum:
// b := b + T(i)
updateB = new AssignmentStatement(b,
new BinaryExpression(b, comprehension.Elements[0], NodeType.Add));
break;
case NodeType.Max:
// b := b < T(i) ? T(i) : b
updateB = new AssignmentStatement(b,
new TernaryExpression(new BinaryExpression(b, comprehension.Elements[0], NodeType.Lt, SystemTypes.Boolean),
comprehension.Elements[0], b, NodeType.Conditional, SystemTypes.Int32));
break;
case NodeType.Min:
// b := b > T(i) ? T(i) : b
updateB = new AssignmentStatement(b,
new TernaryExpression(new BinaryExpression(b, comprehension.Elements[0], NodeType.Gt, SystemTypes.Boolean),
comprehension.Elements[0], b, NodeType.Conditional, SystemTypes.Int32));
break;
default:
Debug.Assert(false);
return null;
}
block.Statements.Add(updateB);
#endregion assign the value of the term to the accumulator
#region Generate the "foreach" and "if P(x)" parts
for (int i = comprehension.BindingsAndFilters.Count - 1; i >= 0; i--) {
ComprehensionBinding binding = comprehension.BindingsAndFilters[i] as ComprehensionBinding ;
if (binding != null){
#region Test to see if loop should terminate early
Expression condition = null;
switch (quantifier.QuantifierType){
case NodeType.Forall:
condition = new UnaryExpression(b,NodeType.LogicalNot,SystemTypes.Boolean);
break;
case NodeType.Exists:
condition = b;
break;
case NodeType.ExistsUnique:
condition = new BinaryExpression(b,Literal.Int32One,NodeType.Gt,SystemTypes.Boolean);
break;
case NodeType.Count:
case NodeType.Max:
case NodeType.Min:
case NodeType.Product:
case NodeType.Sum:
condition = Literal.False; // no short-circuit!! Need to evaluate all of the terms!
break;
default:
Debug.Assert(false);
return null;
}
block.Statements.Add(new If(condition,new Block(new StatementList(new Exit())),null));
#endregion Test to see if loop should terminate early
#region Wrap everything so far into a loop (either for or foreach)
Expression forEachTargetVariable = binding.TargetVariable;
if (binding.AsTargetVariableType != null){
Local l = new Local(Identifier.For("SS$dummyForEachVar"),binding.SourceEnumerable.Type,block);
forEachTargetVariable = l;
Block b2 = new Block(new StatementList(2));
b2.Statements.Add(new AssignmentStatement(binding.TargetVariable,
new BinaryExpression(l,new MemberBinding(null,binding.AsTargetVariableType),NodeType.Isinst,binding.AsTargetVariableType)));
b2.Statements.Add(new If(new BinaryExpression(binding.TargetVariable,new Literal(null,SystemTypes.Type),NodeType.Ne),
block,null));
block = b2;
}
if (binding.SourceEnumerable== null)
return null;
CollectionEnumerator ce = binding.SourceEnumerable as CollectionEnumerator;
UnaryExpression u = ce == null ? null : ce.Collection as UnaryExpression;
BinaryExpression be = u == null ? null : u.Operand as BinaryExpression;
if (be != null && be.NodeType == NodeType.Range){
// implement Range with a for-loop
AssignmentStatement init = new AssignmentStatement(forEachTargetVariable,be.Operand1);
AssignmentStatement incr = new AssignmentStatement(forEachTargetVariable,
new BinaryExpression(forEachTargetVariable,new Literal(1,SystemTypes.Int32),NodeType.Add,SystemTypes.Int32));
Expression cond = new BinaryExpression(forEachTargetVariable,be.Operand2,NodeType.Le,SystemTypes.Boolean);
#region Add loop invariant "be.Operand1 <= forEachTargetVariable"
Block invariantBlock = new Block(new StatementList());
Assertion assertion = new Assertion(new BinaryExpression(be.Operand1, forEachTargetVariable, NodeType.Le, SystemTypes.Boolean));
assertion.SourceContext = be.SourceContext;
foreach (Statement s in this.SerializeAssertion(this.currentModule, assertion.Condition, "For loop index must be at least first operand of range.", assertion.SourceContext, "LoopInvariant")) {
invariantBlock.Statements.Add(s);
}
// need to put the generated invariants in the for-loop's condition because that's where VisitFor
// puts any user-declared invariants.
invariantBlock.Statements.Add(new ExpressionStatement(cond, cond.SourceContext));
cond = new BlockExpression(invariantBlock, SystemTypes.Boolean);
#endregion
For forloop = new For(new StatementList(init),cond,new StatementList(incr),block);
block = new Block(new StatementList(forloop));
}else{
// Just use the source enumerable as an IEnumerable in a foreach loop
ForEach fe = new ForEach(binding.SourceEnumerable.Type,forEachTargetVariable,binding.SourceEnumerable,block);
fe.ScopeForTemporaryVariables = binding.ScopeForTemporaryVariables;
block = new Block(new StatementList(fe));
}
#endregion Wrap everything so far into a loop (either for or foreach)
}else{ // it's a filter
block = new Block(new StatementList(new If(comprehension.BindingsAndFilters[i],block,null)));
}
}
#endregion
#endregion
}
#region Choose initial value for accumulator
Literal initialValue = null;
switch (quantifier.QuantifierType){
case NodeType.Forall:
initialValue = Literal.True;
break;
case NodeType.Exists:
initialValue = Literal.False;
break;
case NodeType.ExistsUnique:
case NodeType.Count:
case NodeType.Sum:
initialValue = Literal.Int32Zero;
break;
case NodeType.Product:
initialValue = Literal.Int32One;
break;
case NodeType.Max:
initialValue = new Literal(Int32.MinValue, SystemTypes.Int32);
break;
case NodeType.Min:
initialValue = new Literal(Int32.MaxValue, SystemTypes.Int32);
break;
default:
Debug.Assert(false);
return null;
}
#endregion Choose initial value for accumulator
#region Set the return value of the quantifier
Expression valueToReturn = null;
switch (quantifier.QuantifierType){
case NodeType.Forall:
valueToReturn = b;
break;
case NodeType.Exists:
valueToReturn = b;
break;
case NodeType.ExistsUnique:
valueToReturn = new BinaryExpression(b,Literal.Int32One,NodeType.Eq,SystemTypes.Boolean);
break;
case NodeType.Count:
case NodeType.Max:
case NodeType.Min:
case NodeType.Product:
case NodeType.Sum:
valueToReturn = b;
break;
default:
Debug.Assert(false);
return null;
}
#endregion Set the boolean to return as the value of the quantifier
BlockExpression returnBlock = new BlockExpression(
new Block(new StatementList(
new AssignmentStatement(b,initialValue),
block,
new ExpressionStatement(valueToReturn))),
SystemTypes.Boolean,comprehension.SourceContext);
if (this.quantifiedVarStack == null) this.quantifiedVarStack = new System.Collections.Generic.Stack<ExpressionList>();
this.quantifiedVarStack.Push(comprehension.BindingsAndFilters);
Expression result = this.VisitBlockExpression(returnBlock);
this.quantifiedVarStack.Pop();
return result;
}
// {1,2,3} ==>
// { [ / (IList/IDictionary) t = new T(); ]
// [ yield return 1 / t.Add(1) ];
// ...
// [ / return (T) t ];
// }
// { T1 x in A, P(x); B(x) ; default } ==>
// { [ /(IList/IDictionary) t = new T(); ]
// bool empty = true; // only for compr. with default
// foreach(T1 x in A) { if P(x){ empty = false; [ yield return B(x) / t.Add(B(x)) ];} }
// if (empty) [ yield return default / t.Add(default) ]; // only for compr. with default
// [ / return (T)t];
// }
public override Expression VisitComprehension(Comprehension comprehension){
if (comprehension == null) return null;
Block b = new Block(new StatementList()); // return value from this visitor
Expression empty = null; // will be either a local or a field
#region Local variables used when in a non-Enumerable context.
// TODO: could be a structure, not a class!! (at least write some test cases)
TypeNode nonEnumClass = null;
Local retVal = null;
Method addMethod = null;
NodeType addMethodCallType = NodeType.Callvirt; // assume virtual calls
bool useIListMethods = false;
// use a local so it is evaluated only once in case of side-effects for get_Key and get_Value
Local de = null;
Method keyMethod = null;
Method valueMethod = null;
#endregion
bool defaultIsPresent = !comprehension.IsDisplay && comprehension.Elements.Count > 1;
bool notEnumContext = comprehension.nonEnumerableTypeCtor != null;
#region Set non-Enumerable locals to the appropriate values.
// TODO: Look for these things in Checker and if it can't find them, issue diagnostics
if (notEnumContext){
Method tempM = comprehension.nonEnumerableTypeCtor as Method;
addMethod = comprehension.AddMethod;
if (!addMethod.IsVirtual)
addMethodCallType = NodeType.Call;
keyMethod = SystemTypes.DictionaryEntry.GetMethod(Identifier.For("get_Key"));
valueMethod = SystemTypes.DictionaryEntry.GetMethod(Identifier.For("get_Value"));
if (tempM != null)
nonEnumClass = (Class) tempM.DeclaringType;
else
nonEnumClass = (TypeNode) comprehension.nonEnumerableTypeCtor;
TypeNode elementType = TypeNode.StripModifiers(comprehension.TemporaryHackToHoldType).TemplateArguments[0];
if (this.GetTypeView(nonEnumClass).IsAssignableTo(SystemTypes.IList)){
retVal = new Local(Identifier.For("SS$retVal"),SystemTypes.IList,b);
useIListMethods = true;
} else if ((comprehension.Elements.Count == 0 || this.GetTypeView(elementType).IsAssignableTo(SystemTypes.DictionaryEntry)) && this.GetTypeView(nonEnumClass).IsAssignableTo(SystemTypes.IDictionary)){
retVal = new Local(Identifier.For("SS$retVal"),SystemTypes.IDictionary,b);
useIListMethods = false; // means "use IDictionary methods"
de = new Local(Identifier.For("SS$dictionaryEntry"),SystemTypes.DictionaryEntry,b);
Debug.Assert(de != null && keyMethod != null && valueMethod != null);
} else if ((comprehension.Elements.Count == 0 || this.GetTypeView(elementType).IsAssignableTo(SystemTypes.DictionaryEntry)) && addMethod != null && addMethod.GetParameterTypes().Length == 2){
retVal = new Local(Identifier.For("SS$retVal"),nonEnumClass,b);
useIListMethods = false; // means "use IDictionary methods"
de = new Local(Identifier.For("SS$dictionaryEntry"),SystemTypes.DictionaryEntry,b);
Debug.Assert(de != null && keyMethod != null && valueMethod != null);
} else if (addMethod != null){
retVal = new Local(Identifier.For("SS$retVal"),nonEnumClass,b);
useIListMethods = true;
}
Debug.Assert(retVal != null && addMethod != null);
}
if (defaultIsPresent){
if (notEnumContext){
empty = new Local(Identifier.For("SS$empty"),SystemTypes.Boolean,b);
}else{
Field emptyField = new Field(Identifier.Empty);
Class scope = null;
// defaultIsPresent ==> comprehension.Elements != null
for (int i = 0, n = comprehension.Elements.Count; i < n; i++){
// really it should always be the first one, but better be careful
ComprehensionBinding cb = comprehension.BindingsAndFilters[i] as ComprehensionBinding;
if (cb != null){
scope = cb.ScopeForTemporaryVariables.ClosureClass;
break;
}
}
Debug.Assert(scope != null); //TODO: this assert actually fires
emptyField.DeclaringType = scope;
emptyField.Flags = FieldFlags.CompilerControlled;
emptyField.Name = Identifier.For("SS$empty: "+comprehension.GetHashCode());
emptyField.Type = SystemTypes.Boolean;
scope.Members.Add(emptyField);
empty = new MemberBinding(new ImplicitThis(scope, 0), emptyField);
}
}
#endregion
#region retVal := new T();
if (notEnumContext){
Method m = comprehension.nonEnumerableTypeCtor as Method;
if (m != null)
b.Statements.Add(new AssignmentStatement(retVal,
new Construct(new MemberBinding(null,m),new ExpressionList(),nonEnumClass)));
else{
TypeNode structure = comprehension.nonEnumerableTypeCtor as TypeNode;
b.Statements.Add(new AssignmentStatement(retVal, new Local(StandardIds.NewObj,nonEnumClass))); // !!!! Local normalizes to a pseudo-ctor call for a structure!
}
}
#endregion
#region bool empty := true;
if (defaultIsPresent){
b.Statements.Add(new AssignmentStatement(empty,new Literal(true,SystemTypes.Boolean)));
}
#endregion
#region Generate code for Displays
if (comprehension.IsDisplay){
for (int i = 0, n = comprehension.Elements.Count; i < n; i++){
// Statement s =
// notEnumContext ?
// new ExpressionStatement(new MethodCall(new MemberBinding(retVal,addMethod),new ExpressionList(Box(comprehension.Elements[i])),
// (retVal.Type.IsValueType ? NodeType.Call : NodeType.Callvirt),
// SystemTypes.Int32,comprehension.SourceContext))
// :
// new Yield(comprehension.Elements[i])
// ;
if (useIListMethods){
if (notEnumContext)
b.Statements.Add(new ExpressionStatement(new MethodCall(new MemberBinding(retVal,addMethod),new ExpressionList(Box(comprehension.Elements[i])),
addMethodCallType, SystemTypes.Int32,comprehension.SourceContext)));
else
b.Statements.Add(new Yield(comprehension.Elements[i]));
}else{ // assume IDictionary!
if (notEnumContext) {
b.Statements.Add(new AssignmentStatement(de,comprehension.Elements[i]));
//retval.Add(de.Key,de.Value) (actually, it is "reval.Add(de.get_Key(),de.get_Value())")
b.Statements.Add(
new ExpressionStatement(
new MethodCall(new MemberBinding(retVal,addMethod),
new ExpressionList(
new MethodCall(new MemberBinding(de,keyMethod),new ExpressionList(),NodeType.Call,SystemTypes.Object),
new MethodCall(new MemberBinding(de,valueMethod),new ExpressionList(),NodeType.Call,SystemTypes.Object)),
addMethodCallType,SystemTypes.Void)));
} else
b.Statements.Add(new Yield(comprehension.Elements[i]));
}
}
if (notEnumContext){
if (retVal.Type.IsValueType){
b.Statements.Add(new ExpressionStatement(retVal));
}else{
b.Statements.Add(new ExpressionStatement(new BinaryExpression(retVal,new Literal(nonEnumClass, SystemTypes.Type), NodeType.Castclass,nonEnumClass)));
}
}
if (notEnumContext)
return this.VisitExpression(new BlockExpression(b,retVal.Type));
else
return new BlockExpression(this.VisitBlock(b),SystemTypes.Void);
}
#endregion
#region Generate code for "true" Comprehensions
Block newBlock = new Block(new StatementList(4));
newBlock.HasLocals = true;
TypeNode t = null;
#region empty := false
if (defaultIsPresent){
newBlock.Statements.Add(new AssignmentStatement(empty,new Literal(false,SystemTypes.Boolean)));
}
#endregion
#region either "yield return T(x)" or "t.Add(T(x))"
if (notEnumContext){
if (useIListMethods){
if (comprehension.Elements[0]== null)
return null;
newBlock.Statements.Add(
new ExpressionStatement(
new MethodCall(new MemberBinding(retVal,addMethod),new ExpressionList(Box(comprehension.Elements[0])),addMethodCallType,SystemTypes.Int32,comprehension.Elements[0].SourceContext)));
}else{ // assume IDictionary!
newBlock.Statements.Add(new AssignmentStatement(de,comprehension.Elements[0]));
//retval.Add(de.Key,de.Value) (actually, it is "reval.Add(de.get_Key(),de.get_Value())")
newBlock.Statements.Add(
new ExpressionStatement(
new MethodCall(new MemberBinding(retVal,addMethod),
new ExpressionList(
new MethodCall(new MemberBinding(de,keyMethod),new ExpressionList(),NodeType.Call,SystemTypes.Object),
new MethodCall(new MemberBinding(de,valueMethod),new ExpressionList(),NodeType.Call,SystemTypes.Object)),
addMethodCallType,SystemTypes.Void)));
}
}else{
newBlock.Statements.Add(new Yield(comprehension.Elements[0]));
}
#endregion
#region Generate the "foreach" and "if P(x)" parts
for (int i = comprehension.BindingsAndFilters.Count - 1; i >= 0; i--) {
ComprehensionBinding qb = comprehension.BindingsAndFilters[i] as ComprehensionBinding ;
if (qb != null){
Expression forEachTargetVariable = qb.TargetVariable;
if (qb.SourceEnumerable== null)
return null;
if (qb.AsTargetVariableType != null){
Local l = new Local(Identifier.For("SS$dummyForEachVar"),qb.SourceEnumerable.Type,newBlock);
forEachTargetVariable = l;
Block b2 = new Block(new StatementList(2));
b2.Statements.Add(new AssignmentStatement(qb.TargetVariable,
new BinaryExpression(l,new MemberBinding(null,qb.AsTargetVariableType),NodeType.Isinst,qb.AsTargetVariableType)));
b2.Statements.Add(new If(new BinaryExpression(qb.TargetVariable,new Literal(null,SystemTypes.Type),NodeType.Ne),
newBlock,null));
newBlock = b2;
}
CollectionEnumerator ce = qb.SourceEnumerable as CollectionEnumerator;
UnaryExpression u = ce == null ? null : ce.Collection as UnaryExpression;
BinaryExpression be = u == null ? null : u.Operand as BinaryExpression;
if (be != null && be.NodeType == NodeType.Range){
// implement Range with a for-loop
AssignmentStatement init = new AssignmentStatement(forEachTargetVariable,be.Operand1);
AssignmentStatement incr = new AssignmentStatement(forEachTargetVariable,
new BinaryExpression(forEachTargetVariable,new Literal(1,SystemTypes.Int32),NodeType.Add,SystemTypes.Int32));
Expression cond = new BinaryExpression(forEachTargetVariable,be.Operand2,NodeType.Le,SystemTypes.Boolean);
For forloop = new For(new StatementList(init),cond,new StatementList(incr),newBlock);
newBlock = new Block(new StatementList(forloop));
}else{
// Just use the source enumerable as an IEnumerable in a foreach loop
ForEach fe = new ForEach(qb.SourceEnumerable.Type,forEachTargetVariable,qb.SourceEnumerable,newBlock);
fe.ScopeForTemporaryVariables = qb.ScopeForTemporaryVariables;
newBlock = new Block(new StatementList(fe));
}
}else{ // it's a filter
newBlock = new Block(new StatementList(new If(comprehension.BindingsAndFilters[i],newBlock,null)));
}
}
// Need to normalize any foreach loop and if-stmt we just generated
newBlock = this.VisitBlock(newBlock);
b.Statements.Add(newBlock);
#endregion
if ( comprehension.Mode == ComprehensionMode.Comprehension ) {
#region if (empty) [ yield return default / t.Add(default) ];
if (defaultIsPresent){
Expression addArg = comprehension.Elements[1];
if (useIListMethods){
if (notEnumContext){
newBlock.Statements.Add(
this.VisitIf( // need to normalize it
new If(new BinaryExpression(empty,new Literal(true,SystemTypes.Boolean),NodeType.Eq),
new Block(new StatementList(new ExpressionStatement(
new MethodCall(new MemberBinding(retVal,addMethod),new ExpressionList(Box(addArg)),addMethodCallType,SystemTypes.Int32,comprehension.Elements[0].SourceContext))))
,null)));
}else{
newBlock.Statements.Add(
this.VisitIf( // need to normalize it
new If(new BinaryExpression(empty,new Literal(true,SystemTypes.Boolean),NodeType.Eq),
new Block(new StatementList(new Yield(addArg))),
null)));
}
} else { //assume IDictionary!
if (notEnumContext){
newBlock.Statements.Add(
this.VisitIf( // need to normalize it
new If(new BinaryExpression(empty,new Literal(true,SystemTypes.Boolean),NodeType.Eq),
new Block(new StatementList(new ExpressionStatement(
new MethodCall(new MemberBinding(retVal,addMethod),
new ExpressionList(
new MethodCall(new MemberBinding(addArg,keyMethod),new ExpressionList(),NodeType.Call,SystemTypes.Object),
new MethodCall(new MemberBinding(addArg,valueMethod),new ExpressionList(),NodeType.Call,SystemTypes.Object)),
addMethodCallType,SystemTypes.Void)))),
null)));
} else {
newBlock.Statements.Add(
this.VisitIf( // need to normalize it
new If(new BinaryExpression(empty,new Literal(true,SystemTypes.Boolean),NodeType.Eq),
new Block(new StatementList(new Yield(addArg))),
null)));
}
}
}
#endregion
#region [ / return t];
if (notEnumContext){
if (retVal.Type.IsValueType)
b.Statements.Add(new ExpressionStatement(retVal));
else
b.Statements.Add(new ExpressionStatement(new BinaryExpression(retVal,new Literal(nonEnumClass, SystemTypes.Type), NodeType.Castclass,nonEnumClass)));
}
#endregion
}else{
#region Reduction
Method getValMethod = this.GetTypeView(t).GetMethod(Identifier.For("get_Value"),null);
MethodCall getValCall = new MethodCall(new MemberBinding(new UnaryExpression(retVal, NodeType.AddressOf, retVal.Type.GetReferenceType()),getValMethod),new ExpressionList(),NodeType.Callvirt,SystemTypes.Object,comprehension.Elements[0].SourceContext);
Expression e = null;
if (comprehension.Elements[0].Type.IsValueType) {
e = Unbox(getValCall,comprehension.Elements[0].Type);
}else{
e = new BinaryExpression(getValCall,new Literal(comprehension.Elements[0].Type, SystemTypes.Type), NodeType.Castclass);
}
newBlock.Statements.Add(new ExpressionStatement(e));
#endregion
}
if (notEnumContext)
return this.VisitExpression(new BlockExpression(b,retVal.Type,comprehension.SourceContext));
else
return new BlockExpression(b,SystemTypes.Void,comprehension.SourceContext);
#endregion
}
public virtual void VisitFor(For For)
{
if (For == null) return;
this.VisitStatementList(For.Initializer);
this.VisitLoopInvariantList(For.Invariants);
this.VisitExpression(For.Condition);
this.VisitStatementList(For.Incrementer);
this.VisitBlock(For.Body);
}
public override Statement VisitFor(For For)
{
throw new ApplicationException("unimplemented");
}
void case_936()
#line 6238 "cs-parser.jay"
{
start_block (GetLocation (yyVals[0+yyTop]));
current_block.IsCompilerGenerated = true;
For f = new For (GetLocation (yyVals[-1+yyTop]));
current_block.AddStatement (f);
lbag.AddStatement (f, current_block.StartLocation);
yyVal = f;
}
internal static stmt Convert(Statement stmt) {
stmt ast;
if (stmt is FunctionDefinition)
ast = new FunctionDef((FunctionDefinition)stmt);
else if (stmt is ReturnStatement)
ast = new Return((ReturnStatement)stmt);
else if (stmt is AssignmentStatement)
ast = new Assign((AssignmentStatement)stmt);
else if (stmt is AugmentedAssignStatement)
ast = new AugAssign((AugmentedAssignStatement)stmt);
else if (stmt is DelStatement)
ast = new Delete((DelStatement)stmt);
else if (stmt is PrintStatement)
ast = new Print((PrintStatement)stmt);
else if (stmt is ExpressionStatement)
ast = new Expr((ExpressionStatement)stmt);
else if (stmt is ForStatement)
ast = new For((ForStatement)stmt);
else if (stmt is WhileStatement)
ast = new While((WhileStatement)stmt);
else if (stmt is IfStatement)
ast = new If((IfStatement)stmt);
else if (stmt is WithStatement)
ast = new With((WithStatement)stmt);
else if (stmt is RaiseStatement)
ast = new Raise((RaiseStatement)stmt);
else if (stmt is TryStatement)
ast = Convert((TryStatement)stmt);
else if (stmt is AssertStatement)
ast = new Assert((AssertStatement)stmt);
else if (stmt is ImportStatement)
ast = new Import((ImportStatement)stmt);
else if (stmt is FromImportStatement)
ast = new ImportFrom((FromImportStatement)stmt);
else if (stmt is ExecStatement)
ast = new Exec((ExecStatement)stmt);
else if (stmt is GlobalStatement)
ast = new Global((GlobalStatement)stmt);
else if (stmt is ClassDefinition)
ast = new ClassDef((ClassDefinition)stmt);
else if (stmt is BreakStatement)
ast = new Break();
else if (stmt is ContinueStatement)
ast = new Continue();
else if (stmt is EmptyStatement)
ast = new Pass();
else
throw new ArgumentTypeException("Unexpected statement type: " + stmt.GetType());
ast.GetSourceLocation(stmt);
return ast;
}
void OP_FOR(out pBaseLangObject outObj, pBaseLangObject parent)
{
var obj = new For(parent); outObj = obj; pBaseLangObject blo;
Expect(61);
Expect(10);
if (StartOf(19)) {
CODEINSTRUCTION_SC(out blo, obj);
obj.forArg1 = blo;
}
TERMINATOR();
if (StartOf(3)) {
EXPRESSION(out blo, obj);
obj.forArg2 = blo;
}
TERMINATOR();
if (StartOf(19)) {
CODEINSTRUCTION_SC(out blo, obj);
obj.forArg3 = blo;
}
Expect(11);
if (la.kind == 14) {
Get();
while (StartOf(21)) {
if (StartOf(14)) {
CODEINSTRUCTION(out blo, obj);
obj.addChild(blo);
} else {
OP_BREAK(out blo, obj);
obj.addChild(blo);
TERMINATOR();
}
}
Expect(15);
} else if (StartOf(14)) {
CODEINSTRUCTION(out blo, obj);
obj.addChild(blo);
} else SynErr(107);
}
public virtual Statement VisitFor(For For, For changes, For deletions, For insertions){
this.UpdateSourceContext(For, changes);
if (For == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return For;
}
public override Statement VisitFor(For For)
{
if (For == null) return null;
return base.VisitFor((For)For.Clone());
}
public virtual Statement VisitFor(For For1, For For2)
{
if (For1 == null) return null;
if (For2 == null)
{
For1.Initializer = this.VisitStatementList(For1.Initializer, null);
For1.Invariants = this.VisitExpressionList(For1.Invariants, null);
For1.Condition = this.VisitExpression(For1.Condition, null);
For1.Incrementer = this.VisitStatementList(For1.Incrementer, null);
For1.Body = this.VisitBlock(For1.Body, null);
}
else
{
For1.Initializer = this.VisitStatementList(For1.Initializer, For2.Initializer);
For1.Invariants = this.VisitExpressionList(For1.Invariants, For2.Invariants);
For1.Condition = this.VisitExpression(For1.Condition, For2.Condition);
For1.Incrementer = this.VisitStatementList(For1.Incrementer, For2.Incrementer);
For1.Body = this.VisitBlock(For1.Body, For2.Body);
}
return For1;
}
void case_875()
#line 6733 "ps-parser.jay"
{
lexer.ForInParsing = false;
var locations = (Tuple<Location,Location>) yyVals[-2+yyTop];
For f = new For (locations.Item1);
current_block.AddStatement (f);
var expList = yyVals[-1+yyTop] as List<Expression>;
if (expList != null)
f.Initializer = ExpressionListToStatementList (expList);
else
f.Initializer = (Statement) yyVals[-1+yyTop];
/* Pass the "For" object to the iterator_part4*/
oob_stack.Push (f);
yyVal = f;
}
