public override IStatement VisitForEachStatement(ForEachStatementSyntax node)
{
var s = this.semanticModel.GetDeclaredSymbol(node) as Microsoft.CodeAnalysis.CSharp.Symbols.LocalSymbol;
if (s != null)
{
var local = new LocalDefinition()
{
Name = this.host.NameTable.GetNameFor(s.Name),
MethodDefinition = this.method,
Type = this.mapper.Map(s.Type),
};
this.expressionVisitor.RegisterLocal(s, local);
var body = this.Visit(node.Statement);
var foreachStmt = new ForEachStatement()
{
Body = this.Visit(node.Statement),
Collection = this.expressionVisitor.Visit(node.Expression),
Variable = local,
Locations = Helper.SourceLocation(this.tree, node),
};
if (!(foreachStmt.Collection.Type is IArrayTypeReference))
{
var msg = String.Format("VisitForEachStatement can't handle the type '{0}'", TypeHelper.GetTypeName(foreachStmt.Collection.Type, NameFormattingOptions.None));
throw new InvalidDataException(msg);
}
return(foreachStmt);
}
throw new InvalidDataException("VisitForEachStatement couldn't find something to return");
}
public virtual ICodeNode VisitForEachStatement(ForEachStatement node)
{
node.Variable = (VariableDeclarationExpression)Visit(node.Variable);
node.Collection = (Expression)Visit(node.Collection);
node.Body = (BlockStatement)Visit(node.Body);
return(node);
}
protected override IPyStatement[] VisitForEachStatement(ForEachStatement src)
{
var g = src.VarName;
var collection = TransValue(src.Collection);
var statement = this.TranslateStatementOne(src.Statement);
PyForEachStatement a = null;
if (src.ItemType.DotnetType.IsGenericType)
{
var gtd = src.ItemType.DotnetType.GetGenericTypeDefinition();
if (gtd == typeof(KeyValuePair <,>))
{
a = new PyForEachStatement(src.VarName, collection, statement);
// $i@Key
a.KeyVarname = src.VarName + "@Key";
a.ValueVarname = src.VarName + "@Value";
}
}
if (a == null)
{
a = new PyForEachStatement(src.VarName, collection, statement);
}
return(MkArray(a));
}
public virtual ICodeNode VisitForEachStatement(ForEachStatement node)
{
node.set_Variable((VariableDeclarationExpression)this.Visit(node.get_Variable()));
node.set_Collection((Expression)this.Visit(node.get_Collection()));
node.set_Body((BlockStatement)this.Visit(node.get_Body()));
return(node);
}
public virtual void VisitForEachStatement(ForEachStatement node)
{
this.Visit(node.get_Variable());
this.Visit(node.get_Collection());
this.Visit(node.get_Body());
return;
}
public override void VisitForEachStatement(ForEachStatement node)
{
Append("foreach (var ");
node.Identifier.Accept(this);
Append(" in ");
node.Expression.Accept(this);
Append(")");
NewLine();
Append("{");
Indent();
NewLine();
if (node.Statement is Block)
{
node.Statement.Accept(this);
}
else
{
var block = new Block(node.Statement);
block.Accept(this);
}
Outdent();
Append("}");
}
private void GenerateForeachStatement()
{
if (foreachVariable == null)
{
foreachVariable = new VariableDefinition(foreachVariableType, this.methodContext.Method);
foreachVariableInstructions.Clear();
this.methodContext.VariablesToRename.Add(foreachVariable);
}
VariableDeclarationExpression vd = new VariableDeclarationExpression(foreachVariable, foreachVariableInstructions);
Expression foreachCollectionExpression = foreachCollection.CloneAndAttachInstructions(foreachCollectionInstructions);
if (foreachCollectionExpression is BaseReferenceExpression)
{
foreachCollectionExpression = new ThisReferenceExpression(this.methodContext.Method.DeclaringType, foreachCollectionExpression.UnderlyingSameMethodInstructions);
}
@foreach = new ForEachStatement(vd, foreachCollectionExpression, foreachBody, foreachConditionInstructions, theTry.Finally.UnderlyingSameMethodInstructions);
GetCurrentFixer gcf = new GetCurrentFixer(theEnumerator, foreachVariable);
gcf.Visit(@foreach);
IsEnumeratorUsedVisitor enumeratorUsedVisitor = new IsEnumeratorUsedVisitor(theEnumerator);
enumeratorUsedVisitor.Visit(@foreach);
isEnumeratorUsedInsideForEach = enumeratorUsedVisitor.IsEnumeratorUsed;
}
/// <summary>
/// Factory method for class <see cref="ForEachStatementASTWalker"/>.
/// </summary>
/// <param name="node"><see cref="CSharpSyntaxNode"/> Used to initialize the walker.</param>
/// <param name="semanticModel">The semantic model.</param>
/// <returns></returns>
public static ForEachStatementASTWalker Create(CSharpSyntaxNode node, SemanticModel semanticModel = null)
{
ForEachStatement helper = new ForEachStatement(node as ForEachStatementSyntax);
var statement = ForEachStatementTranslationUnit.Create();
return(new ForEachStatementASTWalker(node, statement, semanticModel));
}
public ForEachExpressionInterpreter(ExpressionInterpreterHandler expressionInterpreterHandler, ForEachStatement forEachStatement, System.Collections.Generic.List <ParameterExpression> scopedLocalVariable, LabelTarget brk, LabelTarget cont)
{
this.expressionInterpreterHandler = expressionInterpreterHandler;
this.forEachStatement = forEachStatement;
this.scopedLocalVariable = scopedLocalVariable;
this.brk = brk;
this.cont = cont;
}
public override ICodeNode VisitForEachStatement(ForEachStatement node)
{
codeNodeTypes.Push(CodeNodeType.BinaryExpression);
node.Variable = (VariableDeclarationExpression)Visit(node.Variable);
codeNodeTypes.Pop();
node.Collection = (Telerik.JustDecompiler.Ast.Expressions.Expression)Visit(node.Collection);
node.Body = (BlockStatement)Visit(node.Body);
return(node);
}
public override ICodeNode VisitForEachStatement(ForEachStatement node)
{
this.codeNodeTypes.Push(24);
node.set_Variable((VariableDeclarationExpression)this.Visit(node.get_Variable()));
dummyVar0 = this.codeNodeTypes.Pop();
node.set_Collection((Expression)this.Visit(node.get_Collection()));
node.set_Body((BlockStatement)this.Visit(node.get_Body()));
return(node);
}
public object VisitForEachStatement(ForEachStatement s, object context)
{
StringBuilder.Append("foreach (var ");
StringBuilder.Append(s.Variable.Content);
StringBuilder.Append(" : ");
s.Collection.AcceptVisitor(this, context);
StringBuilder.Append(") ");
s.Body.AcceptVisitor(this, context);
return(null);
}
public override void VisitForEachStatement(ForEachStatement node)
{
expressions.Push(ExpressionKind.ForEachVariable);
Visit(node.Variable);
expressions.Pop();
expressions.Push(ExpressionKind.ForEachExpression);
Visit(node.Collection);
expressions.Pop();
ClearPendingForSuggestion();
Visit(node.Body);
}
protected override void VisitForEachStatement(ForEachStatement tree)
{
_TrySetResult(tree);
if (_result != null)
{
return;
}
VisitAnySyntaxTree(tree.exp);
VisitAnySyntaxTree(tree.block);
}
public override void VisitForEachStatement(ForEachStatement node)
{
this.expressions.Push(2);
this.Visit(node.get_Variable());
dummyVar0 = this.expressions.Pop();
this.expressions.Push(3);
this.Visit(node.get_Collection());
dummyVar1 = this.expressions.Pop();
this.ClearPendingForSuggestion();
this.Visit(node.get_Body());
return;
}
protected override object VisitForEachStatement(ForEachStatementSyntax node)
{
var collection = InternalVisitExpression(node.Expression);
#if ROSLYN
var info1 = ModelExtensions.GetDeclaredSymbol(context.RoslynModel, node);
var info = info1 as ILocalSymbol;
if (info == null)
{
throw new ArgumentNullException("info");
}
var rosType = context.Roslyn_ResolveType(info.Type);
var loopVariableType = new LangType(rosType);
var loopVariableName = info.Name;
#else
var type = _VisitExpression(node.Type);
if (type is UnknownIdentifierValue)
{
var xx = type as UnknownIdentifierValue;
if (xx.Identifier == "var")
{
var et = TypesUtil.GetEnumerateItemType(collection.ValueType);
type = new TypeValue(et);
}
else
{
throw new NotSupportedException();
}
}
Debug.Assert(type is TypeValue);
Debug.Assert((type as TypeValue).DotnetType == rosType);
var loopVariableType = new LangType((type as TypeValue).DotnetType);
var loopVariableName = _Name(node.Identifier);
#endif
var ps = new VariableDeclaration(
loopVariableType,
new[]
{
new VariableDeclarator(loopVariableName, null, null)
}
);
return(context.DoWithLocalVariables(ps,
() =>
{
var stat = Visit(node.Statement);
Debug.Assert(stat is IStatement);
var g = new ForEachStatement(loopVariableType, loopVariableName, collection, stat as IStatement);
return g;
}));
}
/// <summary>
/// Visits the specified for each statement.
/// </summary>
/// <param name="forEachStatement">For each statement.</param>
public override void Visit(ForEachStatement forEachStatement)
{
WriteLinkLine(forEachStatement);
if (forEachStatement.Variable == null)
{
localVariableCount++;
Identifier parameterType;
Identifier parameterMember;
if (!TryParameters(forEachStatement.Collection, out parameterType, out parameterMember))
{
Write(@"#error ""Unexpected parameter for 'foreach params' [");
VisitDynamic(forEachStatement.Collection);
WriteLine(@"]. Expecting single property access""");
return;
}
string variable = "____" + localVariableCount;
Write("foreach(").Write("var ").Write(variable).Write(" in ");
VisitDynamic(forEachStatement.Collection);
WriteLine(")");
var statement = forEachStatement.Body as BlockStatement;
if (statement == null)
{
statement = new BlockStatement {
Span = forEachStatement.Body.Span
};
statement.Statements.Add(forEachStatement.Body);
}
AddPushPopParameters(statement, parameterType, parameterMember, new VariableReferenceExpression(variable), forEachStatement.Span);
VisitDynamic(statement);
localVariableCount--;
}
else
{
Write("foreach(");
IsVisitingVariableInlines = true;
VisitDynamic(forEachStatement.Variable);
IsVisitingVariableInlines = false;
Write(" in ");
VisitDynamic(forEachStatement.Collection);
Write(")");
WriteLine();
VisitDynamic(forEachStatement.Body);
}
}
public override void VisitForEachStatement(ForEachStatement node)
{
WriteKeyword("foreach");
WriteSpace();
WriteToken("(");
Visit(node.Variable);
WriteSpace();
WriteKeyword("in");
WriteSpace();
Visit(node.Expression);
WriteToken(")");
WriteLine();
Visit(node.Body);
}
private void ClearState()
{
insideTry = false;
foundEnumeratorAssignment = false;
foundWhile = false;
foreachCollection = null;
foreachVariable = null;
foreachVariableInstructions.Clear();
foreachCollectionInstructions.Clear();
foreachBody = new BlockStatement();
theEnumerator = null;
theTry = null;
@foreach = null;
enumeratorAssignmentStatement = null;
foreachVariableType = null;
isEnumeratorUsedInsideForEach = false;
foreachConditionInstructions = null;
}
public virtual T Visit(ForEachStatement stmt) => Visit(stmt as Statement);
private Statement ParseForEach(TokenSet followers)
//^ requires this.currentToken == Token.Foreach;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
this.GetNextToken();
this.Skip(Token.LeftParenthesis);
TypeExpression variableType = this.ParseTypeExpression(false, false, followers|Parser.IdentifierOrNonReservedKeyword|Token.In|Token.RightParenthesis);
if (this.currentToken == Token.In)
this.HandleError(Error.BadForeachDecl);
NameDeclaration variableName = this.ParseNameDeclaration();
this.Skip(Token.In);
Expression collection = this.ParseExpression(followers|Token.RightParenthesis);
this.Skip(Token.RightParenthesis);
Statement body = this.ParseStatement(followers);
slb.UpdateToSpan(body.SourceLocation);
ForEachStatement result = new ForEachStatement(variableType, variableName, collection, body, slb);
//^ assume followers[this.currentToken] || this.currentToken == Token.EndOfFile;
return result;
}
public virtual void VisitForEachStatement(ForEachStatement node)
{
Visit(node.Variable);
Visit(node.Collection);
Visit(node.Body);
}
private Statement ParseForEach(SourceLocationBuilder slb, TokenSet followers)
//^ requires this.currentToken == Token.Each;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
this.GetNextToken();
NameDeclaration variableName = this.ParseNameDeclaration();
this.Skip(Token.In);
Expression collection = this.ParseExpression(followers|Token.EndOfLine);
this.Skip(Token.EndOfLine);
BlockStatement body = this.ParseStatementBlock(followers|Token.Next);
slb.UpdateToSpan(body.SourceLocation);
TypeExpression variableType = new NamedTypeExpression(new SimpleName(this.nameTable.GetNameFor("var"), SourceDummy.SourceLocation, false));
ForEachStatement result = new ForEachStatement(variableType, variableName, collection, body, slb);
this.SkipClosingKeyword(Token.Next, followers);
return result;
}
/**
* Call back method that must be called as soon as the given <code>
* ForEachStatement</code> object has been traversed.
*
* @param pForEachStatement The <code>ForEachStatement</code> object that
* has just been traversed.
*/
public void actionPerformed(
ForEachStatement pForEachStatement)
{
// Nothing to do.
}
private void AddArrayField(ClassDeclaration c, FieldInfo f)
{
// create a collection
ClassDeclaration col = c.AddClass(conformer.ToSingular(f.Name) + "Collection");
col.Parent = new TypeTypeDeclaration(typeof(System.Collections.CollectionBase));
// add serializable attribute
col.CustomAttributes.Add(typeof(SerializableAttribute));
// default constructor
col.AddConstructor();
// default indexer
IndexerDeclaration index = col.AddIndexer(
typeof(Object)
);
ParameterDeclaration pindex = index.Signature.Parameters.Add(typeof(int), "index", false);
// getter
index.Get.Return(
Expr.This.Prop("List").Item(Expr.Arg(pindex))
);
index.Set.AddAssign(
Expr.This.Prop("List").Item(Expr.Arg(pindex)),
Expr.Value
);
// add object method
MethodDeclaration addObject = col.AddMethod("Add");
ParameterDeclaration paraObject = addObject.Signature.Parameters.Add(new TypeTypeDeclaration(typeof(Object)), "o", true);
addObject.Body.Add(
Expr.This.Prop("List").Method("Add").Invoke(paraObject)
);
// if typed array add methods for type
if (f.FieldType.GetElementType() != typeof(Object))
{
AddCollectionMethods(
col,
MapType(f.FieldType.GetElementType()),
this.conformer.ToCapitalized(f.FieldType.GetElementType().Name),
"o"
);
}
foreach (XmlElementAttribute ea in f.GetCustomAttributes(typeof(XmlElementAttribute), true))
{
string name = this.conformer.ToCapitalized(ea.ElementName);
string pname = this.conformer.ToCamel(name);
ITypeDeclaration mappedType = null;
if (ea.Type != null)
{
mappedType = MapType(ea.Type);
}
if (mappedType == null || mappedType == f.FieldType.GetElementType())
{
continue;
}
AddCollectionMethods(col, mappedType, name, pname);
}
// add field
FieldDeclaration fd = c.AddField(col, f.Name);
fd.InitExpression = Expr.New(col);
PropertyDeclaration p = c.AddProperty(fd, f.Name, true, true, false);
// setting attributes
// attach xml text
if (TypeHelper.HasCustomAttribute(f, typeof(XmlTextAttribute)))
{
AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlTextAttribute));
attr.Arguments.Add("Type", Expr.TypeOf(typeof(string)));
// adding to string to collection
MethodDeclaration tostring = col.AddMethod("ToString");
tostring.Signature.ReturnType = new TypeTypeDeclaration(typeof(String));
tostring.Attributes = MemberAttributes.Public | MemberAttributes.Override;
VariableDeclarationStatement sw = Stm.Var(typeof(StringWriter), "sw");
sw.InitExpression = Expr.New(typeof(StringWriter));
tostring.Body.Add(sw);
ForEachStatement fe = Stm.ForEach(
typeof(string), "s", Expr.This.Prop("List"), false);
fe.Body.Add(
Expr.Var(sw).Method("Write").Invoke(fe.Local)
);
tostring.Body.Add(fe);
tostring.Body.Return(Expr.Var(sw).Method("ToString").Invoke());
}
else if (TypeHelper.HasCustomAttribute(f, typeof(XmlArrayItemAttribute)))
{
// add xml array attribute
AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlArrayAttribute));
attr.Arguments.Add("ElementName", Expr.Prim(f.Name));
// add array item attribute
XmlArrayItemAttribute arrayItem =
(XmlArrayItemAttribute)TypeHelper.GetFirstCustomAttribute(f, typeof(XmlArrayItemAttribute));
attr = p.CustomAttributes.Add(typeof(XmlArrayItemAttribute));
attr.Arguments.Add("ElementName", Expr.Prim(arrayItem.ElementName));
//MMI:attr.Arguments.Add("Type",Expr.Prim(MapType(f.FieldType.GetElementType()).Name));
attr.Arguments.Add("Type", Expr.TypeOf(MapType(f.FieldType.GetElementType())));
if (arrayItem.Type != null)
{
attr.Arguments.Add("DataType", Expr.Prim(arrayItem.DataType));
}
attr.Arguments.Add("IsNullable", Expr.Prim(arrayItem.IsNullable));
if (this.Config.KeepNamespaces)
{
attr.Arguments.Add("Namespace", Expr.Prim(arrayItem.Namespace));
}
}
else
{
AttachXmlElementAttributes(p, f);
}
}
/// <summary>
/// Creates a ForStatement with the same behavior
/// </summary>
/// <param name="forEachStatement">the ForEachStatement</param>
/// <returns>the ForStatement</returns>
private static ForStatement ExpandForEachStatement(ForEachStatement forEachStatement)
{
if (forEachStatement != null)
{
var collec = forEachStatement.Collection.TypeInference.Declaration as Variable;
LiteralExpression dimLit = null;
if (collec.Type is ArrayType)
{
if ((collec.Type as ArrayType).Dimensions.Count == 1)
{
dimLit = (collec.Type as ArrayType).Dimensions[0] as LiteralExpression;
}
}
if (dimLit != null)
{
var initializer = new Variable(ScalarType.Int, forEachStatement.Variable.Name.Text + "Iter", new LiteralExpression(0));
var vre = new VariableReferenceExpression(initializer.Name);
var condition = new BinaryExpression(BinaryOperator.Less, vre, dimLit);
var next = new UnaryExpression(UnaryOperator.PreIncrement, vre);
ForStatement forStatement = new ForStatement(new DeclarationStatement(initializer), condition, next);
var body = new BlockStatement();
var variable = forEachStatement.Variable;
variable.InitialValue = new IndexerExpression(forEachStatement.Collection, new VariableReferenceExpression(initializer));
body.Statements.Add(new DeclarationStatement(variable));
if (forEachStatement.Body is BlockStatement)
body.Statements.AddRange((forEachStatement.Body as BlockStatement).Statements);
else
body.Statements.Add(forEachStatement.Body);
forStatement.Body = body;
return forStatement;
}
// TODO: multidimension-array?
// TODO: unroll?
// TODO: multiple foreach?
}
return null;
}
/**
* Call back method that must be called when the given <code>
* ForEachStatement</code> will become the next <i>traverse candidate</i>.
*
* @param pForEachStatement The <code>ForEachStatement</code> object that
* will become the next <i>traverse candidate</i>.
*/
public void performAction(
ForEachStatement pForEachStatement)
{
// Nothing to do.
}
private void Process_ForEach_Statement(StringBuilder sb, ForEachStatement statement)
{
sb.Append("foreach(");
// Variable
Process_Local_Variable_Declaration(sb, statement.VariableDeclaration as LocalVariableDeclaration);
sb.Append(" in ");
sb.Append(FormatExpression(statement.Expression));
sb.Append(") ");
sb.Append(ProcessStatement(statement.Statement));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public virtual void VisitForEachStatement(ForEachStatement statement)
{
VisitAbstractStatement(statement);
}
public virtual ForEachStatement RewriteForEachStatement(ForEachStatement statement)
{
return(statement);
}
/// <summary>
/// Visits the specified for each statement.
/// </summary>
/// <param name="forEachStatement">For each statement.</param>
public override void Visit(ForEachStatement forEachStatement)
{
WriteLinkLine(forEachStatement);
if (forEachStatement.Variable == null)
{
localVariableCount++;
Identifier parameterType;
Identifier parameterMember;
if (!TryParameters(forEachStatement.Collection, out parameterType, out parameterMember))
{
Write(@"#error ""Unexpected parameter for 'foreach params' [");
VisitDynamic(forEachStatement.Collection);
WriteLine(@"]. Expecting single property access""");
return;
}
string variable = "____" + localVariableCount;
Write("foreach(").Write("var ").Write(variable).Write(" in ");
VisitDynamic(forEachStatement.Collection);
WriteLine(")");
var statement = forEachStatement.Body as BlockStatement;
if (statement == null)
{
statement = new BlockStatement {Span = forEachStatement.Body.Span};
statement.Statements.Add(forEachStatement.Body);
}
AddPushPopParameters(statement, parameterType, parameterMember, new VariableReferenceExpression(variable), forEachStatement.Span);
VisitDynamic(statement);
localVariableCount--;
}
else
{
Write("foreach(");
IsVisitingVariableInlines = true;
VisitDynamic(forEachStatement.Variable);
IsVisitingVariableInlines = false;
Write(" in ");
VisitDynamic(forEachStatement.Collection);
Write(")");
WriteLine();
VisitDynamic(forEachStatement.Body);
}
}
protected abstract void VisitForEachStatement(ForEachStatement tree);
public ClassDeclaration AddClass(NamespaceDeclaration ns)
{
ClassDeclaration col = ns.AddClass(this.CollectionName);
// set base class as CollectionBase
col.Parent = new TypeTypeDeclaration(typeof(CollectionBase));
// default constructor
col.AddConstructor();
// add indexer
if (this.ItemGet || this.ItemSet)
{
IndexerDeclaration index = col.AddIndexer(
this.Type
);
ParameterDeclaration pindex = index.Signature.Parameters.Add(typeof(int), "index", false);
// get body
if (this.ItemGet)
{
index.Get.Return(
(Expr.This.Prop("List").Item(Expr.Arg(pindex)).Cast(this.Type)
)
);
}
// set body
if (this.ItemSet)
{
index.Set.Add(
Stm.Assign(
Expr.This.Prop("List").Item(Expr.Arg(pindex)),
Expr.Value
)
);
}
}
string pname = ns.Conformer.ToCamel(this.Type.Name);
// add method
if (this.Add)
{
MethodDeclaration add = col.AddMethod("Add");
ParameterDeclaration para = add.Signature.Parameters.Add(this.Type, pname, true);
add.Body.Add(
Expr.This.Prop("List").Method("Add").Invoke(para)
);
}
if (this.AddRange)
{
MethodDeclaration add = col.AddMethod("AddRange");
ParameterDeclaration para = add.Signature.Parameters.Add(col, pname, true);
ForEachStatement fe = Stm.ForEach(
this.Type,
"item",
Expr.Arg(para),
false
);
fe.Body.Add(
Expr.This.Prop("List").Method("Add").Invoke(fe.Local)
);
add.Body.Add(fe);
}
// contains method
if (this.Contains)
{
MethodDeclaration contains = col.AddMethod("Contains");
contains.Signature.ReturnType = new TypeTypeDeclaration(typeof(bool));
ParameterDeclaration para = contains.Signature.Parameters.Add(this.Type, pname, true);
contains.Body.Return(
Expr.This.Prop("List").Method("Contains").Invoke(para)
);
}
// remove method
if (this.Remove)
{
MethodDeclaration remove = col.AddMethod("Remove");
ParameterDeclaration para = remove.Signature.Parameters.Add(this.Type, pname, true);
remove.Doc.Summary.AddText("Removes the first occurrence of a specific ParameterDeclaration from this ParameterDeclarationCollection.");
remove.Body.Add(
Expr.This.Prop("List").Method("Remove").Invoke(para)
);
}
// insert
if (this.Insert)
{
MethodDeclaration insert = col.AddMethod("Insert");
ParameterDeclaration index = insert.Signature.Parameters.Add(typeof(int), "index", true);
ParameterDeclaration para = insert.Signature.Parameters.Add(this.Type, pname, true);
insert.Body.Add(
Expr.This.Prop("List").Method("Insert").Invoke(index, para)
);
}
// indexof
if (this.IndexOf)
{
MethodDeclaration indexof = col.AddMethod("IndexOf");
ParameterDeclaration para = indexof.Signature.Parameters.Add(this.Type, pname, true);
indexof.Signature.ReturnType = new TypeTypeDeclaration(typeof(int));
indexof.Body.Return(
Expr.This.Prop("List").Method("IndexOf").Invoke(para)
);
}
if (this.Enumerator)
{
// create subclass
ClassDeclaration en = col.AddClass("Enumerator");
// add wrapped field
FieldDeclaration wrapped = en.AddField(
typeof(IEnumerator), "wrapped"
);
// add IEnumerator
en.Interfaces.Add(typeof(IEnumerator));
// add constructor
ConstructorDeclaration cs = en.AddConstructor();
ParameterDeclaration collection = cs.Signature.Parameters.Add(col, "collection", true);
cs.Body.Add(
Stm.Assign(
Expr.This.Field(wrapped),
Expr.Arg(collection).Cast(typeof(CollectionBase)).Method("GetEnumerator").Invoke()
)
);
// add current
PropertyDeclaration current = en.AddProperty(this.Type, "Current");
current.Get.Return(
(Expr.This.Field(wrapped).Prop("Current")).Cast(this.Type)
);
// add explicit interface implementation
PropertyDeclaration currentEn = en.AddProperty(typeof(Object), "Current");
currentEn.Get.Return(Expr.This.Prop(current));
currentEn.PrivateImplementationType = wrapped.Type;
// add reset
MethodDeclaration reset = en.AddMethod("Reset");
reset.ImplementationTypes.Add(wrapped.Type);
reset.Body.Add(Expr.This.Field(wrapped).Method("Reset").Invoke());
// add movenext
MethodDeclaration movenext = en.AddMethod("MoveNext");
movenext.ImplementationTypes.Add(wrapped.Type);
movenext.Signature.ReturnType = new TypeTypeDeclaration(typeof(bool));
movenext.Body.Return(Expr.This.Field(wrapped).Method("MoveNext").Invoke());
// add get enuemrator
MethodDeclaration geten = col.AddMethod("GetEnumerator");
geten.Attributes |= MemberAttributes.New;
geten.ImplementationTypes.Add(new TypeTypeDeclaration(typeof(IEnumerable)));
geten.Signature.ReturnType = en;
geten.Body.Return(Expr.New(en, Expr.This));
}
return(col);
}
/// <summary>
/// Visits the ForEachStatement Node and collects information from it.
/// </summary>
/// <param name="forEachStatement">The ForEachStatement</param>
public override Node Visit(ForEachStatement forEachStatement)
{
if (expandForEachStatements)
{
// run analysis on collection
VisitDynamic(forEachStatement.Collection);
var inference = forEachStatement.Collection.TypeInference.Declaration as Variable;
if (!(inference != null && inference.Type is ArrayType))
return forEachStatement;
if ((inference.Type as ArrayType).Dimensions.Count > 1)
{
Error(XenkoMessageCode.ErrorMultiDimArray, forEachStatement.Span, inference, forEachStatement, analyzedModuleMixin.MixinName);
return forEachStatement;
}
var dim = (int)((inference.Type as ArrayType).Dimensions.FirstOrDefault() as LiteralExpression).Value;
var result = new StatementList();
for (int i = 0; i < dim; ++i)
{
var cloned = forEachStatement.DeepClone();
var replace = new XenkoReplaceExtern(cloned.Variable, new IndexerExpression(cloned.Collection, new LiteralExpression(i)));
replace.Run(cloned.Body);
result.Add(cloned.Body);
}
VisitDynamic(result);
return result;
}
else
{
base.Visit(forEachStatement);
parsingInfo.ForEachStatements.Add(new StatementNodeCouple(forEachStatement, ParentNode));
return forEachStatement;
}
}
public YieldStateMachineCodeRemover(ForEachStatement @foreach, VariableReference enumeratorVariable)
{
this.@foreach = @foreach;
this.enumeratorVariable = enumeratorVariable;
}
public override ICodeNode VisitForEachStatement(ForEachStatement node)
{
node.set_Collection((Expression)this.Visit(node.get_Collection()));
return(node);
}
public override void VisitForEachStatement(ForEachStatement node)
{
return;
}
public override void VisitForEachStatement(ForEachStatement node)
{
this.Visit(node.get_Collection());
return;
}