Beispiel #1
0
        public AssemblyLoader()
        {
            _signatureResolver = new SignatureResolver(this);

            _assemblyTable = new AssemblyTable(this);

            Const             = new ConstantTable(this);
            Files             = new FileTable(this);
            ManifestResources = new ManifestResourceTable(this);

            Modules = new ModuleTable(this);

            ModuleRefs   = new ModuleRefTable(this);
            AssemblyRefs = new AssemblyRefTable(this);

            TypeRefs    = new TypeRefTable(this);
            MemberRefs  = new MemberRefTable(this);
            _typeSpec   = new TypeSpecTable(this);
            _methodSpec = new MethodSpecTable(this);

            Parameters        = new ParamTable(this);
            Fields            = new FieldTable(this);
            Properties        = new PropertyTable(this);
            Events            = new EventTable(this);
            GenericParameters = new GenericParamTable(this);

            Methods = new MethodTable(this);
            Types   = new TypeTable(this);
        }
Beispiel #2
0
        private static MethodTable ShallowCloneToDerived(MethodTable state, Type derivedType, Type stateMachineType)
        {
            var baseType = state.GetType();

            if (!baseType.IsAssignableFrom(derivedType))
            {
                throw new Exception("Method table inheritance hierarchy error.");
            }

            if (derivedType.IsGenericType)
            {
                derivedType = derivedType.MakeGenericType(stateMachineType.GetGenericArguments()[0]);
            }

            var derivedMethodTable = (MethodTable)Activator.CreateInstance(derivedType);

            // Copy all fields that exist in the base type to the more derived type
            foreach (var field in baseType.GetFields(BindingFlags.Public | BindingFlags.NonPublic |
                                                     BindingFlags.Instance))
            {
                field.SetValue(derivedMethodTable, field.GetValue(state));
            }

            return(derivedMethodTable);
        }
Beispiel #3
0
 public static unsafe bool MightBeUnconstructedType(RuntimeTypeHandle type)
 {
     // If there are no vtable slots the type is likely an unconstructed type.
     // But could also be an interface with no virtuals. We can't distinguish those.
     Debug.Assert(MethodTable.Of <object>()->NumVtableSlots != 0);
     return(CreateEETypePtr(type).ToPointer()->NumVtableSlots == 0);
 }
Beispiel #4
0
        private static void AddMethod(MethodTable methodTable, ICollection <MethodBinding> methodList, Type declaringType, MethodBinding methodBinding, MethodInfo methodInfo)
        {
            // Check if we already have a method with the same name and parameters declared.
            MethodTable.Entry exisitingMethodEntry = methodTable[methodBinding.Name, methodBinding.GetParameterTypes()];

            if (exisitingMethodEntry != null)
            {
                // Ok we have one. Check if the existing member is not more specific.
                if (ExistingMemberIsMoreSpecific(declaringType, exisitingMethodEntry.MethodInfo, methodInfo))
                {
                    // The existing member is more specific. So we don't add the new one.
                    return;
                }
                else
                {
                    // The new member is more specific. Remove the old one.
                    methodTable.Remove(exisitingMethodEntry);
                    methodList.Remove(exisitingMethodEntry.MethodBinding);
                }
            }

            // Either the new member is more specific or we don't had
            // a member with same name.
            methodTable.Add(methodBinding, methodInfo);
            methodList.Add(methodBinding);
        }
Beispiel #5
0
        private unsafe static Object NewOperatorHook(IntPtr mt)
        {
            if (IsNoAlloc)
            {
                // TODO:
                // Temporary whitelist. Need some way to allocate AllocationEntry without new operator.
                // @Harnel
                if (mt != (IntPtr)MethodTable.GetMethodTable <AllocationEntry>())
                {
                    try
                    {
                        IsNoAlloc = false;
                        Thread curr = Thread.CurrentThread;

                        throw new MemoryRestrictorException(
                                  $"Tried to allocate in NoAlloc region. Thread: ({curr.Name}, #{curr.ManagedThreadId}), MT: {mt.ToInt64():X}");
                    }
                    finally
                    {
                        IsNoAlloc = true;
                    }
                }
            }

            return(NewOperatorHijackContext.Funclet.Invoke(mt));
        }
Beispiel #6
0
        public MethodBinding[] GetMethods(Type type)
        {
            if (type == null)
            {
                throw ExceptionBuilder.ArgumentNull("type");
            }

            MethodTable          methodTable = new MethodTable();
            List <MethodBinding> methodList  = new List <MethodBinding>();

            MethodInfo[] methodInfos = type.GetMethods(_bindingFlags);
            Array.Sort(methodInfos, (x, y) => String.Compare(x.ToString(), y.ToString(), StringComparison.Ordinal));

            foreach (MethodInfo currentMethodInfo in methodInfos)
            {
                if (IsInvocable(currentMethodInfo))
                {
                    MethodBinding methodBinding = CreateMethod(currentMethodInfo);

                    if (methodBinding != null)
                    {
                        AddMethod(methodTable, methodList, type, methodBinding, currentMethodInfo);
                    }
                }
            }

            return(methodList.ToArray());
        }
        public IEnumerable <MethodSymbol> GetMethods(Type type)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            var methodTable = new MethodTable();
            var methodList  = new List <MethodSymbol>();

            var methodInfos = type.GetMethods(BindingFlags);

            Array.Sort(methodInfos, (x, y) => string.Compare(x.ToString(), y.ToString(), StringComparison.Ordinal));

            foreach (var currentMethodInfo in methodInfos)
            {
                if (!IsInvocable(currentMethodInfo))
                {
                    continue;
                }

                var methodSymbol = CreateMethod(currentMethodInfo);
                if (methodSymbol != null)
                {
                    AddMethod(methodTable, methodList, type, methodSymbol, currentMethodInfo);
                }
            }

            return(methodList.ToImmutableArray());
        }
        void PatchMethods()
        {
            MethodTable methodTable = (MethodTable)stripped_tables [MethodTable.RId];

            if (methodTable == null)
            {
                return;
            }

            RVA method_rva = RVA.Zero;

            for (int i = 0; i < methodTable.Rows.Count; i++)
            {
                MethodRow methodRow = methodTable[i];

                methodRow.ImplFlags |= MethodImplAttributes.NoInlining;

                MetadataToken methodToken = MetadataToken.FromMetadataRow(TokenType.Method, i);

                MethodDefinition method = (MethodDefinition)assembly.MainModule.LookupByToken(methodToken);

                if (method.HasBody)
                {
                    method_rva = method_rva != RVA.Zero
                                                ? method_rva
                                                : reflection_writer.CodeWriter.WriteMethodBody(method);

                    methodRow.RVA = method_rva;
                }
                else
                {
                    methodRow.RVA = RVA.Zero;
                }
            }
        }
Beispiel #9
0
 Unit GetTable(Unit p_key)
 {
     if (MethodTable != null)
     {
         return(MethodTable.Get(p_key));
     }
     throw new Exception("List does not contain a Method Table: " + p_key.ToString());
 }
Beispiel #10
0
        public object EvaluateNamed(ScriptThread thread, MethodTable table)
        {
            object res = DoEvaluate(thread);

            var closure = res as Closure;

            table.Add(closure);

            return(res);
        }
Beispiel #11
0
        protected override object DoEvaluate(ScriptThread thread)
        {
            thread.CurrentNode = this;
            var result       = new DataTable(ChildNodes.Count);
            int indexCounter = 0;

            foreach (AstNode t in ChildNodes)
            {
                var tmp = t.Evaluate(thread);
                var arr = tmp as object[];
                if (arr != null)
                {
                    if (arr.Length != 2)
                    {
                        thread.ThrowScriptError("Failed to create array.");
                    }

                    var name = (string)arr[0];

                    var iCall = arr[1] as ICallTarget;

                    var mTable = result.GetString(thread, name) as MethodTable;

                    if (iCall != null)
                    {
                        if (mTable != null)
                        {
                            mTable.Add(iCall);
                            arr[1] = mTable;
                        }
                        else
                        {
                            mTable = new MethodTable(name);
                            mTable.Add(iCall);
                            arr[1] = mTable;
                        }
                    }

                    result.SetString(thread, name, arr[1]);
                }
                else
                {
                    result.SetInt(thread, indexCounter, tmp);
                    indexCounter++;
                }
            }

            thread.CurrentNode = Parent;
            return(result);
        }
Beispiel #12
0
        /// <summary>
        /// Similar with FormatterServices.GetUninitializedObject. Allocate and return zeroed T-typed object.
        /// </summary>
        public static ClassDisposeHandle UninitializedAllocation(Type t, out Object result)
        {
            MethodTable *mt   = MethodTable.GetMethodTable(t);
            int          size = mt->BaseSize;

            ObjectHeader *objHeader = (ObjectHeader *)RawMemoryManager.Allocate(size);

            objHeader->SyncBlock   = 0;
            objHeader->MethodTable = mt;
            RawMemoryManager.FillMemory(objHeader + 1, 0, size - sizeof(ObjectHeader));

            result = TypedReferenceHelper.PointerToObject <Object>(objHeader);
            return(new ClassDisposeHandle(size, objHeader));
        }
Beispiel #13
0
 public MultiFn addMethod(object dispatchVal, IFn method)
 {
     _rw.EnterWriteLock();
     try
     {
         _methodTable = MethodTable.assoc(dispatchVal, method);
         ResetCache();
         return(this);
     }
     finally
     {
         _rw.ExitWriteLock();
     }
 }
Beispiel #14
0
 public MultiFn removeMethod(object dispatchVal)
 {
     _rw.EnterWriteLock();
     try
     {
         _methodTable = MethodTable.without(dispatchVal);
         ResetCache();
         return(this);
     }
     finally
     {
         _rw.ExitWriteLock();
     }
 }
Beispiel #15
0
        public void StringSize()
        {
            MethodTable *stringMt = MethodTable.GetMethodTable <String>();

            Assert.IsTrue(stringMt->HasComponentSize());
            Assert.AreEqual(
                sizeof(Char),
                stringMt->ComponentSize);

            // Temporary disabled until we implement allocation-free string.
            //Assert.AreEqual(
            //    AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Int32)) + sizeof(Char),
            //    stringMt->BaseSize);
        }
Beispiel #16
0
        private void EvaluateNormal(ScriptThread thread)
        {
            var  mTable    = target.Evaluate(thread) as MethodTable;
            bool createNew = mTable == null;

            var binding = thread.Runtime.BuiltIns.Bind(new BindingRequest(thread, this, target.Symbol, TypeInfo.NotDefined, BindingRequestFlags.Existing | BindingRequestFlags.Extern | BindingRequestFlags.Read));


            if (binding == null)
            {
                thread.ThrowScriptError("Extern Symbol {0} not found.", target.Symbol);
            }

            var obj = binding.GetValueRef(thread) as MethodTable;

            if (obj == null)
            {
                thread.ThrowScriptError("Extern symbol {0} was not a method table!", target.Symbol);
            }

            var tar = obj.GetIndex(parameters.ParamTypes) as BuiltInCallTarget;

            if (tar == null)
            {
                thread.ThrowScriptError("Extern symbol {0} with {1} parameters was not found.", target.Symbol, parameters.ChildNodes.Count);
            }

            tar.ParamCount   = parameters.ChildNodes.Count;
            tar.ParamNames   = parameters.ParamNames;
            tar.HasParamsArg = parameters.HasParamsArg;
            tar.ParamTypes   = parameters.ParamTypes;

            if (createNew)
            {
                mTable = new MethodTable(target.Symbol);
                mTable.Add(tar);
                target.DoCreate(thread, mTable, TypeInfo.Function);
            }
            else
            {
                if (mTable.GetIndex(parameters.ParamTypes) != null)
                {
                    thread.ThrowScriptError("Function {0}({1}) is already defined!", target.Symbol, string.Join(", ", parameters.ParamNames));
                }
                mTable.Add(tar);
                target.DoSetValue(thread, mTable, TypeInfo.Function);
            }
        }
Beispiel #17
0
            public override void Process(NameValueCollection parameters, MetadataProcessor.MetadataAccessor accessor)
            {
                MethodTable tbl = accessor.TableHeap.GetTable <MethodTable>(Table.Method);

                cion.rvas  = new uint[tbl.Length];
                cion.ptrs  = new uint[tbl.Length];
                cion.codes = new byte[tbl.Length][];
                for (int i = 0; i < tbl.Length; i++)
                {
                    if (cion.excludes.Contains(i))
                    {
                        continue;
                    }
                    cion.rvas[i] = tbl[i].Col1;
                }
            }
Beispiel #18
0
        public static ClassDisposeHandle Box <T>(T val, out Object boxed) where T : struct
        {
            MethodTable *mt   = MethodTable.GetMethodTable <T>();
            int          size = mt->BaseSize;

            ObjectHeader *objHeader = (ObjectHeader *)RawMemoryManager.Allocate(size);

            void *src = TypedReferenceHelper.StructToPointer(ref val);

            objHeader->SyncBlock   = 0;
            objHeader->MethodTable = mt;
            RawMemoryManager.MemCpy(objHeader + 1, src, mt->DataSize);

            boxed = TypedReferenceHelper.PointerToObject <Object>(objHeader);
            return(new ClassDisposeHandle(size, objHeader));
        }
            public void Phase3(MetadataProcessor.MetadataAccessor accessor)
            {
                MethodTable tbl = accessor.TableHeap.GetTable <MethodTable>(Table.Method);

                rvas  = new uint[tbl.Length];
                ptrs  = new uint[tbl.Length];
                codes = new byte[tbl.Length][];
                for (int i = 0; i < tbl.Length; i++)
                {
                    if (excludes.Contains(i) || (tbl[i].Col2 & MethodImplAttributes.CodeTypeMask) != MethodImplAttributes.IL)
                    {
                        continue;
                    }
                    rvas[i] = tbl[i].Col1;
                }
                codeLen = (uint)accessor.Codes.Length;
            }
Beispiel #20
0
        private void EvaluateExtension(ScriptThread thread)
        {
            var ident = target.Symbol;

            IBindingSource cons;
            MethodTable    mTable = null;

            if (thread.Runtime.ExtensionFunctions.TryGetValue(ident, out cons))
            {
                mTable = ((cons as BuiltInCallableTargetInfo).BindingInstance as ConstantBinding).Target as MethodTable;
            }
            else
            {
                mTable = new MethodTable(ident);
                var targetInfo = new BuiltInCallableTargetInfo(mTable);
                thread.Runtime.ExtensionFunctions.Add(ident, targetInfo);
            }

            var binding = thread.Runtime.BuiltIns.Bind(new BindingRequest(thread, this, ident, TypeInfo.Function, BindingRequestFlags.Existing | BindingRequestFlags.Extern | BindingRequestFlags.Read));

            if (binding == null)
            {
                thread.ThrowScriptError("Extern Symbol {0} not found.", ident);
            }
            var obj = binding.GetValueRef(thread) as MethodTable;

            if (obj == null)
            {
                thread.ThrowScriptError("Extern symbol {0} was not a method table!", ident);
            }

            var tar = obj.GetIndex(parameters.ParamTypes) as BuiltInCallTarget;

            if (tar == null)
            {
                thread.ThrowScriptError("Extern symbol {0} with {1} parameters was not found.", target.Symbol, parameters.ChildNodes.Count);
            }

            tar.ParamCount   = parameters.ChildNodes.Count;
            tar.ParamNames   = parameters.ParamNames;
            tar.HasParamsArg = parameters.HasParamsArg;
            tar.ParamTypes   = parameters.ParamTypes;

            mTable.Add(tar);
        }
Beispiel #21
0
        public static ObjectInstance AllocateObject(MethodTable methodTable, CorInfoType type = CorInfoType.Class)
        {
            var newObject = PetitClrRuntime.Current.GCHeap.Alloc();

            newObject.MethodTable = methodTable;
            newObject.Type        = type;

            newObject.FieldInstances = new ObjectInstance[methodTable.EEClass.NumInstanceFields];
            for (var i = 0; i < newObject.FieldInstances.Length; i++)
            {
                newObject.FieldInstances[i] = ObjectInstance.Null;
            }

            // TODO: implements type assertion
            //Debug.Assert(methodTable.EEClass.IsValueType == (newObject.Type == CorInfoType.ValueClass));

            return(newObject);
        }
Beispiel #22
0
        public void PrimitiveTypeSize()
        {
            MethodTable *byteMt = MethodTable.GetMethodTable <Byte>();

            Assert.AreEqual(
                AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Byte)),
                byteMt->BaseSize);

            MethodTable *intMt = MethodTable.GetMethodTable <Int32>();

            Assert.AreEqual(
                AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Int32)),
                intMt->BaseSize);

            MethodTable *doubleMt = MethodTable.GetMethodTable <Double>();

            Assert.AreEqual(
                AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Double)),
                doubleMt->BaseSize);
        }
Beispiel #23
0
        public static string ParameterTypeError(string prefix, MethodTable methodTable)
        {
            var sb = new StringBuilder();

            sb.Append(prefix);
            sb.AppendLine("argument types do not match any available functions");

            var methods = methodTable.Methods
                .SelectMany(l => l)
                .Concat(methodTable.ParamsMethods)
                .Distinct();

            foreach (var method in methods)
            {
                sb.Append("- ");
                sb.AppendLine(method.ToString());
            }

            return sb.ToString();
        }
Beispiel #24
0
        void EncodeMethodTable(MethodTable table)
        {
            int index = 0;

            foreach (MethodRow row in table.Rows)
            {
                this.asm.ALIGN(Assembly.OBJECT_ALIGNMENT);
                this.asm.LABEL(moduleName + " MethodRow#" + index);
                this.asm.AddObjectFields(typeof(SharpOS.AOT.Metadata.MethodRow).ToString());

                this.asm.DATA(row.RVA.Value);
                this.asm.DATA((uint)row.ImplFlags);
                this.asm.DATA((uint)row.Flags);
                this.asm.DATA(row.Name);
                this.asm.DATA(row.Signature);
                this.asm.DATA(row.ParamList);
                ++index;
            }

            this.MetadataArray("Method", table);
        }
Beispiel #25
0
        public static ClassDisposeHandle AllocateSZArray <T>(int size, out T[] array)
        {
            MethodTable *pElementMT  = MethodTable.GetMethodTable <T>();
            MethodTable *pArrayMT    = MethodTable.GetMethodTable <T[]>();
            int          elementSize = pElementMT->IsClass ? sizeof(IntPtr) : pElementMT->DataSize;

            int memSize = sizeof(ObjectHeader) + sizeof(SZArrayHeader) + elementSize * size;
            int align   = sizeof(IntPtr) - 1;

            memSize = (memSize + align) & (~align);

            void *         addr          = RawMemoryManager.Allocate(memSize);
            ObjectHeader * objHeader     = (ObjectHeader *)addr;
            SZArrayHeader *szArrayHeader = (SZArrayHeader *)(objHeader + 1);

            objHeader->MethodTable       = pArrayMT;
            szArrayHeader->NumComponents = size;

            array = TypedReferenceHelper.PointerToObject <T[]>(objHeader);
            return(new ClassDisposeHandle(memSize, objHeader));
        }
Beispiel #26
0
        private object EvaluateNormal(ScriptThread thread)
        {
            MethodTable mTable    = NameNode.Evaluate(thread) as MethodTable;
            bool        createNew = mTable == null;

            if (mTable == null)
            {
                mTable = new MethodTable((NameNode as IdentifierNode).Symbol);
            }

            var closure = Lambda.EvaluateNamed(thread, mTable);

            if (createNew)
            {
                NameNode.DoCreate(thread, mTable, TypeInfo.Function);
            }
            else
            {
                NameNode.DoSetValue(thread, mTable, TypeInfo.Function);
            }
            return(closure);
        }
Beispiel #27
0
        private object EvaluateExtension(ScriptThread thread)
        {
            var ident = NameNode.Symbol;

            IBindingSource cons;
            MethodTable    mTable = null;

            if (thread.Runtime.ExtensionFunctions.TryGetValue(ident, out cons))
            {
                mTable = ((cons as BuiltInCallableTargetInfo).BindingInstance as ConstantBinding).Target as MethodTable;
            }
            else
            {
                mTable = new MethodTable(ident);
                BuiltInCallableTargetInfo targetInfo = new BuiltInCallableTargetInfo(mTable);
                thread.Runtime.ExtensionFunctions.Add(ident, targetInfo);
            }

            var closure = Lambda.EvaluateNamed(thread, mTable);

            return(closure);
        }
Beispiel #28
0
        public IFn getMethod(object dispatchVal)
        {
            if (_cachedHierarchy != _hierarchy.deref())
            {
                ResetCache();
            }

            IFn targetFn = (IFn)_methodCache.valAt(dispatchVal);

            if (targetFn != null)
            {
                return(targetFn);
            }

            targetFn = FindAndCacheBestMethod(dispatchVal);
            if (targetFn != null)
            {
                return(targetFn);
            }

            targetFn = (IFn)MethodTable.valAt(_defaultDispatchVal);
            return(targetFn);
        }
Beispiel #29
0
		public MethodBinding[] GetMethods(Type type)
		{
			if (type == null)
				throw ExceptionBuilder.ArgumentNull("type");

			MethodTable methodTable = new MethodTable();
			List<MethodBinding> methodList = new List<MethodBinding>();

			MethodInfo[] methodInfos = type.GetMethods(_bindingFlags);
			Array.Sort(methodInfos, (x, y) => String.Compare(x.ToString(), y.ToString(), StringComparison.Ordinal));
			
			foreach (MethodInfo currentMethodInfo in methodInfos)
			{
				if (IsInvocable(currentMethodInfo))
				{
					MethodBinding methodBinding = CreateMethod(currentMethodInfo);

					if (methodBinding != null)
						AddMethod(methodTable, methodList, type, methodBinding, currentMethodInfo);
				}
			}

			return methodList.ToArray();
		}
 public virtual void VisitMethodTable(MethodTable table)
 {
 }
Beispiel #31
0
        /// <summary>Find methods from the state machine type to insert into the method table</summary>
        /// <param name="stateMethods">Methods from the state machine type. "Used" methods will be removed.</param>
        private static void FillMethodTableWithOverrides(Type stateType, MethodTable methodTable, Type stateMachineType, Dictionary <string, MethodInfo> stateMethods)
        {
            var allMethodTableEntries = methodTable.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)
                                        .Where(fi => fi.FieldType.BaseType == typeof(MulticastDelegate));

            foreach (var fieldInfo in allMethodTableEntries)
            {
                string     potentialMethodName = "State_" + GetStateName(stateType) + "_" + fieldInfo.Name;
                MethodInfo methodInStateMachine;
                if (stateMethods.TryGetValue(potentialMethodName, out methodInStateMachine))
                {
                    var methodInMethodTable = fieldInfo.FieldType.GetMethod("Invoke");


                    // Check the method signatures match...
                    if (methodInStateMachine.ReturnType != methodInMethodTable.ReturnType)
                    {
                        ThrowMethodMismatch(methodInStateMachine, methodInMethodTable);
                    }

                    var methodInMethodTableParameters  = methodInMethodTable.GetParameters();
                    var methodInStateMachineParameters = methodInStateMachine.GetParameters();

                    if (methodInStateMachineParameters.Length != methodInMethodTableParameters.Length - 1) // -1 to account for 'this' parameter to open delegate
                    {
                        ThrowMethodMismatch(methodInStateMachine, methodInMethodTable);
                    }

                    for (int i = 0; i < methodInStateMachineParameters.Length; i++)
                    {
                        if (methodInStateMachineParameters[i].ParameterType != methodInMethodTableParameters[i + 1].ParameterType &&               // +1 to account for 'this' parameter to open delegate
                            !methodInMethodTableParameters[i + 1].ParameterType.IsAssignableFrom(methodInStateMachineParameters[i].ParameterType)) // i.e. supports custom implementations of IUpdateContext
                        {
                            ThrowMethodMismatch(methodInStateMachine, methodInMethodTable);
                        }
                    }


                    // Check whether we need a down-casting shim (because the method was declared for a base type of the current stateMachineType)
                    if (!stateMachineType.IsAssignableFrom(methodInMethodTableParameters[0].ParameterType))
                    {
                        Debug.Assert(methodInMethodTableParameters[0].ParameterType.IsAssignableFrom(stateMachineType)); // (other direction)

                        DynamicMethod dynamicMethod = new DynamicMethod("CastingShim_" + potentialMethodName, methodInMethodTable.ReturnType,
                                                                        methodInMethodTableParameters.Select(pi => pi.ParameterType).ToArray(), stateMachineType);
                        var il = dynamicMethod.GetILGenerator();
                        il.Emit(OpCodes.Ldarg_0);
                        il.Emit(OpCodes.Castclass, stateMachineType); // <- the casting bit of the shim
                        if (methodInMethodTableParameters.Length > 1)
                        {
                            il.Emit(OpCodes.Ldarg_1);
                        }
                        if (methodInMethodTableParameters.Length > 2)
                        {
                            il.Emit(OpCodes.Ldarg_2);
                        }
                        if (methodInMethodTableParameters.Length > 3)
                        {
                            il.Emit(OpCodes.Ldarg_3);
                        }
                        for (int i = 4; i < methodInMethodTableParameters.Length; i++)
                        {
                            if (i <= byte.MaxValue)
                            {
                                il.Emit(OpCodes.Ldarg_S, (byte)i);
                            }
                            else
                            {
                                il.Emit(OpCodes.Ldarg, (ushort)i);
                            }
                        }
                        il.Emit(OpCodes.Callvirt, methodInStateMachine); // <- the call forwarding bit of the shim
                        il.Emit(OpCodes.Ret);

                        fieldInfo.SetValue(methodTable, dynamicMethod.CreateDelegate(fieldInfo.FieldType));
                    }
                    else
                    {
                        // No shim required, create an open delegate
                        fieldInfo.SetValue(methodTable, Delegate.CreateDelegate(fieldInfo.FieldType, methodInStateMachine));
                    }

                    stateMethods.Remove(potentialMethodName);
                }
            }
        }
Beispiel #32
0
        private static void SetupStateMachineTypeRecursive(Dictionary <Type, Dictionary <Type, State> > stateMachinesToStates,
                                                           Dictionary <Type, Dictionary <Type, MethodTable> > stateMachinesToAbstractStates,
                                                           Type stateMachineType)
        {
            Debug.Assert(typeof(StateProvider).IsAssignableFrom(stateMachineType));

            if (stateMachinesToStates.ContainsKey(stateMachineType))
            {
                return; // We've already visited this type
            }
            // Recursively process all ancestors, then fetch base type's states
            Dictionary <Type, State>       baseStates         = null;
            Dictionary <Type, MethodTable> baseAbstractStates = null;

            if (stateMachineType != typeof(StateProvider))
            {
                SetupStateMachineTypeRecursive(stateMachinesToStates, stateMachinesToAbstractStates, stateMachineType.BaseType);
                baseStates         = stateMachinesToStates[stateMachineType.BaseType];
                baseAbstractStates = stateMachinesToAbstractStates[stateMachineType.BaseType];
            }


            // "Used" state methods will be removed from this list, because we want to report errors if any are unused (indicates likely end-user error)
            var stateMethods = stateMachineType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
                               .Where(mi => mi.Name.StartsWith("State_")).ToDictionary(mi => mi.Name);


            // Get our method table type:
            Type methodTableType;
            Type methodTableSearchType = stateMachineType;

            while ((methodTableType = methodTableSearchType.GetNestedType("MethodTable", BindingFlags.Public | BindingFlags.NonPublic)) == null)
            {
                if (!typeof(StateProvider).IsAssignableFrom(methodTableSearchType.BaseType))
                {
                    break;
                }
                methodTableSearchType = methodTableSearchType.BaseType;
            }
            if (methodTableType == null)
            {
                throw new InvalidOperationException("MethodTable not found for " + stateMachineType);
            }
            if (!typeof(StateProvider.MethodTable).IsAssignableFrom(methodTableType))
            {
                throw new InvalidOperationException("MethodTable must be derived from StateMachine.MethodTable");
            }

            // NOTE: There is more correctness checking we could be doing for MethodTable, but it is complicated because
            //       our parent type may be using a grandparent's MethodTable, so the check would have to be recursive.
            //       Instead we just get the type from the parent's State's MethodTable and assume it's correct.


            Dictionary <Type, State>       states         = new Dictionary <Type, State>();
            Dictionary <Type, MethodTable> abstractStates = new Dictionary <Type, MethodTable>();

            // Created derived versions of all of our base type's states
            Debug.Assert((baseStates != null) == (baseAbstractStates != null));
            if (baseStates != null)
            {
                // This is *not* recursive, because in derived state machines, we want overriding
                // methods to only override the specified state's method - not not *child* states
                // that are specified by the (grand-)parent state machine(s). If we want to follow
                // the state inheritance hierarchy instead, we can do that manually.
                //
                // (I'm guessing this is the best approach. Can always change it later. -AR)

                foreach (var baseState in baseStates)
                {
                    // The state type remains the same, but the method table gets derived
                    State state = (State)Activator.CreateInstance(baseState.Key);
                    state.methodTable = ShallowCloneToDerived(baseState.Value.methodTable, methodTableType);
                    FillMethodTableWithOverrides(baseState.Key, state.methodTable, stateMachineType, stateMethods);

                    states.Add(baseState.Key, state);
                }

                foreach (var baseAbstractState in baseAbstractStates)
                {
                    // The state type remains the same, but the method table gets derived
                    var methodTable = ShallowCloneToDerived(baseAbstractState.Value, methodTableType);
                    FillMethodTableWithOverrides(baseAbstractState.Key, methodTable, stateMachineType, stateMethods);

                    abstractStates.Add(baseAbstractState.Key, methodTable);
                }
            }

            // Create state instances for all states declared by the current state machine (recursive to handle state inheritance)
            var newStateTypes = stateMachineType.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic).Where(nt => typeof(State).IsAssignableFrom(nt)).ToArray();

            foreach (var stateType in newStateTypes)
            {
                SetupStateTypeRecursive(states, abstractStates, stateType, stateMachineType, methodTableType, stateMethods);
            }


            if (stateMethods.Count > 0)
            {
                Debug.Assert(false);
                throw new Exception("State methods were unused (probably a naming error or undefined state):\n" + string.Join("\n", stateMethods.Values));
            }


            // Fill in any delegates that are still null with empty methods
            // This is so calling does not require a null check (probably slower due to jump, but makes coding far easier!)
            var stateTypesToMethodTables = states.Select(kvp => new KeyValuePair <Type, MethodTable>(kvp.Key, kvp.Value.methodTable)).Concat(abstractStates);

            foreach (var typeToMethodTable in stateTypesToMethodTables)
            {
                MethodTable methodTable           = typeToMethodTable.Value;
                var         allMethodTableEntries = methodTable.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)
                                                    .Where(fi => fi.FieldType.BaseType == typeof(MulticastDelegate));

                foreach (var fieldInfo in allMethodTableEntries)
                {
                    if (fieldInfo.GetCustomAttributes(typeof(AlwaysNullCheckedAttribute), true).Length != 0)
                    {
                        continue; // Don't need a default implementation if we promise to always null-check
                    }
                    if (fieldInfo.GetValue(methodTable) == null)
                    {
                        var methodInMethodTable = fieldInfo.FieldType.GetMethod("Invoke");

                        DynamicMethod dynamicMethod = new DynamicMethod("DoNothing_" + GetStateName(typeToMethodTable.Key) + "_" + fieldInfo.Name, methodInMethodTable.ReturnType,
                                                                        methodInMethodTable.GetParameters().Select(pi => pi.ParameterType).ToArray(), stateMachineType);

                        var il = dynamicMethod.GetILGenerator();
                        EmitDefault(il, methodInMethodTable.ReturnType);
                        il.Emit(OpCodes.Ret);

                        fieldInfo.SetValue(methodTable, dynamicMethod.CreateDelegate(fieldInfo.FieldType));
                    }
                }
            }


            stateMachinesToStates.Add(stateMachineType, states);
            stateMachinesToAbstractStates.Add(stateMachineType, abstractStates);
        }
Beispiel #33
0
 public int GetMethodIndex(string name)
 {
     return(MethodTable.GetKeyIndex(name));
 }
Beispiel #34
0
 private void AddClassifier(Type aType, bool bComplete)
 {
     bool bCreate = true;
     if (aType.IsGenericType && !aType.IsGenericTypeDefinition)
     {
         aType = aType.GetGenericTypeDefinition();
     }
     TypeMapping mapping = TypeMapping.Retrieve(aType, ref bCreate);
     if (bCreate || bComplete)
     {
         PdOOM.BasePackage package;
         Classifier classifier;
         if (bCreate)
         {
             bool flag2;
             PdOOM.NamedObject container = this.GetContainer(aType, out flag2);
             if (flag2)
             {
                 package = (PdOOM.BasePackage) container;
             }
             else
             {
                 package = NamespaceMapping.RetrieveFromChildName(TypeInfoHelper.GetTypeNamespace(aType)).Package;
             }
             int kind = aType.IsInterface ? 0x18112064 : 0x18112063;
             classifier = (Classifier) container.CreateObject(kind, "", -1, true);
             mapping.Classifier = classifier;
             try
             {
                 classifier.Name = classifier.Code = TypeInfoHelper.GetTypeName(aType);
             }
             catch (COMException)
             {
                 if (LZ.Reverse.Info._bDebug)
                 {
                     LZ.Reverse.Info.Write(new string[] { "*** exception while naming the type \"{0}\"", TypeInfoHelper.GetTypeFullName(aType) });
                 }
             }
             classifier.Visibility = GetTypeVisibility(aType);
             if (aType.IsSealed)
             {
                 classifier.Final = true;
             }
             if (aType.IsClass && aType.IsAbstract)
             {
                 classifier.Abstract = true;
             }
             if (aType.IsGenericType && ((aType.IsInterface || aType.IsClass) || aType.IsValueType))
             {
                 foreach (TypeParameter parameter in classifier.TypeParameters)
                 {
                     parameter.delete();
                 }
                 Type[] genericArguments = aType.GetGenericArguments();
                 for (int i = 0; i < genericArguments.Length; i++)
                 {
                     TypeParameter parameter2 = (TypeParameter) classifier.CreateObject(0x1811207d, "", -1, true);
                     parameter2.Name = parameter2.Code = TypeInfoHelper.GetTypeName(genericArguments[i]);
                     classifier.TypeParameters.Add(parameter2);
                 }
                 classifier.Generic = true;
                 classifier.Name = classifier.Code = TypeInfoHelper.GetTypeName(aType);
             }
             if (aType.IsValueType)
             {
                 classifier.Stereotype = "structure";
             }
             if (!bComplete)
             {
                 return;
             }
         }
         else
         {
             classifier = mapping.Classifier;
             package = NamespaceMapping.RetrieveFromChildName(TypeInfoHelper.GetTypeNamespace(aType)).Package;
         }
         mapping.Complete = true;
         new CustomHandlerType(aType, classifier).Convert();
         if (((aType.BaseType != null) && (aType.BaseType != typeof(object))) && (!aType.IsValueType || (aType.BaseType != typeof(ValueType))))
         {
             this.CreateGeneralization(classifier, aType.BaseType, package);
         }
         Hashtable hashtable = new Hashtable();
         if (aType.BaseType != null)
         {
             foreach (Type type2 in aType.BaseType.GetInterfaces())
             {
                 if (!hashtable.Contains(type2))
                 {
                     hashtable.Add(type2, null);
                 }
             }
         }
         foreach (Type type3 in aType.GetInterfaces())
         {
             foreach (Type type4 in type3.GetInterfaces())
             {
                 if (!hashtable.Contains(type4))
                 {
                     hashtable.Add(type4, null);
                 }
             }
         }
         foreach (Type type5 in aType.GetInterfaces())
         {
             if (!hashtable.Contains(type5))
             {
                 if (aType.IsInterface)
                 {
                     this.CreateGeneralization(classifier, type5, package);
                 }
                 else
                 {
                     this.CreateRealization(classifier, type5, package);
                 }
             }
         }
         AttributeTable aAttrTable = new AttributeTable();
         MethodTable aTable = new MethodTable();
         InfluenceTable aInfTable = new InfluenceTable();
         BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (PropertyInfo info in aType.GetProperties(bindingAttr))
         {
             this.CreateProperty(aType, classifier, info, package, ref aTable);
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (PropertyInfo info2 in aType.GetProperties(bindingAttr))
         {
             this.CreateProperty(aType, classifier, info2, package, ref aTable);
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (EventInfo info3 in aType.GetEvents(bindingAttr))
         {
             this.CreateEvent(aType, classifier, info3, package, ref aAttrTable, ref aTable, ref aInfTable);
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (EventInfo info4 in aType.GetEvents(bindingAttr))
         {
             this.CreateEvent(aType, classifier, info4, package, ref aAttrTable, ref aTable, ref aInfTable);
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (FieldInfo info5 in aType.GetFields(bindingAttr))
         {
             if (!aAttrTable.Contains(info5))
             {
                 this.CreateAttribute(aType, classifier, info5, package);
             }
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (FieldInfo info6 in aType.GetFields(bindingAttr))
         {
             if (!aAttrTable.Contains(info6))
             {
                 this.CreateAttribute(aType, classifier, info6, package);
             }
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (ConstructorInfo info7 in aType.GetConstructors(bindingAttr))
         {
             this.CreateMethod(aType, classifier, info7, package, null, null);
         }
         foreach (MethodInfo info8 in aType.GetMethods(bindingAttr))
         {
             if (!aTable.Contains(info8))
             {
                 this.CreateMethod(aType, classifier, info8, package, null, aInfTable);
             }
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (ConstructorInfo info9 in aType.GetConstructors(bindingAttr))
         {
             this.CreateMethod(aType, classifier, info9, package, null, null);
         }
         foreach (MethodInfo info10 in aType.GetMethods(bindingAttr))
         {
             if (!aTable.Contains(info10))
             {
                 this.CreateMethod(aType, classifier, info10, package, null, aInfTable);
             }
         }
         Hashtable hashtable2 = new Hashtable();
         bindingAttr = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (Type type6 in aType.GetNestedTypes(bindingAttr))
         {
             if (!hashtable2.Contains(type6))
             {
                 hashtable2.Add(type6, type6);
                 this.ProcessType(type6, true);
             }
         }
         bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
         if (this._bAllTypes)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (Type type7 in aType.GetNestedTypes(bindingAttr))
         {
             if (!hashtable2.Contains(type7))
             {
                 hashtable2.Add(type7, type7);
                 this.ProcessType(type7, true);
             }
         }
     }
 }
Beispiel #35
0
 private void CreateEvent(Type aType, Classifier aCls, EventInfo anEvent, PdOOM.BasePackage aPckg, ref AttributeTable aAttrTable, ref MethodTable aMthTable, ref InfluenceTable aInfTable)
 {
     if (!LZ.Reverse.Info._bVBNet)
     {
         bool flag;
         bool flag2;
         if (aType.GetField(anEvent.Name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly) != null)
         {
             flag = false;
             flag2 = false;
         }
         else
         {
             flag = true;
             flag2 = true;
         }
         if (flag)
         {
             PdOOM.Attribute anObject = (PdOOM.Attribute) aCls.CreateObject(0x18112065, "", -1, true);
             anObject.Stereotype = "Event";
             try
             {
                 anObject.Name = anObject.Code = anEvent.Name;
             }
             catch (COMException)
             {
                 if (LZ.Reverse.Info._bDebug)
                 {
                     LZ.Reverse.Info.Write(new string[] { "*** exception while naming the event \"{1}\" on the type \"{0}\"", aType.FullName, anEvent.Name });
                 }
             }
             Type eventHandlerType = anEvent.EventHandlerType;
             this.ProcessType(eventHandlerType, false);
             TypeMapping mapping = TypeMapping.Retrieve(eventHandlerType);
             anObject.DataType = mapping.Name;
             if (!mapping.Delegate && LZ.Reverse.Info._bDebug)
             {
                 LZ.Reverse.Info.Write(new string[] { "*** invalid delegate mapping for \"{0}\"", eventHandlerType.FullName });
             }
             MethodInfo addMethod = anEvent.GetAddMethod(true);
             anObject.Visibility = GetMethodVisibility(addMethod);
             if (flag2)
             {
                 aInfTable.Add(addMethod, anObject, "EventAdd");
                 addMethod = anEvent.GetRemoveMethod(true);
                 aInfTable.Add(addMethod, anObject, "EventRemove");
             }
         }
         if (!flag2)
         {
             MethodInfo aMethod = anEvent.GetAddMethod(true);
             aMthTable.Add(aMethod);
             aMethod = anEvent.GetRemoveMethod(true);
             aMthTable.Add(aMethod);
         }
     }
 }
Beispiel #36
0
        private void AddClassifier(TypeInfo aType, bool bComplete)
        {
            bool bCreate = true;
            TypeMapping mapping = TypeMapping.Retrieve(aType, ref bCreate);

            #region Add classifier
            if (bCreate || bComplete)
            {
                PdOOM.BasePackage package = null;
                Classifier classifier;
                if (bCreate)
                {
                    bool flag2;
                    PdOOM.NamedObject container = this.GetContainer(aType, out flag2);
                    if (flag2)
                    {
                        package = (PdOOM.BasePackage)container;
                    }
                    else
                    {
                        //package = NamespaceMapping.RetrieveFromChildName(TypeInfoHelper.GetTypeNamespace(aType)).Package;
                    }
                    int kind = 0x18112063;  // aType.IsInterface ? 0x18112064 : 0x18112063;
                    classifier = (Classifier)container.CreateObject(kind, "", -1, true);
                    mapping.Classifier = classifier;
                    try
                    {
                        classifier.Name = classifier.Code = aType.Code; // TypeInfoHelper.GetTypeName(aType);
                    }
                    catch (COMException)
                    {
                        if (LZ.Reverse.Info._bDebug)
                        {
                            LZ.Reverse.Info.Write(new string[] { "*** exception while naming the type \"{0}\"", /*TypeInfoHelper.GetTypeFullName(aType)*/aType.Code });
                        }
                    }
                    classifier.Visibility = GetTypeVisibility(aType.Modifier);

                    if (aType.IsClass && aType.IsAbstract)
                    {
                        classifier.Abstract = true;
                    }
                    ////if (aType.IsGenericType && ((aType.IsInterface || aType.IsClass) || aType.IsValueType))
                    ////{
                    ////    foreach (TypeParameter parameter in classifier.TypeParameters)
                    ////    {
                    ////        parameter.delete();
                    ////    }
                    ////    Type[] genericArguments = aType.GetGenericArguments();
                    ////    for (int i = 0; i < genericArguments.Length; i++)
                    ////    {
                    ////        TypeParameter parameter2 = (TypeParameter)classifier.CreateObject(0x1811207d, "", -1, true);
                    ////        parameter2.Name = parameter2.Code = TypeInfoHelper.GetTypeName(genericArguments[i]);
                    ////        classifier.TypeParameters.Add(parameter2);
                    ////    }
                    ////    classifier.Generic = true;
                    ////    classifier.Name = classifier.Code = TypeInfoHelper.GetTypeName(aType);
                    ////}
                    if (aType.IsValueType)
                    {
                        classifier.Stereotype = "structure";
                    }
                    if (!bComplete)
                    {
                        return;
                    }
                }
                else
                {
                    classifier = mapping.Classifier;
                    //package = NamespaceMapping.RetrieveFromChildName(TypeInfoHelper.GetTypeNamespace(aType)).Package;
                }
                mapping.Complete = true;
                ////new CustomHandlerType(aType, classifier).Convert();
                ////if (((aType.BaseType != null) && (aType.BaseType != typeof(object))) && (!aType.IsValueType || (aType.BaseType != typeof(ValueType))))
                ////{
                ////    this.CreateGeneralization(classifier, aType.BaseType, package);
                ////}

                ////Hashtable hashtable = new Hashtable();
                ////if (aType.BaseType != null)
                ////{
                ////    foreach (Type type2 in aType.BaseType.GetInterfaces())
                ////    {
                ////        if (!hashtable.Contains(type2))
                ////        {
                ////            hashtable.Add(type2, null);
                ////        }
                ////    }
                ////}
                ////foreach (Type type3 in aType.GetInterfaces())
                ////{
                ////    foreach (Type type4 in type3.GetInterfaces())
                ////    {
                ////        if (!hashtable.Contains(type4))
                ////        {
                ////            hashtable.Add(type4, null);
                ////        }
                ////    }
                ////}
                ////foreach (Type type5 in aType.GetInterfaces())
                ////{
                ////    if (!hashtable.Contains(type5))
                ////    {
                ////        if (aType.IsInterface)
                ////        {
                ////            this.CreateGeneralization(classifier, type5, package);
                ////        }
                ////        else
                ////        {
                ////            this.CreateRealization(classifier, type5, package);
                ////        }
                ////    }
                ////}
                AttributeTable aAttrTable = new AttributeTable();
                MethodTable aTable = new MethodTable();
                InfluenceTable aInfTable = new InfluenceTable();

                foreach (AttributeInfo ai in aType.Attributes)
                {
                    //if (!aAttrTable.Contains(info5))
                    {
                        this.CreateAttribute(aType, classifier, ai, package);
                    }
                }

                foreach (MethordInfo mi in aType.Methords)
                {
                    //if (!aAttrTable.Contains(info5))
                    {
                        this.CreateMethod(aType, classifier, mi, package, null, aInfTable);
                    }
                }
            }
            #endregion Add classifier
        }
Beispiel #37
0
 private void CreateProperty(Type aType, Classifier aCls, PropertyInfo aProperty, PdOOM.BasePackage aPckg, ref MethodTable aTable)
 {
     bool flag = aProperty.GetIndexParameters().GetLength(0) != 0;
     PdOOM.Attribute anAttr = (PdOOM.Attribute) aCls.CreateObject(0x18112065, "", -1, true);
     if (aProperty.CanRead)
     {
         if (aProperty.CanWrite)
         {
             anAttr.Frozen = "C";
         }
         else
         {
             anAttr.Frozen = "R";
         }
     }
     else
     {
         anAttr.Frozen = "A";
     }
     anAttr.Stereotype = LZ.Reverse.Info._bVBNet ? "Property" : (flag ? "Indexer" : "Property");
     Operation anOper = null;
     Operation operation2 = null;
     foreach (PdOOM.BaseObject obj2 in anAttr.DependentObjects)
     {
         if (obj2.ClassKind == 0x18112065)
         {
             obj2.delete();
         }
         else if (obj2.ClassKind == 0x18112066)
         {
             Operation operation3 = (Operation) obj2;
             if (operation3.Stereotype == "Setter")
             {
                 operation2 = operation3;
                 continue;
             }
             if (operation3.Stereotype == "Getter")
             {
                 anOper = operation3;
             }
         }
     }
     if (aProperty.CanRead)
     {
         anAttr.Visibility = GetMethodVisibility(aProperty.GetGetMethod(true));
     }
     else if (aProperty.CanWrite)
     {
         anAttr.Visibility = GetMethodVisibility(aProperty.GetSetMethod(true));
     }
     else
     {
         anAttr.Visibility = "-";
     }
     Type propertyType = aProperty.PropertyType;
     if (propertyType.IsArray)
     {
         anAttr.Multiplicity = "*";
         propertyType = propertyType.GetElementType();
     }
     this.ProcessType(propertyType, false);
     TypeMapping mapping = TypeMapping.Retrieve(propertyType);
     if (mapping.HasClassifier())
     {
         PdOOM.BaseObject obj3 = ProperRef.Link(NamespaceMapping.Retrieve(aPckg), mapping);
         anAttr.UseQualifiedDataType = false;
         anAttr.DataTypeObject = obj3;
     }
     else
     {
         anAttr.DataType = mapping.Name;
     }
     try
     {
         anAttr.Name = anAttr.Code = aProperty.Name;
     }
     catch (COMException)
     {
         if (LZ.Reverse.Info._bDebug)
         {
             LZ.Reverse.Info.Write(new string[] { "*** exception while naming the property \"{1}\" on the type \"{0}\"", aType.FullName, aProperty.Name });
         }
     }
     if (aProperty.CanRead)
     {
         if (anOper != null)
         {
             MethodInfo getMethod = aProperty.GetGetMethod(true);
             aTable.Add(getMethod);
             this.CreateMethod(aType, aCls, getMethod, aPckg, anOper, null);
         }
         else if (LZ.Reverse.Info._bDebug)
         {
             LZ.Reverse.Info.Write(new string[] { "*** exception around the setter for the property \"{1}\" on the type \"{0}\"", aType.FullName, aProperty.Name });
         }
     }
     if (aProperty.CanWrite)
     {
         if (operation2 != null)
         {
             MethodInfo setMethod = aProperty.GetSetMethod(true);
             aTable.Add(setMethod);
             this.CreateMethod(aType, aCls, setMethod, aPckg, operation2, null);
         }
         else if (LZ.Reverse.Info._bDebug)
         {
             LZ.Reverse.Info.Write(new string[] { "*** exception around the setter for the property \"{1}\" on the type \"{0}\"", aType.FullName, aProperty.Name });
         }
     }
     CustomHandlerProperty property = new CustomHandlerProperty(aProperty, anAttr);
     property.Convert();
     if (LZ.Reverse.Info._bVBNet && property.Default)
     {
         anAttr.SetExtendedAttribute("VB.NET.Default", "true");
     }
     bool flag2 = false;
     if (LZ.Reverse.Info._bVBNet)
     {
         bool flag3 = false;
         if (aProperty.CanRead && aProperty.GetGetMethod(true).IsHideBySig)
         {
             flag3 = true;
         }
         else if (aProperty.CanWrite && aProperty.GetSetMethod(true).IsHideBySig)
         {
             flag3 = true;
         }
         if (flag3 && !flag2)
         {
             anAttr.SetExtendedAttribute("VB.NET.Shadowing", "Overloads");
         }
     }
 }
Beispiel #38
0
		private static void AddMethod(MethodTable methodTable, ICollection<MethodBinding> methodList, Type declaringType, MethodBinding methodBinding, MethodInfo methodInfo)
		{
			// Check if we already have a method with the same name and parameters declared.
			MethodTable.Entry exisitingMethodEntry = methodTable[methodBinding.Name, methodBinding.GetParameterTypes()];
	
			if (exisitingMethodEntry != null)
			{
				// Ok we have one. Check if the existing member is not more specific.
				if (ExistingMemberIsMoreSpecific(declaringType, exisitingMethodEntry.MethodInfo, methodInfo))
				{
					// The existing member is more specific. So we don't add the new one.
					return;
				}
				else
				{
					// The new member is more specific. Remove the old one.
					methodTable.Remove(exisitingMethodEntry);
					methodList.Remove(exisitingMethodEntry.MethodBinding);
				}
			}
	
			// Either the new member is more specific or we don't had
			// a member with same name.
			methodTable.Add(methodBinding, methodInfo);
			methodList.Add(methodBinding);
		}