static public void InvokeCustomSlot(IntPtr obj, string slotname, IntPtr stack, IntPtr ret) { QObject qobj = (QObject)((GCHandle)obj).Target; #if DEBUG if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0) { Console.WriteLine("ENTER InvokeCustomSlot() {0}.{1}", qobj, slotname); } #endif MethodInfo slot = Qyoto.GetSlotMethodInfo(qobj.GetType(), slotname); ParameterInfo[] parameters = slot.GetParameters(); object[] args = new object[parameters.Length]; unsafe { StackItem *stackPtr = (StackItem *)stack; for (int i = 0; i < args.Length; i++) { args[i] = SmokeMarshallers.BoxFromStackItem(parameters[i].ParameterType, 0, stackPtr + i); } object returnValue = slot.Invoke(qobj, args); StackItem *retval = (StackItem *)ret; if (slot.ReturnType != typeof(void)) { SmokeMarshallers.UnboxToStackItem(returnValue, retval); } } }
public override IMessage Invoke(IMessage message) { IMethodCallMessage callMessage = (IMethodCallMessage)message; StackItem[] stack = new StackItem[callMessage.ArgCount + 1]; #if DEBUG if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0) { Console.WriteLine("ENTER SignalInvocation.Invoke() MethodName: {0}.{1} Type: {2} ArgCount: {3}", instance, callMessage.MethodName, callMessage.TypeName, callMessage.ArgCount.ToString()); } #endif unsafe { fixed(StackItem *stackPtr = stack) { for (int i = 0; i < callMessage.ArgCount; i++) { SmokeMarshallers.UnboxToStackItem(callMessage.Args[i], stackPtr + i + 1); } IMethodReturnMessage returnMessage = new ReturnMessage(null, callMessage); /*(IMethodReturnMessage) message;*/ MethodReturnMessageWrapper returnValue = new MethodReturnMessageWrapper((IMethodReturnMessage)returnMessage); #if DEBUG GCHandle instanceHandle = DebugGCHandle.Alloc(instance); #else GCHandle instanceHandle = GCHandle.Alloc(instance); #endif Qyoto.CPPMethod signalEntry = Qyoto.GetSignalSignature(signalsInterface, (MethodInfo)callMessage.MethodBase); Type returnType = ((MethodInfo)returnMessage.MethodBase).ReturnType; SignalEmit(signalEntry.signature, signalEntry.type, (IntPtr)instanceHandle, (IntPtr)stackPtr, callMessage.ArgCount); if (returnType != typeof(void)) { returnValue.ReturnValue = SmokeMarshallers.BoxFromStackItem(returnType, 0, stackPtr); } returnMessage = returnValue; return(returnMessage); } } }
public static void InvokeMethod(IntPtr instanceHandle, IntPtr methodHandle, IntPtr stack, IntPtr typeIDs) { object instance = ((GCHandle)instanceHandle).Target; MethodInfo method = (MethodInfo)((GCHandle)methodHandle).Target; #if DEBUG if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0 && (QDebug.DebugChannel() & QtDebugChannel.QTDB_VIRTUAL) != 0) { Console.WriteLine("ENTER InvokeMethod() {0}.{1}", instance, method.Name); } #endif unsafe { StackItem * stackPtr = (StackItem *)stack; ParameterInfo[] parameters = method.GetParameters(); object[] args = new object[parameters.Length]; TypeId * typeIDsPtr = (TypeId *)typeIDs; for (int i = 0; i < args.Length; i++) { args[i] = SmokeMarshallers.BoxFromStackItem(parameters[i].ParameterType, (int)typeIDsPtr[i + 1], stackPtr + i + 1); } object returnValue = method.Invoke(instance, args); * typeIDsPtr = SmokeMarshallers.GetTypeId(returnValue == null ? typeof(object) : returnValue.GetType()); //TODO: should this always be unboxing something? if (method.ReturnType != typeof(void)) { SmokeMarshallers.UnboxToStackItem(returnValue, stackPtr); } } return; }
public object Invoke(string mungedName, string signature, Type returnType, bool refArgs, params object[] args) { #if DEBUG if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0) { Console.WriteLine("ENTER SmokeInvocation.Invoke() MethodName: {0}.{1} Type: {2} ArgCount: {3}", className, signature, returnType, args.Length / 2); } #endif if (signature.StartsWith("operator==")) { if (args[1] == null && args[3] == null) { return(true); } else if (args[1] == null || args[3] == null) { return(false); } } ModuleIndex methodId; methodId.smoke = IntPtr.Zero; methodId.index = -1; if (!methodIdCache.TryGetValue(signature, out methodId)) { methodId = FindMethodId(className, mungedName, signature); if (methodId.index == -1) { Console.Error.WriteLine("LEAVE Invoke() ** Missing method ** {0}.{1}", className, signature); return(null); } methodIdCache[signature] = methodId; } StackItem[] stack = new StackItem[(args.Length / 2) + 1]; TypeId[] typeIDs = new TypeId[(args.Length / 2) + 1]; unsafe { fixed(StackItem *stackPtr = stack) { fixed(TypeId *typeIDsPtr = typeIDs) { typeIDs[0] = 0; for (int i = 1, k = 1; i < args.Length; i += 2, k++) { typeIDs[k] = SmokeMarshallers.UnboxToStackItem(args[i], stackPtr + k); } object returnValue = null; if (instance == null) { CallSmokeMethod(methodId.smoke, (int)methodId.index, (IntPtr)0, (IntPtr)stackPtr, args.Length / 2, (IntPtr)typeIDsPtr); } else { #if DEBUG GCHandle instanceHandle = DebugGCHandle.Alloc(instance); #else GCHandle instanceHandle = GCHandle.Alloc(instance); #endif CallSmokeMethod(methodId.smoke, methodId.index, (IntPtr)instanceHandle, (IntPtr)stackPtr, args.Length / 2, (IntPtr)typeIDsPtr); #if DEBUG DebugGCHandle.Free(instanceHandle); #else instanceHandle.Free(); #endif } if (returnType != typeof(void)) { returnValue = SmokeMarshallers.BoxFromStackItem(returnType, (int)typeIDs[0], stackPtr); } if (refArgs) { for (int i = 1, k = 1; i < args.Length; i += 2, k++) { Type t = args[i].GetType(); if (t.IsPrimitive || t == typeof(NativeLong) || t == typeof(NativeULong)) { args[i] = SmokeMarshallers.BoxFromStackItem(args[i].GetType(), (int)typeIDs[k], stackPtr + k); } } } return(returnValue); } } } }