private void CheckUniqueUser()
{
var path = Path;
if (!path.StartsWith(string.Concat(Repository.ImsFolderPath, RepositoryPath.PathSeparator)) || Parent.Path == Repository.ImsFolderPath)
{
throw new InvalidOperationException("Invalid path: user nodes can only be saved under a /Root/IMS/[DomainName] folder.");
}
string domainPath = path.Substring(0, Repository.ImsFolderPath.Length + 1 + path.Substring(Repository.ImsFolderPath.Length + 1).IndexOf('/') + 1);
//We validate here the uniqueness of the user. The constraint is the user name itself and that in Active Directory
//there must not exist two users and/or groups with the same name under a domain. Organizational units may have
//the same name as a user.
//CONDITIONAL EXECUTE
IEnumerable <int> identifiers;
int count;
if (StorageContext.Search.IsOuterEngineEnabled && StorageContext.Search.SearchEngine != InternalSearchEngine.Instance)
{
var query = new NodeQuery();
var nameExpression = new StringExpression(StringAttribute.Name, StringOperator.Equal, Name);
var pathExpression = new StringExpression(StringAttribute.Path, StringOperator.StartsWith, domainPath);
var orTypes = new ExpressionList(ChainOperator.Or);
orTypes.Add(new TypeExpression(ActiveSchema.NodeTypes["User"]));
orTypes.Add(new TypeExpression(ActiveSchema.NodeTypes["Group"]));
query.Add(pathExpression);
query.Add(nameExpression);
query.Add(orTypes);
var result = query.Execute();
identifiers = result.Identifiers;
count = result.Count;
}
else
{
var nodes = NodeQuery.QueryNodesByTypeAndPathAndName(new List <NodeType> {
ActiveSchema.NodeTypes["User"], ActiveSchema.NodeTypes["Group"]
}, false, domainPath, false, Name).Nodes;
var nodeList = nodes as NodeList <Node>;
if (nodeList != null)
{
identifiers = nodeList.GetIdentifiers();
count = nodeList.Count;
}
else
{
identifiers = nodes.Select(x => x.Id);
count = identifiers.Count();
}
}
if (count > 1 || (count == 1 && identifiers.First() != this.Id))
{
var ids = String.Join(", ", (from x in identifiers select x.ToString()).ToArray());
throw GetUniqueUserException(domainPath, ids);
}
}
private ActionResult SearchNodeQuery(string searchStr, string searchRoot, string contentTypes)
{
if (!string.IsNullOrEmpty(searchStr))
{
// simple nodequery
var query = new NodeQuery();
query.Add(new SearchExpression(searchStr));
var nodes = query.Execute().Nodes;
// filter with path
if (!string.IsNullOrEmpty(searchRoot))
{
nodes = nodes.Where(n => n.Path.StartsWith(searchRoot));
}
// filter with contenttypes
if (!string.IsNullOrEmpty(contentTypes))
{
var contentTypesArr = GetContentTypes(contentTypes);
nodes = nodes.Where(n => contentTypesArr.Contains(n.NodeType.Name));
}
var contents = nodes.Where(n => n != null).Select(n => new Content(n, true, false, false, false, 0, 0));
return(Json(contents.ToArray(), JsonRequestBehavior.AllowGet));
}
else
{
if (string.IsNullOrEmpty(searchRoot) && string.IsNullOrEmpty(contentTypes))
{
return(Json(null, JsonRequestBehavior.AllowGet));
}
var query = new NodeQuery();
var andExpression = new ExpressionList(ChainOperator.And);
query.Add(andExpression);
// filter with path
if (!string.IsNullOrEmpty(searchRoot))
{
andExpression.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, searchRoot));
}
// filter with contenttypes
if (!string.IsNullOrEmpty(contentTypes))
{
var contentTypesArr = GetContentTypes(contentTypes);
var orExpression = new ExpressionList(ChainOperator.Or);
foreach (var contentType in contentTypesArr)
{
orExpression.Add(new TypeExpression(NodeType.GetByName(contentType), true));
}
andExpression.Add(orExpression);
}
var nodes = query.Execute().Nodes;
var contents = nodes.Select(n => new Content(n, true, false, false, false, 0, 0));
return(Json(contents.ToArray(), JsonRequestBehavior.AllowGet));
}
}
private User GetRegisteredUser(string resetEmail, string domain)
{
if (String.IsNullOrEmpty(resetEmail))
{
throw new ArgumentNullException("resetEmail");
}
if (String.IsNullOrEmpty(domain))
{
throw new ArgumentNullException("domain");
}
var query = new NodeQuery();
var expressionList = new ExpressionList(ChainOperator.And);
expressionList.Add(new TypeExpression(ActiveSchema.NodeTypes[Configuration.UserTypeName], false));
expressionList.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, string.Concat(Repository.ImsFolderPath, RepositoryPath.PathSeparator, domain, RepositoryPath.PathSeparator)));
expressionList.Add(new StringExpression(ActiveSchema.PropertyTypes["Email"], StringOperator.Equal, resetEmail));
query.Add(expressionList);
AccessProvider.ChangeToSystemAccount();
var resultList = query.Execute();
AccessProvider.RestoreOriginalUser();
// no user has beeen found
if (resultList.Count == 0)
{
return(null);
}
var u = resultList.Nodes.First() as User;
return(u);
}
/// <summary>
/// Sets datasource of listview.
/// </summary>
/// <remarks>
/// Loads tags form Content Repository and adds the following properties of them to a datatable:
/// DisplayName, Created By, Creation Date, Modification Date, Reference Count, Path, Is Blacklisted an Node ID.
/// Sets this datatable as datasource to the listview.
/// </remarks>
private void SetDataSource()
{
var refCounts = TagManager.GetTagOccurrencies();
var exprList = new ExpressionList(ChainOperator.And);
exprList.Add(new TypeExpression(ActiveSchema.NodeTypes["Tag"], true));
exprList.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, TagPath));
var nq = new NodeQuery(exprList);
var result = nq.Execute();
var dt = new DataTable();
_tagsInRepository = new List <string>();
dt.Columns.AddRange(new[] {
new DataColumn("DisplayName", typeof(String)),
new DataColumn("CreatedBy", typeof(String)),
new DataColumn("CreationDate", typeof(DateTime)),
new DataColumn("ModificationDate", typeof(DateTime)),
new DataColumn("RefCount", typeof(Int32)),
new DataColumn("Path", typeof(String)),
new DataColumn("IsBlackListed", typeof(String)),
new DataColumn("ID", typeof(Int32))
});
foreach (var item in result.Nodes.ToList())
{
var black = GetIsBlackListed(item.Id);
dt.Rows.Add(new object[]
{
item.DisplayName,
item.CreatedBy,
item.CreationDate,
item.ModificationDate,
refCounts.ContainsKey(item.DisplayName) ? refCounts[item.DisplayName] : 0,
item.Path, black,
Convert.ToInt32(item.Id)
});
if (black == "No")
{
_tagsInRepository.Add(item.DisplayName);
}
}
_allTags = TagManager.GetAllTags(null, SearchPaths);
dt.DefaultView.Sort = !String.IsNullOrEmpty(Request.QueryString["OrderBy"]) ? String.Concat(Request.QueryString["OrderBy"], " " + Request.QueryString["Direction"]) : "DisplayName ASC";
_lv = FindControl("LVTags") as ListView;
if (_lv != null)
{
_lv.DataSource = dt.DefaultView;
_lv.DataBind();
}
}
public static IEnumerable <Node> GetPortletsFromRepo()
{
var query = new NodeQuery();
var expression = new ExpressionList(ChainOperator.And);
expression.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, PortletsFolderPath));
expression.Add(new TypeExpression(NodeType.GetByName("Portlet")));
query.Add(expression);
return(query.Execute().Nodes);
}
public Node ExprList()
{
var node = new ExpressionList();
node.Add(Expr());
while (CurrentToken == TokenCategory.COMMA)
{
Expect(TokenCategory.COMMA);
node.Add(Expr());
}
return(node);
}
public Node ExprList()
{
var expressionList = new ExpressionList();
expressionList.Add(Expr());
while (firstOfListContinuation.Contains(CurrentToken))
{
Expect(TokenCategory.COMMA);
expressionList.Add(Expr());
}
return(expressionList);
}
public void CopyToTest()
{
ExpressionList<ConstantTypes.Integer> list = new ExpressionList<ConstantTypes.Integer>();
var zero = new ConstantTypes.Integer(0);
var one = new ConstantTypes.Integer(1);
list.Add(zero);
list.Add(one);
ConstantTypes.Integer[] array = new ConstantTypes.Integer[2];
list.CopyTo(array, 0);
Assert.IsTrue(array.Length == 2);
Assert.IsTrue(array[0] == zero);
Assert.IsTrue(array[1] == one);
}
//<expr-list>//
public Node ExpressionList()
{
var elist = new ExpressionList();
if (firstExpr.Contains(CurrentToken))
{
elist.Add(Expression());
while (firstOfIdListCont.Contains(CurrentToken))
{
Expect(TokenCategory.COMMA);
elist.Add(Expression());
}
}
return(elist);
}
public void AddTest()
{
var list = new ExpressionList<ConstantTypes.Integer>();
var one = new ConstantTypes.Integer(1);
list.Add(one);
Assert.IsTrue(list.Contains(one));
}
public Node ExprList()
{
var result = new ExpressionList();
if (firstOfExpression.Contains(CurrentToken))
{
result.Add(Expression());
while (CurrentToken == TokenCategory.LIST_ELEMENT)
{
Expect(TokenCategory.LIST_ELEMENT);
result.Add(Expression());
}
}
return(result);
}
/// <summary>
/// Parses expressions into a tree until seperator is hit
/// </summary>
/// <returns></returns>
ExpressionList ParseExpressions()
{
/* Note to self: Base must be after eventual paranthese to respect scope (E.g 'void method([HERE]...')) */
ExpressionList expressions = new ExpressionList();
int Scope = 1;
while (Scope > 0)
{
//if (tokenReader.Expect(LexKind.ParentheseOpen))
//{
// Scope++;
//}
//else
if (tokenReader.Expect(LexKind.ParentheseClose))
{
Scope = 0;
}
if (ParseExpression(out Expression expression))
{
expressions.Add(expression);
}
else
{
tokenReader.Skip(1);
}
}
return(expressions);
}
public SearchedCase(params KeyValuePair<Predicate, Expression>[] cases)
{
SearchCases = new ExpressionList<SearchedCaseExpression>();
foreach (var kvp in cases)
{
SearchCases.Add(new SearchedCaseExpression(kvp.Key, kvp.Value));
}
}
public void NodeQuery_Bug2125()
{
Expression exp;
ExpressionList expList;
var query1 = new NodeQuery();
exp = new SearchExpression("dummy");
query1.Add(exp);
Assert.IsTrue(Object.ReferenceEquals(exp.Parent, query1), "#1");
expList = new ExpressionList(ChainOperator.And);
query1.Add(expList);
Assert.IsTrue(Object.ReferenceEquals(expList.Parent, query1), "#2");
exp = new StringExpression(StringAttribute.Name, StringOperator.Equal, "Root");
expList.Add(exp);
Assert.IsTrue(Object.ReferenceEquals(exp.Parent, expList), "#3");
exp = new IntExpression(IntAttribute.Id, ValueOperator.Equal, 2);
expList.Add(exp);
Assert.IsTrue(Object.ReferenceEquals(exp.Parent, expList), "#4");
//------------------------------------------------------------------------------------
var query2 = new NodeQuery
(
new SearchExpression("dummy"),
new ExpressionList
(
ChainOperator.And,
new StringExpression(StringAttribute.Name, StringOperator.Equal, "Root"),
new IntExpression(IntAttribute.Id, ValueOperator.Equal, 2)
)
);
Assert.IsTrue(Object.ReferenceEquals(query2.Expressions[0].Parent, query2), "#5");
Assert.IsTrue(Object.ReferenceEquals(query2.Expressions[1].Parent, query2), "#6");
Assert.IsTrue(Object.ReferenceEquals(((ExpressionList)query2.Expressions[1]).Expressions[0].Parent, query2.Expressions[1]), "#7");
Assert.IsTrue(Object.ReferenceEquals(((ExpressionList)query2.Expressions[1]).Expressions[1].Parent, query2.Expressions[1]), "#8");
}
public void ClearTest()
{
var list = new ExpressionList<ConstantTypes.Integer>();
var one = new ConstantTypes.Integer(1);
list.Add(one);
Assert.IsTrue(list.Count == 1);
list.Clear();
Assert.IsTrue(list.Count == 0);
}
public override Expression VisitRefTypeExpression(RefTypeExpression reftypexp) {
if (reftypexp == null) return null;
Expression result = base.VisitRefTypeExpression (reftypexp);
if (result != reftypexp) return result;
UnaryExpression refanytype = new UnaryExpression(reftypexp.Operand, NodeType.Refanytype, SystemTypes.RuntimeTypeHandle, reftypexp.SourceContext);
ExpressionList arguments = new ExpressionList(1);
arguments.Add(refanytype);
MemberBinding mb = new MemberBinding(null, Runtime.GetTypeFromHandle);
return new MethodCall(mb, arguments, NodeType.Call, SystemTypes.Type);
}
public Node ExprList()
{
var exprList = new ExpressionList();
if (Current != TokenCategory.CLOSE_PARENTHESIS)
{
exprList.Add(Expr());
ExprListCont(exprList);
}
return(exprList);
}
public static IEnumerable <Node> GetContainerUsers(Node container)
{
var query = new NodeQuery();
ExpressionList expressionList = new ExpressionList(ChainOperator.And);
// nodetype
TypeExpression typeExpression = new TypeExpression(Common.GetNodeType(ADObjectType.User));
expressionList.Add(typeExpression);
// from container as root
StringExpression pathExpression = new StringExpression(StringAttribute.Path, StringOperator.StartsWith, container.Path);
expressionList.Add(pathExpression);
query.Add(expressionList);
var result = query.Execute();
return(result.Nodes);
}
public static NodeQueryResult GetWebContentTypeList()
{
var contentTypeNames = ConfigurationManager.AppSettings[ContentTypeNameListKey];
if (String.IsNullOrEmpty(contentTypeNames))
{
contentTypeNames = DefaultContentTypeName;
}
var list = contentTypeNames.Split(',');
var validCtdNames = new List <string>();
foreach (var c in list)
{
if (IsValidContentType(c.Trim()))
{
validCtdNames.Add(c.Trim());
}
}
var expressionList = new ExpressionList(ChainOperator.Or);
var query = new NodeQuery();
foreach (var ctd in validCtdNames)
{
var stringExpressionValue = RepositoryPath.Combine(Repository.ContentTypesFolderPath, String.Concat(ActiveSchema.NodeTypes[ctd].NodeTypePath, "/"));
expressionList.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, stringExpressionValue));
}
if (validCtdNames.Count == 0)
{
var stringExpressionValue = RepositoryPath.Combine(Repository.ContentTypesFolderPath, String.Concat(ActiveSchema.NodeTypes[DefaultContentTypeName].NodeTypePath, "/"));
expressionList.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, stringExpressionValue));
}
query.Add(expressionList);
return(query.Execute());
}
ExpressionList Parse (int start, int end)
{
if (string.IsNullOrWhiteSpace (source))
return new ExpressionList ();
var ret = new ExpressionList ();
while (start < end) {
int bak = start;
ret.Add (ParseSingle (ref start, end));
if (bak == start)
throw new Exception ("Parser failed to progress token position: " + source);
}
return ret;
}
public void AddClause(Expression expression, ChainOperator chainOp)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
ExpressionList finalExpList;
var origExpList = expression as ExpressionList;
if (origExpList != null)
{
finalExpList = origExpList;
}
else
{
finalExpList = new ExpressionList(chainOp);
finalExpList.Add(expression);
}
this.Text = AddFilterToNodeQuery(Text, finalExpList.ToXml());
}
public VisitedExpression Append(VisitedExpression expression)
{
ExpressionList.Add(expression);
return(this);
}
/// <summary>
/// Create a proxy method implementing the abstractMethod and which calls the implementingMethod.
/// This is needed when the implementingMethod is supposed to be used for the implementation
/// of the abstractMethod, but cannot be because it lives in another assembly or isn't virtual
/// or the abstractMethod has an out-of-band contract and the implementingMethod must have
/// an identical type signature (i.e., no optional type modifiers for the non-null types).
/// </summary>
/// <param name="type">The type containing the implementingMethod and to which the
/// proxy will be added as a member.</param>
/// <param name="abstractMethod">The abstract method that the proxy is an implementation of.</param>
/// <param name="implementingMethod">The implementing method that is supposed to implement
/// the abstractMethod, but is unable to for various reasons.</param>
/// <returns>The newly created proxy method.</returns>
private Method CreateProxy(TypeNode type, Method abstractMethod, Method implementingMethod) {
ParameterList parameters = abstractMethod.Parameters;
if (parameters == null)
parameters = new ParameterList(0);
else
parameters = parameters.Clone();
int m = parameters.Count;
ExpressionList arguments = new ExpressionList(m);
for (int j = 0; j < m; j++) {
Parameter p = (Parameter)parameters[j].Clone();
parameters[j] = p;
if (this.typeSystem.IsNonNullType(p.Type)) {
arguments.Add(this.typeSystem.ExplicitNonNullCoercion(p, p.Type));
} else {
arguments.Add(p);
}
p.Type = TypeNode.DeepStripModifiers(p.Type, (abstractMethod.Template!=null)?abstractMethod.Template.Parameters[j].Type:null, SystemTypes.NonNullType);
}
This ThisParameter = new This(this.currentType);
StatementList statements = new StatementList(2);
NodeType typeOfCall = type.IsValueType ? NodeType.Call : NodeType.Callvirt;
MethodCall mCall = new MethodCall(new MemberBinding(ThisParameter, implementingMethod), arguments, typeOfCall, implementingMethod.ReturnType);
if (implementingMethod.ReturnType != SystemTypes.Void) {
statements.Add(new Return(mCall));
} else {
statements.Add(new ExpressionStatement(mCall));
statements.Add(new Return());
}
TypeNode returnType = TypeNode.DeepStripModifiers(abstractMethod.ReturnType, (abstractMethod.Template != null) ? abstractMethod.Template.ReturnType : null, SystemTypes.NonNullType);
ProxyMethod proxy = new ProxyMethod(type, null, new Identifier(abstractMethod.DeclaringType.Name + "." + abstractMethod.Name, implementingMethod.Name.SourceContext), parameters, returnType, new Block(statements));
proxy.ProxyFor = implementingMethod;
proxy.ThisParameter = ThisParameter;
proxy.CallingConvention = CallingConventionFlags.HasThis;
proxy.Flags = MethodFlags.CompilerControlled | MethodFlags.HideBySig | MethodFlags.NewSlot | MethodFlags.Virtual | MethodFlags.Final;
proxy.ImplementedInterfaceMethods = new MethodList(abstractMethod);
type.Members.Add(proxy);
return proxy;
}
private void AddAsyncPost(List <Ensures> asyncPostconditions)
{
var origBody = new Block(this.checkPostBody);
origBody.HasLocals = true;
var newBodyBlock = new Block(new StatementList());
newBodyBlock.HasLocals = true;
var methodBody = new StatementList();
var methodBodyBlock = new Block(methodBody);
methodBodyBlock.HasLocals = true;
checkPostMethod.Body = methodBodyBlock;
methodBody.Add(newBodyBlock);
Block newExitBlock = new Block();
methodBody.Add(newExitBlock);
// Map closure locals to fields and initialize closure fields
foreach (Ensures e in asyncPostconditions)
{
if (e == null)
{
continue;
}
this.Visit(e);
if (this.forwarder != null)
{
this.forwarder.Visit(e);
}
ReplaceResult repResult = new ReplaceResult(
this.checkPostMethod, this.originalResultLocal,
this.rewriter.AssemblyBeingRewritten);
repResult.Visit(e);
if (repResult.ContractResultWasCapturedInStaticContext)
{
this.contractResultCapturedInStaticContext.Add(e.Assertion.SourceContext);
}
// now need to initialize closure result fields
foreach (var target in repResult.NecessaryResultInitializationAsync(this.closureLocals))
{
// note: target here
methodBody.Add(new AssignmentStatement(target, this.originalResultLocal));
}
}
// Emit normal postconditions
SourceContext?lastEnsuresSourceContext = null;
var ensuresChecks = new StatementList();
Method contractEnsuresMethod = this.rewriter.RuntimeContracts.EnsuresMethod;
foreach (Ensures e in GetTaskResultBasedEnsures(asyncPostconditions))
{
// TODO: Not sure that 'break' is enough! It seems that this is possible
// only when something is broken, because normal postconditions
// are using Contract.Result<T>() and this is possible only for
// generic tasks.
if (IsVoidTask())
{
break; // something is wrong in the original contract
}
lastEnsuresSourceContext = e.SourceContext;
//
// Call Contract.RewriterEnsures
//
ExpressionList args = new ExpressionList();
args.Add(e.PostCondition);
args.Add(e.UserMessage ?? Literal.Null);
args.Add(e.SourceConditionText ?? Literal.Null);
ensuresChecks.Add(
new ExpressionStatement(
new MethodCall(
new MemberBinding(null, contractEnsuresMethod),
args, NodeType.Call, SystemTypes.Void),
e.SourceContext));
}
this.rewriter.CleanUpCodeCoverage.VisitStatementList(ensuresChecks);
//
// Normal postconditions
//
// Wrapping normal ensures into following if statement
// if (task.Status == TaskStatus.RanToCompletion)
// { postcondition check }
//
// Implementation of this stuff is a bit tricky because if-statements
// are inverse in the IL.
// Basically, we need to generate following code:
// if (!(task.Status == Task.Status.RanToCompletion))
// goto EndOfNormalPostcondition;
// {postcondition check}
// EndOfNormalPostcondition:
// {other Code}
// Marker for EndOfNormalPostcondition
Block endOfNormalPostcondition = new Block();
// Generate: if (task.Status != RanToCompletion) goto endOfNormalPostcondition;
StatementList checkStatusStatements = CreateIfTaskResultIsEqualsTo(
checkMethodTaskParameter, TaskStatus.RanToCompletion, endOfNormalPostcondition);
methodBodyBlock.Statements.Add(new Block(checkStatusStatements));
// Emit a check for __ContractsRuntime.insideContractEvaluation around Ensures
this.rewriter.EmitRecursionGuardAroundChecks(this.checkPostMethod, methodBodyBlock, ensuresChecks);
// Now, normal postconditions are written to the method body.
// We need to add endOfNormalPostcondition block as a marker.
methodBodyBlock.Statements.Add(endOfNormalPostcondition);
//
// Exceptional postconditions
//
var exceptionalPostconditions = GetExceptionalEnsures(asyncPostconditions).ToList();
if (exceptionalPostconditions.Count > 0)
{
// For exceptional postconditions we need to generate CheckException method first
Method checkExceptionMethod = CreateCheckExceptionMethod();
EmitCheckExceptionBody(checkExceptionMethod, exceptionalPostconditions);
this.closureClass.Members.Add(checkExceptionMethod);
// Then, we're using the same trick as for normal postconditions:
// wrapping exceptional postconditions only when task.Status is TaskStatus.Faulted
Block checkExceptionBlock = new Block(new StatementList());
// Marker for endOfExceptionPostcondition
Block endOfExceptionPostcondition = new Block();
StatementList checkStatusIsException = CreateIfTaskResultIsEqualsTo(
checkMethodTaskParameter, TaskStatus.Faulted, endOfExceptionPostcondition);
checkExceptionBlock.Statements.Add(new Block(checkStatusIsException));
// Now we need to emit actuall check for exceptional postconditions
// Emit: var ae = task.Exception;
var aeLocal = new Local(aggregateExceptionType.Value);
checkExceptionBlock.Statements.Add(
new AssignmentStatement(aeLocal,
new MethodCall(
new MemberBinding(checkMethodTaskParameter,
GetTaskProperty(checkMethodTaskParameter, "get_Exception")),
new ExpressionList())));
// Emit: CheckException(ae);
// Need to store method result somewhere, otherwise stack would be corrupted
var checkResultLocal = new Local(SystemTypes.Boolean);
checkExceptionBlock.Statements.Add(
new AssignmentStatement(checkResultLocal,
new MethodCall(new MemberBinding(null,
checkExceptionMethod),
new ExpressionList(checkExceptionMethod.ThisParameter, aeLocal))));
checkExceptionBlock.Statements.Add(endOfExceptionPostcondition);
methodBody.Add(checkExceptionBlock);
}
// Copy original block to body statement for both: normal and exceptional postconditions.
newBodyBlock.Statements.Add(origBody);
Block returnBlock = CreateReturnBlock(checkMethodTaskParameter, lastEnsuresSourceContext);
methodBody.Add(returnBlock);
}
void AddError(StatementList statements, Identifier reader, RuntimeError code, params Expression[] args) {
ExpressionList list = new ExpressionList();
list.Add(new Literal(code, Runtime.RuntimeError));
foreach (Expression e in args) list.Add(e);
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Error")), list)));
}
void AddReadOptional(Block block, StatementList statements, Member mem, Expression target, Identifier reader, Expression result) {
TypeNode boxed = Checker.GetMemberType(mem);
TypeNode type = Checker.GetCollectionElementType(boxed);
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToContent")), new ExpressionList())));
Local nameLocal = new Local(Identifier.For("name"),SystemTypes.String, block);
Local nsLocal = new Local(Identifier.For("ns"),SystemTypes.String, block);
statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName"))));
statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI"))));
StringBuilder expecting = new StringBuilder();
Expression isFound = null;
if (mem.IsAnonymous) {
isFound = IsStartOf(block, type, statements, nameLocal, nsLocal, expecting);
} else {
ExpressionList args = new ExpressionList();
args.Add(new Literal(mem.Name.Name, SystemTypes.String));
isFound = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("IsStartElement")), args);
}
StatementList trueStatements = new StatementList();
If ifIsFound = new If(isFound, new Block(trueStatements), null);
statements.Add(ifIsFound);
if (!AddReadSimpleType(type, trueStatements, reader, target, result, false)) {
Local localRequired = new Local(Identifier.Empty,SystemTypes.Boolean,block);
statements.Add(new AssignmentStatement(localRequired, Literal.True));
AddCallDeserializer(type, trueStatements, reader, target, localRequired, result);
}
}
public static Expression Convert(ConversionState state, ConversionResult expressionResult, MethodStruct methodStruct)
{
#region // result will be stored in a temporary value
bool complexIndexer;
ComputeType receiverComputeType;
if (methodStruct.Type is ARRAY_TYPE)
{
// result is array
ComputeType.FromType(methodStruct.Type).TryGetValue(out receiverComputeType);
}
else
{
// result is scalar
receiverComputeType = new ComputeType(ComputeScalarType.Single, 1);
}
Identifier receiverIdentifier = Identifier.For("ret");
Expression[] indices = ConversionHelper.GetExpressionsFromIndexer(null, ref receiverComputeType, out complexIndexer);
complexIndexer |= expressionResult.HasComplexIndexer;
#endregion
List <ConversionHelper.Argument> sortedArguments = ConversionHelper.ExtractArguments(state, false);
List <ConversionHelper.Argument> scalarArguments = ConversionHelper.ExtractArguments(state, true);
//ExpressionArgument receiverArgument;
//ConversionHelper.ProcessReceiver(state, expressionResult, receiverIdentifier, receiverComputeType, indices, null, ref sortedArguments, complexIndexer, out receiverArgument);
#region // add the temporary variable as a receiver
ExpressionArgument receiverArgument = new ExpressionArgument(sortedArguments.Count, indices, null, -1);
sortedArguments.Add(new ConversionHelper.Argument {
Index = receiverArgument.Index,
Name = receiverIdentifier.ToString(),
Indexers = receiverArgument.Indexers,
IsRead = false,
IsWritten = true,
IsCall = receiverArgument.IsCall,
CallRank = receiverArgument.CallRank,
});
Identifier receiverDataIdentifier = Identifier.For("data" + receiverArgument.Index);
if (!expressionResult.HasComplexIndexer)
{
// allocate receiver (1D array with size 1 for scalar result, matrix (vector) in other cases)
ExpressionList ctorExpr = new ExpressionList();
for (int index = 0; index < receiverComputeType.Rank; index++)
{
ctorExpr.Add(NodeHelper.GetConstantIndexerForExpression(expressionResult.SizeIdentifier, index));
}
state.Constructor.Body.Statements.Add(
new AssignmentStatement {
Target = new AddressDereference {
Address = receiverDataIdentifier,
Type = STANDARD.Data,
},
Source = new Construct {
Constructor = new MemberBinding {
BoundMember = STANDARD.Data.GetConstructor(SystemTypes.Array),
},
Operands = new ExpressionList(
new ConstructArray {
ElementType = expressionResult.Type.ScalarType.TypeNode,
Rank = (methodStruct.Type is ARRAY_TYPE) ? receiverComputeType.Rank : 1,
Operands = (methodStruct.Type is ARRAY_TYPE) ? ctorExpr : new ExpressionList(Literal.Int32One),
}
),
}
}
);
}
else
{
state.Constructor.Body.Statements.Add(new Block {
Statements = ConversionHelper.GenerateIndexedSize(expressionResult, receiverComputeType, receiverDataIdentifier, state.GetNextTempSizeIdentifier())
});
}
#endregion
#region // generate kernel
ConversionResult?result = GenereteKernel(state, expressionResult, Identifier.For("buffer" + receiverArgument.Index.ToString()), methodStruct);
ConversionResult finalConversionResult;
if (result.HasValue)
{
finalConversionResult = result.Value;
}
else
{
return(null);
}
#endregion
#region // generate delegates
DelegateNode getOpenCLTimeDelegateType;
DelegateNode startOpenCLDelegateType;
ConversionHelper.GenerateOpenCLDelegates(state, out getOpenCLTimeDelegateType, out startOpenCLDelegateType);
#endregion
#region // generate get time method
ConversionHelper.GenerateTimeMethod(state);
#endregion
#region // generate the codelets
Identifier codeletsIdentifier;
ConversionHelper.GenerateCodelets(state, getOpenCLTimeDelegateType, startOpenCLDelegateType, out codeletsIdentifier);
#endregion
#region // process all arguments - add them to parameters and data uses
ExpressionList ctorArgs = new ExpressionList();
ExpressionList callArgs = new ExpressionList();
ParameterList callParams = new ParameterList();
List <TypeNode> typeList = new List <TypeNode>();
Identifier dataUsesIdentifier;
ConversionHelper.ProcessArguments(state, sortedArguments, scalarArguments, complexIndexer, startOpenCLDelegateType, out dataUsesIdentifier, ref callParams, ref callArgs, ref state.Constructor.Parameters, ref ctorArgs, ref typeList);
#endregion
ConversionHelper.GenerateSubmitCodelet(state, codeletsIdentifier, dataUsesIdentifier);
ConversionHelper.FinishOperation(state, finalConversionResult);
Class actualOperationClass = CONTEXT._operationRegistry.RegisterOperation(finalConversionResult.CompleteExpression, state.Class);
#region // create method 'call'
Identifier callIdentifier = Identifier.For("call");
Method callMethod = actualOperationClass.GetMethod(callIdentifier, typeList.ToArray());
Expression returnExp;
if (methodStruct.Type is ARRAY_TYPE)
{
returnExp = receiverIdentifier;
}
else
{
returnExp = new BinaryExpression {
NodeType = NodeType.Castclass,
Operand2 = new MemberBinding {
BoundMember = expressionResult.Type.ScalarType.TypeNode.GetArrayType(1)
},
Operand1 = new MethodCall {
Callee = new MemberBinding {
TargetObject = receiverIdentifier,
BoundMember = STANDARD.Data.GetMethod(Identifier.For("GetHostArray")),
},
}
};
}
if (methodStruct.Type is ARRAY_TYPE)
{
}
else
{
returnExp = NodeHelper.GetConstantIndexerForExpression(returnExp, 0);
if (methodStruct.Type is BOOLEAN_TYPE)
{
// if it was a boolean operation invert the value (1 is false in OpenCL kernel)
returnExp = new BinaryExpression {
NodeType = NodeType.Eq,
Operand1 = returnExp,
Operand2 = Literal.Int32Zero
};
}
}
if (callMethod == null)
{
actualOperationClass.Members.Add(new Method {
DeclaringType = state.Class,
Flags = MethodFlags.Static,
ReturnType = (methodStruct.Type is ARRAY_TYPE) ? STANDARD.Data : methodStruct.Type.convert() as TypeNode /*receiverComputeType.ScalarType.TypeNode*/,
Parameters = callParams,
Name = callIdentifier,
Body = new Block {
Statements = new StatementList(
new VariableDeclaration {
Name = receiverIdentifier,
Type = STANDARD.Data,
},
new ExpressionStatement(new Construct {
Constructor = new MemberBinding {
BoundMember = actualOperationClass.GetConstructors()[0],
},
Operands = ctorArgs,
}),
new Return(returnExp)
)
}
});
}
#endregion
#region // return call to 'call'
return(new MethodCall {
Operands = callArgs,
Callee = new MemberBinding(null, actualOperationClass.GetMethod(callIdentifier, typeList.ToArray())),
Type = expressionResult.Type.ScalarType.TypeNode,
});
#endregion
}
public override Expression VisitMethodCall(MethodCall call)
{
// We only reach this point for calls to predicate methods within "wait"
// join conditions.
ZMethod method = (ZMethod)((MemberBinding)call.Callee).BoundMember;
ExpressionList ctorArgs;
QualifiedIdentifier methodClass = new QualifiedIdentifier(
new QualifiedIdentifier(
new QualifiedIdentifier(Identifier.For("Z"), Identifier.For("Application")),
method.DeclaringType.Name),
method.Name);
MethodCall predCall =
new MethodCall(
new QualifiedIdentifier(Identifier.For("p"), Identifier.For("CallPredicateMethod")),
new ExpressionList(
new Construct(
new MemberBinding(null, new TypeExpression(methodClass)),
ctorArgs = new ExpressionList())));
ctorArgs.Add(Identifier.For("application"));
if (!method.IsStatic)
ctorArgs.Add(this.VisitExpression(((MemberBinding)call.Callee).TargetObject));
for (int i = 0, n = call.Operands.Count; i < n; i++)
ctorArgs.Add(this.VisitExpression(call.Operands[i]));
return predCall;
}
public void NodeQuery_BuildFromXml()
{
SchemaEditor editor = new SchemaEditor();
NodeType nodeType1 = editor.CreateNodeType(null, "nodeType1");
NodeType nodeType2 = editor.CreateNodeType(null, "nodeType2");
PropertyType stringSlot1 = editor.CreatePropertyType("stringSlot1", DataType.String);
PropertyType stringSlot2 = editor.CreatePropertyType("stringSlot2", DataType.String);
PropertyType intSlot1 = editor.CreatePropertyType("intSlot1", DataType.Int);
PropertyType intSlot2 = editor.CreatePropertyType("intSlot2", DataType.Int);
PropertyType dateTimeSlot1 = editor.CreatePropertyType("dateTimeSlot1", DataType.DateTime);
PropertyType dateTimeSlot2 = editor.CreatePropertyType("dateTimeSlot2", DataType.DateTime);
PropertyType currencySlot1 = editor.CreatePropertyType("currencySlot1", DataType.Currency);
PropertyType currencySlot2 = editor.CreatePropertyType("currencySlot2", DataType.Currency);
PropertyType refSlot1 = editor.CreatePropertyType("refSlot1", DataType.Reference);
PropertyType refSlot2 = editor.CreatePropertyType("refSlot2", DataType.Reference);
NodeQuery query = new NodeQuery();
//==== Operators
ExpressionList strOpExp = new ExpressionList(ChainOperator.Or);
query.Add(strOpExp);
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.Contains, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.EndsWith, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.Equal, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.GreaterThan, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.GreaterThanOrEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.LessThan, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.LessThanOrEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.NotEqual, "{path}"));
strOpExp.Add(new StringExpression(StringAttribute.Path, StringOperator.StartsWith, "{path}"));
//==== StringExpression
ExpressionList strExp = new ExpressionList(ChainOperator.Or);
query.Add(strExp);
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, "{value}"));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, stringSlot2));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, StringAttribute.Path));
strExp.Add(new StringExpression(stringSlot1, StringOperator.Equal, (string)null));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, "{value}"));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, stringSlot2));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, StringAttribute.Path));
strExp.Add(new StringExpression(StringAttribute.Name, StringOperator.Equal, (string)null));
//==== IntExpression
ExpressionList intExp = new ExpressionList(ChainOperator.Or);
query.Add(intExp);
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, 123));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, IntAttribute.MajorVersion));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, intSlot2));
intExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.Equal, (int?)null));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, 123));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, IntAttribute.MajorVersion));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, intSlot2));
intExp.Add(new IntExpression(intSlot1, ValueOperator.Equal, (int?)null));
//==== DateTimeExpression
ExpressionList dtExp = new ExpressionList(ChainOperator.Or);
query.Add(dtExp);
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, DateTime.Now));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, DateTimeAttribute.ModificationDate));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, dateTimeSlot2));
dtExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.Equal, (DateTime?)null));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, DateTime.Now));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, DateTimeAttribute.ModificationDate));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, dateTimeSlot2));
dtExp.Add(new DateTimeExpression(dateTimeSlot1, ValueOperator.Equal, (DateTime?)null));
//==== CurrencyExpression
ExpressionList curExp = new ExpressionList(ChainOperator.Or);
query.Add(curExp);
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, (decimal)123.456));
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, currencySlot2));
curExp.Add(new CurrencyExpression(currencySlot1, ValueOperator.Equal, (decimal?)null));
//==== ReferenceExpression
ExpressionList subExp = new ExpressionList(ChainOperator.And);
subExp.Add(new IntExpression(IntAttribute.Index, ValueOperator.GreaterThan, 123));
subExp.Add(new DateTimeExpression(DateTimeAttribute.CreationDate, ValueOperator.GreaterThan, DateTime.Now));
ExpressionList refExp = new ExpressionList(ChainOperator.Or);
query.Add(refExp);
refExp.Add(new ReferenceExpression(refSlot1));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy));
refExp.Add(new ReferenceExpression(refSlot1, (Node)null));
refExp.Add(new ReferenceExpression(refSlot1, Repository.Root));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, (Node)null));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, Repository.Root));
refExp.Add(new ReferenceExpression(refSlot1, subExp));
refExp.Add(new ReferenceExpression(ReferenceAttribute.LockedBy, subExp));
//==== TypeExpression
ExpressionList typeExp = new ExpressionList(ChainOperator.Or);
query.Add(typeExp);
typeExp.Add(new TypeExpression(nodeType1));
typeExp.Add(new TypeExpression(nodeType2, true));
//==== Negation
Expression negExp = new NotExpression(
new ExpressionList(ChainOperator.And,
new StringExpression(StringAttribute.Path, StringOperator.StartsWith, "/Root1/"),
new StringExpression(StringAttribute.Name, StringOperator.NotEqual, "name")
));
query.Add(negExp);
//==== Orders
query.Orders.Add(new SearchOrder(DateTimeAttribute.ModificationDate, OrderDirection.Desc));
query.Orders.Add(new SearchOrder(IntAttribute.MajorVersion, OrderDirection.Asc));
query.Orders.Add(new SearchOrder(StringAttribute.Name, OrderDirection.Asc));
//==== Paging
query.PageSize = 123;
query.StartIndex = 987;
string queryString = query.ToXml();
NodeQueryAccessor queryAcc = new NodeQueryAccessor(new NodeQuery());
NodeQuery newQuery = queryAcc.Parse(queryString, editor);
string newQueryString = newQuery.ToXml();
Assert.IsTrue(queryString != null && queryString == newQueryString);
}
public void Append(string literal)
{
ExpressionList.Add(new LiteralExpression(literal));
}
private Expression DecompileBooleanExpression(Block b)
{
ExpressionList eList = new ExpressionList();
Expression e = null;
int i = 0;
while (i < b.Statements.Count)
{
if (b.Statements[i] is Branch)
{
break;
}
Statement s = b.Statements[i];
i++;
if (s == null || s.NodeType == NodeType.Nop)
{
continue;
}
ExpressionStatement es = s as ExpressionStatement;
if (es != null)
{
MethodCall mc = es.Expression as MethodCall;
if (mc != null)
{
MemberBinding mb = mc.Callee as MemberBinding;
if (mb != null)
{
Method m = mb.BoundMember as Method;
if (m != null)
{
if (this.contractNodes.IsPlainPrecondition(m) || this.contractNodes.IsPostcondition(m))
{
eList.Add(mc.Operands[0]);
}
else
{
eList.Add(es.Expression);
}
}
}
else
{
eList.Add(es.Expression);
}
}
else
{
eList.Add(SimplifyLiteral(es.Expression));
}
}
}
if (i == b.Statements.Count) // no branch at end of block
{
return(eList[0]);
}
Branch br = b.Statements[b.Statements.Count - 1] as Branch;
if (br.Condition == null) // unconditional branch
{
return(eList[0]);
}
e = TypeReconstructorAndExpressionSimplifier.ReconstructBooleanExpression(br.Condition); // should be: e = Combine(e, br.Condition);
Expression trueBranch = DecompileBooleanExpression(br.Target);
Expression falseBranch = DecompileBooleanExpression(blocks[((int)block2Index[b.UniqueKey]) + 1]);
Expression result = Ternary(e, trueBranch, falseBranch);
return(result);
}
void AddCallSerializer(TypeNode srcType, StatementList statements, Expression src, Identifier writer, Expression rootName, Expression rootNamespace ) {
TypeNode type = Unwrap(srcType);
Class memberSerializer = this.CreateSerializerFor(type);
// call the Serialize method on it, passing the member we're serializing.
ExpressionList args = new ExpressionList();
args.Add(src);
args.Add(writer);
args.Add(rootName);
args.Add(rootNamespace);
MethodCall call = new MethodCall();
Method serialize = memberSerializer.GetMethod(Identifier.For("Serialize"), new TypeNode[4] { type, Runtime.XmlSerializationWriter, SystemTypes.String, SystemTypes.String} );
call.Callee = new MemberBinding(new MemberBinding(null, memberSerializer), serialize);
call.Operands = args;
statements.Add( new ExpressionStatement( call ) );
}
void AddCallDeserializer(TypeNode type, StatementList statements, Identifier reader,
Expression target, Expression required, Expression result) {
Class memberSerializer = this.CreateSerializerFor(type);
// call the Deserialize method on it, and assign result to target object.
ExpressionList args = new ExpressionList();
args.Add(reader);
args.Add(required);
if (result is Local)
result = new UnaryExpression(result, NodeType.AddressOf);
args.Add(result);
MethodCall call = new MethodCall();
Method deserialize = memberSerializer.GetMethod(Identifier.For("Deserialize"), new TypeNode[3] { Runtime.XmlSerializationReader, SystemTypes.Boolean, SystemTypes.Boolean.GetReferenceType() } );
call.Callee = new MemberBinding(new MemberBinding(null, memberSerializer), deserialize);
call.Operands = args;
statements.Add(new AssignmentStatement(target, call));
}
public VisitedExpression Append(string literal)
{
ExpressionList.Add(new LiteralExpression(literal));
return(this);
}
/// <returns>A list of expression that should, by default, be tried as witness for the consistency of an expression of witnessType</returns>
private static ExpressionList GetDefaultWitnesses(TypeNode witnessType) {
ExpressionList result = new ExpressionList();
if (witnessType.IsPrimitiveNumeric || witnessType == SystemTypes.Char) {
result.Add(new Literal(0, witnessType, new SourceContext()));
result.Add(new Literal(1, witnessType, new SourceContext()));
} else if (witnessType is Struct) //for user-defined structs, return new S() as default (null doesn't work).
//Note that primitive numeric types are also structs, so the order of the if and else brach matters.
result.Add(new Local(StandardIds.NewObj, witnessType, new SourceContext()));
else
result.Add(new Literal(null, witnessType, new SourceContext()));
//special-case String! and object! (for which we know a consistent constructor)
OptionalModifier possibleNonNullType = (witnessType as OptionalModifier);
TypeNode t = (possibleNonNullType != null ? possibleNonNullType.ModifiedType : null);
if (witnessType == SystemTypes.String || witnessType == SystemTypes.Object || t == SystemTypes.String || t == SystemTypes.Object)
result.Add(new Literal("Let's Boogie!", witnessType));
return result;
}
public virtual Differences VisitExpressionList(ExpressionList list1, ExpressionList list2,
out ExpressionList changes, out ExpressionList deletions, out ExpressionList insertions){
changes = list1 == null ? null : list1.Clone();
deletions = list1 == null ? null : list1.Clone();
insertions = list1 == null ? new ExpressionList() : list1.Clone();
//^ assert insertions != null;
Differences differences = new Differences();
for (int j = 0, n = list2 == null ? 0 : list2.Count; j < n; j++){
//^ assert list2 != null;
Expression nd2 = list2[j];
if (nd2 == null) continue;
insertions.Add(null);
}
TrivialHashtable savedDifferencesMapFor = this.differencesMapFor;
this.differencesMapFor = null;
TrivialHashtable matchedNodes = new TrivialHashtable();
for (int i = 0, k = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
Expression nd1 = list1[i];
if (nd1 == null) continue;
Differences diff;
int j;
Expression nd2 = this.GetClosestMatch(nd1, list1, list2, i, ref k, matchedNodes, out diff, out j);
if (nd2 == null || diff == null){Debug.Assert(nd2 == null && diff == null); continue;}
matchedNodes[nd1.UniqueKey] = nd1;
matchedNodes[nd2.UniqueKey] = nd2;
changes[i] = diff.Changes as Expression;
deletions[i] = diff.Deletions as Expression;
insertions[i] = diff.Insertions as Expression;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
Debug.Assert(diff.Changes == changes[i] && diff.Deletions == deletions[i] && diff.Insertions == insertions[i]);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
}
//Find deletions
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
Expression nd1 = list1[i];
if (nd1 == null) continue;
if (matchedNodes[nd1.UniqueKey] != null) continue;
changes[i] = null;
deletions[i] = nd1;
insertions[i] = null;
differences.NumberOfDifferences += 1;
}
//Find insertions
for (int j = 0, n = list1 == null ? 0 : list1.Count, m = list2 == null ? 0 : list2.Count; j < m; j++){
//^ assert list2 != null;
Expression nd2 = list2[j];
if (nd2 == null) continue;
if (matchedNodes[nd2.UniqueKey] != null) continue;
insertions[n+j] = nd2; //Records nd2 as an insertion into list1, along with its position in list2
differences.NumberOfDifferences += 1; //REVIEW: put the size of the tree here?
}
if (differences.NumberOfDifferences == 0){
changes = null;
deletions = null;
insertions = null;
}
this.differencesMapFor = savedDifferencesMapFor;
return differences;
}
protected static Expression GetInferredWitness(ExpressionList eListIn, TypeNode resultType, Member theModelfield) {
#region Split Conjunct and Disjuncts into NoAndOrList, then look for this.mf == P or this.mf <==> P, return P if found
ExpressionList splitAndList = new ExpressionList();
foreach (Expression e in eListIn)
foreach (Expression e2 in SplitConjuncts(e))
splitAndList.Add(e2);
Expression inferredWitness = null; //stores the witness that we are constructing.
//eList is a list of ensures or satisfies clauses.
//if eList contains an expression "this.theModelfield == B", then either B is a witness or the mfC does not have a witness.
foreach (Expression e in splitAndList) {
if (e.NodeType == NodeType.Eq || e.NodeType == NodeType.Iff) {
inferredWitness = Checker.GetWitnessHelper(e, theModelfield);
if (inferredWitness != null)
return inferredWitness; //witness found
}
}
//split conjuncts and disjuncts for better chance of finding witness:
//ignore, will be replace anyway
/*
ExpressionList splitAndOrList = new ExpressionList();
foreach (Expression e in splitAndList)
WitnessAndOrSplit(e, splitAndOrList);
*/
ExpressionList splitAndOrList = splitAndList;
//try again
foreach (Expression e in splitAndOrList) {
if (e.NodeType == NodeType.Eq) {
inferredWitness = Checker.GetWitnessHelper(e, theModelfield);
if (inferredWitness != null)
return inferredWitness; //witness found
}
}
#endregion
/*
foreach (Expression e in eList) {
BinaryExpression eBinary = e as BinaryExpression;
if (eBinary != null && e.NodeType == NodeType.Eq) {
//equality found. Check if it is of the shape this.mf == P (where mf is the modelfield). If so, either P is a witness, or no witness exists.
MemberBinding posMf = eBinary.Operand1 as MemberBinding;
//can't compare against theModelfieldBinding as they are not the same object.
//not completely sure if the This check is good enough (no type info) but I think it should be enough (can't be of the wrong type as type is added automatically)
if (posMf != null && posMf.TargetObject is This && posMf.BoundMember == theModelfield)
return eBinary.Operand2;
posMf = eBinary.Operand2 as MemberBinding;
if (posMf != null && posMf.TargetObject is This && posMf.BoundMember == theModelfield)
return eBinary.Operand1;
}
}
*/
//no equalities.
if (resultType.IsPrimitiveNumeric || resultType == SystemTypes.Char) {
#region try numeric heuristics and return result
//Lets try our heuristics for >, <, <=, >=, !=.
bool greaterOk = true;
bool smallerOk = true;
foreach (Expression e in splitAndOrList) {
Expression improver = Checker.GetWitnessHelper(e, theModelfield);
if (improver == null) continue; //Not of the shape "this.themodelfield op B", no heuristic applies: we have to hope that the witness we come up with will satisfy this constraint.
NodeType addOrSub = NodeType.DefaultValue;
bool improve = true;
if (e.NodeType == NodeType.Ge && greaterOk) { //improve witness to max(inferredWitness, improver)
smallerOk = false;
} else if (e.NodeType == NodeType.Gt && greaterOk) { //improve witness to max(inferredWitness, improver + 1)
addOrSub = NodeType.Add;
smallerOk = false;
} else if (e.NodeType == NodeType.Le && smallerOk) {//improve witness to min(inferredWitness, improver)
greaterOk = false;
} else if (e.NodeType == NodeType.Lt && smallerOk) {//improve witness to min(inferredWitness, improver - 1)
addOrSub = NodeType.Sub;
greaterOk = false;
} else if (e.NodeType == NodeType.Ne) {
if (greaterOk)
addOrSub = NodeType.Add; //improve witness to inferredWitness != improver ? inferredWitness : improver + 1)
else if (smallerOk)
addOrSub = NodeType.Sub; //improve witness to inferredWitness != improver ? inferredWitness : improver - 1)
//do not change greaterOk and smallerOk: any value but improver is ok as a witness
} else
improve = false;
if (improve) {
Expression condition = new BinaryExpression(inferredWitness, improver, e.NodeType, new TypeExpression(new Literal(TypeCode.Boolean), 0));
if (addOrSub != NodeType.DefaultValue)
improver = new BinaryExpression(improver, new Literal(1, resultType), addOrSub, resultType);
if (inferredWitness == null)
inferredWitness = improver;
else {
inferredWitness = new TernaryExpression(condition, inferredWitness, improver, NodeType.Conditional, inferredWitness.Type);
}
}
}
if (inferredWitness == null)
inferredWitness = new Literal(0, resultType); //no witness candidate found, try 0 and hope for the best.
return inferredWitness;
#endregion
} else if (resultType.TypeCode == System.TypeCode.Boolean) {
#region try boolean heuristics and return result
//Try heuristics for ==> and != (note that we already checked for equalities in noAndOrList)
inferredWitness = new Literal(false, resultType); //false deals with this.theModelfield ==> P
Expression improver;
foreach (Expression e in splitAndOrList) {
if (e.NodeType == NodeType.Ne) {
improver = Checker.GetWitnessHelper(e, theModelfield);
if (improver != null) { //this.theModelfield != improver found.
return new UnaryExpression(improver, NodeType.Neg); //improve witness to !inferredWitness and return.
}
}
if (e.NodeType != NodeType.Implies) continue; //no heuristic applies.
improver = Checker.GetWitnessHelper(e, theModelfield, false);
if (improver != null) //found improver ==> this.theModelfield. Improve witness to inferredWitness || improver.
inferredWitness = new BinaryExpression(inferredWitness, improver, NodeType.Or);
}
return inferredWitness;
#endregion
}
//no heuristic applies. Return a default witness.
return Checker.GetDefaultWitnesses(resultType)[0]; //Allowing multiple witnesses for modelfields has not been implemented yet. Just return the first one for now.
}
// The method added by Jiri Adamek
// It generates NAtiveZOM calls
private void GenerateNativeZOMCall(Block block, MethodCall call, bool callIsAsync, AssignmentStatement assignmentStatement)
{
ZMethod method = (ZMethod)((MemberBinding)call.Callee).BoundMember;
// Eventually, this will be checked by an earlier phase.
Debug.Assert(method.Parameters.Count == call.Operands.Count);
// Asynchronous calls
Debug.Assert(!callIsAsync, "async not supporrted for NativeZOM calls");
// Debugging - parameters
for (int i = 0, n = call.Operands.Count; i < n; i++)
{
Parameter param = method.Parameters[i];
Debug.Assert(param != null);
// In fact, call.operands[i] MAY BE null due to the error recovery (if the type of the
// expression does not match the type in the method definition)
//
// Debug.Assert(call.Operands[i] != null);
Debug.Assert((param.Flags & ParameterFlags.Out) == 0, "out parameters not supported for NativeZOM calls");
}
Expression typename = new QualifiedIdentifier(new Identifier("Microsoft.Zing"), method.DeclaringType.Name);
Expression callee;
if (!method.IsStatic)
{
callee = Templates.GetExpressionTemplate("NativeZOMCallee");
Replacer.Replace(callee, "_TypeName", typename);
Expression pointer = this.VisitExpression(((MemberBinding)call.Callee).TargetObject);
Replacer.Replace(callee, "_Pointer", pointer);
Replacer.Replace(callee, "_MethodName", method.Name);
}
else
{
callee = Templates.GetExpressionTemplate("NativeZOMStaticCall");
Replacer.Replace(callee, "_ClassName", typename);
Replacer.Replace(callee, "_MethodName", method.Name);
}
ExpressionList argumentList = new ExpressionList();
argumentList.Add(Templates.GetExpressionTemplate("NativeZOMCallFirstArgument"));
foreach (Expression operand in call.Operands) argumentList.Add(this.VisitExpression(operand));
MethodCall nativeCall = new MethodCall(callee, argumentList);
Statement newStatement;
if (assignmentStatement != null)
{
newStatement = Templates.GetStatementTemplate("NativeZOMCallWithAssignment");
Replacer.Replace(newStatement, "_Dest", this.VisitExpression(assignmentStatement.Target));
Replacer.Replace(newStatement, "_Source", nativeCall);
}
else
{
newStatement = new ExpressionStatement(nativeCall);
}
block.Statements.Add(newStatement);
}
public static void SplitConjuncts(Expression e, ExpressionList el) {
if (e == null) return;
BinaryExpression be = e as BinaryExpression;
if (be == null) { el.Add(e); return; }
if (be.NodeType != NodeType.LogicalAnd) { el.Add(e); return; }
SplitConjuncts(be.Operand1, el);
SplitConjuncts(be.Operand2, el);
}
private Content[] GetFeed2Private(string feedPath, bool onlyFiles, bool onlyFolders, int start, int limit)
{
Node container = GetNodeById(feedPath);
if (container == null)
{
throw new NodeLoadException("Error loading path");
}
IFolder folder = container as IFolder;
if (folder == null)
{
return new Content[] { }
}
;
IEnumerable <Node> nodeList;
NodeQuery query;
if (onlyFiles || onlyFolders)
{
nodeList = onlyFiles ?
from child in folder.Children where child is IFile select child :
from child in folder.Children where child is IFolder select child;
}
else
{
//nodeList = folder.Children;
if (start == 0 && limit == 0)
{
nodeList = folder.Children;
}
else
{
SmartFolder smartFolder = folder as SmartFolder;
if (folder is SmartFolder)
{
query = new NodeQuery();
string queryString = ((SmartFolder)folder).Query;
ExpressionList orExp = new ExpressionList(ChainOperator.Or);
if (!string.IsNullOrEmpty(queryString))
{
orExp.Add(NodeQuery.Parse(queryString));
}
orExp.Add(new IntExpression(IntAttribute.ParentId, ValueOperator.Equal, container.Id));
query.Add(orExp);
}
else
{
query = new NodeQuery();
query.Add(new IntExpression(IntAttribute.ParentId, ValueOperator.Equal, container.Id));
}
query.PageSize = limit;
query.StartIndex = start == 0 ? 1 : start;
nodeList = query.Execute().Nodes;
}
}
return(nodeList.Select(node => new Content(node, false, false, false, false, start, limit)).ToArray());
}
/// <summary>
/// <para>
/// Serializes the expressions in toSerialize to an attribute determined by ctor, as if they come from module containingModule.
/// Uses the SourceContext information of <param name="sc">sc</param> for the source context for the attribute.
/// </para>
/// <para><code>
/// requires ctor != null && sc != null;
/// </code></para>
/// <para><code>
/// requires ctor.DeclaringType <: Microsoft.Contracts.AttributeWithContext;
/// </code></para>
/// </summary>
/// <returns></returns>
public static AttributeNode SerializeExpressions(InstanceInitializer/*!*/ ctor, ExpressionList dontSerialize, ExpressionList toSerialize, SourceContext/*!*/ sc, Module containingModule) {
MemberBinding attrBinding = new MemberBinding(null, ctor);
ExpressionList args = new ExpressionList();
if (dontSerialize != null) {
foreach (Expression e in dontSerialize) {
args.Add(e);
}
}
if (toSerialize != null) {
foreach (Expression e in toSerialize) {
ContractSerializer cs = new ContractSerializer(containingModule);
cs.Visit(e);
string val = cs.SerializedContract;
args.Add(new Literal(val, SystemTypes.String));
}
}
if (sc.SourceText != null) {
args.Add(new NamedArgument(Identifier.For("Filename"), new Literal(sc.Document.Name, SystemTypes.String)));
args.Add(new NamedArgument(Identifier.For("StartLine"), new Literal(sc.StartLine, SystemTypes.Int32)));
args.Add(new NamedArgument(Identifier.For("StartColumn"), new Literal(sc.StartColumn, SystemTypes.Int32)));
args.Add(new NamedArgument(Identifier.For("EndLine"), new Literal(sc.EndLine, SystemTypes.Int32)));
args.Add(new NamedArgument(Identifier.For("EndColumn"), new Literal(sc.EndColumn, SystemTypes.Int32)));
args.Add(new NamedArgument(Identifier.For("SourceText"), new Literal(sc.SourceText, SystemTypes.String)));
}
return new AttributeNode(attrBinding, args, (AttributeTargets)0);
}
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));
}
}
}
/// <summary>
/// requires serFor is Method || serFor is ModelfieldContract
/// </summary>
protected virtual void SerializeWUCList(System.Collections.Generic.List<Checker.WitnessUnderConstruction>/*!*/ toSer, bool isNotLowerbound, Node serFor) {
ModelfieldContract mfC = serFor as ModelfieldContract;
foreach (WitnessUnderConstruction wuc in toSer) {
InstanceInitializer ctor = SystemTypes.WitnessAttribute.GetConstructor(SystemTypes.Boolean, SystemTypes.Int32,
SystemTypes.String, SystemTypes.String, SystemTypes.String);
ExpressionList serList = new ExpressionList(wuc.Guard, wuc.Witness);
if (mfC != null)
serList.Add(new MemberBinding(new This(mfC.Modelfield.DeclaringType), mfC.Modelfield)); //add the name of the modelfield
else
serList.Add(null); //The witness-attribute will sit on the node, no need to add identifier
AttributeNode wa = Checker.SerializeExpressions(ctor, serList, wuc.Witness.SourceContext, this.currentModule);
//Now add the remaining 2 expressions to wa
ExpressionList eList = new ExpressionList(new Literal(isNotLowerbound, SystemTypes.Boolean), new Literal(wuc.NrOfDuplications, SystemTypes.Int32));
for (int i = 0; i < wa.Expressions.Count; i++) //use for loop to make sure the order of the expressions is preserved
eList.Add(wa.Expressions[i]);
wa.Expressions = eList;
if (mfC != null)
mfC.DeclaringType.Attributes.Add(wa);
else
(serFor as Method).Attributes.Add(wa);
}
}
If AddReadChild(Block scope, StatementList statements, Identifier name, TypeNode type, Expression target, Identifier reader, Expression result, bool unwrapChild, bool ignoreNamespace) {
ExpressionList args = new ExpressionList();
args.Add(new Literal(name.Name, SystemTypes.String));
if (name.Prefix != null) args.Add(new Literal(name.Prefix.Name, SystemTypes.String));
// see if we're on a text node...
Local nodeType = new Local(Identifier.For("nodeType"), Runtime.XmlNodeType, scope);
statements.Add(new AssignmentStatement(nodeType, new QualifiedIdentifier(reader, Identifier.For("NodeType"))));
StatementList ifTextStatements = new StatementList();
If ifIsText = new If(
new BinaryExpression(IsTextNode(nodeType),
new BinaryExpression(nodeType,
new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("EndElement")), NodeType.Eq),
NodeType.Or), new Block(ifTextStatements), new Block(new StatementList()));
statements.Add(ifIsText);
// then see if we can force the text into the desired type.
TypeNode unwrapped = UnwrapSingletonTuple(Unwrap(type), false);
if (unwrapped == null) unwrapped = type;
Expression readString = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("ReadString")), null, NodeType.Callvirt, SystemTypes.String);
Expression coercion = GetConvertFromString(unwrapped, readString, false);
if (coercion != null) {
ifTextStatements = ifIsText.TrueBlock.Statements;
ifTextStatements.Add(new AssignmentStatement(target, CastTo(CastTo(coercion, unwrapped),type)));
ifTextStatements.Add(new AssignmentStatement(result, Literal.True));
}
statements = ifIsText.FalseBlock.Statements;
If ifFound = null;
string method = ignoreNamespace ? "IsStartElementIgnoreNamespace" : "IsStartElement";
MethodCall isStartEle = new MethodCall(new QualifiedIdentifier(reader, Identifier.For(method)), args);
ifFound = new If(isStartEle, new Block(new StatementList()), new Block(new StatementList()));
statements.Add(ifFound);
statements = ifFound.TrueBlock.Statements;
statements.Add(new AssignmentStatement(result, Literal.True));
// body of if test, parse the child element as the specified type.
MethodCall read = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Read")), new ExpressionList());
bool isStructuralType = this.IsStructuralType(type);
if (isStructuralType && unwrapChild) {
// consume member element wrapper.
statements.Add(new ExpressionStatement(read));
}
if (type.Template == SystemTypes.GenericBoxed){
type = Checker.GetCollectionElementType(type);
}
if (!AddReadSimpleType(type, statements, reader, target, result, false)) {
AddCallDeserializer(type, statements, reader, target, result, result);
}
if (isStructuralType && unwrapChild) {
// consume member element end tag wrapper.
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("ReadEndTag")), new ExpressionList(new Literal(name.Name, SystemTypes.String)))));
}
return ifFound;
}
private void EmitCheckExceptionBody(Method checkExceptionMethod, List <EnsuresExceptional> exceptionalPostconditions)
{
Contract.Requires(checkExceptionMethod != null);
Contract.Requires(exceptionalPostconditions != null);
Contract.Requires(exceptionalPostconditions.Count > 0);
// We emit the following method:
// bool CheckException(Exception e) {
// var ex = e as C1;
// if (ex != null) {
// EnsuresOnThrow(predicate)
// }
// else {
// var ex2 = e as AggregateException;
// if (ex2 != null) {
// ex2.Handle(CheckException);
// }
// }
//
// // Method always returns true. This is by design!
// // We need to check all exceptions in the AggregateException
// // and fail in EnsuresOnThrow if the postcondition is not met.
// return true; // handled
var body = checkExceptionMethod.Body.Statements;
var returnBlock = new Block(new StatementList());
foreach (var e in exceptionalPostconditions)
{
// The catchBlock contains the catchBody, and then
// an empty block that is used in the EH.
// TODO ST: name is confusing because there is no catch blocks in this method!
Block catchBlock = new Block(new StatementList());
// local is: var ex1 = e as C1;
Local localEx = new Local(e.Type);
body.Add(
new AssignmentStatement(localEx,
new BinaryExpression(checkExceptionMethod.Parameters[0],
new MemberBinding(null, e.Type),
NodeType.Isinst)));
Block skipBlock = new Block();
body.Add(new Branch(new UnaryExpression(localEx, NodeType.LogicalNot), skipBlock));
body.Add(catchBlock);
body.Add(skipBlock);
// call Contract.EnsuresOnThrow
ExpressionList args = new ExpressionList();
args.Add(e.PostCondition);
args.Add(e.UserMessage ?? Literal.Null);
args.Add(e.SourceConditionText ?? Literal.Null);
args.Add(localEx);
var checks = new StatementList();
checks.Add(
new ExpressionStatement(
new MethodCall(
new MemberBinding(null, this.rewriter.RuntimeContracts.EnsuresOnThrowMethod),
args,
NodeType.Call,
SystemTypes.Void),
e.SourceContext));
this.rewriter.CleanUpCodeCoverage.VisitStatementList(checks);
// TODO ST: actually I can't see this recursion guard check in the resulting IL!!
rewriter.EmitRecursionGuardAroundChecks(checkExceptionMethod, catchBlock, checks);
catchBlock.Statements.Add(new Branch(null, returnBlock));
}
// recurse on AggregateException itself
{
// var ae = e as AggregateException;
// if (ae != null) {
// ae.Handle(this.CheckException);
// }
Block catchBlock = new Block(new StatementList());
var aggregateType = aggregateExceptionType.Value;
// var ex2 = e as AggregateException;
Local localEx2 = new Local(aggregateType);
body.Add(
new AssignmentStatement(localEx2,
new BinaryExpression(
checkExceptionMethod.Parameters[0],
new MemberBinding(null, aggregateType),
NodeType.Isinst)));
Block skipBlock = new Block();
body.Add(new Branch(new UnaryExpression(localEx2, NodeType.LogicalNot), skipBlock));
body.Add(catchBlock);
body.Add(skipBlock);
var funcType = func2Type.Value;
funcType = funcType.GetTemplateInstance(this.rewriter.AssemblyBeingRewritten, SystemTypes.Exception, SystemTypes.Boolean);
var handleMethod = aggregateType.GetMethod(Identifier.For("Handle"), funcType);
var funcLocal = new Local(funcType);
var ldftn =
new UnaryExpression(
new MemberBinding(null, checkExceptionMethod),
NodeType.Ldftn,
CoreSystemTypes.IntPtr);
catchBlock.Statements.Add(
new AssignmentStatement(funcLocal,
new Construct(
new MemberBinding(null, funcType.GetConstructor(SystemTypes.Object, SystemTypes.IntPtr)),
new ExpressionList(checkExceptionMethod.ThisParameter, ldftn))));
catchBlock.Statements.Add(
new ExpressionStatement(new MethodCall(new MemberBinding(localEx2, handleMethod),
new ExpressionList(funcLocal))));
}
// add return true to CheckException method
body.Add(returnBlock);
body.Add(new Return(Literal.True));
}
bool AddWriteSimpleAttribute(TypeNode type, Identifier name, StatementList statements, TypeNode referringType, Identifier writer, Expression src) {
ExpressionList args = new ExpressionList();
args.Add(GetXmlNameFromId(name));
args.Add(GetXmlNamespaceFromId(name));
args.Add(src);
if (type == SystemTypes.String) {
statements = AddCheckForNull(statements, Duplicate(src, referringType), type);
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeString")), args)));
} else if( type == SystemTypes.Boolean) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeBoolean")), args)));
} else if( type == SystemTypes.Int8) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeSByte")), args)));
} else if( type == SystemTypes.Char) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeChar")), args)));
} else if( type == SystemTypes.DateTime) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeDateTime")), args)));
} else if( type == SystemTypes.Decimal) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeDecimal")), args)));
} else if( type == SystemTypes.Double) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeDouble")), args)));
} else if( type == SystemTypes.Guid) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeGuid")), args)));
} else if( type == SystemTypes.Int16) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeInt16")), args)));
} else if( type == SystemTypes.Int32) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeInt32")), args)));
} else if( type == SystemTypes.Int64) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeInt64")), args)));
} else if( type == SystemTypes.UInt8) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeByte")), args)));
} else if( type == SystemTypes.Single) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeSingle")), args)));
} else if( type == SystemTypes.TimeSpan) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeTimeSpan")), args)));
} else if( type == SystemTypes.UInt16 ) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeUInt16")), args)));
} else if( type == SystemTypes.UInt32) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeUInt32")), args)));
} else if( type == SystemTypes.UInt64) {
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeUInt64")), args)));
} else {
Expression conversion = GetConvertToString(type, src, true);
if (conversion != null) {
statements = AddCheckForNull(statements, Duplicate(src, referringType), type);
ExpressionList args2 = new ExpressionList();
args2.Add(args[0]);
args2.Add(args[1]);
args2.Add(conversion);
statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, Identifier.For("WriteAttributeString")), args2)));
} else {
return false;
}
}
return true;
}
public virtual Expression VisitBinaryExpression(BinaryExpression binaryExpression, Expression opnd1, Expression opnd2, TypeNode t1, TypeNode t2){
if (binaryExpression == null){Debug.Assert(false); return null;}
if (t1 == SystemTypes.String || t2 == SystemTypes.String) {
switch (binaryExpression.NodeType) {
case NodeType.Add:
if (opnd1 is Literal && opnd2 is Literal && t1 == SystemTypes.String && t2 == SystemTypes.String) {
string s1 = ((Literal)opnd1).Value as string;
string s2 = ((Literal)opnd2).Value as string;
return new Literal(s1 + s2, SystemTypes.String, binaryExpression.SourceContext);
}
Method operatorMethod = this.GetBinaryOperatorOverload(binaryExpression);
if (operatorMethod != null) break;
if (this.typeSystem.ImplicitCoercionFromTo(t1, SystemTypes.String, this.TypeViewer) && this.typeSystem.ImplicitCoercionFromTo(t2, SystemTypes.String, this.TypeViewer))
return new MethodCall(new MemberBinding(null, Runtime.StringConcatStrings), new ExpressionList(opnd1, opnd2),
NodeType.Call, SystemTypes.String, binaryExpression.SourceContext);
else
return new MethodCall(new MemberBinding(null, Runtime.StringConcatObjects), new ExpressionList(opnd1, opnd2),
NodeType.Call, SystemTypes.String, binaryExpression.SourceContext);
case NodeType.Eq:
case NodeType.Ne:
binaryExpression.Type = SystemTypes.Boolean;
if (t1 == SystemTypes.String && t2 == SystemTypes.String)
return this.StringValueComparison(binaryExpression);
else if (t1 == SystemTypes.Object || t2 == SystemTypes.Object)
return binaryExpression;
else
break;
}
}
if ((t1 is DelegateNode) && (t2 is DelegateNode) && t1 != t2 && (binaryExpression.NodeType == NodeType.Eq || binaryExpression.NodeType == NodeType.Ne)) {
this.HandleError(binaryExpression, Error.BadBinaryOps,
binaryExpression.NodeType == NodeType.Eq ? "==" : "!=", this.GetTypeName(t1), this.GetTypeName(t2));
return null;
}
if ((t1 != SystemTypes.Object && t2 != SystemTypes.Object) ||
!(binaryExpression.NodeType == NodeType.Eq || binaryExpression.NodeType == NodeType.Ne) ||
(t1.Template == SystemTypes.GenericBoxed || t2.Template == SystemTypes.GenericBoxed)){
Method operatorMethod = this.GetBinaryOperatorOverload(binaryExpression);
if (operatorMethod != null) {
MemberBinding callee = new MemberBinding(null, operatorMethod);
ExpressionList arguments = new ExpressionList(2);
if (t1 == SystemTypes.Delegate && t2 is DelegateNode && (binaryExpression.NodeType == NodeType.Eq || binaryExpression.NodeType == NodeType.Ne)) {
if (opnd1 is MemberBinding && ((MemberBinding)opnd1).BoundMember is Method)
opnd1 = this.VisitExpression(new Construct(new MemberBinding(null, t2), new ExpressionList(opnd1)));
}
arguments.Add(opnd1);
if (t1 is DelegateNode && t2 == SystemTypes.Delegate && (binaryExpression.NodeType == NodeType.Eq || binaryExpression.NodeType == NodeType.Ne)) {
if (opnd2 is MemberBinding && ((MemberBinding)opnd2).BoundMember is Method)
opnd2 = this.VisitExpression(new Construct(new MemberBinding(null, t1), new ExpressionList(opnd2)));
}
arguments.Add(opnd2);
MethodCall call = new MethodCall(callee, arguments);
call.SourceContext = binaryExpression.SourceContext;
call.Type = operatorMethod.ReturnType;
switch (binaryExpression.NodeType) {
case NodeType.LogicalAnd:
case NodeType.LogicalOr:
binaryExpression.Operand1 = new Local(call.Type);
binaryExpression.Operand2 = call;
binaryExpression.Type = call.Type;
return binaryExpression;
}
return call;
}else if ((t1 == SystemTypes.String || t2 == SystemTypes.String) &&
(binaryExpression.NodeType == NodeType.Eq || binaryExpression.NodeType == NodeType.Ne) &&
this.typeSystem.ImplicitCoercionFromTo(t1, SystemTypes.String, this.TypeViewer) &&
this.typeSystem.ImplicitCoercionFromTo(t2, SystemTypes.String, this.TypeViewer)){
return this.StringValueComparison(binaryExpression);
}
}
if (t1 is DelegateNode || t2 is DelegateNode){
if (binaryExpression.NodeType == NodeType.Add || binaryExpression.NodeType == NodeType.Sub) {
binaryExpression.Type = this.typeSystem.ImplicitCoercionFromTo(opnd1, t1, t2, this.TypeViewer) ? t2 : t1;
return binaryExpression;
}
}
if ((t1 is Pointer || t2 is Pointer) && (binaryExpression.NodeType == NodeType.Add || binaryExpression.NodeType == NodeType.Sub)){
TypeNode elementType = t1 is Pointer ? ((Pointer)t1).ElementType : ((Pointer)t2).ElementType;
Expression sizeOf = this.VisitUnaryExpression(new UnaryExpression(new Literal(elementType, SystemTypes.Type), NodeType.Sizeof, SystemTypes.UInt32));
if (binaryExpression.NodeType == NodeType.Sub) {
if (elementType == SystemTypes.Void) {
this.HandleError(binaryExpression, Error.VoidError);
return null;
}
if (t1 is Pointer && t2 is Pointer && ((Pointer)t1).ElementType == ((Pointer)t2).ElementType) {
binaryExpression.Operand1 = new BinaryExpression(opnd1, new Literal(SystemTypes.Int64, SystemTypes.Type), NodeType.ExplicitCoercion, SystemTypes.Int64, opnd1.SourceContext);
binaryExpression.Operand2 = new BinaryExpression(opnd2, new Literal(SystemTypes.Int64, SystemTypes.Type), NodeType.ExplicitCoercion, SystemTypes.Int64, opnd2.SourceContext);
binaryExpression.Type = SystemTypes.Int64;
return new BinaryExpression(binaryExpression, sizeOf, NodeType.Div, SystemTypes.Int64, binaryExpression.SourceContext);
}
}
if (!(t1 is Pointer && t2 is Pointer)) {
binaryExpression.Type = t1 is Pointer ? t1 : t2;
if (elementType == SystemTypes.Void) {
this.HandleError(binaryExpression, Error.VoidError);
return null;
}
sizeOf.Type = SystemTypes.IntPtr;
if (t1 is Pointer) {
Literal lit = binaryExpression.Operand2 as Literal;
if (lit == null || !(lit.Value is int) || ((int)lit.Value) != 1) {
if (!(sizeOf is Literal) || !(((Literal)sizeOf).Value is int) || (int)((Literal)sizeOf).Value != 1) {
if (binaryExpression.Operand2.Type == SystemTypes.Int32) binaryExpression.Operand2.Type = SystemTypes.IntPtr;
binaryExpression.Operand2 = new BinaryExpression(binaryExpression.Operand2, sizeOf, NodeType.Mul, SystemTypes.IntPtr, binaryExpression.Operand2.SourceContext);
}
} else
binaryExpression.Operand2 = sizeOf;
} else {
if (binaryExpression.NodeType == NodeType.Sub) return binaryExpression; //Let Checker issue a message
Literal lit = binaryExpression.Operand1 as Literal;
if (lit == null || !(lit.Value is int) || ((int)lit.Value) != 1) {
if (!(sizeOf is Literal) || !(((Literal)sizeOf).Value is int) || (int)((Literal)sizeOf).Value != 1) {
if (binaryExpression.Operand1.Type == SystemTypes.Int32) binaryExpression.Operand1.Type = SystemTypes.IntPtr;
binaryExpression.Operand1 = new BinaryExpression(binaryExpression.Operand1, sizeOf, NodeType.Mul, SystemTypes.IntPtr, binaryExpression.Operand1.SourceContext);
}
} else
binaryExpression.Operand1 = sizeOf;
}
return binaryExpression;
}
}
binaryExpression.Type = this.InferTypeOfBinaryExpression(t1, t2, binaryExpression);
if (binaryExpression.Operand1 == null || binaryExpression.Operand2 == null) binaryExpression.IsErroneous = true;
try{
bool savedCheckOverflow = this.typeSystem.checkOverflow;
this.typeSystem.checkOverflow = !this.typeSystem.suppressOverflowCheck;
MemberBinding mb = opnd1 as MemberBinding;
if (mb != null && mb.Type == SystemTypes.Delegate && mb.BoundMember is Method && binaryExpression.NodeType == NodeType.Is) { return Literal.False; }
Literal lit = PureEvaluator.EvalBinaryExpression(this.EvaluateAsLiteral(opnd1), this.EvaluateAsLiteral(opnd2), binaryExpression, this.typeSystem);
this.typeSystem.checkOverflow = savedCheckOverflow;
if (lit != null){
if (binaryExpression.Type != lit.Type) {
EnumNode enType = binaryExpression.Type as EnumNode;
if (enType != null && this.typeSystem.ImplicitCoercionFromTo(lit, lit.Type, enType.UnderlyingType, this.TypeViewer))
lit.Type = enType;
else if (binaryExpression.Type == SystemTypes.Single && lit.Type == SystemTypes.Double)
lit.Type = SystemTypes.Single;
else if (binaryExpression.Type is EnumNode && ((EnumNode)binaryExpression.Type).UnderlyingType == SystemTypes.UInt32 &&
lit.Type == SystemTypes.Int64 && ((long)lit.Value) <= uint.MaxValue)
lit = new Literal((uint)(long)lit.Value, SystemTypes.UInt32);
else if (binaryExpression.Type == SystemTypes.Int64 && lit.Type == SystemTypes.UInt64)
binaryExpression.Type = SystemTypes.UInt64;
}
lit.SourceExpression = binaryExpression;
lit.SourceContext = binaryExpression.SourceContext;
if (binaryExpression.NodeType == NodeType.ExplicitCoercion){
lit.SourceExpression = opnd1;
lit.TypeWasExplicitlySpecifiedInSource = true;
}
return lit;
}
}catch (OverflowException){
if (binaryExpression.Type is EnumNode && this.currentField != null) {
this.HandleError(binaryExpression, Error.EnumerationValueOutOfRange, this.GetMemberSignature(this.currentField));
return Literal.Int32Zero;
}
this.HandleError(binaryExpression, Error.CTOverflow);
return null;
}catch{} //TODO: be more specific
return binaryExpression;
}
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 virtual Expression StringValueComparison(BinaryExpression binaryExpression){
if (binaryExpression == null) return null;
ExpressionList arguments = new ExpressionList(2);
arguments.Add(binaryExpression.Operand1);
arguments.Add(binaryExpression.Operand2);
MethodCall mcall = new MethodCall(new MemberBinding(null, Runtime.StringEquals), arguments, NodeType.Call);
mcall.Type = SystemTypes.Boolean;
mcall.SourceContext = binaryExpression.SourceContext;
if (binaryExpression.NodeType == NodeType.Eq) return mcall;
UnaryExpression uex = new UnaryExpression(mcall, NodeType.LogicalNot);
uex.Type = SystemTypes.Boolean;
uex.SourceContext = binaryExpression.SourceContext;
return uex;
}
public virtual ExpressionList VisitExpressionList(ExpressionList expressions, ExpressionList changes, ExpressionList deletions, ExpressionList insertions){
if (changes == null || deletions == null || insertions == null) return expressions;
int n = expressions == null ? 0 : expressions.Count;
if (n > changes.Count){Debug.Assert(false); n = changes.Count;}
if (n > deletions.Count){Debug.Assert(false); n = deletions.Count;}
if (n > insertions.Count){Debug.Assert(false); n = insertions.Count;}
if (expressions != null)
for (int i = 0; i < n; i++)
expressions[i] = this.VisitExpression(expressions[i], changes[i], deletions[i], insertions[i]);
ExpressionList result = new ExpressionList(insertions.Count-n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Expression VisitBooleanExpression(Expression expr) {
UnaryExpression uexpr = expr as UnaryExpression;
if (uexpr != null && uexpr.NodeType == NodeType.LogicalNot) {
Expression e = uexpr.Operand = this.VisitBooleanExpression(uexpr.Operand);
if (e == null) return null;
MethodCall mcall = e as MethodCall;
if (mcall != null) {
MemberBinding mb = mcall.Callee as MemberBinding;
Member m = null;
if (mb == null || (m = mb.BoundMember) == null) return null;
if (m == this.GetTypeView(m.DeclaringType).GetOpTrue()) {
Method meth = this.GetTypeView(m.DeclaringType).GetOpFalse();
if (meth != null) {
mb.BoundMember = meth; return mcall;
}
} else if (m == this.GetTypeView(m.DeclaringType).GetOpFalse()) {
Method meth = this.GetTypeView(m.DeclaringType).GetOpTrue();
if (meth != null) {
mb.BoundMember = meth; return mcall;
}
}
}
} else
expr = this.VisitExpression(expr);
TypeNode eType = null;
if (expr == null || (eType = expr.Type) == null) return null;
if (!this.typeSystem.ImplicitCoercionFromTo(eType, SystemTypes.Boolean, this.TypeViewer)) {
Method opTrue = this.GetTypeView(eType).GetOpTrue();
if (opTrue != null) {
ExpressionList args = new ExpressionList(1);
args.Add(this.typeSystem.ImplicitCoercion(expr, opTrue.DeclaringType, this.TypeViewer));
return new MethodCall(new MemberBinding(null, opTrue), args, NodeType.Call, SystemTypes.Boolean, expr.SourceContext);
}
}
return this.typeSystem.ImplicitCoercion(expr, SystemTypes.Boolean, this.TypeViewer);
}
public void Append(VisitedExpression expression)
{
ExpressionList.Add(expression);
}
public virtual void CoerceArguments(ParameterList parameters, ref ExpressionList arguments, bool doNotVisitArguments, CallingConventionFlags callingConvention) {
if (arguments == null) arguments = new ExpressionList();
int n = arguments.Count;
int m = parameters == null ? 0 : parameters.Count;
//if fewer arguments than parameters, supply default values
for (; n < m; n++) {
Parameter p = parameters[n];
TypeNode type = p == null ? null : p.Type;
if (type == null) type = SystemTypes.Object;
type = TypeNode.StripModifiers(type);
if (p.DefaultValue != null)
arguments.Add(p.DefaultValue);
else {
//There should already have been a complaint. Just recover.
TypeNode elementType = parameters[n].GetParamArrayElementType();
if (elementType != null) break;
arguments.Add(new UnaryExpression(new Literal(type, SystemTypes.Type), NodeType.DefaultValue, type));
}
}
if (m > 0) {
TypeNode elementType = TypeNode.StripModifiers(parameters[m-1].GetParamArrayElementType());
TypeNode lastArgType = null;
if (elementType != null && (n > m || (n == m - 1) || n == m
&& (lastArgType = TypeNode.StripModifiers(arguments[m-1].Type)) != null &&
!this.GetTypeView(lastArgType).IsAssignableTo(TypeNode.StripModifiers(parameters[m-1].Type)) &&
!(arguments[m-1].Type == SystemTypes.Object && arguments[m-1] is Literal && ((Literal)arguments[m-1]).Value == null))) {
ExpressionList varargs = new ExpressionList(n-m+1);
for (int i = m-1; i < n; i++)
varargs.Add(arguments[i]);
Debug.Assert(m <= n || m == n+1);
while (m > n++) arguments.Add(null);
arguments[m-1] = new ConstructArray(parameters[m-1].GetParamArrayElementType(), varargs);
arguments.Count = m;
n = m;
}
}
if (n > m) {
// Handle Varargs
Debug.Assert(n == m+1);
Debug.Assert((callingConvention & CallingConventionFlags.VarArg) != 0);
ArglistArgumentExpression ale = arguments[n-1] as ArglistArgumentExpression;
if (ale != null) {
// rewrite nested arguments to one level.
// otherwise, the method does not match and I expect the Checker to issue a nice message.
ExpressionList newArgs = new ExpressionList(n - 1 + ale.Operands.Count);
for (int i=0; i<n-1; i++) {
newArgs.Add(arguments[i]);
}
for (int i=0; i<ale.Operands.Count; i++) {
newArgs.Add(ale.Operands[i]);
}
arguments = newArgs;
// adjust formal parameters to actuals
parameters = (ParameterList)parameters.Clone();
for (int i=0; i<ale.Operands.Count; i++) {
if (arguments[i+m] != null) {
TypeNode pType = arguments[i+m].Type;
Reference r = pType as Reference;
if (r != null) pType = r.ElementType;
parameters.Add(new Parameter(null, pType));
} else {
parameters.Add(new Parameter(null, SystemTypes.Object));
}
}
m = arguments.Count;
n = m;
} else {
// leave arguments and let type coercion fail
// adjust formal parameters to actuals
parameters = (ParameterList)parameters.Clone();
parameters.Add(Resolver.ArglistDummyParameter);
n = parameters.Count;
}
}
if (doNotVisitArguments) {
for (int i = 0; i < n; i++) {
Parameter p = this.typeSystem.currentParameter = parameters[i];
Literal lit = arguments[i] as Literal;
if (lit != null && lit.Value is TypeNode && p.Type == SystemTypes.Type)
arguments[i] = lit;
else {
if (!this.DoNotVisitArguments(p.DeclaringMethod)) {
Expression e = arguments[i] = this.typeSystem.ImplicitCoercion(arguments[i], p.Type, this.TypeViewer);
if (e is BinaryExpression && e.NodeType == NodeType.Box) e = arguments[i] = ((BinaryExpression)e).Operand1;
}
}
}
} else {
for (int i = 0; i < n; i++) {
Parameter p = this.typeSystem.currentParameter = parameters[i];
bool savedMayReferenceThisAndBase = this.MayReferenceThisAndBase;
if (p.IsOut
&& this.currentMethod is InstanceInitializer) {
// allow calls "f(out this.x)" before the explicit base ctor call
this.MayReferenceThisAndBase = true;
}
arguments[i] = this.CoerceArgument(this.VisitExpression(arguments[i]), p);
this.MayReferenceThisAndBase = savedMayReferenceThisAndBase;
}
}
this.typeSystem.currentParameter = null;
}
private static void AddInterfaceImplementationWrapper(Class Class, Method intfMethod, Method baseMethod)
{
var d = new Duplicator(Class.DeclaringModule, Class);
d.SkipBodies = true;
var copy = d.VisitMethod(baseMethod);
copy.Flags = MethodFlags.Private | MethodFlags.HideBySig | MethodFlags.Virtual | MethodFlags.NewSlot |
MethodFlags.Final;
copy.ImplementedInterfaceMethods = new MethodList(intfMethod);
copy.Name = Identifier.For("InheritedInterfaceImplementationContractWrapper$" + intfMethod.Name.Name);
copy.ClearBody();
copy.ThisParameter.Type = Class;
var bodyBlock = new Block(new StatementList());
copy.Body = new Block(new StatementList(bodyBlock));
// add call to baseMethod
var calledMethod = (baseMethod.TemplateParameters != null && baseMethod.TemplateParameters.Count > 0)
? baseMethod.GetTemplateInstance(Class, copy.TemplateParameters)
: baseMethod;
var argList = new ExpressionList();
for (int i = 0; i < copy.Parameters.Count; i++)
{
argList.Add(copy.Parameters[i]);
}
var callExpression = new MethodCall(new MemberBinding(copy.ThisParameter, calledMethod), argList);
if (HelperMethods.IsVoidType(intfMethod.ReturnType))
{
bodyBlock.Statements.Add(new ExpressionStatement(callExpression));
}
else
{
bodyBlock.Statements.Add(new Return(callExpression));
}
Class.Members.Add(copy);
}
public virtual AttributeNode VisitAttributeNode(AttributeNode attribute, Node target) {
if (attribute == null || target == null) return null;
attribute.Constructor = this.VisitAttributeConstructor(attribute, target);
ExpressionList expressions = attribute.Expressions = this.VisitExpressionList(attribute.Expressions);
MemberBinding mb = attribute.Constructor as MemberBinding;
if (mb == null || mb.BoundMember == null) {
Debug.Assert(attribute.Constructor == null);
return null;
}
//Check arguments for validity
TypeNode attributeType = mb.BoundMember.DeclaringType;
if (attributeType == null) return null;
InstanceInitializer ctor = (InstanceInitializer)mb.BoundMember;
ParameterList pars = ctor.Parameters;
ExpressionList positionalArgs = new ExpressionList();
TrivialHashtable alreadySeenNames = new TrivialHashtable();
for (int i = 0, n = expressions == null ? 0 : expressions.Count; i < n; i++) {
Expression e = expressions[i];
this.TypeInVariableContext(e as Literal);
NamedArgument narg = e as NamedArgument;
if (narg == null) { positionalArgs.Add(e); expressions[i] = null; continue; }
if (narg.Name == null) { expressions[i] = null; continue; }
if (alreadySeenNames[narg.Name.UniqueIdKey] != null) {
this.HandleError(narg.Name, Error.DuplicateNamedAttributeArgument, narg.Name.ToString());
expressions[i] = null; continue;
}
alreadySeenNames[narg.Name.UniqueIdKey] = narg.Name;
Member mem = null;
TypeNode aType = attributeType;
while (aType != null) {
MemberList members = this.GetTypeView(aType).GetMembersNamed(narg.Name);
for (int j = 0, m = members == null ? 0 : members.Count; j < m; j++) {
mem = members[j];
if (mem == null) continue;
switch (mem.NodeType) {
case NodeType.Field:
if (!mem.IsPublic) goto error;
Field f = (Field)mem;
if (f.IsInitOnly || f.IsLiteral || f.IsStatic) goto error;
if (!this.IsValidTypeForCustomAttributeParameter(f.Type)) {
this.HandleError(narg, Error.BadNamedAttributeArgumentType, this.GetMemberSignature(f));
this.HandleRelatedError(f);
return null;
}
this.CheckForObsolesence(narg, f);
narg.IsCustomAttributeProperty = false;
e = this.typeSystem.ImplicitCoercion(narg.Value, narg.Type = f.Type, this.TypeViewer);
if (!this.IsValidTypeForCustomAttributeArgument(e, narg.Value)) return null;
if (e is BinaryExpression && e.NodeType == NodeType.Box) {
narg.ValueIsBoxed = true;
e = ((BinaryExpression)e).Operand1;
}
narg.Value = e;
goto doneWithArg;
case NodeType.Property:
if (!mem.IsPublic) goto error;
Property p = (Property)mem;
if (!this.IsValidTypeForCustomAttributeParameter(p.Type)) {
this.HandleError(narg, Error.BadNamedAttributeArgumentType, this.GetMemberSignature(p));
this.HandleRelatedError(p);
return null;
}
if (p.Setter == null || p.Getter == null || p.IsStatic || !p.Setter.IsPublic || !p.Getter.IsPublic) goto error;
this.CheckForObsolesence(narg, p);
narg.IsCustomAttributeProperty = true;
e = this.typeSystem.ImplicitCoercion(narg.Value, narg.Type = p.Type, this.TypeViewer);
if (!this.IsValidTypeForCustomAttributeArgument(e, narg.Value)) return null;
if (e is BinaryExpression && e.NodeType == NodeType.Box) {
narg.ValueIsBoxed = true;
e = ((BinaryExpression)e).Operand1;
}
narg.Value = e;
goto doneWithArg;
}
}
aType = aType.BaseType;
}
error:
if (mem != null) {
this.HandleError(narg, Error.BadNamedAttributeArgument, narg.Name.ToString());
this.HandleRelatedError(mem);
} else
this.HandleError(narg, Error.NoSuchMember, this.GetTypeName(attributeType), narg.Name.ToString());
doneWithArg: ;
}
ExpressionList exprs = positionalArgs.Clone();
this.CoerceArguments(pars, ref positionalArgs, true, ctor.CallingConvention);
attribute.Expressions = positionalArgs;
for (int i = 0, n = positionalArgs == null ? 0 : positionalArgs.Count; i < n; i++) {
Expression e = positionalArgs[i];
if (e == null) continue;
if (!this.IsValidTypeForCustomAttributeArgument(e, exprs[i])) return null;
if (e is BinaryExpression && e.NodeType == NodeType.Box) e = ((BinaryExpression)e).Operand1;
positionalArgs[i] = e;
}
for (int i = 0, n = expressions == null ? 0 : expressions.Count; i < n; i++) {
Expression e = expressions[i];
if (e == null) continue;
positionalArgs.Add(e);
}
attribute.Expressions = positionalArgs;
//Now call specific visitors to deal with any pseudo custom attributes that describe metadata settings for target
switch (target.NodeType) {
case NodeType.Assembly: return this.VisitAssemblyAttribute(attribute, (AssemblyNode)target);
case NodeType.Field: return this.VisitFieldAttribute(attribute, (Field)target);
case NodeType.InstanceInitializer:
case NodeType.StaticInitializer:
case NodeType.Method: return this.VisitMethodAttribute(attribute, (Method)target);
case NodeType.Property: return this.VisitPropertyAttribute(attribute, (Property)target);
case NodeType.Parameter: return this.VisitParameterAttribute(attribute, (Parameter)target);
default:
TypeNode t = target as TypeNode;
if (t != null) return this.VisitTypeAttribute(attribute, t);
break;
}
return attribute;
}