public override void Visit(IArrayIndexer arrayIndexer)
{
if (arrayIndexer.Indices.Count() == 1 && Names.NameTable.ContainsKey(arrayIndexer.IndexedObject))
{
// the array expression, e.g.: this.array
var arrayName = Names.NameTable[arrayIndexer.IndexedObject];
// the contents expression, e.g.: this.array[..]
var arrayContents = NameBuilder.FormElementsExpression(arrayName);
// mark array indexes as compatible
var index = arrayIndexer.Indices.First();
if (Names.NameTable.ContainsKey(index))
{
// The array reference may not have been used in a comparable way yet.
if (!ids.ContainsKey(arrayContents))
{
ids.Add(arrayContents, comparability.AddElement());
}
if (!collectionIndexes.ContainsKey(arrayContents))
{
collectionIndexes.Add(arrayContents, new HashSet <string>());
}
if (collectionIndexes[arrayContents].Add(Names.NameTable[index]))
{
// we haven't seen this index before, so re-mark indexes
Mark(collectionIndexes[arrayContents]);
}
}
PropogateTypeReference(arrayIndexer.IndexedObject, arrayIndexer);
}
}
public override void Visit(IArrayIndexer arrayIndexer)
{
if (Process(arrayIndexer))
{
visitor.Visit(arrayIndexer);
}
base.Visit(arrayIndexer);
}
public override void TraverseChildren(IArrayIndexer arrayIndexer)
{
base.TraverseChildren(arrayIndexer);
IArrayTypeReference /*?*/ arrayType = arrayIndexer.IndexedObject.Type as IArrayTypeReference;
if (arrayType == null)
{
return;
}
((ArrayIndexer)arrayIndexer).Type = arrayType.ElementType;
}
private HLLocation ProcessArrayIndexerExpression(IArrayIndexer pExpression)
{
if (pExpression.Indices.Count() != 1)
{
throw new NotSupportedException();
}
HLLocation locationInstance = ProcessExpression(pExpression.IndexedObject);
HLLocation locationIndex = ProcessExpression(pExpression.Indices.First());
HLType typeElement = HLDomain.GetOrCreateType(pExpression.Type);
return(HLArrayElementLocation.Create(locationInstance, locationIndex, typeElement));
}
public override void Visit(IArrayIndexer arrayIndexer)
{
if (arrayIndexer.Indices.Count() == 1 && NameTable.ContainsKey(arrayIndexer.IndexedObject))
{
var arrayName = NameTable[arrayIndexer.IndexedObject];
TryAdd(arrayIndexer, FormElementsExpression(arrayName));
// propogate instance expression information
if (InstanceExpressionsReferredTypes.ContainsKey(arrayIndexer.IndexedObject))
{
AddInstanceExpr(InstanceExpressionsReferredTypes[arrayIndexer.IndexedObject], arrayIndexer);
}
}
}
private HLLocation ProcessAddressableExpression(IAddressableExpression pExpression)
{
if (pExpression.Definition is ILocalDefinition)
{
return(HLLocalLocation.Create(HLDomain.GetLocal(pExpression.Definition as ILocalDefinition)));
}
else if (pExpression.Definition is IParameterDefinition)
{
return(HLParameterLocation.Create(HLDomain.GetParameter(pExpression.Definition as IParameterDefinition)));
}
else if (pExpression.Definition is IFieldDefinition || pExpression.Definition is IFieldReference)
{
IFieldDefinition definition = pExpression.Definition is IFieldDefinition ? (IFieldDefinition)pExpression.Definition : ((IFieldReference)pExpression.Definition).ResolvedField;
HLType typeFieldContainer = HLDomain.GetOrCreateType(definition.Container);
HLField field = HLDomain.GetField(definition);
if (field.IsStatic)
{
return(HLStaticFieldLocation.Create(field));
}
HLLocation instance = ProcessExpression(pExpression.Instance);
return(HLFieldLocation.Create(instance, field));
}
else if (pExpression.Definition is IArrayIndexer)
{
IArrayIndexer definition = (IArrayIndexer)pExpression.Definition;
if (definition.Indices.Count() != 1)
{
throw new NotSupportedException();
}
HLLocation locationInstance = ProcessExpression(pExpression.Instance);
HLLocation locationIndex = ProcessExpression(definition.Indices.First());
HLType typeElement = HLDomain.GetOrCreateType(pExpression.Type);
return(HLArrayElementLocation.Create(locationInstance, locationIndex, typeElement));
}
else if (pExpression.Definition is IDefaultValue)
{
HLType typeDefaultValue = HLDomain.GetOrCreateType(((IDefaultValue)pExpression.Definition).DefaultValueType);
HLLocation locationDefaultValue = HLTemporaryLocation.Create(CreateTemporary(typeDefaultValue));
mCurrentBlock.EmitAssignment(locationDefaultValue, HLDefaultLocation.Create(typeDefaultValue));
return(locationDefaultValue);
}
throw new NotSupportedException();
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public virtual void Visit(IArrayIndexer arrayIndexer)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(arrayIndexer);
this.Visit(arrayIndexer.IndexedObject);
this.Visit(arrayIndexer.Indices);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not to decrease this.path.Count.
this.path.Pop();
}
public void Visit(IArrayIndexer arrayIndexer)
{
Contract.Requires(arrayIndexer != null);
throw new NotImplementedException();
}
public void Visit(IArrayIndexer arrayIndexer)
{
this.traverser.Traverse(arrayIndexer);
}
/// <summary>
/// Traverses the array indexer expression.
/// </summary>
public void Traverse(IArrayIndexer arrayIndexer)
{
Contract.Requires(arrayIndexer != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(arrayIndexer);
if (this.StopTraversal) return;
this.TraverseChildren(arrayIndexer);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(arrayIndexer);
}
public override void TraverseChildren(IArrayIndexer arrayIndexer)
{ MethodEnter(arrayIndexer);
base.TraverseChildren(arrayIndexer);
MethodExit(); }
/// <summary>
/// Visits the specified array indexer.
/// </summary>
/// <param name="arrayIndexer">The array indexer.</param>
public override void Visit(IArrayIndexer arrayIndexer)
{
ArrayIndexer mutableArrayIndexer = arrayIndexer as ArrayIndexer;
if (alwaysMakeACopy || mutableArrayIndexer == null) mutableArrayIndexer = new ArrayIndexer(arrayIndexer);
this.resultExpression = this.myCodeMutator.Visit(mutableArrayIndexer);
}
/// <summary>
/// Generates IL for the specified array indexer.
/// </summary>
/// <param name="arrayIndexer">The array indexer.</param>
public override void TraverseChildren(IArrayIndexer arrayIndexer)
{
this.Traverse(arrayIndexer.IndexedObject);
this.Traverse(arrayIndexer.Indices);
IArrayTypeReference arrayType = (IArrayTypeReference)arrayIndexer.IndexedObject.Type;
if (arrayType.IsVector)
this.LoadVectorElement(arrayType.ElementType);
else {
this.generator.Emit(OperationCode.Array_Get, arrayIndexer.IndexedObject.Type);
this.StackSize -= (ushort)IteratorHelper.EnumerableCount(arrayIndexer.Indices);
}
}
/// <summary>
/// Rewrites the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public virtual IExpression Rewrite(IArrayIndexer arrayIndexer)
{
var mutableArrayIndexer = arrayIndexer as ArrayIndexer;
if (mutableArrayIndexer == null) return arrayIndexer;
this.RewriteChildren(mutableArrayIndexer);
return mutableArrayIndexer;
}
public override void Visit(IArrayIndexer arrayIndexer)
{
if(Process(arrayIndexer)){visitor.Visit(arrayIndexer);}
base.Visit(arrayIndexer);
}
private HLLocation ProcessArrayIndexerExpression(IArrayIndexer pExpression)
{
if (pExpression.Indices.Count() != 1) throw new NotSupportedException();
HLLocation locationInstance = ProcessExpression(pExpression.IndexedObject);
HLLocation locationIndex = ProcessExpression(pExpression.Indices.First());
HLType typeElement = HLDomain.GetOrCreateType(pExpression.Type);
return HLArrayElementLocation.Create(locationInstance, locationIndex, typeElement);
}
/// <summary>
///
/// </summary>
/// <param name="arrayIndexer"></param>
public ArrayIndexer(IArrayIndexer arrayIndexer)
: base(arrayIndexer)
{
Contract.Requires(arrayIndexer != null);
this.indexedObject = arrayIndexer.IndexedObject;
this.indices = new List<IExpression>(arrayIndexer.Indices);
}
public void Visit(IArrayIndexer arrayIndexer)
{
this.result = this.copier.Copy(arrayIndexer);
}
public virtual void onASTElement(IArrayIndexer arrayIndexer) { }
public override IExpression Rewrite(IArrayIndexer arrayIndexer) {
if (ExpressionTraverser.IsAtomicInstance(arrayIndexer.IndexedObject)) return arrayIndexer;
// arrayIndexer == AI(inst, [index]), i.e., inst[index0, index1,...]
// return { loc := e; [assert loc != null;] | AI(BE(null,loc), [index]) }
// where e is the rewritten array instance
var e = base.Rewrite(arrayIndexer.IndexedObject);
var loc = new LocalDefinition() {
Name = this.host.NameTable.GetNameFor("_loc" + this.sink.LocalCounter.ToString()),
Type = e.Type
};
var locDecl = new LocalDeclarationStatement() {
InitialValue = e,
LocalVariable = loc,
};
return new BlockExpression() {
BlockStatement = new BlockStatement() {
Statements = new List<IStatement> { locDecl },
},
Expression = new ArrayIndexer() {
IndexedObject = new BoundExpression() {
Definition = loc,
Instance = null,
Type = loc.Type,
},
Indices = new List<IExpression>(arrayIndexer.Indices),
Type = arrayIndexer.Type,
},
};
}
/// <summary>
/// Returns a shallow copy of the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public ArrayIndexer Copy(IArrayIndexer arrayIndexer)
{
return new ArrayIndexer(arrayIndexer);
}
public void Visit(IArrayIndexer arrayIndexer)
{
this.result = this.rewriter.Rewrite(arrayIndexer);
}
public override void TraverseChildren(IArrayIndexer arrayIndexer) {
//if (!IsAtomicInstance(arrayIndexer.IndexedObject)) {
// // Simplify the BE so that all nested dereferences and method calls are broken up into separate assignments to locals.
// var se = ExpressionSimplifier.Simplify(this.sink, arrayIndexer);
// this.Traverse(se);
// return;
//}
this.Traverse(arrayIndexer.IndexedObject);
Bpl.Expr arrayExpr = TranslatedExpressions.Pop();
var be = arrayIndexer.IndexedObject as IBoundExpression;
if (be != null && be.Instance != null) {
var l = this.sink.CreateFreshLocal(be.Type);
var lhs = Bpl.Expr.Ident(l);
var cmd = Bpl.Cmd.SimpleAssign(arrayIndexer.Token(), lhs, arrayExpr);
this.StmtTraverser.StmtBuilder.Add(cmd);
arrayExpr = lhs;
}
this.Traverse(arrayIndexer.Indices);
int count = arrayIndexer.Indices.Count();
Bpl.Expr[] indexExprs = new Bpl.Expr[count];
for (int i = count; i > 0; i--) {
indexExprs[i - 1] = TranslatedExpressions.Pop();
}
Bpl.Expr indexExpr;
if (indexExprs.Length == 1) {
indexExpr = indexExprs[0];
}
else {
Bpl.Function f = this.sink.FindOrCreateNaryIntFunction(indexExprs.Length);
indexExpr = new Bpl.NAryExpr(arrayIndexer.Token(), new Bpl.FunctionCall(f), new List<Bpl.Expr>(indexExprs));
}
AssertOrAssumeNonNull(arrayIndexer.Token(), arrayExpr);
this.TranslatedExpressions.Push(this.sink.Heap.ReadHeap(arrayExpr, indexExpr, AccessType.Array, this.sink.CciTypeToBoogie(arrayIndexer.Type)));
}
public override void Visit(IArrayIndexer arrayIndexer)
{
allElements.Add(new InvokInfo(Traverser, "IArrayIndexer", arrayIndexer));
}
public virtual void onASTElement(IArrayIndexer arrayIndexer)
{
}
/// <summary>
/// Rewrites the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public virtual IExpression Rewrite(IArrayIndexer arrayIndexer)
{
return arrayIndexer;
}
/// <summary>
/// Performs some computation with the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public virtual void Visit(IArrayIndexer arrayIndexer)
{
}
public override void TraverseChildren(IArrayIndexer arrayIndexer) {
base.TraverseChildren(arrayIndexer);
IArrayTypeReference/*?*/ arrayType = arrayIndexer.IndexedObject.Type as IArrayTypeReference;
if (arrayType == null) return;
((ArrayIndexer)arrayIndexer).Type = arrayType.ElementType;
}
/// <summary>
/// Traverses the children of the array indexer expression.
/// </summary>
public virtual void TraverseChildren(IArrayIndexer arrayIndexer)
{
Contract.Requires(arrayIndexer != null);
this.TraverseChildren((IExpression)arrayIndexer);
if (this.StopTraversal) return;
this.Traverse(arrayIndexer.IndexedObject);
if (this.StopTraversal) return;
this.Traverse(arrayIndexer.Indices);
}
/// <summary>
/// Returns a deep copy of the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public ArrayIndexer Copy(IArrayIndexer arrayIndexer) {
Contract.Requires(arrayIndexer != null);
Contract.Ensures(Contract.Result<ArrayIndexer>() != null);
var mutableCopy = this.shallowCopier.Copy(arrayIndexer);
this.CopyChildren((Expression)mutableCopy);
mutableCopy.IndexedObject = this.Copy(mutableCopy.IndexedObject);
mutableCopy.Indices = this.Copy(mutableCopy.Indices);
return mutableCopy;
}
/// <summary>
/// Performs some computation with the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public virtual void Visit(IArrayIndexer arrayIndexer)
{
this.Visit((IExpression)arrayIndexer);
}
/// <summary>
/// Returns a shallow copy of the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public ArrayIndexer Copy(IArrayIndexer arrayIndexer) {
Contract.Requires(arrayIndexer != null);
Contract.Ensures(Contract.Result<ArrayIndexer>() != null);
return new ArrayIndexer(arrayIndexer);
}
public void Visit(IArrayIndexer arrayIndexer)
{
throw new NotImplementedException();
}
/// <summary>
/// Performs some computation with the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public virtual void Visit(IArrayIndexer arrayIndexer)
{
}
public override void Visit(IArrayIndexer arrayIndexer) {
this.Visit(arrayIndexer.IndexedObject);
this.Visit(arrayIndexer.Indices);
//TODO
}
/// <summary>
/// Visits the specified array indexer.
/// </summary>
/// <param name="arrayIndexer">The array indexer.</param>
public override void Visit(IArrayIndexer arrayIndexer)
{
ArrayIndexer mutableArrayIndexer = new ArrayIndexer(arrayIndexer);
this.resultExpression = this.myCodeCopier.DeepCopy(mutableArrayIndexer);
}
public override void TraverseChildren(IArrayIndexer arrayIndexer) {
this.Traverse(arrayIndexer.IndexedObject);
this.sourceEmitterOutput.Write("[");
this.Traverse(arrayIndexer.Indices);
this.sourceEmitterOutput.Write("]");
}
/// <summary>
/// Returns a deep copy of the given array indexer expression.
/// </summary>
/// <param name="arrayIndexer"></param>
public ArrayIndexer Copy(IArrayIndexer arrayIndexer)
{
var mutableCopy = this.shallowCopier.Copy(arrayIndexer);
this.CopyChildren((Expression)mutableCopy);
mutableCopy.IndexedObject = this.Copy(mutableCopy.IndexedObject);
mutableCopy.Indices = this.Copy(mutableCopy.Indices);
return mutableCopy;
}
public override void TraverseChildren(IArrayIndexer arrayIndexer)
{
MethodEnter(arrayIndexer);
base.TraverseChildren(arrayIndexer);
MethodExit();
}
/// <summary>
/// Visits the specified array indexer.
/// </summary>
/// <param name="arrayIndexer">The array indexer.</param>
public override void Visit(IArrayIndexer arrayIndexer)
{
ArrayIndexer mutableArrayIndexer = arrayIndexer as ArrayIndexer;
if (mutableArrayIndexer == null) return;
this.resultExpression = this.myCodeMutator.Visit(mutableArrayIndexer);
}
