protected ConstructorInfo GrabConstructor(ConstructorInfo Original, TypeBuilder On)
{
if(Original == null) return null;
if(ConstructorsDone.ContainsKey(Original))
return ConstructorsDone[Original];
if(!Sources.Contains(Original.Module))
return ConstructorReplaceGenerics(Original);
if(On == null)
On = GrabType(Original.DeclaringType) as TypeBuilder;
ConstructorBuilder Builder = On.DefineConstructor(Original.Attributes,
Original.CallingConvention, ParameterTypes(Original));
Builder.SetImplementationFlags(Original.GetMethodImplementationFlags());
if(ConstructorsDone.ContainsKey(Original))
return ConstructorsDone[Original];
ConstructorsDone.Add(Original, Builder);
CopyMethodBody(Original, Builder);
return Builder;
}
static private void AppendConstructorInfo(ConstructorInfo constructor, StringBuilder sb)
{
sb.Append(".method");
foreach (var attribute in constructor.GetCustomAttributesData())
{
sb.Append(" ");
AppendCustomAttributeData(attribute, sb);
}
sb.Append(" ");
AppendMethodAttributes(sb, constructor.Attributes);
sb.Append(" ");
sb.Append("void ");
sb.Append(constructor.Name);
if (constructor.IsGenericMethod)
{
sb.Append("<");
foreach (var typeParameter in constructor.GetGenericArguments())
{
AppendType(typeParameter, sb, true);
AppendComma(sb);
}
RemoveTrailingComma(sb);
sb.Append(">");
}
sb.Append("(");
foreach (var parameter in constructor.GetParameters())
{
AppendParameterInfo(parameter, sb);
AppendComma(sb);
}
RemoveTrailingComma(sb);
sb.Append(")");
var implFlags = constructor.GetMethodImplementationFlags();
if (implFlags.HasFlag(MethodImplAttributes.IL)) sb.Append(" cil");
if (implFlags.HasFlag(MethodImplAttributes.ForwardRef)) sb.Append(" forwardref");
if (implFlags.HasFlag(MethodImplAttributes.InternalCall)) sb.Append(" internalcall");
if (implFlags.HasFlag(MethodImplAttributes.Managed)) sb.Append(" managed");
if (implFlags.HasFlag(MethodImplAttributes.Native)) sb.Append(" native");
if (implFlags.HasFlag(MethodImplAttributes.NoInlining)) sb.Append(" noinlining");
if (implFlags.HasFlag(MethodImplAttributes.NoOptimization)) sb.Append(" nooptimization");
if (implFlags.HasFlag(MethodImplAttributes.OPTIL)) sb.Append(" optil");
if (implFlags.HasFlag(MethodImplAttributes.PreserveSig)) sb.Append(" preservesig");
if (implFlags.HasFlag(MethodImplAttributes.Runtime)) sb.Append(" runtime");
if (implFlags.HasFlag(MethodImplAttributes.Synchronized)) sb.Append(" synchronized");
if (implFlags.HasFlag(MethodImplAttributes.Unmanaged)) sb.Append(" unmanaged");
}
private String GetArgValue(Assembly scope)
{
if (instruction.Operand == null)
{
return("");
}
else
{
bool isLocalCall;
string s = "";
if (instruction.Operand != null)
{
switch (instruction.Code.OperandType)
{
case OperandType.InlineField:
System.Reflection.FieldInfo fOperand = ((System.Reflection.FieldInfo)instruction.Operand);
s = fOperand.FieldType.FullName + " " + Helper.ProcessSpecialTypes(fOperand.ReflectedType, scope) + "::" + fOperand.Name + "";
break;
case OperandType.InlineMethod:
try
{
System.Reflection.MethodInfo mOperand = (System.Reflection.MethodInfo)instruction.Operand;
String t = Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope);
isLocalCall = t.StartsWith("local");
if (isLocalCall)
{
s = mOperand.ReturnType.ToString() + " " + t + "::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters(), !mOperand.IsStatic);
}
else
{
s = mOperand.ReturnType.ToString() + " " + t + "::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters());
}
}
catch
{
try
{
System.Reflection.ConstructorInfo mOperand = (System.Reflection.ConstructorInfo)instruction.Operand;
String t = Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope);
bool isDelegateCall = ((mOperand.GetMethodImplementationFlags() & System.Reflection.MethodImplAttributes.Runtime) != 0);
if (isDelegateCall)
{
s = "delegate " + Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope) +
"::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters(), !mOperand.IsStatic);
}
else
{
isLocalCall = t.StartsWith("local");
if (isLocalCall)
{
s = "System.Void " + Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope) +
"::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters(), !mOperand.IsStatic);
}
else
{
s = "System.Void " + Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope) +
"::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters());
}
}
}
catch
{
}
}
break;
case OperandType.ShortInlineBrTarget:
case OperandType.InlineBrTarget:
// can assign anything, not used
s = instruction.Offset.ToString();
break;
case OperandType.InlineType:
s = Helper.ProcessSpecialTypes((Type)instruction.Operand, scope);
break;
case OperandType.InlineString:
s = instruction.Operand.ToString();
break;
case OperandType.ShortInlineVar:
s = instruction.Operand.ToString();
break;
case OperandType.InlineI:
case OperandType.InlineI8:
case OperandType.InlineR:
case OperandType.ShortInlineI:
case OperandType.ShortInlineR:
s = instruction.Operand.ToString();
break;
case OperandType.InlineTok:
if (instruction.Operand is Type)
{
s = ((Type)instruction.Operand).FullName;
}
else
{
s = "not supported";
}
break;
default: s = "not supported"; break;
}
}
return(s);
}
}
