void AddReadAllGroup(Class serializer, Block block, TypeNode type, StatementList statements, Identifier reader,
Expression target, Expression required, Expression result, ArrayList members, Member mixedMember) {
// todo: keep track of which members have been read and report error on duplicates
MethodCall read = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Read")), new ExpressionList());
Local sb = new Local(SystemTypes.StringBuilder);
bool isMixed = mixedMember != null;
if (isMixed) {
statements.Add(new AssignmentStatement(sb,
new Construct(new MemberBinding(null, SystemTypes.StringBuilder), new ExpressionList(), SystemTypes.StringBuilder)));
}
Block whileBody = new Block(new StatementList());
BinaryExpression notEndTag = new BinaryExpression(
new QualifiedIdentifier(reader, Identifier.For("NodeType")) ,
new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("EndElement")), NodeType.Ne);
BinaryExpression notEOF = new BinaryExpression(
new QualifiedIdentifier(reader, Identifier.For("EOF")), Literal.True, NodeType.Ne);
While w = new While(new BinaryExpression(notEndTag, notEOF, NodeType.And), whileBody);
statements.Add(w);
Local nameLocal = new Local(Identifier.For("name"),SystemTypes.String,block);
Local nsLocal = new Local(Identifier.For("ns"),SystemTypes.String,block);
Local nodeType = new Local(Identifier.For("nodeType"),Runtime.XmlNodeType,block);
whileBody.Statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName"))));
whileBody.Statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI"))));
whileBody.Statements.Add(new AssignmentStatement(nodeType, new QualifiedIdentifier(reader, Identifier.For("NodeType"))));
Block childBlock = whileBody;
if (isMixed) {
// Append the text node to the current StringBuilder contents.
childBlock = new Block(new StatementList());
If ifText = new If(IsTextNode(nodeType), new Block(new StatementList()), childBlock);
whileBody.Statements.Add(ifText);
ExpressionList args = new ExpressionList();
args.Add(new QualifiedIdentifier(reader, Identifier.For("Value")));
ifText.TrueBlock.Statements.Add(new ExpressionStatement(new MethodCall(
new QualifiedIdentifier(sb, Identifier.For("Append")), args)));
ifText.TrueBlock.Statements.Add(new ExpressionStatement(read)); // advance to next node
}
If ifElement = new If(new BinaryExpression(nodeType,
new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("Element")), NodeType.Eq),
new Block(new StatementList()), new Block(new StatementList()));
childBlock.Statements.Add(ifElement);
childBlock = ifElement.TrueBlock;
//AddConsoleWrite(statements, new Literal("name=",SystemTypes.String));
//AddConsoleWriteLine(statements, nameLocal);
//AddConsoleWrite(statements, new Literal("nodeType=",SystemTypes.String));
//AddConsoleWriteLine(statements, nodeType);
foreach (NamedNode childNode in members) {
if (!(childNode.Member is Field || childNode.Member is Property)) {
AddError(statements, reader, RuntimeError.SerializationOfTypeNotSupported,
new Literal(childNode.Member.GetType().FullName, SystemTypes.String));
} else {
Expression mb = GetMemberBinding(target, childNode.Member);
childBlock = AddReadChild(block, childBlock.Statements, childNode.Name, childNode.TypeNode, mb, reader, result, true, false).FalseBlock;
// todo: throw error if child is required. (e.g. NonEmptyIEnumerable...)
}
}
// if it isn't any of the expected elements then throw an error.
AddError(childBlock.Statements, reader, RuntimeError.NoSuchMember,
new Expression[2]{new Literal(tempChecker.GetTypeName(type),SystemTypes.String), nameLocal});
// If it's not an element then consume it anyway to keep the reader advancing.
// Probably a comment or PI or something.
ifElement.FalseBlock.Statements.Add(new ExpressionStatement(new MethodCall(
new QualifiedIdentifier(reader, Identifier.For("Skip")), new ExpressionList())));
if (isMixed) {
statements.Add(new AssignmentStatement(GetMemberBinding(target, mixedMember),
new MethodCall(new QualifiedIdentifier(sb, Identifier.For("ToString")), new ExpressionList())));
}
statements.Add(new AssignmentStatement(result, Literal.True));
}
public override Statement VisitWhile(While While)
{
WriteStart("while ");
this.VisitParenthesizedExpression(While.Condition);
this.VisitBlock(While.Body);
return While;
}
void AddReadStream(Block block, TypeNode type, StatementList statements, Identifier reader,
Expression target, Expression result){
// Read next element and figure out if it matches the stream element type, if so read it and add it to the list
// If not, then return (throw an error if there are no items and the list is the non-empty type).
// flexArray = new flexarray();
// while (reader.Read() && read.NodeType != XmlNodeType.EndElement) {
// if (reader.NodeType == XmlNodeType.Element) {
// readchild(flexarray);
// }
// }
// target = flexArray;
Local nameLocal = new Local(Identifier.For("name"),SystemTypes.String, block);
Local nsLocal = new Local(Identifier.For("ns"),SystemTypes.String, block);
Local nodeType = new Local(Identifier.For("nodeType"),Runtime.XmlNodeType, block);
Local optional = new Local(Identifier.Empty, SystemTypes.Boolean, block);
Local foundChild = new Local(Identifier.Empty, SystemTypes.Boolean, block);
statements.Add(new AssignmentStatement(optional, Literal.False));
TypeNode eType = Checker.GetCollectionElementType(type);
Local local = new Local(Identifier.Empty, eType, block);
Method addMethod = null;
Local localArray = null;
if (type.Template == SystemTypes.GenericBoxed) {
addMethod = null; // only needs one!
} else if (Checker.IsGenericList(type)) {
//TODO: this call is invalid if the eType is not public
TypeNode flexArrayType = SystemTypes.GenericList.GetTemplateInstance(this.module, eType);
localArray = new Local(Identifier.For("stream"+streamCount++), flexArrayType, block);
statements.Add(new AssignmentStatement(localArray,
new Construct(new MemberBinding(null, flexArrayType), new ExpressionList(), flexArrayType)));
addMethod = flexArrayType.GetMethod(Identifier.For("Add"), eType);
} else {
TypeNode arrayType = SystemTypes.ArrayList;
localArray = new Local(Identifier.Empty, arrayType, block);
statements.Add(new AssignmentStatement(localArray,
new Construct(new MemberBinding(null, arrayType), new ExpressionList(), arrayType)));
addMethod = arrayType.GetMethod(Identifier.For("Add"), SystemTypes.Object);
}
Block whileBody = new Block(new StatementList());
MethodCall moveToContent = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToContent")), new ExpressionList());
BinaryExpression notAtEnd = new BinaryExpression(moveToContent,
new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("EndElement")), NodeType.Ne);
BinaryExpression notEOF = new BinaryExpression(
new QualifiedIdentifier(reader, Identifier.For("EOF")), Literal.True, NodeType.Ne);
While w = new While(new BinaryExpression(notAtEnd, notEOF, NodeType.And), whileBody);
statements.Add(w);
whileBody.Statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName"))));
whileBody.Statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI"))));
whileBody.Statements.Add(new AssignmentStatement(nodeType, new QualifiedIdentifier(reader, Identifier.For("NodeType"))));
StatementList trueStatements = whileBody.Statements;
if (type.Template == SystemTypes.GenericBoxed){
type = Checker.GetCollectionElementType(type);
}
trueStatements.Add(new AssignmentStatement(foundChild, Literal.False));
if (eType is TupleType || eType is TypeUnion || IsStream(eType)) {
AddCallDeserializer(eType, trueStatements, reader, local, optional, foundChild);
} else {
AddReadChild(whileBody, trueStatements, Checker.GetDefaultElementName(eType), eType, local, reader, foundChild, true, false);
}
If ifFound = new If(new BinaryExpression(foundChild, Literal.True, NodeType.Eq),
new Block(new StatementList()), new Block(new StatementList()));
ifFound.TrueBlock.Statements.Add(new AssignmentStatement(result, Literal.True)); // set our result to true then.
ifFound.FalseBlock.Statements.Add(new Exit()); // break out of loop then.
trueStatements.Add(ifFound);
if (addMethod == null) {
trueStatements.Add(new AssignmentStatement(target,
CastTo(local, type))); // box the result.
trueStatements.Add(new Exit()); // break out of loop we have it!
} else {
MemberBinding addCall = new MemberBinding(localArray, addMethod);
trueStatements.Add(new ExpressionStatement(new MethodCall(addCall,
new ExpressionList(new Expression[1] {local}))));
}
// clear out the local, it is a struct of some sort.
if (local.Type.IsValueType && ! local.Type.IsPrimitive) {
trueStatements.Add(new AssignmentStatement(local,
new Construct(new MemberBinding(null,local.Type), new ExpressionList(), local.Type)));
}
// end while
// assign resulting array to the target object (if we have anything to assign).
If ifResult = new If(new BinaryExpression(result, Literal.True, NodeType.Eq),
new Block(new StatementList()), null);
statements.Add(ifResult);
statements = ifResult.TrueBlock.Statements;
if (addMethod != null) {
if (type is ArrayType) {
// target = (type)localArray.ToArray(etype);
Method toArray = SystemTypes.ArrayList.GetMethod(Identifier.For("ToArray"), SystemTypes.Type);
ExpressionList args = new ExpressionList();
args.Add(new UnaryExpression(new Literal(eType, SystemTypes.Type), NodeType.Typeof, SystemTypes.Type));
statements.Add(new AssignmentStatement(target,
CastTo(new MethodCall(new MemberBinding(localArray, toArray),
args, NodeType.Callvirt, SystemTypes.Array), type)));
} else if (type.Template == SystemTypes.GenericNonEmptyIEnumerable) {
// Explicit coercion of IEnumerable to NonEmptyIEnumerable requires constructing
// the NonEmptyIEnumerable object passing in the IEnumerable as an argument.
TypeNode ienumtype = Checker.GetIEnumerableTypeFromNonEmptyIEnumerableStruct(this.module, type);
Debug.Assert(ienumtype!=null);
//TODO: this call is invalid if the eType is not public
TypeNode nonEmptyIEnum = SystemTypes.GenericNonEmptyIEnumerable.GetTemplateInstance(this.module, eType);
InstanceInitializer ii = nonEmptyIEnum.GetConstructor(ienumtype);
Construct c = new Construct(new MemberBinding(null, ii), new ExpressionList(localArray), nonEmptyIEnum);
statements.Add(new AssignmentStatement(target, c));
} else {
statements.Add(new AssignmentStatement(target, localArray));
}
}
}
//================= reader methods ==========================================
void AddReadAttributes(TypeNode type, StatementList statements, Identifier reader, Expression target, SchemaValidator validator) {
if (validator.Attributes != null) {
Block whileBody = new Block(new StatementList());
Literal trueLit = Literal.True;
MethodCall movenext = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToNextAttribute")), new ExpressionList());
BinaryExpression condition = new BinaryExpression(movenext, trueLit, NodeType.Eq);
While w = new While(condition, whileBody);
statements.Add(w);
Block lastElseBlock = null;
Local nameLocal = new Local(SystemTypes.String);
whileBody.Statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName"))));
Local nsLocal = new Local(SystemTypes.String);
whileBody.Statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI"))));
foreach (SchemaAttDef ad in validator.Attributes) {
// todo: any way to do tokenized compares?
BinaryExpression nameEqual = new BinaryExpression(nameLocal,
new Literal(ad.Name.Name, SystemTypes.String), NodeType.Eq);
BinaryExpression nsEqual = new BinaryExpression(nsLocal,
new Literal(ad.Name.Prefix != null ? ad.Name.Prefix.Name : "", SystemTypes.String), NodeType.Eq);
Block elseBlock = new Block(new StatementList());
If ifExpr = new If(new BinaryExpression(nameEqual, nsEqual, NodeType.And), new Block(new StatementList()), elseBlock);
if (lastElseBlock != null) {
lastElseBlock.Statements.Add(ifExpr);
} else {
whileBody.Statements.Add(ifExpr);
}
lastElseBlock = elseBlock;
// body of if test, parse the attribute value as the specified type.
Debug.Assert(ad.Member is Field || ad.Member is Property);
AddReadSimpleType(Checker.GetMemberType(ad.Member), ifExpr.TrueBlock.Statements, reader, GetMemberBinding(target, ad.Member), null, true);
}
//todo: report unknown attributes?
}
}
public override Statement VisitWhile(While While)
{
if (While == null) return null;
return base.VisitWhile((While)While.Clone());
}
public virtual Statement VisitWhile(While While)
{
if (While == null) return null;
While.Condition = this.VisitExpression(While.Condition);
While.Invariants = this.VisitLoopInvariantList(While.Invariants);
While.Body = this.VisitBlock(While.Body);
return While;
}
private While ParseWhile(TokenSet followers){
While While = new While();
While.SourceContext = this.scanner.CurrentSourceContext;
Debug.Assert(this.currentToken == Token.While);
this.GetNextToken();
While.Condition = this.ParseParenthesizedExpression(followers);
While.Invariants = ParseLoopInvariants(followers);
SourceContext savedCompoundStatementOpeningContext = this.compoundStatementOpeningContext;
While.SourceContext.EndPos = this.scanner.endPos;
this.compoundStatementOpeningContext = While.SourceContext;
Block b = this.ParseStatementAsBlock(followers);
While.Body = b;
if (b != null)
While.SourceContext.EndPos = b.SourceContext.EndPos;
this.SkipTo(followers);
this.compoundStatementOpeningContext = savedCompoundStatementOpeningContext;
return While;
}
private bool IsCoalescableWhileStmt(While s)
{
return (IsCoalescableExpr(s.Condition) &&
IsCoalescableBlock(s.Body));
}
public override Statement VisitWhile(While While)
{
if (While == null || While.Condition == null)
return While;
if (insideAtomicBlock && IsCoalescableWhileStmt(While))
{
CurrentContinuation =
AddBlock(new BasicBlock(While, CurrentContinuation));
return While;
}
Normalizer normalizer = new Normalizer(splicer, null, false);
BasicBlock testBlock = new BasicBlock(null);
testBlock.SourceContext = While.Condition.SourceContext;
PushContinuationStack(testBlock);
this.Visit(While.Body);
BasicBlock bodyBlock = PopContinuationStack();
testBlock.ConditionalExpression = normalizer.VisitExpression(While.Condition);
testBlock.ConditionalTarget = bodyBlock;
testBlock.UnconditionalTarget = CurrentContinuation;
testBlock.ConditionalExpression.SourceContext = testBlock.SourceContext;
CurrentContinuation = AddBlock(testBlock);
return While;
}
public override Statement VisitWhile(While While)
{
WriteStart("while (");
this.VisitExpression(While.Condition);
WriteFinish(")");
this.VisitBlock(While.Body);
return While;
}
public EventingVisitor(Action<While> visitWhile) { VisitedWhile += visitWhile; } public event Action<While> VisitedWhile; public override Statement VisitWhile(While While) { if (VisitedWhile != null) VisitedWhile(While); return base.VisitWhile(While); }
