/// <summary>
/// Initializes a new instance of the <see cref="axScript3.NetFunction"/> class.
/// </summary>
/// <param name='function'>
/// Function.
/// </param>
/// <param name='target'>
/// Owner of function, leave null if static function.
/// </param>
public NetFunction(MethodBase function, object target = null)
{
Method = function;
Inputs = function.GetParameters();
Output = function.GetType();
Target = target;
HasParamArray = Inputs.Length > 0 && Inputs[Inputs.Length - 1].GetCustomAttributes(typeof (ParamArrayAttribute), false).Length > 0;
}
private static Function EmitFunction(Module module, MethodBase method)
{
var methodInfo = method as MethodInfo;
var methodConstructor = method as ConstructorInfo;
var declaringType = method.DeclaringType;
if (methodInfo == null && methodConstructor == null)
throw new CudaSharpException("Unknown MethodBase type " + method.GetType().FullName);
if (declaringType == null)
throw new CudaSharpException("Could not find the declaring type of " + method.Name.StripNameToValidPtx());
var parameters = method.GetParameters().Select(p => p.ParameterType);
if (methodConstructor != null)
parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
if (methodInfo != null && methodInfo.IsStatic == false)
{
if (declaringType.IsValueType == false)
throw new CudaSharpException("Cannot compile object instance methods (did you forget to mark the method as static?)");
parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
}
var llvmParameters =
parameters.Select(t => ConvertType(module, t)).ToArray();
var funcType = new FunctionType(ConvertType(module, methodInfo == null ? typeof(void) : methodInfo.ReturnType), llvmParameters);
var intrinsic = method.GetCustomAttribute<Gpu.BuiltinAttribute>();
if (intrinsic != null)
{
var name = intrinsic.Intrinsic;
var preExisting = module.GetFunction(name);
if (preExisting != null)
return preExisting;
return module.CreateFunction(name, funcType);
}
var function = module.CreateFunction(methodConstructor == null ? method.Name.StripNameToValidPtx() : declaringType.Name.StripNameToValidPtx() + "_ctor", funcType);
var block = new Block("entry", module.Context, function);
var writer = new InstructionBuilder(module.Context, block);
var opcodes = method.Disassemble().ToList();
FindBranchTargets(opcodes, module.Context, function);
var body = method.GetMethodBody();
var efo = new EmitFuncObj(module, function, body, writer, null, new Stack<Value>(),
body == null ? null : new Value[body.LocalVariables.Count], new Value[llvmParameters.Length]);
PrintHeader(efo);
foreach (var opcode in opcodes)
{
if (EmitFunctions.ContainsKey(opcode.Opcode) == false)
throw new CudaSharpException("Unsupported CIL instruction " + opcode.Opcode);
var func = EmitFunctions[opcode.Opcode];
efo.Argument = opcode.Parameter;
func(efo);
}
return function;
}
public static bool IsInternalFrame(MethodBase mb) {
//All the dynamic methods created for DLR rules have a special name.
//We also check if the method has a different type than the known
//non-static method. If it does, it is a dynamic method.
//This could be improved if the CLR provides a way to attach some information
//to the dynamic method we create, like CustomAttributes.
if (mb.Name == "CallSite.Target" && mb.GetType() != _knownNonDynamicMethodType) {
return true;
}
//Filter out the helper methods.
if (mb.DeclaringType == typeof(System.Dynamic.UpdateDelegates)) {
return true;
}
return false;
}
public static MethodBodyInfo Create(MethodBase method)
{
MethodBodyInfo mbi = new MethodBodyInfo();
mbi.Identity = method.GetHashCode();
mbi.TypeName = method.GetType().Name;
mbi.MethodToString = ".method " + method.ToIL();
ILReader reader = ILReaderFactory.Create(method);
mbi.Exceptions = reader.ILProvider.GetExceptionInfos();
ReadableILStringVisitor visitor = new ReadableILStringVisitor(
new MethodBodyInfoBuilder(mbi),
DefaultFormatProvider.Instance);
reader.Accept(visitor);
return mbi;
}
private void CreateMethod(Type aType, Classifier aCls, MethodBase aMethod, PdOOM.BasePackage aPckg, Operation anOper, InfluenceTable anInfTable)
{
Operation operation;
if (anOper != null)
{
operation = anOper;
}
else
{
operation = (Operation) aCls.CreateObject(0x18112066, "", -1, true);
}
operation.Static = aMethod.IsStatic;
operation.Visibility = GetMethodVisibility(aMethod);
operation.Final = aMethod.IsFinal;
if (aMethod.IsGenericMethod)
{
operation.Generic = true;
foreach (TypeParameter parameter in operation.TypeParameters)
{
parameter.delete();
}
foreach (Type type in aMethod.GetGenericArguments())
{
TypeParameter parameter2 = (TypeParameter) operation.CreateObject(0x1811207d, "", -1, true);
this.ProcessType(type, false);
TypeMapping mapping = TypeMapping.Retrieve(type);
parameter2.Name = parameter2.Code = mapping.Name;
operation.TypeParameters.Add(parameter2);
}
}
if (aMethod.IsVirtual)
{
if (LZ.Reverse.Info._bVBNet)
{
operation.SetExtendedAttribute("VB.NET.Overridable", "true");
}
else
{
operation.SetExtendedAttribute("C#.virtual", "true");
}
}
if (aMethod.IsAbstract)
{
operation.Abstract = true;
}
new CustomHandlerMethod(aMethod, operation).Convert();
if (anOper == null)
{
foreach (ParameterInfo info in aMethod.GetParameters())
{
this.AddParameter(operation, info, aPckg);
}
}
bool flag = aMethod.IsConstructor || aMethod.GetType().IsSubclassOf(typeof(ConstructorInfo));
if (!flag)
{
MethodInfo info2 = (MethodInfo) aMethod;
Type returnType = info2.ReturnType;
if (returnType.IsArray)
{
operation.Array = true;
returnType = returnType.GetElementType();
}
this.ProcessType(returnType, false);
TypeMapping mapping2 = TypeMapping.Retrieve(returnType);
if (mapping2.HasClassifier())
{
PdOOM.BaseObject obj2 = ProperRef.Link(NamespaceMapping.Retrieve(aPckg), mapping2);
operation.UseQualifiedDataType = false;
operation.ReturnTypeObject = obj2;
}
else
{
operation.ReturnType = mapping2.Name;
}
if ((anInfTable != null) && anInfTable.Contains(info2))
{
anInfTable.Impact(info2, operation);
}
if (LZ.Reverse.Info._bVBNet)
{
new CustomHandlerReturn(info2, anOper).Convert();
}
bool flag2 = false;
if (!info2.IsHideBySig && info2.GetBaseDefinition().Equals(info2))
{
string name = info2.Name;
if (!aType.BaseType.Equals(aType))
{
BindingFlags bindingAttr = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
bool flag3 = false;
foreach (MethodInfo info3 in aType.GetMethods(bindingAttr))
{
if (info3.Name == name)
{
flag3 = true;
break;
}
}
if (flag3)
{
flag2 = true;
}
}
}
if (info2.GetBaseDefinition().Equals(info2))
{
if (flag2)
{
if (LZ.Reverse.Info._bVBNet)
{
operation.SetExtendedAttribute("VB.NET.Shadowing", "Shadows");
}
else
{
operation.SetExtendedAttribute("C#.new", "true");
}
}
else if (aMethod.IsHideBySig && LZ.Reverse.Info._bVBNet)
{
operation.SetExtendedAttribute("VB.NET.Shadowing", "Overloads");
}
}
else if (LZ.Reverse.Info._bVBNet)
{
operation.SetExtendedAttribute("VB.NET.Overrides", "true");
}
else
{
operation.SetExtendedAttribute("C#.override", "true");
}
}
if (flag)
{
operation.Stereotype = "Constructor";
operation.ReturnType = "";
operation.InfluentObject = aCls;
operation.Automatic = true;
try
{
if (LZ.Reverse.Info._bVBNet)
{
operation.Name = operation.Code = "New";
}
else
{
operation.Name = operation.Code = TypeInfoHelper.GetTypeName(aType);
}
return;
}
catch (COMException)
{
if (LZ.Reverse.Info._bDebug)
{
LZ.Reverse.Info.Write(new string[] { "*** exception while naming the operation \"{1}\" on the type \"{0}\"", aType.FullName, aMethod.Name });
}
return;
}
}
if (anOper == null)
{
string aName = aMethod.Name;
if (!LZ.Reverse.Info._bVBNet && ShortenOperator(aMethod.GetParameters().Length, ref aName))
{
operation.Stereotype = "Operator";
}
try
{
operation.Name = operation.Code = aName;
}
catch (COMException)
{
if (LZ.Reverse.Info._bDebug)
{
LZ.Reverse.Info.Write(new string[] { "*** exception while naming the operation \"{1}\" on the type \"{0}\"", aType.FullName, aMethod.Name });
}
}
}
}
// Return the type of the returned value of the method:
private static Type GetMethodReturnType(MethodBase method)
{
MethodInfo info = method as MethodInfo;
if (info == null)
{
throw new ArgumentException("Unsupported MethodBase : " + method.GetType().Name, "method");
}
return info.ReturnType;
}
private void GetMethodBaseChildren (NodeInfoCollection c, NodeInfo parent, MethodBase mb)
{
AddSubnodes (c, parent, mb.GetType(), mb);
}
private static Type GetMethodReturnType(MethodBase method)
{
var methodInfo = method as MethodInfo;
if (methodInfo == null)
{
// Constructor info.
throw new ArgumentException("Unsupported MethodBase : " + method.GetType().Name, "method");
}
return methodInfo.ReturnType;
}
public List<IlInstruction> ReadInstructions(MethodBase method)
{
ilInstructions = new List<IlInstruction>();
this.currentMethod = method;
var body = method.GetMethodBody();
parameters = method.GetParameters();
if (body == null)
return ilInstructions;
locals = body.LocalVariables;
instructions = method.GetMethodBody().GetILAsByteArray();
var str = new ByteStream(instructions, instructions.Length);
stream = new BinaryReader(str);
if (!(typeof(ConstructorInfo).IsAssignableFrom(method.GetType())))
methodArgs = method.GetGenericArguments();
if (method.DeclaringType != null)
typeArgs = method.DeclaringType.GetGenericArguments();
IlInstruction instruction = null;
while (stream.BaseStream.Position < stream.BaseStream.Length)
{
instruction = new IlInstruction();
bool isDoubleByte = false;
OpCode code = ReadOpCode(ref isDoubleByte);
instruction.OpCode = code;
instruction.Offset = stream.BaseStream.Position-1;
if (isDoubleByte)
{
instruction.Offset--;
}
instruction.Operand = ReadOperand(code, method.Module,ref instruction.LocalVariableIndex);
ilInstructions.Add(instruction);
}
return ilInstructions;
}
private static void GetMethod(MethodDescription md,MethodBase mi, string NickName,string returnName)
{
md.Method = mi;
md.InputArgs = new List<MethodFieldDescription>();
md.Output = null;
md.RawType = mi.GetType();
md.TypeName = GeneratorHelper.GetTypeName(md.RawType);
md.Name = mi.Name;
md.NickName = string.IsNullOrEmpty(NickName) ? md.Name : NickName;
md.IsStatic = mi.IsStatic;
foreach (ParameterInfo pi in md.Method.GetParameters())
{
MethodFieldDescription mfd = new MethodFieldDescription();
mfd.Name = pi.Name;
mfd.RawType = pi.ParameterType;
mfd.TypeName = GeneratorHelper.GetTypeName(mfd.RawType);
mfd.IsStatic = false;
mfd.Type = GetMessageFieldType(mfd.RawType);
md.InputArgs.Add(mfd);
}
MethodInfo mii = md.Method as MethodInfo;
if (null != mii)
{
if (!string.Equals(mii.ReturnType.FullName, "System.Void"))
{
MethodFieldDescription mfd = new MethodFieldDescription();
mfd.Name = returnName;
mfd.RawType = mii.ReturnType;
mfd.TypeName = GeneratorHelper.GetTypeName(mfd.RawType);
mfd.IsStatic = false;
mfd.Type = GetMessageFieldType(mfd.RawType);
md.Output = mfd;
}
}
}
public static bool IsDynamicOrRTDynamicMethod(MethodBase method)
{
Type type = method.GetType();
return rtDynamicMethodType.Equals(type) || dynamicMethodType.Equals(type);
}
public static bool IsRTDynamicMethod(MethodBase method)
{
return rtDynamicMethodType.Equals(method.GetType());
}
public ILReader(MethodBase method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
Type rtType = method.GetType();
if (rtType != s_runtimeMethodInfoType && rtType != s_runtimeConstructorInfoType)
{
throw new ArgumentException("method must be RuntimeMethodInfo or RuntimeConstructorInfo for this constructor.");
}
m_ilProvider = new MethodBaseILProvider(method);
m_resolver = new ModuleScopeTokenResolver(method);
InstructionBytes = m_ilProvider.GetByteArray();
m_position = 0;
}
public static MethodBodyInfo Create(MethodBase method)
{
MethodBodyInfo mbi = new MethodBodyInfo();
mbi.Identity = method.GetHashCode();
mbi.TypeName = method.GetType().Name;
mbi.MethodToString = method.ToString();
ReadableILStringVisitor readableIlStringVisitor = new ReadableILStringVisitor((IILStringCollector) new MethodBodyInfo.MethodBodyInfoBuilder(mbi), (IFormatProvider) DefaultFormatProvider.Instance);
new ILReader(method).Accept((ILInstructionVisitor) readableIlStringVisitor);
return mbi;
}
