public StatementTraverser(Sink sink, PdbReader/*?*/ pdbReader, bool contractContext, TraverserFactory factory) {
this.sink = sink;
this.factory = factory;
PdbReader = pdbReader;
this.contractContext = contractContext;
this.captureState = sink.Options.captureState;
this.PreorderVisitor = new SourceContextEmitter(this);
}
///// <summary>
///// Use this constructor for translating expressions that do *not* occur
///// within the context of the statements in a method body.
///// </summary>
//public ExpressionTraverser(Sink sink)
// : this(sink, null)
//{ }
/// <summary>
/// Use this constructor for translating expressions that do occur within
/// the context of the statements in a method body.
/// </summary>
public ExpressionTraverser(Sink sink, StatementTraverser/*?*/ statementTraverser, bool contractContext, bool expressionIsStatement)
{
this.sink = sink;
this.StmtTraverser = statementTraverser;
TranslatedExpressions = new Stack<Bpl.Expr>();
this.contractContext = contractContext;
this.currentExpressionIsOpAssignStatement = expressionIsStatement;
}
public override bool MakeHeap(Sink sink, out Heap heap, out Bpl.Program/*?*/ program) {
heap = this;
program = null;
this.sink = sink;
string prelude = this.InitialPreludeText + this.CommonText;
var b = RepresentationFor.ParsePrelude(prelude, this, out program);
if (b) {
this.FieldType = new Bpl.CtorType(this.FieldTypeDecl.tok, this.FieldTypeDecl, new List<Bpl.Type>());
this.RefType = new Bpl.CtorType(this.RefTypeDecl.tok, this.RefTypeDecl, new List<Bpl.Type>());
this.RealType = new Bpl.CtorType(this.RealTypeDecl.tok, this.RealTypeDecl, new List<Bpl.Type>());
}
return b;
}
public override ExpressionTraverser MakeExpressionTraverser(Sink sink, StatementTraverser/*?*/ statementTraverser, bool contractContext, bool expressionIsStatement) {
return new CLRExpressionSemantics(sink, statementTraverser, contractContext, expressionIsStatement);
}
public CLRExpressionSemantics(Sink sink, StatementTraverser/*?*/ statementTraverser, bool contractContext, bool expressionIsStatement)
: base(sink, statementTraverser, contractContext, expressionIsStatement) { }
/// <summary>
/// Use this constructor for translating expressions that do *not* occur
/// within the context of the statements in a method body.
/// </summary>
public ExpressionTraverser(Sink sink)
: this(sink, null)
{ }
public BCTMetadataTraverser(Sink sink, IDictionary<IUnit, PdbReader> pdbReaders, TraverserFactory factory)
: base() {
this.sink = sink;
this.Factory = factory;
this.PdbReaders = pdbReaders;
}
/// <summary> /// Returns two things: an object that determines the heap representation, /// and (optionally) an initial program that contains declarations needed /// for the heap representation. /// </summary> /// <param name="sink"> /// The heap might need to generate declarations so it needs access to the Sink. /// </param> /// <returns> /// false if and only if an error occurrs and the heap and/or program are not in a /// good state to be used. /// </returns> public abstract bool MakeHeap(Sink sink, out Heap heap, out Bpl.Program/*?*/ program);
public static Bpl.Program/*?*/ TranslateAssembly(List<string> assemblyNames, HeapFactory heapFactory, Options options, List<Regex> exemptionList, bool whiteList) {
Contract.Requires(assemblyNames != null);
Contract.Requires(heapFactory != null);
var libPaths = options.libpaths;
var wholeProgram = options.wholeProgram;
var/*?*/ stubAssemblies = options.stub;
var phoneControlsConfigFile = options.phoneControls;
var doPhoneNav = options.phoneNavigationCode;
var doPhoneFeedback = options.phoneFeedbackCode;
var host = new CodeContractAwareHostEnvironment(libPaths != null ? libPaths : Enumerable<string>.Empty, true, true);
Host = host;
Bpl.CommandLineOptions.Install(new Bpl.CommandLineOptions());
#region Assemlies to translate (via cmd line)
modules = new List<IModule>();
var contractExtractors = new Dictionary<IUnit, IContractProvider>();
var pdbReaders = new Dictionary<IUnit, PdbReader>();
#region Load *all* of the assemblies before doing anything else so that they can all vote on unification matters
foreach (var a in assemblyNames) {
var module = host.LoadUnitFrom(a) as IModule;
if (module == null || module == Dummy.Module || module == Dummy.Assembly) {
Console.WriteLine(a + " is not a PE file containing a CLR module or assembly, or an error occurred when loading it.");
Console.WriteLine("Skipping it, continuing with other input assemblies");
continue;
}
modules.Add(module);
}
#endregion
#region Decompile all of the assemblies
var decompiledModules = new List<IModule>();
foreach (var m in modules) {
PdbReader/*?*/ pdbReader = null;
string pdbFile = Path.ChangeExtension(m.Location, "pdb");
if (File.Exists(pdbFile)) {
Stream pdbStream = File.OpenRead(pdbFile);
pdbReader = new PdbReader(pdbStream, host);
}
var m2 = Decompiler.GetCodeModelFromMetadataModel(host, m, pdbReader, DecompilerOptions.Unstack) as IModule;
// The decompiler does not turn calls to Assert/Assume into Code Model nodes
m2 = new Microsoft.Cci.MutableContracts.ContractExtractor.AssertAssumeExtractor(host, pdbReader).Rewrite(m2);
decompiledModules.Add(m2);
host.RegisterAsLatest(m2);
contractExtractors.Add(m2, host.GetContractExtractor(m2.UnitIdentity));
pdbReaders.Add(m2, pdbReader);
}
modules = decompiledModules;
#endregion
#endregion
#region Assemblies to translate (stubs)
if (stubAssemblies != null) {
foreach (var s in stubAssemblies) {
var module = host.LoadUnitFrom(s) as IModule;
if (module == null || module == Dummy.Module || module == Dummy.Assembly) {
Console.WriteLine(s + " is not a PE file containing a CLR module or assembly, or an error occurred when loading it.");
Console.WriteLine("Skipping it, continuing with other input assemblies");
}
PdbReader/*?*/ pdbReader = null;
string pdbFile = Path.ChangeExtension(module.Location, "pdb");
if (File.Exists(pdbFile)) {
Stream pdbStream = File.OpenRead(pdbFile);
pdbReader = new PdbReader(pdbStream, host);
}
module = Decompiler.GetCodeModelFromMetadataModel(host, module, pdbReader, DecompilerOptions.Unstack) as IModule;
var copier = new CodeDeepCopier(host);
var mutableModule = copier.Copy(module);
var mscorlib = TypeHelper.GetDefiningUnit(host.PlatformType.SystemObject.ResolvedType);
//var mutator = new ReparentModule(host, mscorlib, mutableModule);
//module = mutator.Rewrite(mutableModule);
//modules.Add(Tuple.Create(module, pdbReader));
RewriteUnitReferences renamer = new RewriteUnitReferences(host, mutableModule);
var mscorlibAssembly = (IAssembly)mscorlib;
renamer.targetAssembly = mscorlibAssembly;
renamer.originalAssemblyIdentity = mscorlibAssembly.AssemblyIdentity;
renamer.RewriteChildren(mutableModule);
modules.Add((IModule)mutableModule);
contractExtractors.Add(module, host.GetContractExtractor(module.UnitIdentity));
pdbReaders.Add(module, pdbReader);
}
}
#endregion
if (modules.Count == 0) {
throw new TranslationException("No input assemblies to translate.");
}
var primaryModule = modules[0];
Sink sink= new Sink(host, heapFactory, options, exemptionList, whiteList);
TranslationHelper.tmpVarCounter = 0;
// TODO move away, get all plugin and translators from a config file or alike
#region Plugged translators
List<Translator> translatorsPlugged = new List<Translator>();
ITranslationPlugin bctPlugin= new BytecodeTranslatorPlugin(wholeProgram);
Translator bcTranslator = bctPlugin.getTranslator(sink, contractExtractors, pdbReaders);
translatorsPlugged.Add(bcTranslator);
if (phoneControlsConfigFile != null && phoneControlsConfigFile != "") {
// TODO this should be part of the translator initialziation
PhoneCodeHelper.initialize(host);
PhoneCodeHelper.instance().PhonePlugin = new PhoneControlsPlugin(phoneControlsConfigFile);
if (doPhoneNav) {
// TODO this should be part of the translator initialziation
PhoneCodeHelper.instance().PhoneNavigationToggled = true;
ITranslationPlugin phoneInitPlugin = new PhoneInitializationPlugin();
ITranslationPlugin phoneNavPlugin = new PhoneNavigationPlugin();
Translator phInitTranslator = phoneInitPlugin.getTranslator(sink, contractExtractors, pdbReaders);
Translator phNavTranslator = phoneNavPlugin.getTranslator(sink, contractExtractors, pdbReaders);
translatorsPlugged.Add(phInitTranslator);
translatorsPlugged.Add(phNavTranslator);
}
if (doPhoneFeedback) {
// TODO this should be part of the translator initialziation
PhoneCodeHelper.instance().PhoneFeedbackToggled = true;
ITranslationPlugin phoneFeedbackPlugin = new PhoneFeedbackPlugin();
Translator phFeedbackTranslator = phoneFeedbackPlugin.getTranslator(sink, contractExtractors, pdbReaders);
translatorsPlugged.Add(phFeedbackTranslator);
}
}
#endregion
sink.TranslationPlugins = translatorsPlugged;
/*
if (phoneControlsConfigFile != null && phoneControlsConfigFile != "") {
// TODO send this all way to initialization of phone plugin translator
PhoneCodeHelper.initialize(host);
PhoneCodeHelper.instance().PhonePlugin = new PhoneControlsPlugin(phoneControlsConfigFile);
// TODO these parameters will eventually form part of plugin configuration
if (doPhoneNav) {
PhoneCodeHelper.instance().PhoneNavigationToggled = true;
PhoneInitializationMetadataTraverser initTr = new PhoneInitializationMetadataTraverser(host);
initTr.InjectPhoneCodeAssemblies(modules);
PhoneNavigationMetadataTraverser navTr = new PhoneNavigationMetadataTraverser(host);
navTr.InjectPhoneCodeAssemblies(modules);
}
if (doPhoneFeedback) {
PhoneCodeHelper.instance().PhoneFeedbackToggled = true;
PhoneControlFeedbackMetadataTraverser fbMetaDataTraverser= new PhoneControlFeedbackMetadataTraverser(host);
fbMetaDataTraverser.Visit(modules);
}
}
*/
// TODO replace the whole translation by a translator initialization and an orchestrator calling back for each element
// TODO for the current BC translator it will possibly just implement onMetadataElement(IModule)
// TODO refactor this away, handle priorities between plugged translators
IOrderedEnumerable<Translator> prioritizedTranslators = translatorsPlugged.OrderBy(t => t.getPriority());
foreach (Translator t in prioritizedTranslators) {
t.initialize();
if (t.isOneShot())
t.TranslateAssemblies(modules);
}
foreach (var pair in sink.delegateTypeToDelegates.Values) {
CreateDispatchMethod(sink, pair.Item1, pair.Item2);
CreateDelegateCreateMethod(sink, pair.Item1, pair.Item2);
CreateDelegateAddMethod(sink, pair.Item1, pair.Item2);
CreateDelegateRemoveMethod(sink, pair.Item1, pair.Item2);
}
// Subtyping for extern types
if(sink.Options.typeInfo > 0) sink.DeclareExternTypeSubtyping();
string outputFileName = primaryModule.Name + ".bpl";
callPostTranslationTraversers(modules, sink, phoneControlsConfigFile, outputFileName);
if (PhoneCodeHelper.instance().PhoneNavigationToggled) {
finalizeNavigationAnalysisAndBoogieCode(phoneControlsConfigFile, sink, outputFileName);
}
//sink.CreateIdentifierCorrespondenceTable(primaryModule.Name.Value);
//var rc = new Bpl.ResolutionContext((Bpl.IErrorSink)null);
//foreach (var decl in sink.TranslatedProgram.TopLevelDeclarations) {
// decl.Register(rc);
//}
//sink.TranslatedProgram.Resolve(rc);
//var goodDecls = new List<Bpl.Declaration>();
//var tc = new Bpl.TypecheckingContext(null);
//foreach (var decl in sink.TranslatedProgram.TopLevelDeclarations) {
// var impl = decl as Bpl.Implementation;
// if (impl == null) {
// goodDecls.Add(decl);
// continue;
// }
// try {
// //var tc = new Bpl.TypecheckingContext(null);
// impl.Typecheck(tc);
// goodDecls.Add(impl);
// } catch {
// Console.WriteLine("Deleting implementation for: " + impl.Name);
// // nothing to do, just continue
// }
//}
//sink.TranslatedProgram.TopLevelDeclarations = goodDecls;
return sink.TranslatedProgram;
}
private static void CreateDelegateRemoveMethod(Sink sink, ITypeDefinition type, HashSet<IMethodDefinition> delegates)
{
Bpl.Formal a = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "a", sink.Heap.RefType), true);
Bpl.Formal b = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "b", sink.Heap.RefType), true);
Bpl.Formal c = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "c", sink.Heap.RefType), false);
Bpl.IdentifierExpr aExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, a);
Bpl.IdentifierExpr bExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, b);
Bpl.IdentifierExpr cExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, c);
Bpl.Procedure proc = new Bpl.Procedure(
Bpl.Token.NoToken,
sink.DelegateRemove(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] { a, b }),
new List<Bpl.Variable>(new Bpl.Variable[] {c}),
new List<Bpl.Requires>(),
new List<Bpl.IdentifierExpr>(),
new List<Bpl.Ensures>());
proc.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(proc);
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
stmtBuilder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, "Alloc", new List<Bpl.Expr>(), new List<Bpl.IdentifierExpr>(new Bpl.IdentifierExpr[] {cExpr})));
foreach (IMethodDefinition defn in delegates)
{
Bpl.IdentifierExpr cie = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.FindOrCreateDelegateMethodConstant(defn));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Iff, sink.ReadMethod(cie, cExpr), Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.And, sink.ReadMethod(cie, aExpr), Bpl.Expr.Unary(Bpl.Token.NoToken, Bpl.UnaryOperator.Opcode.Not, sink.ReadMethod(cie, bExpr))))));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadReceiver(cie, cExpr), sink.ReadReceiver(cie, aExpr))));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadTypeParameters(cie, cExpr), sink.ReadTypeParameters(cie, aExpr))));
}
Bpl.IdentifierExpr nullExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.Heap.NullRef);
Bpl.IfCmd ifCmd = BuildIfCmd(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, bExpr, nullExpr), TranslationHelper.BuildAssignCmd(cExpr, aExpr), stmtBuilder.Collect(Bpl.Token.NoToken));
ifCmd = BuildIfCmd(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, aExpr, nullExpr), TranslationHelper.BuildAssignCmd(cExpr, nullExpr), ifCmd);
Bpl.Implementation impl = new Bpl.Implementation(
Bpl.Token.NoToken,
sink.DelegateRemove(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] { a, b }),
new List<Bpl.Variable>(new Bpl.Variable[] {c}),
new List<Bpl.Variable>(),
BuildStmtList(ifCmd)
);
impl.AddAttribute("inline", Bpl.Expr.Literal(1));
impl.Proc = proc;
sink.TranslatedProgram.AddTopLevelDeclaration(impl);
}
public virtual StatementTraverser MakeStatementTraverser(Sink sink, PdbReader/*?*/ pdbReader, bool contractContext) {
return new StatementTraverser(sink, pdbReader, contractContext, this);
}
private static void BuildAssignment(Sink sink, Bpl.StmtListBuilder stmtBuilder, List<Bpl.Variable> lvars, List<Bpl.Variable> rvars) {
for (int i = 0; i < lvars.Count; i++) {
Bpl.Variable lvar = lvars[i];
Bpl.Type ltype = lvar.TypedIdent.Type;
Bpl.Variable rvar = rvars[i];
Bpl.Type rtype = rvar.TypedIdent.Type;
Bpl.IdentifierExpr lexpr = Bpl.Expr.Ident(lvar);
Bpl.Expr rexpr = Bpl.Expr.Ident(rvar);
if (rtype == ltype) {
// do nothing
} else if (ltype == sink.Heap.UnionType) {
rexpr = sink.Heap.ToUnion(Bpl.Token.NoToken, rtype, rexpr, false, stmtBuilder);
}
else if (rtype == sink.Heap.UnionType) {
rexpr = sink.Heap.FromUnion(Bpl.Token.NoToken, ltype, rexpr, false);
}
else {
System.Diagnostics.Debug.Assert(false);
}
stmtBuilder.Add(TranslationHelper.BuildAssignCmd(lexpr, rexpr));
}
}
private static void CreateDelegateCreateMethod(Sink sink, ITypeDefinition type, HashSet<IMethodDefinition> delegates)
{
Bpl.Formal method = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "Method", Bpl.Type.Int), true);
Bpl.Formal receiver = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "Receiver", sink.Heap.RefType), true);
Bpl.Formal typeParameters = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "TypeParameters", sink.Heap.TypeType), true);
Bpl.Formal returnDelegate = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "c", sink.Heap.RefType), false);
Bpl.IdentifierExpr methodExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, method);
Bpl.IdentifierExpr receiverExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, receiver);
Bpl.IdentifierExpr typeParametersExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, typeParameters);
Bpl.IdentifierExpr returnDelegateExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, returnDelegate);
Bpl.Procedure proc = new Bpl.Procedure(
Bpl.Token.NoToken,
sink.DelegateCreate(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] {method, receiver, typeParameters}),
new List<Bpl.Variable>(new Bpl.Variable[] {returnDelegate}),
new List<Bpl.Requires>(),
new List<Bpl.IdentifierExpr>(),
new List<Bpl.Ensures>());
proc.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(proc);
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
stmtBuilder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, "Alloc", new List<Bpl.Expr>(), new List<Bpl.IdentifierExpr>(new Bpl.IdentifierExpr[] {returnDelegateExpr})));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadReceiver(methodExpr, returnDelegateExpr), receiverExpr)));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadTypeParameters(methodExpr, returnDelegateExpr), typeParametersExpr)));
foreach (IMethodDefinition defn in delegates)
{
Bpl.IdentifierExpr cie = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.FindOrCreateDelegateMethodConstant(defn));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Iff, sink.ReadMethod(cie, returnDelegateExpr), Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, methodExpr, cie))));
}
Bpl.Implementation impl = new Bpl.Implementation(
Bpl.Token.NoToken,
sink.DelegateCreate(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] { method, receiver, typeParameters }),
new List<Bpl.Variable>(new Bpl.Variable[] {returnDelegate}),
new List<Bpl.Variable>(),
stmtBuilder.Collect(Bpl.Token.NoToken));
impl.AddAttribute("inline", Bpl.Expr.Literal(1));
impl.Proc = proc;
sink.TranslatedProgram.AddTopLevelDeclaration(impl);
}
private static void createPhoneBoogieCallStubs(Sink sink) {
foreach (IMethodDefinition def in PhoneNavigationCodeTraverser.NavCallers) {
if (!PhoneCodeHelper.instance().isKnownBackKeyOverride(def))
PhoneCodeHelper.instance().addHandlerStubCaller(sink, def);
}
PhoneCodeHelper.instance().addNavigationUriHavocer(sink);
}
private static void callPostTranslationTraversers(List<IModule> modules, Sink sink, string phoneControlsConfigFile, string outputFileName) {
if (PhoneCodeHelper.instance().PhoneFeedbackToggled) {
PhoneCodeHelper.instance().CreateFeedbackCallingMethods(sink);
}
if (PhoneCodeHelper.instance().PhoneFeedbackToggled || PhoneCodeHelper.instance().PhoneNavigationToggled) {
PhoneMethodInliningMetadataTraverser inlineTraverser =
new PhoneMethodInliningMetadataTraverser(PhoneCodeHelper.instance());
inlineTraverser.findAllMethodsToInline(modules);
PhoneCodeHelper.updateInlinedMethods(sink, inlineTraverser.getMethodsToInline());
System.Console.WriteLine("Total methods seen: {0}, inlined: {1}", inlineTraverser.TotalMethodsCount, inlineTraverser.InlinedMethodsCount);
PhoneBackKeyCallbackTraverser traverser = new PhoneBackKeyCallbackTraverser(sink.host);
traverser.Traverse(modules);
}
}
private static void finalizeNavigationAnalysisAndBoogieCode(string phoneControlsConfigFile, Sink sink, string outputFileName) {
outputBoogieTrackedControlConfiguration(phoneControlsConfigFile);
checkTransitivelyCalledBackKeyNavigations(modules);
createPhoneBoogieCallStubs(sink);
PhoneCodeHelper.instance().createQueriesBatchFile(sink, outputFileName);
outputBackKeyWarnings();
}
public abstract Translator getTranslator(Sink sink, IDictionary<IUnit, IContractProvider> contractProviders, IDictionary<IUnit, PdbReader> reader);
private static void CreateDispatchMethod(Sink sink, ITypeDefinition type, HashSet<IMethodDefinition> delegates) {
Contract.Assert(type.IsDelegate);
IMethodDefinition invokeMethod = null;
foreach (IMethodDefinition m in type.Methods) {
if (m.Name.Value == "Invoke") {
invokeMethod = m;
break;
}
}
try {
IMethodDefinition unspecializedInvokeMethod = Sink.Unspecialize(invokeMethod).ResolvedMethod;
Sink.ProcedureInfo invokeProcedureInfo = sink.FindOrCreateProcedure(unspecializedInvokeMethod);
Bpl.Procedure invokeProcedure = (Bpl.Procedure) invokeProcedureInfo.Decl;
invokeProcedure.AddAttribute("inline", Bpl.Expr.Literal(1));
Bpl.Formal delegateVariable = invokeProcedureInfo.ThisVariable;
Bpl.IToken token = invokeMethod.Token();
List<Bpl.Variable> dispatchProcInExprs = new List<Bpl.Variable>();
for (int i = 1; i < invokeProcedure.InParams.Count; i++) {
Bpl.Variable v = invokeProcedure.InParams[i];
dispatchProcInExprs.Add(v);
}
List<Bpl.Variable> dispatchProcOutExprs = new List<Bpl.Variable>();
foreach (Bpl.Variable v in invokeProcedure.OutParams) {
dispatchProcOutExprs.Add(v);
}
List<Bpl.Variable> localVariables = new List<Bpl.Variable>();
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
int localCounter = 0;
foreach (IMethodDefinition defn in delegates) {
Bpl.Constant c = sink.FindOrCreateDelegateMethodConstant(defn);
Sink.ProcedureInfo delegateProcedureInfo = sink.FindOrCreateProcedure(defn);
Bpl.Procedure delegateProcedure = (Bpl.Procedure)delegateProcedureInfo.Decl;
Bpl.Formal thisVariable = delegateProcedureInfo.ThisVariable;
int numArguments = defn.ParameterCount;
List<Bpl.Variable> tempInputs = new List<Bpl.Variable>();
List<Bpl.Variable> tempOutputs = new List<Bpl.Variable>();
for (int i = 0; i < defn.ParameterCount; i++) {
Bpl.Variable v = delegateProcedure.InParams[(thisVariable == null ? 0 : 1) + i];
Bpl.LocalVariable localVariable = new Bpl.LocalVariable(Bpl.Token.NoToken,
new Bpl.TypedIdent(Bpl.Token.NoToken, "local" + localCounter++, v.TypedIdent.Type));
localVariables.Add(localVariable);
tempInputs.Add(localVariable);
}
for (int i = 0; i < delegateProcedure.OutParams.Count; i++) {
Bpl.Variable v = delegateProcedure.OutParams[i];
Bpl.LocalVariable localVariable = new Bpl.LocalVariable(Bpl.Token.NoToken,
new Bpl.TypedIdent(Bpl.Token.NoToken, "local" + localCounter++, v.TypedIdent.Type));
localVariables.Add(localVariable);
tempOutputs.Add(localVariable);
}
List<Bpl.Expr> ins = new List<Bpl.Expr>();
List<Bpl.IdentifierExpr> outs = new List<Bpl.IdentifierExpr>();
if (!defn.IsStatic)
ins.Add(sink.ReadReceiver(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable)));
for (int i = 0; i < tempInputs.Count; i++) {
ins.Add(Bpl.Expr.Ident(tempInputs[i]));
}
if (defn.IsGeneric) {
for (int i = 0; i < defn.GenericParameterCount; i++) {
ins.Add(new Bpl.NAryExpr(Bpl.Token.NoToken,
new Bpl.FunctionCall(sink.FindOrCreateTypeParameterFunction(i)),
new List<Bpl.Expr>(new Bpl.Expr[] {sink.ReadTypeParameters(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable))})));
}
}
if (defn.IsStatic) {
int numTypeParameters = Sink.ConsolidatedGenericParameterCount(defn.ContainingType);
for (int i = 0; i < numTypeParameters; i++) {
ins.Add(new Bpl.NAryExpr(Bpl.Token.NoToken,
new Bpl.FunctionCall(sink.FindOrCreateTypeParameterFunction(i)),
new List<Bpl.Expr>(new Bpl.Expr[] {sink.ReadTypeParameters(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable))})));
}
}
for (int i = 0; i < tempOutputs.Count; i++) {
outs.Add(Bpl.Expr.Ident(tempOutputs[i]));
}
Bpl.Expr bexpr = sink.ReadMethod(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable));
Bpl.StmtListBuilder ifStmtBuilder = new Bpl.StmtListBuilder();
System.Diagnostics.Debug.Assert(tempInputs.Count == dispatchProcInExprs.Count);
if (tempInputs.Count > 0) {
BuildAssignment(sink, ifStmtBuilder, tempInputs, dispatchProcInExprs);
}
ifStmtBuilder.Add(EmitDummySourceContext());
ifStmtBuilder.Add(new Bpl.CallCmd(token, delegateProcedure.Name, ins, outs));
System.Diagnostics.Debug.Assert(tempOutputs.Count == dispatchProcOutExprs.Count);
if (tempOutputs.Count > 0) {
BuildAssignment(sink, ifStmtBuilder, dispatchProcOutExprs, tempOutputs);
}
stmtBuilder.Add(new Bpl.IfCmd(bexpr.tok, bexpr, ifStmtBuilder.Collect(bexpr.tok), null, null));
}
Bpl.Implementation dispatchImpl =
new Bpl.Implementation(token,
invokeProcedure.Name,
new List<Bpl.TypeVariable>(),
invokeProcedure.InParams,
invokeProcedure.OutParams,
localVariables,
stmtBuilder.Collect(token)
);
dispatchImpl.Proc = invokeProcedure;
dispatchImpl.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(dispatchImpl);
} catch (TranslationException te) {
throw new NotImplementedException(te.ToString());
} catch {
throw;
} finally {
// Maybe this is a good place to add the procedure to the toplevel declarations
}
}
public virtual BCTMetadataTraverser MakeMetadataTraverser(Sink sink,
IDictionary<IUnit, IContractProvider> contractProviders, // TODO: remove this parameter?
IDictionary<IUnit, PdbReader> sourceLocationProviders)
{
return new BCTMetadataTraverser(sink, sourceLocationProviders, this);
}
public static IExpression Simplify(Sink sink, IExpression expression) {
var a = new ExpressionSimplifier(sink);
return a.Rewrite(expression);
}
public virtual ExpressionTraverser MakeExpressionTraverser(Sink sink, StatementTraverser/*?*/ statementTraverser, bool contractContext, bool expressionIsOpAssignStatement = false) {
return new ExpressionTraverser(sink, statementTraverser, contractContext, expressionIsOpAssignStatement);
}
public virtual StatementTraverser MakeStatementTraverser(Sink sink) { return new StatementTraverser(sink); }
private ExpressionSimplifier(Sink sink)
: base(sink.host) {
this.sink = sink;
}
public MetadataTraverser(Sink sink, IContractProvider cp)
: base() {
this.sink = sink;
this.factory = sink.Factory;
ContractProvider = cp;
}
public override ExpressionTraverser MakeExpressionTraverser(Sink sink, StatementTraverser/*?*/ statementTraverser) {
return new CLRExpressionSemantics(sink, statementTraverser);
}
public CLRExpressionSemantics(Sink sink, StatementTraverser/*?*/ statementTraverser)
: base(sink, statementTraverser) { }
public virtual ExpressionTraverser MakeExpressionTraverser(Sink sink, StatementTraverser/*?*/ statementTraverser) { return new ExpressionTraverser(sink, statementTraverser); }
public override Translator getTranslator(Sink sink, IDictionary<IUnit, IContractProvider> contractProviders, IDictionary<IUnit, PdbReader> pdbReaders) {
Translator translator = new BaseTranslator(this, sink, contractProviders, pdbReaders);
return translator;
}
/// <summary>
/// Use this constructor for translating expressions that do occur within
/// the context of the statements in a method body.
/// </summary>
public ExpressionTraverser(Sink sink, StatementTraverser/*?*/ statementTraverser) {
this.sink = sink;
HeapVariable = sink.HeapVariable;
this.StmtTraverser = statementTraverser;
TranslatedExpressions = new Stack<Bpl.Expr>();
}
public BaseTranslator(TraverserFactory factory, Sink sink, IDictionary<IUnit, IContractProvider> contractProviders, IDictionary<IUnit, PdbReader> pdbReaders) {
Factory = factory;
this.sink = sink;
this.contractProviders = contractProviders;
this.pdbReaders = pdbReaders;
}