/// <summary>
/// Registers metadata token to TypeRef table from metadata scope A to metadata scope B.
/// </summary>
/// <param name="token">Token in metadata scope A.</param>
/// <returns>Token in metadata scope B.</returns>
private MetadataToken registerTypeRef(MetadataToken token)
{
string name;
uint scope, newToken;
NewImporter.GetTypeRefProps(token.ToUInt32(), out name, out scope);
MetadataToken assmToken = TranslateToken(new MetadataToken(scope));
OldEmitter.CorMetaDataEmit.DefineTypeRefByName(assmToken.ToUInt32(), name, out newToken);
return(new MetadataToken(newToken));
}
/// <summary>
/// Registers metadata token to TypeSpec table from metadata scope A to metadata scope B.
/// </summary>
/// <param name="token">Token in metadata scope A.</param>
/// <returns>Token in metadata scope B.</returns>
private MetadataToken registerTypeSpec(MetadataToken token)
{
uint nToken;
byte[] signature = NewImporter.GetTypeSpec(token.ToUInt32());
Signature sig = new Signature(signature);
sig.Migrate(this);
signature = sig.Compress();
OldEmitter.CorMetaDataEmit.GetTokenFromTypeSpec(signature, (uint)signature.Length, out nToken);
return(new MetadataToken(nToken));
}
/// <summary>
/// Registers metadata token to MemberRef table from metadata scope A to metadata scope B.
/// </summary>
/// <param name="token">Token in metadata scope A.</param>
/// <returns>Token in metadata scope B.</returns>
private MetadataToken registerMemberRef(MetadataToken token)
{
string name;
byte[] sig;
uint ptk, nToken;
NewImporter.GetMemberRefProps(token.ToUInt32(), out name, out ptk, out sig);
MetadataToken scope = TranslateToken(new MetadataToken(ptk));
Signature signa = new Signature(sig);
signa.Migrate(this);
sig = signa.Compress();
OldEmitter.CorMetaDataEmit.DefineMemberRef(scope.ToUInt32(), name, sig, (uint)sig.Length, out nToken);
return(new MetadataToken(nToken));
}
void WriteMetadataToken(MetadataToken token)
{
WriteUInt32(token.ToUInt32());
}
void WriteMetadataToken (MetadataToken token)
{
WriteUInt32 (token.ToUInt32 ());
}
public void WriteForwardInfo(MetadataToken import_parent)
{
Write(CustomMetadataType.ForwardInfo, () => writer.WriteUInt32(import_parent.ToUInt32()));
}
/// <summary>
/// This method returns the member with the specified metadata token in the given module. It supports more TokenTypes than the standard Cecil method.
/// </summary>
/// <param name="module"></param>
/// <param name="token"></param>
/// <returns></returns>
internal static IMetadataTokenProvider LookupTokenExtended(this ModuleDefinition module, MetadataToken token)
{
switch (token.TokenType)
{
case TokenType.TypeDef:
case TokenType.TypeRef:
case TokenType.MemberRef:
case TokenType.Field:
case TokenType.Method:
case TokenType.MethodSpec:
case TokenType.TypeSpec:
return(module.LookupToken(token));
default:
IMetadataTokenProvider provider;
var success = _tokenProviderCache.GetValue(module, InitializeTokenProviderCache).TryGetValue(token.ToUInt32(),
out provider);
return(success ? provider : null);
}
}
private void WriteMetadataToken(MetadataToken token)
{
base.WriteUInt32(token.ToUInt32());
}
/// <summary>
/// Used to be able to reference methods created in this round from code changed also in the same round. Must not be in cache,
/// because it can be cleared.
/// </summary>
/// <param name="newToken">Token in new assembly.</param>
/// <param name="registeredToken">Token in running assembly.</param>
public void RegisterNewMethod(MetadataToken newToken, MetadataToken registeredToken)
{
addedMethods.Add(newToken.ToUInt32(), registeredToken);
}
/// <summary>
/// Registers any metadata token from tables
/// (MemberRef,UserString,TypeRef,Method,TypeDef,Field,ModuleRef,AssemblyRef)
/// from metadata scope A to metadata scope B.
/// </summary>
/// <param name="token">Token in metadata scope A.(new assembly)</param>
/// <returns>Token in metadata scope B.(running assembly)</returns>
public MetadataToken TranslateToken(MetadataToken cecToken)
{
uint token = cecToken.ToUInt32();
MetadataToken new_token;
// Look in cache first
if (cache.TryGetValue(token, out new_token))
{
return(new_token);
}
switch (cecToken.TokenType)
{
case TokenType.MemberRef:
new_token = registerMemberRef(cecToken);
break;
case TokenType.String:
{
uint nToken;
string str = NewImporter.GetUserString(token);
OldEmitter.CorMetaDataEmit.DefineUserString(str, (uint)str.Length, out nToken);
new_token = new MetadataToken(nToken);
}
break;
case TokenType.TypeRef:
new_token = registerTypeRef(cecToken);
break;
case TokenType.Method:
{
if (addedMethods.TryGetValue(token, out new_token))
{
break;
}
string name; uint classTk; byte[] signature; uint attr; uint rva; uint flags;
NewImporter.GetMethodProps(token, out name, out classTk, out attr, out signature, out rva, out flags);
MetadataToken classToken = TranslateToken(new MetadataToken(classTk));
Signature sig = new Signature(signature);
sig.Migrate(this);
signature = sig.Compress();
new_token = new MetadataToken(OldImporter.FindMethod(classToken.ToUInt32(), name, signature));
}
break;
case TokenType.Field:
{
FieldProps fProps = NewImporter.GetFieldProps(token);
uint newMClass = TranslateToken(new MetadataToken(fProps.mClass)).ToUInt32();
fProps.sigBlob = Signature.Migrate(fProps.sigBlob, this, 1);
//metadata.OldEmitter.CorMetaDataEmit.DefineMemberRef(newMClass,fProps.fName,fProps.sigBlob,(uint)fProps.sigBlob.Length,out new_token);
uint nCorToken = OldImporter.FindField(newMClass, fProps.fName, fProps.sigBlob);
if (nCorToken == 0)
{
OldEmitter.CorMetaDataEmit.DefineField(newMClass, fProps.fName, fProps.pdwAttr, fProps.sigBlob, (uint)fProps.sigBlob.Length, fProps.pdwCPlusTypeFlag, fProps.ppValue, (uint)fProps.ppValue.Length, out nCorToken);
}
new_token = new MetadataToken(nCorToken);
}
break;
case TokenType.TypeDef:
TypeDefProps tProps = NewImporter.GetTypeDefProps(token);
new_token = new MetadataToken(OldImporter.FindTypeDef(tProps.tName));
break;
case TokenType.ModuleRef:
{
uint nToken;
string name = NewImporter.GetModuleRefProps(token);
OldEmitter.CorMetaDataEmit.DefineModuleRef(name, out nToken);
new_token = new MetadataToken(nToken);
}
break;
case TokenType.AssemblyRef:
{
int index = manager.ResourceManager.NewAssembly.Modules[0].AssemblyReferences.FindIndex(delegate(AssemblyNameReference asmRef){
return(asmRef.MetadataToken.ToUInt32() == token);
});
string scopeName = manager.ResourceManager.NewAssembly.Modules[0].AssemblyReferences[index].FullName;
index = manager.ResourceManager.OldAssembly.Modules[0].AssemblyReferences.FindIndex(delegate(AssemblyNameReference asmRef){
return(asmRef.FullName == scopeName);
});
if (index == -1)
{
throw new TranslatingException("Assembly reference not found, maybe it wasn't in used in original version");
}
else
{
new_token = manager.ResourceManager.OldAssembly.Modules[0].AssemblyReferences[index].MetadataToken;
}
}
break;
case TokenType.TypeSpec:
new_token = registerTypeSpec(cecToken);
break;
case TokenType.MethodSpec:
uint new_token_cor;
MethodSpecProps props = newImporter.GetMethodSpecProps(token);
props.tkParent = TranslateToken(new MetadataToken(props.tkParent)).ToUInt32();
props.signature = Signature.Migrate(props.signature, this);
OldEmitter.CorMetaDataEmit.DefineMethodSpec(props.tkParent, props.signature, (uint)props.signature.Length, out new_token_cor);
new_token = new MetadataToken(new_token_cor);
break;
case TokenType.Property:
default:
throw new NotImplementedException();
}
// Add to cache
cache.Add(token, new_token);
return(new_token);
}
/// <summary>
/// Stores byte representation of operand to the IL stream. If neccessary,
/// translate metadata token to original metadata scope.
/// </summary>
/// <param name="operand">Operand, that is being processed.</param>
private void processOperand(Object operand)
{
if (operand is Mono.Cecil.Cil.Operand)
{
//operand with token
MetadataToken token = metadata.TranslateToken(((Mono.Cecil.Cil.Operand)operand).Token);
buffer.AddRange(BitConverter.GetBytes(token.ToUInt32()));//uintToByteArray(token.ToUInt32()));
}
else if (operand != null)
{
// operand as value
if (operand is SByte)
{
System.SByte oper = (SByte)operand;
byte a;
unchecked {
a = (byte)((IConvertible)oper).ToSByte(null);
}
buffer.Add(a);
}
else if (operand is Int32)
{
Int32 oper = (Int32)operand;
buffer.AddRange(BitConverter.GetBytes(((IConvertible)oper).ToInt32(null)));
}
else if (operand is Int64)
{
Int64 oper = (Int64)operand;
buffer.AddRange(BitConverter.GetBytes(((IConvertible)oper).ToInt64(null)));
}
else if (operand is Double)
{
byte[] arr = BitConverter.GetBytes(((IConvertible)operand).ToDouble(null));
buffer.AddRange(arr);
}
else if (operand is Single)
{
byte[] arr = BitConverter.GetBytes(((IConvertible)operand).ToSingle(null));
buffer.AddRange(arr);
}
else if (operand is UInt16)
{
byte[] arr = BitConverter.GetBytes(((IConvertible)operand).ToUInt16(null));
buffer.AddRange(arr);
}
else if (operand is byte)
{
buffer.Add((byte)operand);
}
else if (operand is Int32[])
{
Int32[] oper = (Int32[])operand;
buffer.AddRange(BitConverter.GetBytes(((IConvertible)oper.Length).ToInt32(null)));
foreach (Int32 a in oper)
{
byte[] arr = BitConverter.GetBytes(((IConvertible)a).ToInt32(null));
buffer.AddRange(arr);
}
}
else
{
throw new NotImplementedException();
}
}
}
public static string ToScopeId(this MetadataToken token)
{
return(token.ToUInt32().ToString("x8", CultureInfo.InvariantCulture));
}
private void PatchRawCode(ByteBuffer buffer, int code_size, CodeWriter writer)
{
MetadataBuilder metadata = writer.metadata;
buffer.WriteBytes(ReadBytes(code_size));
int position = buffer.position;
buffer.position -= code_size;
while (buffer.position < position)
{
byte b = buffer.ReadByte();
OpCode opCode;
if (b != 254)
{
opCode = OpCodes.OneByteOpCode[b];
}
else
{
byte b2 = buffer.ReadByte();
opCode = OpCodes.TwoBytesOpCode[b2];
}
MetadataToken metadataToken;
switch (opCode.OperandType)
{
case OperandType.ShortInlineBrTarget:
case OperandType.ShortInlineI:
case OperandType.ShortInlineVar:
case OperandType.ShortInlineArg:
buffer.position++;
break;
case OperandType.InlineVar:
case OperandType.InlineArg:
buffer.position += 2;
break;
case OperandType.InlineBrTarget:
case OperandType.InlineI:
case OperandType.ShortInlineR:
buffer.position += 4;
break;
case OperandType.InlineI8:
case OperandType.InlineR:
buffer.position += 8;
break;
case OperandType.InlineSwitch:
{
int num = buffer.ReadInt32();
buffer.position += num * 4;
break;
}
case OperandType.InlineString:
{
string @string = GetString(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
metadataToken = new MetadataToken(TokenType.String, metadata.user_string_heap.GetStringIndex(@string));
buffer.WriteUInt32(metadataToken.ToUInt32());
break;
}
case OperandType.InlineSig:
{
CallSite callSite = GetCallSite(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
metadataToken = writer.GetStandAloneSignature(callSite);
buffer.WriteUInt32(metadataToken.ToUInt32());
break;
}
case OperandType.InlineField:
case OperandType.InlineMethod:
case OperandType.InlineTok:
case OperandType.InlineType:
{
IMetadataTokenProvider provider = reader.LookupToken(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
metadataToken = metadata.LookupToken(provider);
buffer.WriteUInt32(metadataToken.ToUInt32());
break;
}
}
}
}
public static string GetFullMetadataTokenString(MetadataToken mt)
{
return(UintToHexString(mt.ToUInt32(), 8));
}
private void PatchRawCode(ByteBuffer buffer, int code_size, CodeWriter writer)
{
OpCode twoBytesOpCode;
MetadataToken standAloneSignature;
MetadataBuilder metadataBuilder = writer.metadata;
buffer.WriteBytes(base.ReadBytes(code_size));
int num = buffer.position;
buffer.position -= code_size;
while (buffer.position < num)
{
byte num1 = buffer.ReadByte();
if (num1 == 254)
{
byte num2 = buffer.ReadByte();
twoBytesOpCode = OpCodes.TwoBytesOpCode[num2];
}
else
{
twoBytesOpCode = OpCodes.OneByteOpCode[num1];
}
switch (twoBytesOpCode.OperandType)
{
case OperandType.InlineBrTarget:
case OperandType.InlineI:
case OperandType.ShortInlineR:
{
buffer.position += 4;
continue;
}
case OperandType.InlineField:
case OperandType.InlineMethod:
case OperandType.InlineTok:
case OperandType.InlineType:
{
IMetadataTokenProvider metadataTokenProvider = this.reader.LookupToken(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
standAloneSignature = metadataBuilder.LookupToken(metadataTokenProvider);
buffer.WriteUInt32(standAloneSignature.ToUInt32());
continue;
}
case OperandType.InlineI8:
case OperandType.InlineR:
{
buffer.position += 8;
continue;
}
case OperandType.InlineSig:
{
Mono.Cecil.CallSite callSite = this.GetCallSite(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
standAloneSignature = writer.GetStandAloneSignature(callSite);
buffer.WriteUInt32(standAloneSignature.ToUInt32());
continue;
}
case OperandType.InlineString:
{
string str = this.GetString(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
standAloneSignature = new MetadataToken(Mono.Cecil.TokenType.String, metadataBuilder.user_string_heap.GetStringIndex(str));
buffer.WriteUInt32(standAloneSignature.ToUInt32());
continue;
}
case OperandType.InlineSwitch:
{
int num3 = buffer.ReadInt32();
ByteBuffer byteBuffer = buffer;
byteBuffer.position = byteBuffer.position + num3 * 4;
continue;
}
case OperandType.InlineVar:
case OperandType.InlineArg:
{
buffer.position += 2;
continue;
}
case OperandType.ShortInlineBrTarget:
case OperandType.ShortInlineI:
case OperandType.ShortInlineVar:
case OperandType.ShortInlineArg:
{
buffer.position++;
continue;
}
default:
{
continue;
}
}
}
}
