context: // 
  // ILDecoderAdapter.cs
  // 
  // Authors:
  //	Alexander Chebaturkin (chebaturkin@gmail.com)
  // 
  // Copyright (C) 2011 Alexander Chebaturkin
  // 
  // Permission is hereby granted, free of charge, to any person obtaining
  // a copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to
  // permit persons to whom the Software is furnished to do so, subject to
  // the following conditions:
  // 
  // The above copyright notice and this permission notice shall be
  // included in all copies or substantial portions of the Software.
  //  
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  //
  
  using System;
  using System.Collections.Generic;
  using Mono.CodeContracts.Static.AST;
  using Mono.CodeContracts.Static.AST.Visitors;
  using Mono.CodeContracts.Static.Analysis.HeapAnalysis;
  using Mono.CodeContracts.Static.ControlFlow;
  using Mono.CodeContracts.Static.DataStructures;
  
  namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis {
  	/// <summary>
  	/// This class performs translation from (source) SymbolicValue to LabeledSymbol
  	/// </summary>
  	struct ILDecoderAdapter<SymbolicValue, Data, Result, Visitor>
  		: IILVisitor<APC, SymbolicValue, SymbolicValue, Data, Result>
  		where SymbolicValue : IEquatable<SymbolicValue>
  		where Visitor : IILVisitor<APC, LabeledSymbol<APC, SymbolicValue>, SymbolicValue, Data, Result> {
  		private readonly Visitor visitor;
  
  		public ILDecoderAdapter (Visitor visitor)
  		{
  			this.visitor = visitor;
  		}
  
  		#region IILVisitor<APC,SymbolicValue,SymbolicValue,Data,Result> Members
  		public Result Binary (APC pc, BinaryOperator op, SymbolicValue dest, SymbolicValue operand1, SymbolicValue operand2, Data data)
  		{
  			return this.visitor.Binary (pc, op, dest, Convert (pc, operand1), Convert (pc, operand2), data);
  		}
  
  		public Result Isinst (APC pc, TypeNode type, SymbolicValue dest, SymbolicValue obj, Data data)
  		{
  			return this.visitor.Isinst (pc, type, dest, Convert (pc, obj), data);
  		}
  
  		public Result LoadNull (APC pc, SymbolicValue dest, Data polarity)
  		{
  			return this.visitor.LoadNull (pc, dest, polarity);
  		}
  
  		public Result LoadConst (APC pc, TypeNode type, object constant, SymbolicValue dest, Data data)
  		{
  			return this.visitor.LoadConst (pc, type, constant, dest, data);
  		}
  
  		public Result Sizeof (APC pc, TypeNode type, SymbolicValue dest, Data data)
  		{
  			return this.visitor.Sizeof (pc, type, dest, data);
  		}
  
  		public Result Unary (APC pc, UnaryOperator op, bool unsigned, SymbolicValue dest, SymbolicValue source, Data data)
  		{
  			return this.visitor.Unary (pc, op, unsigned, dest, Convert (pc, source), data);
  		}
  
  		public Result Entry (APC pc, Method method, Data data)
  		{
  			return this.visitor.Entry (pc, method, data);
  		}
  
  		public Result Assume (APC pc, EdgeTag tag, SymbolicValue condition, Data data)
  		{
  			return this.visitor.Assume (pc, tag, Convert (pc, condition), data);
  		}
  
  		public Result Assert (APC pc, EdgeTag tag, SymbolicValue condition, Data data)
  		{
  			return this.visitor.Assert (pc, tag, Convert (pc, condition), data);
  		}
  
  		public Result BeginOld (APC pc, APC matchingEnd, Data data)
  		{
  			return this.visitor.BeginOld (pc, matchingEnd, data);
  		}
  
  		public Result EndOld (APC pc, APC matchingBegin, TypeNode type, SymbolicValue dest, SymbolicValue source, Data data)
  		{
  			return this.visitor.EndOld (pc, matchingBegin, type, dest, Convert (pc, source), data);
  		}
  
  		public Result LoadStack (APC pc, int offset, SymbolicValue dest, SymbolicValue source, bool isOld, Data data)
  		{
  			return this.visitor.LoadStack (pc, offset, dest, Convert (pc, source), isOld, data);
  		}
  
  		public Result LoadStackAddress (APC pc, int offset, SymbolicValue dest, SymbolicValue source, TypeNode type, bool isOld, Data data)
  		{
  			return this.visitor.LoadStackAddress (pc, offset, dest, Convert (pc, source), type, isOld, data);
  		}
  
  		public Result LoadResult (APC pc, TypeNode type, SymbolicValue dest, SymbolicValue source, Data data)
  		{
  			return this.visitor.LoadResult (pc, type, dest, Convert (pc, source), data);
  		}
  
  		public Result Arglist (APC pc, SymbolicValue dest, Data data)
  		{
  			return this.visitor.Arglist (pc, dest, data);
  		}
  
  		public Result Branch (APC pc, APC target, bool leavesExceptionBlock, Data data)
  		{
  			throw new Exception ("Should not get branches at this level of abstraction.");
  		}
  
  		public Result BranchCond (APC pc, APC target, BranchOperator bop, SymbolicValue value1, SymbolicValue value2, Data data)
  		{
  			throw new Exception ("Should not get branches at this level of abstraction.");
  		}
  
  		public Result BranchTrue (APC pc, APC target, SymbolicValue cond, Data data)
  		{
  			throw new Exception ("Should not get branches at this level of abstraction.");
  		}
  
  		public Result BranchFalse (APC pc, APC target, SymbolicValue cond, Data data)
  		{
  			throw new Exception ("Should not get branches at this level of abstraction.");
  		}
  
  		public Result Break (APC pc, Data data)
  		{
  			return this.visitor.Break (pc, data);
  		}
  
  		public Result Call<TypeList, ArgList> (APC pc, Method method, bool virt, TypeList extraVarargs, SymbolicValue dest, ArgList args, Data data)
  			where TypeList : IIndexable<TypeNode>
  			where ArgList : IIndexable<SymbolicValue>
  		{
  			return this.visitor.Call (pc, method, virt, extraVarargs, dest, Convert (pc, args), data);
  		}
  
  		public Result Calli<TypeList, ArgList> (APC pc, TypeNode returnType, TypeList argTypes, bool instance, SymbolicValue dest, SymbolicValue functionPointer, ArgList args, Data data)
  			where TypeList : IIndexable<TypeNode> where ArgList : IIndexable<SymbolicValue>
  		{
  			return this.visitor.Calli (pc, returnType, argTypes, instance, dest, Convert (pc, functionPointer), Convert (pc, args), data);
  		}
  
  		public Result CheckFinite (APC pc, SymbolicValue dest, SymbolicValue source, Data data)
  		{
  			return this.visitor.CheckFinite (pc, dest, Convert (pc, source), data);
  		}
  
  		public Result CopyBlock (APC pc, SymbolicValue destAddress, SymbolicValue srcAddress, SymbolicValue len, Data data)
  		{
  			return this.visitor.CopyBlock (pc, Convert (pc, destAddress), Convert (pc, srcAddress), Convert (pc, len), data);
  		}
  
  		public Result EndFilter (APC pc, SymbolicValue decision, Data data)
  		{
  			return this.visitor.EndFilter (pc, Convert (pc, decision), data);
  		}
  
  		public Result EndFinally (APC pc, Data data)
  		{
  			return this.visitor.EndFinally (pc, data);
  		}
  
  		public Result Jmp (APC pc, Method method, Data data)
  		{
  			return this.visitor.Jmp (pc, method, data);
  		}
  
  		public Result LoadArg (APC pc, Parameter argument, bool isOld, SymbolicValue dest, Data data)
  		{
  			return this.visitor.LoadArg (pc, argument, isOld, dest, data);
  		}
  
  		public Result LoadArgAddress (APC pc, Parameter argument, bool isOld, SymbolicValue dest, Data data)
  		{
  			return this.visitor.LoadArgAddress (pc, argument, isOld, dest, data);
  		}
  
  		public Result LoadLocal (APC pc, Local local, SymbolicValue dest, Data data)
  		{
  
gt: 			return this.visitor.LoadLocal (pc, local, dest, data);