/*
The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License");
you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language
governing rights and limitations under the License.
The Original Code is RAIL(Runtime Assembly Instrumentation Library) Alpha Version.
The Initial Developer of the Original Code is University of Coimbra,
Computer Science Department, Dependable Systems Group. Copyright (C) University of Coimbra.
All Rights Reserved.
*/
using System;
using Rail.Reflect;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections;
namespace Rail.Transformation{
/// <summary>
/// Replaces de create new object instruction with a static method call
/// </summary>
/// <remarks> The method being called in replacement of the create new instruction
/// must be static and accept the same number, order and type of arguments</remarks>
public class ReplaceNew : EmptyVisitor
{
private readonly RMethod newMethod;
private readonly RType origType;
/// <summary>
/// Constructor
/// </summary>
/// <param name="origType">The type of the instance created with the create new instruction</param>
/// <param name="newMethod">The static method to replace the create new instruction</param>
public ReplaceNew(RType origType, RMethod newMethod)
{
this.origType = origType;
this.newMethod = newMethod;
}
/// <summary>
/// This method is used to instrument the code in <code>RMethodDef</code> and <code>RConstrucorDef</code>
/// ojects
/// </summary>
/// <param name="method">the <code>RMethodBase</code> object to be instrumented</param>
private void VisitMethodBody(RMethodBase method)
{
VisitMethodBody(method,0);
}
private void VisitMethodBody(RMethodBase method,int changeNumber)
{
#region Changes the body of the method
int currentToUpdate = 0;
bool changed = false;
MSIL.MethodBody mb = null;
if (method is RConstructor)
mb = ((RConstructorDef)method).MethodBody;
else if (method is RMethod)
mb = ((RMethodDef)method).MethodBody;
MSIL.Code code = null;
if (mb!=null)
code = mb.GetCode();
if (code!=null)
{
code.updateInstructionIndex();
foreach (MSIL.Instruction i in code)
{
if (i.OpCode.Value==OpCodes.Newobj.Value)
{
MSIL.ILMethod ilm = (MSIL.ILMethod)i;
RConstructor rc = (RConstructor)ilm.Method;
if (rc.DeclaringType.Equals(this.origType))
{
if (rc.ParametersCount==this.newMethod.ParametersCount)
{
if (rc.ParametersCount==0)
{
if (changeNumber==currentToUpdate)
{
Replace(code,i.index);
changed=true;
}
else
currentToUpdate++;
}
else
{
RParameter [] rcParams = rc.GetParameters();
RParameter [] newMethParams = this.newMethod.GetParameters();
bool parametersAreIdentical = true;
for (int j=0; j< rcParams.Length;j++)
{
if (!rcParams[j].ParameterType.Equals(newMethParams[j].ParameterType))
{
parametersAreIdentical = false;
break;
}
}
if (parametersAreIdentical)
{
if (changeNumber==currentToUpdate)
{
Replace(code,i.index);
changed=true;
}
else
currentToUpdate++;
}
}
}
}
}
if (changed)
{
VisitMethodBody(method,currentToUpdate+1);
break;
}
}
}
#endregion
}
/// <summary>
/// Method to replace the create new intruction at position <code>pos</code> of the
/// <code>Code</code> MSIL instructions list
/// </summary>
/// <param name="code">The MSIL instrucions </param>
/// <param name="pos">The position in the <code>Code</code> where to make the change</param>
private void Replace(MSIL.Code code, int pos)
{
MSIL.ILMethod ilm = new MSIL.ILMethod(OpCodes.Call, this.newMethod);
code.Remove(pos);
code.Insert(pos,ilm);
}
/// <summary>
///
/// </summary>
/// <param name="method"></param>
public override void VisitMethod(RMethodDef method)
{
//check the method body
VisitMethodBody((RMethodBase)method);
}
/// <summary>
///
/// </summary>
/// <param name="method"></param>
public override void VisitConstructor(RConstructorDef method)
{
//Check the method body
VisitMethodBody((RMethodBase)method);
}
}
}
|