internal void PreAnalyze(Analyzer/*!*/ analyzer, GenericParameter/*!*/ parameter) { this.parameter = parameter; PhpRoutine routine = parameter.DeclaringMember as PhpRoutine; PhpType type = (routine != null) ? routine.DeclaringType as PhpType : parameter.DeclaringPhpType; parameter.WriteUp(analyzer.ResolveType(defaultType, type, routine, position, false)); }
/// <summary> /// Creates a <see cref="PhpRoutineSignature"/> partially initialized with the type parameters of this type signature. /// Used by generic routines. /// </summary> internal PhpRoutineSignature/*!*/ ToPhpRoutineSignature(DMember/*!*/ declaringRoutine) { Debug.Assert(declaringRoutine != null); int mandatory_generic_param_count; GenericParameterDesc[] descs = this.ToGenericParameters(declaringRoutine, out mandatory_generic_param_count); GenericParameter[] types = new GenericParameter[descs.Length]; for (int i = 0; i < descs.Length; i++) types[i] = descs[i].GenericParameter; return new PhpRoutineSignature(types, mandatory_generic_param_count); }
public abstract void Build(GameObject parent, GenericParameter parameter);
public override void Build(GameObject parent, GenericParameter parameter) { IntDropdownParam.Instantiate(parent, parameter, 0, "From:", textFromOptions); StringInputFieldParam.Instantiate(parent, parameter, 0, "From Variable:"); StringInputFieldParam.Instantiate(parent, parameter, 1, "Custom Text:"); }
public GenericParamDef(GenericParameter genericParameter, int index) : base(genericParameter, null, index) { }
private void AppendConstraints(StringBuilder buf, GenericParameter genArg) { if (MemberFormatterState == MemberFormatterState.WithinGenericTypeParameters) { // check to avoid such a code: // Public Class MyList(Of A As {Class, Generic.IList(Of B --->As {Class, A}<----), New}, B As {Class, A}) return; } GenericParameterAttributes attrs = genArg.Attributes; IList <TypeReference> constraints = genArg.Constraints; if (attrs == GenericParameterAttributes.NonVariant && constraints.Count == 0) { return; } bool isref = (attrs & GenericParameterAttributes.ReferenceTypeConstraint) != 0; bool isvt = (attrs & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0; bool isnew = (attrs & GenericParameterAttributes.DefaultConstructorConstraint) != 0; bool comma = false; if (!isref && !isvt && !isnew && constraints.Count == 0) { return; } int constraintsCount = Convert.ToInt32(isref) + Convert.ToInt32(isvt) + Convert.ToInt32(isnew) + constraints.Count; buf.Append(" As "); if (constraintsCount > 1 && !isvt) { buf.Append("{"); } if (isref) { buf.Append("Class"); comma = true; } else if (isvt) { buf.Append("Structure"); comma = true; } if (constraints.Count > 0 && !isvt) { if (comma) { buf.Append(", "); } buf.Append(GetTypeName(constraints[0])); for (int i = 1; i < constraints.Count; ++i) { buf.Append(", ").Append(GetTypeName(constraints[i])); } } if (isnew && !isvt) { if (comma) { buf.Append(", "); } buf.Append("New"); } if (constraintsCount > 1 && !isvt) { buf.Append("}"); } }
static bool IsParameterCompatibleWith(GenericParameter a, GenericParameter b) { return(a.Position == b.Position); }
/// <summary> /// Creates a signature partially initialized with type parameters. /// Rationale for partial initialization: /// When analyzing a routine, the analyzer needs to know about type parameters prior to the analysis of actual parameters. /// </summary> public PhpRoutineSignature(GenericParameter[]/*!!*/ genericParams, int mandatoryGenericParamCount) { Debug.Assert(genericParams != null); Debug.Assert(mandatoryGenericParamCount >= 0 && mandatoryGenericParamCount <= genericParams.Length); this.genericParams = genericParams; this.mandatoryGenericParamCount = mandatoryGenericParamCount; }
static void CreateConvertMethodForComponentDataTypes(TypeDefinition authoringType, TypeDefinition componentDataType) { var moduleDefinition = componentDataType.Module; var entityTypeReference = moduleDefinition.ImportReference(typeof(Unity.Entities.Entity)); var entityManagerTypeReference = moduleDefinition.ImportReference(typeof(Unity.Entities.EntityManager)); var gameObjectTypeReference = moduleDefinition.ImportReference(typeof(UnityEngine.GameObject)); MethodDefinition convertMethod = CreateEmptyConvertMethod(moduleDefinition, authoringType); // Make a local variable which we'll populate with the values stored in the MonoBehaviour var variableDefinition = new VariableDefinition(componentDataType); convertMethod.Body.Variables.Add(variableDefinition); var ilProcessor = convertMethod.Body.GetILProcessor(); // Initialize the local variable. (we might not need this, but all c# compilers emit it, so let's play it safe for now) if (componentDataType.IsValueType()) { ilProcessor.Emit(OpCodes.Ldloca, variableDefinition); ilProcessor.Emit(OpCodes.Initobj, componentDataType); } else { var componentDataConstructor = componentDataType.GetConstructors().FirstOrDefault(c => c.Parameters.Count == 0); if (componentDataConstructor == null) { UserError.DC0030(componentDataType).Throw(); } ilProcessor.Emit(OpCodes.Newobj, moduleDefinition.ImportReference(componentDataConstructor)); ilProcessor.Emit(OpCodes.Stloc, variableDefinition); } var getPrimaryEntityGameObjectMethod = moduleDefinition.ImportReference( typeof(GameObjectConversionSystem).GetMethod("GetPrimaryEntity", new Type[] { typeof(UnityEngine.GameObject) })); var getPrimaryEntityComponentMethod = moduleDefinition.ImportReference( typeof(GameObjectConversionSystem).GetMethod("GetPrimaryEntity", new Type[] { typeof(UnityEngine.Component) })); var convertGameObjectsToEntitiesFieldMethod = moduleDefinition.ImportReference( typeof(GameObjectConversionUtility).GetMethod(nameof(GameObjectConversionUtility.ConvertGameObjectsToEntitiesField))); // Let's transfer every field in the MonoBehaviour over to the corresponding field in the IComponentData foreach (var field in authoringType.Fields) { var destinationField = componentDataType.Fields.Single(f => f.Name == field.Name); // Special case when destination field is a array of entities, we need to emit IL to create our destination array // and convert from array of GameObjects // https://sharplab.io/#v2:C4LglgNgNAJiDUAfAAgJgIwFgBQyAMABMugCwDcOOyAzEagQKIB2wYwAngQN4C+VtaAgHEAhgFsApgHkARgCsJAY2Dc+uAfWasOAWRFMRAcwkAnVfzrDx0+UuABhAPZMAbqYDOYZ8QI4uOAkCiWi02TiEJYAAFEzAxERN2UI4AClFJWQVlAkNHAEoAoP9sINKiAHYCJgBXCAgyIMLAtTULQQBJJzEAB2cJFgAREWARc3VLACVHEdZnAGVuiQkYAH0AMUcTBhFFAAsCEAJOxx6+weGRPybgggAzCEdhggmRGDB9dyjTOaVnGAoSkEaIwWGEANoAXQI/W0YAk7gBrXGxAAbJYABISCCLEzuK6AwLA1FEEgEJyuUzAdI2LLAdwAFUcyTh7g2JgAgtVgLtNmAmIY0tZMnZyW5cV4mD5FM4xZ5vOgoFYMrZlJCckKVXTFSYJLcQdp2GqYWwWQUCdxrqVjax4QQALxVCQAd314MMGtp7gAdAAZfqGbkQgFlIK3TYEFJ8lRgO14BpgAA81pZvv93Ia8HgYDNIZDyfhYLAUId0op4vlXoi0Vi8USyXYKXdys9hYheWDQTUpWuRPQaOQpPZMBg7JMJhE7Ckt2pwuU7nZ7gmutM/UUyxiupEMncgubdjVTZpdncip9YHcwATM81AD4CDrbiumGuYBvblv3DmipbQ5sJDt9hSFwEnVPdsj5UCjznL8Q2KXMygfJ8XzfD8vSHGBGw9Ox2x/Zpri7RpzV7ftB2HLpeiYGEhhGFJuXPV1dH0IxTAIGB4VYAxZiYPQDGMExFXraFQQ4RUphmCUFiWVY2W2PYCGlU5KJYGCLXNFpKGRegxOGCTFmWdZNlk3ZOW5Xl+XxUpgXuR4VBeN4Pi+EwflLf4e1oa9aSNYSWQ7QI3JJMkZUpFJBOtdgBOE9geOYsw2IvPkdOcaK+MVDyRSC8tJXQeSMrlLKzQASGKAqCu0rjJP0mSAPvaZEqYCrpMM6qHUol0yt0qSDK2ACUhw7ASpMWryr0xrur2L07PeJhPm+X4mBge1nleKaZqcubXPNUpMWxDwvVFSk0rnRlmXhNkTJ5WJ+RSUtZQlYhFXzE9711GrxPmEauqMr1Hr6krtpxb10PIs5gGokQUjiji6uS0wHsi7Uho6yqmr2X6kQKolSQGJQIASCQl0fHVn3XB8PxSM8LyvLDlDvRCieQ0nt0KuDc3+3b0NHcdJ2nam6QXAmkJJzdtxSR7tWXemhffJmAQK9TASAA=== if (destinationField.FieldType.IsArray && destinationField.FieldType.GetElementType().TypeReferenceEquals(entityTypeReference)) { ilProcessor.Emit(OpCodes.Ldarg_3); ilProcessor.Emit(OpCodes.Ldarg_0); ilProcessor.Emit(OpCodes.Ldfld, field); ilProcessor.Emit(OpCodes.Ldloc, variableDefinition); ilProcessor.Emit(OpCodes.Ldflda, destinationField); ilProcessor.Emit(OpCodes.Callvirt, convertGameObjectsToEntitiesFieldMethod); } else { // Load the local iComponentData we are populating, so we can later write to it ilProcessor.Emit(componentDataType.IsValueType() ? OpCodes.Ldloca : OpCodes.Ldloc, variableDefinition); // Special case when destination is an entity and we our converting from a GameObject if (destinationField.FieldType.TypeReferenceEquals(entityTypeReference)) { ilProcessor.Emit(OpCodes.Ldarg_3); ilProcessor.Emit(OpCodes.Ldarg_0); ilProcessor.Emit(OpCodes.Ldfld, field); var methodToCall = field.FieldType.TypeReferenceEquals(gameObjectTypeReference) ? getPrimaryEntityGameObjectMethod : getPrimaryEntityComponentMethod; ilProcessor.Emit(OpCodes.Callvirt, methodToCall); } else { ilProcessor.Emit(OpCodes.Ldarg_0); ilProcessor.Emit(OpCodes.Ldfld, field); } // Store it to the IComponentData we already placed on the stack ilProcessor.Emit(OpCodes.Stfld, destinationField); } } // Now that our local IComponentData is properly setup, the only thing left for us is to call: // entityManager.AddComponentData(entity, myPopulatedIComponentData). // IL method arguments go on the stack from first to last so: ilProcessor.Emit(OpCodes.Ldarg_2); //entityManager ilProcessor.Emit(OpCodes.Ldarg_1); //entity ilProcessor.Emit(OpCodes.Ldloc_0); //myPopulatedIComponentData // Build a MethodReference to EntityManager.AddComponentData MethodReference addComponentDataMethodReference = null; #if !UNITY_DISABLE_MANAGED_COMPONENTS // For managed components this is void EntityManagerManagedComponentExtensions.AddComponentData<T>(this EntityMananger mananger, Entity target, T payload); var entityManagerManagedComponentExtensionsTypeReference = moduleDefinition.ImportReference(typeof(Unity.Entities.EntityManagerManagedComponentExtensions)); if (!componentDataType.IsValueType()) { addComponentDataMethodReference = new MethodReference("AddComponentData", moduleDefinition.TypeSystem.Void, entityManagerManagedComponentExtensionsTypeReference) { Parameters = { new ParameterDefinition("manager", ParameterAttributes.None, entityManagerTypeReference), new ParameterDefinition("entity", ParameterAttributes.None, entityTypeReference), }, ReturnType = moduleDefinition.TypeSystem.Void }; } #endif // For non-managed components this is EntityManager.AddComponentData<T>(Entity target, T payload); if (componentDataType.IsValueType()) { addComponentDataMethodReference = new MethodReference("AddComponentData", moduleDefinition.TypeSystem.Void, entityManagerTypeReference) { HasThis = true, Parameters = { new ParameterDefinition("entity", ParameterAttributes.None, entityTypeReference), }, ReturnType = moduleDefinition.TypeSystem.Boolean }; } var genericParameter = new GenericParameter("T", addComponentDataMethodReference); addComponentDataMethodReference.GenericParameters.Add(genericParameter); addComponentDataMethodReference.Parameters.Add(new ParameterDefinition("payload", ParameterAttributes.None, genericParameter)); // Since AddComponentData<T> is a generic method, we cannot call it super easily. // We have to wrap the generic method reference into a GenericInstanceMethod, // which let's us specify what we want to use for T for this specific invocation. // In our case T is the IComponentData we're operating on var genericInstanceMethod = new GenericInstanceMethod(addComponentDataMethodReference) { GenericArguments = { componentDataType }, }; ilProcessor.Emit(OpCodes.Callvirt, genericInstanceMethod); // Pop off return value since AddComponentData returns a bool (managed AddComponentData strangely does not however) if (componentDataType.IsValueType()) { ilProcessor.Emit(OpCodes.Pop); } // We're done already! Easy peasy. ilProcessor.Emit(OpCodes.Ret); }
/// <summary> /// Relink the given type reference. /// </summary> /// <param name="type">The reference to relink.</param> /// <param name="relinker">The relinker to use during the relinking process.</param> /// <param name="context">The generic context provided to relink generic references.</param> /// <returns>A relinked reference.</returns> public static TypeReference Relink(this TypeReference type, Relinker relinker, IGenericParameterProvider context) { if (type == null) { return(null); } if (type is TypeSpecification ts) { TypeReference relinkedElem = ts.ElementType.Relink(relinker, context); if (type.IsSentinel) { return(new SentinelType(relinkedElem)); } if (type.IsByReference) { return(new ByReferenceType(relinkedElem)); } if (type.IsPointer) { return(new PointerType(relinkedElem)); } if (type.IsPinned) { return(new PinnedType(relinkedElem)); } if (type.IsArray) { ArrayType at = new ArrayType(relinkedElem, ((ArrayType)type).Rank); for (int i = 0; i < at.Rank; i++) { // It's a struct. at.Dimensions[i] = ((ArrayType)type).Dimensions[i]; } return(at); } if (type.IsRequiredModifier) { return(new RequiredModifierType(((RequiredModifierType)type).ModifierType.Relink(relinker, context), relinkedElem)); } if (type.IsOptionalModifier) { return(new OptionalModifierType(((OptionalModifierType)type).ModifierType.Relink(relinker, context), relinkedElem)); } if (type.IsGenericInstance) { GenericInstanceType git = new GenericInstanceType(relinkedElem); foreach (TypeReference genArg in ((GenericInstanceType)type).GenericArguments) { git.GenericArguments.Add(genArg?.Relink(relinker, context)); } return(git); } if (type.IsFunctionPointer) { FunctionPointerType fp = (FunctionPointerType)type; fp.ReturnType = fp.ReturnType.Relink(relinker, context); for (int i = 0; i < fp.Parameters.Count; i++) { fp.Parameters[i].ParameterType = fp.Parameters[i].ParameterType.Relink(relinker, context); } return(fp); } throw new NotSupportedException($"MonoMod can't handle TypeSpecification: {type.FullName} ({type.GetType()})"); } if (type.IsGenericParameter && context != null) { GenericParameter genParam = context.ResolveGenericParameter((GenericParameter)type); if (genParam == null) { throw new RelinkTargetNotFoundException($"{RelinkTargetNotFoundException.DefaultMessage} {type.FullName} (context: {context})", type, context); } for (int i = 0; i < genParam.Constraints.Count; i++) { if (!genParam.Constraints[i].GetConstraintType().IsGenericInstance) // That is somehow possible and causes a stack overflow. { genParam.Constraints[i] = genParam.Constraints[i].Relink(relinker, context); } } return(genParam); } return((TypeReference)relinker(type, context)); }
/// <summary> /// Resolve a given generic parameter in another context. /// </summary> /// <param name="provider">The new context.</param> /// <param name="orig">The original generic parameter.</param> /// <returns>A generic parameter provided by the given context which matches the original generic parameter.</returns> public static GenericParameter ResolveGenericParameter(this IGenericParameterProvider provider, GenericParameter orig) { // This can be true for T[,].Get in "Enter the Gungeon" if (provider is GenericParameter && ((GenericParameter)provider).Name == orig.Name) { return((GenericParameter)provider); } foreach (GenericParameter param in provider.GenericParameters) { if (param.Name == orig.Name) { return(param); } } int index = orig.Position; if (provider is MethodReference && orig.DeclaringMethod != null) { if (index < provider.GenericParameters.Count) { return(provider.GenericParameters[index]); } else { return(new GenericParameter(orig.Name, provider).Update(index, GenericParameterType.Method)); } } if (provider is TypeReference && orig.DeclaringType != null) { if (index < provider.GenericParameters.Count) { return(provider.GenericParameters[index]); } else { return(new GenericParameter(orig.Name, provider).Update(index, GenericParameterType.Type)); } } return ((provider as TypeSpecification)?.ElementType.ResolveGenericParameter(orig) ?? (provider as MemberReference)?.DeclaringType?.ResolveGenericParameter(orig)); }
/// <summary> /// Force-update a generic parameter's position and type. /// </summary> /// <param name="param">The generic parameter to update.</param> /// <param name="position">The new position.</param> /// <param name="type">The new type.</param> /// <returns>The updated generic parameter.</returns> public static GenericParameter Update(this GenericParameter param, int position, GenericParameterType type) { f_GenericParameter_position.SetValue(param, position); f_GenericParameter_type.SetValue(param, type); return(param); }
static GenericParameter CloneGenericParameter(GenericParameter gp) { return((GenericParameter)genericParameterConstructor.Invoke(new object[] { gp.Position, gp.Type, gp.Module })); }
/// <summary> /// Invokes the behavior. /// </summary> /// <param name="item">Item on which to invoke the behavior.</param> /// <returns>Result of the invocation.</returns> protected abstract TReturn InvokeForItem(GenericParameter item);
public void ProcessType(CecilSerializerContext context, TypeReference type, MethodDefinition updateMainMethod) { var typeDefinition = type.Resolve(); // No need to process Enum if (typeDefinition.IsEnum) { return; } var updateCurrentMethod = updateMainMethod; ResolveGenericsVisitor replaceGenericsVisitor = null; if (typeDefinition.HasGenericParameters) { // Make a prepare method for just this object since it might need multiple instantiation updateCurrentMethod = new MethodDefinition(ComputeUpdateMethodName(typeDefinition), MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static, context.Assembly.MainModule.TypeSystem.Void); var genericsMapping = new Dictionary <TypeReference, TypeReference>(); foreach (var genericParameter in typeDefinition.GenericParameters) { var genericParameterCopy = new GenericParameter(genericParameter.Name, updateCurrentMethod) { Attributes = genericParameter.Attributes, }; foreach (var constraint in genericParameter.Constraints) { genericParameterCopy.Constraints.Add( new GenericParameterConstraint(context.Assembly.MainModule.ImportReference(constraint.ConstraintType))); } updateCurrentMethod.GenericParameters.Add(genericParameterCopy); genericsMapping[genericParameter] = genericParameterCopy; } replaceGenericsVisitor = new ResolveGenericsVisitor(genericsMapping); updateMainMethod.DeclaringType.Methods.Add(updateCurrentMethod); } var il = updateCurrentMethod.Body.GetILProcessor(); var typeIsValueType = type.IsResolvedValueType(); var emptyObjectField = typeIsValueType ? null : updateMainMethod.DeclaringType.Fields.FirstOrDefault(x => x.Name == "emptyObject"); VariableDefinition emptyStruct = null; // Note: forcing fields and properties to be processed in all cases foreach (var serializableItem in ComplexSerializerRegistry.GetSerializableItems(type, ComplexTypeSerializerFlags.SerializePublicFields | ComplexTypeSerializerFlags.SerializePublicProperties | ComplexTypeSerializerFlags.Updatable)) { if (serializableItem.MemberInfo is FieldReference fieldReference) { var field = fieldReference.Resolve(); // First time it is needed. Let's create an empty object in the class (var emptyObject = new object()) // or empty local struct in the method if (typeIsValueType) { if (emptyStruct is null) { emptyStruct = new VariableDefinition(type); updateMainMethod.Body.Variables.Add(emptyStruct); } } else { if (emptyObjectField is null) { emptyObjectField = new FieldDefinition("emptyObject", FieldAttributes.Static | FieldAttributes.Private, context.Assembly.MainModule.TypeSystem.Object); // Create static ctor that will initialize this object var staticConstructor = new MethodDefinition(".cctor", MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, context.Assembly.MainModule.TypeSystem.Void); var staticConstructorIL = staticConstructor.Body.GetILProcessor(); staticConstructorIL.Emit(OpCodes.Newobj, context.Assembly.MainModule.ImportReference( emptyObjectField.FieldType.Resolve().GetConstructors().Single(ctor => !ctor.IsStatic && !ctor.HasParameters))); staticConstructorIL.Emit(OpCodes.Stsfld, emptyObjectField); staticConstructorIL.Emit(OpCodes.Ret); updateMainMethod.DeclaringType.Fields.Add(emptyObjectField); updateMainMethod.DeclaringType.Methods.Add(staticConstructor); } } il.Emit(OpCodes.Ldtoken, type); il.Emit(OpCodes.Call, getTypeFromHandleMethod); il.Emit(OpCodes.Ldstr, field.Name); if (typeIsValueType) { il.Emit(OpCodes.Ldloca, emptyStruct); } else { il.Emit(OpCodes.Ldsfld, emptyObjectField); } il.Emit(OpCodes.Ldflda, context.Assembly.MainModule.ImportReference(fieldReference)); il.Emit(OpCodes.Conv_I); if (typeIsValueType) { il.Emit(OpCodes.Ldloca, emptyStruct); } else { il.Emit(OpCodes.Ldsfld, emptyObjectField); } il.Emit(OpCodes.Conv_I); il.Emit(OpCodes.Sub); il.Emit(OpCodes.Conv_I4); var fieldType = context.Assembly.MainModule.ImportReference(replaceGenericsVisitor != null ? replaceGenericsVisitor.VisitDynamic(field.FieldType) : field.FieldType); il.Emit(OpCodes.Newobj, context.Assembly.MainModule.ImportReference(updatableFieldGenericCtor).MakeGeneric(fieldType)); il.Emit(OpCodes.Call, updateEngineRegisterMemberMethod); } if (serializableItem.MemberInfo is PropertyReference propertyReference) { var property = propertyReference.Resolve(); var propertyGetMethod = context.Assembly.MainModule.ImportReference(property.GetMethod) .MakeGeneric(updateCurrentMethod.GenericParameters.ToArray()); il.Emit(OpCodes.Ldtoken, type); il.Emit(OpCodes.Call, getTypeFromHandleMethod); il.Emit(OpCodes.Ldstr, property.Name); // If it's a virtual or interface call, we need to create a dispatcher using ldvirtftn if (property.GetMethod.IsVirtual) { propertyGetMethod = CreateDispatcher(context.Assembly, propertyGetMethod); } il.Emit(OpCodes.Ldftn, propertyGetMethod); // Set whether getter method uses a VirtualDispatch (static call) or instance call il.Emit(property.GetMethod.IsVirtual ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0); // Only uses setter if it exists and it's public if (property.SetMethod != null && property.SetMethod.IsPublic) { var propertySetMethod = context.Assembly.MainModule.ImportReference(property.SetMethod).MakeGeneric(updateCurrentMethod.GenericParameters.ToArray()); if (property.SetMethod.IsVirtual) { propertySetMethod = CreateDispatcher(context.Assembly, propertySetMethod); } il.Emit(OpCodes.Ldftn, propertySetMethod); } else { // 0 (native int) il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Conv_I); } // Set whether setter method uses a VirtualDispatch (static call) or instance call il.Emit((property.SetMethod?.IsVirtual ?? false) ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0); var propertyType = context.Assembly.MainModule.ImportReference(replaceGenericsVisitor != null ? replaceGenericsVisitor.VisitDynamic(property.PropertyType) : property.PropertyType); var updatablePropertyInflatedCtor = GetOrCreateUpdatablePropertyCtor(context.Assembly, propertyType); il.Emit(OpCodes.Newobj, updatablePropertyInflatedCtor); il.Emit(OpCodes.Call, updateEngineRegisterMemberMethod); } } if (updateCurrentMethod != updateMainMethod) { // If we have a local method, close it il.Emit(OpCodes.Ret); // Also call it from main method if it was a closed generic instantiation if (type is GenericInstanceType) { il = updateMainMethod.Body.GetILProcessor(); il.Emit(OpCodes.Call, updateCurrentMethod.MakeGeneric(((GenericInstanceType)type).GenericArguments.Select(context.Assembly.MainModule.ImportReference).ToArray())); } } }
private static void GenerateArray(MethodDefinition method, TypeReference baseEnumerable, GenericParameter T, TypeReference TPredicate, TypeReference predicate) { method.Parameters.Add(new ParameterDefinition("@this", ParameterAttributes.None, baseEnumerable)); method.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.Out, new ByReferenceType(T))); method.Parameters.Add(new ParameterDefinition("TPredicate", ParameterAttributes.In, new ByReferenceType(TPredicate)) { CustomAttributes = { Helper.GetSystemRuntimeCompilerServicesIsReadOnlyAttributeTypeReference() } }); var loopStart = Instruction.Create(OpCodes.Ldarg_0); var success = Instruction.Create(OpCodes.Ldarg_1); var fail = InstructionUtility.LoadConstant(false); var body = method.Body; body.InitLocals = true; body.Variables.Add(new VariableDefinition(method.Module.TypeSystem.IntPtr)); body.Variables.Add(new VariableDefinition(new ByReferenceType(T))); method.Body.GetILProcessor() .ArgumentNullCheck(0, Instruction.Create(OpCodes.Ldarg_0)) .LdLen() .BrFalseS(fail) .LdArg(0) .LdLen() .StLoc(0) .Add(loopStart) .LdLoc(0) .LdC(1) .Sub() .Dup() .StLoc(0) .LdElemA(T) .StLoc(1) .LdArg(2) .LdLoc(1) .Constrained(TPredicate) .CallVirtual(predicate.FindMethod("Calc")) .BrTrueS(success) .LdLoc(0) .BrTrueS(loopStart) .Add(fail) .Ret() .Add(success) .LdLoc(1) .CpObj(T) .LdC(true) .Ret(); }
public void RemoveGenericConstraintMapping(GenericParameter generic_parameter) { GenericConstraints.Remove(generic_parameter.token.RID); }
bool Initialize(ref Rect position, ref bool displayLock, SerializedProperty property, GenericParameter asGeneric) { Type targetType = property.serializedObject.targetObject.GetType(); SerializedType isTypeRestricted = null; var path = property.GetPath(); FieldInfo paramFieldInfo = path.MaterializeToFieldInfo(targetType); var typeAttribute = paramFieldInfo.GetCustomAttribute <TypeRestricted>(); if (typeAttribute != null) { switch (typeAttribute.Source) { case TypeRestricted.TypeSource.Value: { isTypeRestricted = new SerializedType(typeAttribute.Type); break; } case TypeRestricted.TypeSource.Field: { var field = targetType.GetField(typeAttribute.SourceValue); if (field != null) { var typeValue = field.GetValue(property.serializedObject.targetObject); switch (typeValue) { case SerializedType asSerialized: { isTypeRestricted = asSerialized; break; } case Type asSystem: { isTypeRestricted = new SerializedType(asSystem); break; } } break; } return(false); } default: return(false); } } View.Target = property.serializedObject.targetObject; View.AsParametrized = View.Target as IBaseObject; View.DataProvider = View.AsParametrized?.GetProvider(); if (isTypeRestricted != null && isTypeRestricted.Type != null) { displayLock = true; View.Parameters = View.DataProvider.GetParameters(t => { if (string.IsNullOrEmpty(isTypeRestricted.Metadata)) { return(isTypeRestricted.Type.IsAssignableFrom(t.HoldType.Type)); } else { return(isTypeRestricted.Equals(t.HoldType)); } }); View.Typename = KnownType.GetDisplayedName(isTypeRestricted.Type); } else { displayLock = false; View.Parameters = View.DataProvider.GetParameters(); View.Typename = "Parameter"; } if (asGeneric.HoldType != isTypeRestricted) { asGeneric.HoldType = isTypeRestricted; } if (View.Typename == null) { EditorGUI.HelpBox(position, string.Format("Type {0} is not a known type!", fieldInfo.FieldType), MessageType.Error); return(false); } if (!View.DataProvider.HasObject(View.Target)) { EditorGUI.HelpBox(position, "Unable to edit this object!", MessageType.Error); return(false); } if (View.DataProvider == null) { EditorGUI.HelpBox(position, $"{property.name}: Unable to get instance of IDataSetProvider!", MessageType.Error); return(false); } return(true); }
internal void GetConstraintInfoForGenericParam( GenericParameter genericParam, out uint genericParamConstraintRowIdStart, out uint genericParamConstraintRowIdEnd ) { uint constraintCount; genericParamConstraintRowIdStart = this.PEFileReader.GenericParamConstraintTable.FindConstraintForGenericParam(genericParam.GenericParameterRowId, out constraintCount); genericParamConstraintRowIdEnd = genericParamConstraintRowIdStart + constraintCount; }
private static TypeReference ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, GenericParameter genericParameterElement) => ((genericParameterElement.MetadataType != MetadataType.MVar) ? genericInstanceType.GenericArguments[genericParameterElement.Position] : ((genericInstanceMethod == null) ? genericParameterElement : genericInstanceMethod.GenericArguments[genericParameterElement.Position]));
public static bool IsPositionalGenericParameter(GenericParameter gp) { return(gp.Name[0] == '!'); }
internal bool AreSame(GenericParameter a, GenericParameter b) { return(a.Position == b.Position); }
public void VisitGenericParameter(GenericParameter genparam) { }
private void FixReferences(GenericParameter definition) { FixReferences(definition.Constraints); FixReferences(definition.CustomAttributes); }
private static void GenerateGeneric(TypeDefinition @static, ModuleDefinition mainModule) { var method = new MethodDefinition("Aggregate", Helper.StaticMethodAttributes, mainModule.TypeSystem.Boolean) { DeclaringType = @static, AggressiveInlining = true, CustomAttributes = { Helper.ExtensionAttribute } }; @static.Methods.Add(method); var genericParameters = method.GenericParameters; var(T, TEnumerator, TEnumerable) = method.Define3GenericParameters(); var TAccumulate = new GenericParameter("TAccumulate", method); genericParameters.Add(TAccumulate); var TResult = new GenericParameter("TResult", method); genericParameters.Add(TResult); method.ReturnType = TResult; var TFunc = new GenericInstanceType(mainModule.GetType("UniNativeLinq", "RefAction`2")) { GenericArguments = { TAccumulate, T } }; var TResultFunc = new GenericInstanceType(mainModule.GetType("UniNativeLinq", "RefFunc`2")) { GenericArguments = { TAccumulate, TResult } }; method.Parameters.Add(new ParameterDefinition("@this", ParameterAttributes.In, new ByReferenceType(TEnumerable)) { CustomAttributes = { Helper.GetSystemRuntimeCompilerServicesIsReadOnlyAttributeTypeReference() } }); method.Parameters.Add(new ParameterDefinition("accumulate", ParameterAttributes.None, new ByReferenceType(TAccumulate))); method.Parameters.Add(new ParameterDefinition("func", ParameterAttributes.None, TFunc)); method.Parameters.Add(new ParameterDefinition("resultFunc", ParameterAttributes.None, TResultFunc)); var body = method.Body; var enumeratorVariable = new VariableDefinition(TEnumerator); body.Variables.Add(enumeratorVariable); body.Variables.Add(new VariableDefinition(method.Module.TypeSystem.Boolean)); body.Variables.Add(new VariableDefinition(new ByReferenceType(T))); var loopStart = Instruction.Create(OpCodes.Ldarg_2); var condition = Instruction.Create(OpCodes.Ldloca_S, enumeratorVariable); body.GetILProcessor() .ArgumentNullCheck(2, 3, Instruction.Create(OpCodes.Ldarg_0)) .GetEnumeratorEnumerable(TEnumerable) .StLoc(0) .BrS(condition) .Add(loopStart) .LdArg(1) .LdLoc(2) .CallVirtual(TFunc.FindMethod("Invoke")) .Add(condition) .LdLocA(1) .TryGetNextEnumerator(TEnumerator) .StLoc(2) .LdLoc(1) .BrTrueS(loopStart) .LdLocA(0) .DisposeEnumerator(TEnumerator) .LdArg(3) .LdArg(1) .CallVirtual(TResultFunc.FindMethod("Invoke")) .Ret(); }
public MyGenericParameterInfo(GenericParameter genericParameter) : base() { this.name = genericParameter.Name; this.constraints = CreateGenericConstraints(genericParameter); }
public abstract string ToString(GenericParameter parameter);
private List <GenericConstraint> CreateGenericConstraints(GenericParameter genericParameter) { List <GenericConstraint> result = null; if ((genericParameter.Attributes & GenericParameterAttributes.ReferenceTypeConstraint) == GenericParameterAttributes.ReferenceTypeConstraint) { result = new List <GenericConstraint>(); result.Add(new BuiltInGenericConstraint(BuiltInGenericConstraintsTypes.Class)); } else if ((genericParameter.Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) == GenericParameterAttributes.NotNullableValueTypeConstraint) { result = new List <GenericConstraint>(); result.Add(new BuiltInGenericConstraint(BuiltInGenericConstraintsTypes.Struct)); } var baseOrInterfaceConstraints = genericParameter.Constraints; if (baseOrInterfaceConstraints != null) { if (result == null) { result = new List <GenericConstraint>(); } for (int i = 0; i < baseOrInterfaceConstraints.Count; i++) { TypeReference baseTypeOrInterface = baseOrInterfaceConstraints[i]; if (baseTypeOrInterface.FullName == "System.ValueType") { continue; } if (Utils.IsGenericParameter(baseTypeOrInterface)) { result.Add(new NakedTypeConstraint(baseTypeOrInterface.Name)); } else { string[] readableForms = Tools.GetHumanReadableForms(baseTypeOrInterface); result.Add(new TypeGenericConstraint(readableForms[0])); } } } if ((genericParameter.Attributes & GenericParameterAttributes.DefaultConstructorConstraint) == GenericParameterAttributes.DefaultConstructorConstraint && (genericParameter.Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0) { if (result == null) { result = new List <GenericConstraint>(); } result.Add(new BuiltInGenericConstraint(BuiltInGenericConstraintsTypes.New)); } return(result); }
public override string ToString(GenericParameter parameter) { return("'" + parameter.SafeString(0) + "'"); }
public override TypeReference Visit(GenericParameter type) { if (type.Type == GenericParameterType.Method) { if (genericContextMethod != null && type.Position < genericContextMethod.GenericArguments.Count) { // Look for generic parameter in both resolved and element method var genericContext1 = genericContextMethod.ElementMethod; var genericContext2 = genericContextMethod.Resolve(); var genericParameter1 = genericContext1.GenericParameters[type.Position]; var genericParameter2 = genericContext2.GenericParameters[type.Position]; if (resolveOnlyReferences) { if (genericParameter1.Name == type.Name) { return(genericParameter2); } } else { if (genericParameter1.Name == type.Name) { return(genericContextMethod.GenericArguments[type.Position]); } if (genericParameter2.Name == type.Name) { return(genericContextMethod.GenericArguments[type.Position]); } } } } else { if (genericContextType != null && type.Position < genericContextType.GenericArguments.Count) { // Look for generic parameter in both resolved and element method var genericContext1 = genericContextType.ElementType; var genericContext2 = genericContextType.Resolve(); var genericParameter1 = genericContext1.GenericParameters[type.Position]; var genericParameter2 = genericContext2.GenericParameters[type.Position]; if (resolveOnlyReferences) { if (genericParameter1.Name == type.Name) { return(genericParameter2); } } else { if (genericParameter1.Name == type.Name) { return(genericContextType.GenericArguments[type.Position]); } if (genericParameter2.Name == type.Name) { return(genericContextType.GenericArguments[type.Position]); } } } } return(base.Visit(type)); }
private GenericParameterDesc[]/*!!*/ ToGenericParameters(DMember/*!*/ declaringMember, out int mandatoryCount) { Debug.Assert(declaringMember != null); if (typeParams.Count == 0) { mandatoryCount = 0; return GenericParameterDesc.EmptyArray; } GenericParameterDesc[] result = new GenericParameterDesc[typeParams.Count]; mandatoryCount = 0; for (int i = 0; i < typeParams.Count; i++) { result[i] = new GenericParameter(typeParams[i].Name, i, declaringMember).GenericParameterDesc; if (typeParams[i].DefaultType == null) mandatoryCount++; } return result; }
private void UpdateParameterLeastType(ParameterReference parameter, IEnumerable <StackEntryUsageResult> usageResults) { int pIndex = parameter.Index; int parameterDepth = GetActualTypeDepth(parameter.ParameterType); int currentLeastDepth = 0; TypeReference currentLeastType = null; List <MethodSignature> signatures = null; //update the result array as in if (needUpdate) block below foreach (var usage in usageResults) { bool needUpdate = false; switch (usage.Instruction.OpCode.Code) { case Code.Newobj: case Code.Call: case Code.Callvirt: MethodReference method = (MethodReference)usage.Instruction.Operand; //potential generalization to object does not really make sense //from a readability/maintainability point of view if (IsSystemObjectMethod(method)) { continue; } //we cannot really know if suggestion would work since the collection //is non-generic thus we ignore it TypeReference type = method.DeclaringType; if (IsFromNonGenericCollectionNamespace(type.Namespace)) { continue; } int pcount = method.HasParameters ? method.Parameters.Count : 0; if (usage.StackOffset == pcount) { //argument is used as `this` in the call if (signatures == null) { signatures = GetSignatures(usageResults); } currentLeastType = GetBaseImplementor(GetActualType(type), signatures); } else { //argument is also used as an argument in the call currentLeastType = method.Parameters [pcount - usage.StackOffset - 1].ParameterType; //if parameter type is a generic, find the 'real' constructed type GenericParameter gp = (currentLeastType as GenericParameter); if (gp != null) { currentLeastType = GetConstructedGenericType(method, gp); } } //if the best we could find is object or non-generic collection, ignore this round if (currentLeastType == null || IsIgnoredSuggestionType(currentLeastType)) { continue; } needUpdate = true; break; case Code.Stfld: case Code.Stsfld: FieldReference field = (FieldReference)usage.Instruction.Operand; currentLeastType = field.FieldType; needUpdate = true; break; } if (needUpdate) { currentLeastDepth = GetActualTypeDepth(currentLeastType); if (null == types_least [pIndex] || currentLeastDepth > depths_least [pIndex]) { types_least [pIndex] = currentLeastType; depths_least [pIndex] = currentLeastDepth; } if (currentLeastDepth == parameterDepth) //no need to check further { return; } } } }
static bool AreSame(GenericParameter a, GenericParameter b) { return a.Position == b.Position; }
private static TypeReference GetConstructedGenericType(MemberReference method, GenericParameter parameter) { int position = parameter.Position; if (parameter.Owner is MethodReference) { GenericInstanceMethod gim = (method as GenericInstanceMethod); // 'gim' can be null in special cases, e.g. a generated Set method on a multidim array if (gim != null) { return(gim.GenericArguments [position]); } } if (parameter.Owner is TypeReference) { GenericInstanceType git = (method.DeclaringType as GenericInstanceType); if (git != null) { return(git.GenericArguments [position]); } } return(parameter.Owner.GenericParameters [position]); }
public bool TryGetGenericConstraintMapping(GenericParameter generic_parameter, out MetadataToken[] mapping) { return GenericConstraints.TryGetValue(generic_parameter.token.RID, out mapping); }
internal GenericParameterDeclarationWithMonoCecil(AssemblyWithMonoCecil assembly, GenericParameter type) { this.type = type; attributes = new Lazy <Attributes>(() => new Attributes(assembly, type)); typeConstraint = GetTypeConstraint(type); direction = GetDirection(type); hasEmptyConstructorConstraint = type.HasDefaultConstructorConstraint && !type.HasNotNullableValueTypeConstraint; genericParameterConstraints = new List <GenericParameterReferenceWithMonoCecil>(); interfaceConstraints = new List <InterfaceReferenceWithMonoCecil>(); foreach (TypeReference constraintType in type.Constraints) { TypeDefinition constraintTypeDefinition = constraintType.Resolve(); if (constraintType.IsGenericParameter) { genericParameterConstraints.Add(new GenericParameterReferenceWithMonoCecil(constraintType)); } else if (constraintTypeDefinition.IsInterface) { interfaceConstraints.Add(new InterfaceReferenceWithMonoCecil(assembly, constraintType)); } else if (constraintTypeDefinition.IsClass) { if (baseClassConstraint != null) { throw new InvalidOperationException("GenericParameterDeclaration appears to have 2 base classes."); } if (constraintType.FullName != "System.ValueType") { baseClassConstraint = new ClassReferenceWithMonoCecil(assembly, constraintType); } } else { throw new InvalidOperationException("Unknown constraint type."); } } }
/// <summary> /// Returns a <see cref="PhpRoutineSignature"/> for the specified argfull <see cref="MethodInfo"/>. /// </summary> /// <exception cref="ReflectionException">Invalid argfull.</exception> public static PhpRoutineSignature/*!*/ FromArgfullInfo(PhpRoutine/*!*/ routine, MethodInfo/*!*/ argfull) { // determine aliasReturn bool alias_return = false; if (argfull.ReturnType != Types.Object[0]) { if (argfull.ReturnType == Types.PhpReference[0]) alias_return = true; else throw new ReflectionException("TODO"); } ParameterInfo[] parms = argfull.GetParameters(); int parms_length = parms.Length; int parms_offset = 1; if (--parms_length < 0 || parms[0].ParameterType != Types.ScriptContext[0]) { // TODO: resource throw new ReflectionException("Invalid static argfull signature of method " + routine.FullName); } // process pseudo-generic parameters: int j = parms_offset; while (j < parms.Length && parms[j].ParameterType == Types.DTypeDesc[0]) j++; int generic_param_count = j - parms_offset; int mandatory_generic_param_count = 0; GenericParameter[] generic_params = (generic_param_count > 0) ? new GenericParameter[generic_param_count] : GenericParameter.EmptyArray; for (int i = 0; i < generic_param_count; i++) { ParameterInfo pinfo = parms[i + parms_offset]; generic_params[i] = new GenericParameter(new Name(pinfo.Name), i, routine); DTypeSpecAttribute default_type = DTypeSpecAttribute.Reflect(pinfo); if (default_type != null) { // TODO: // generic_params[i].WriteUp(default_type.TypeSpec.GetTypeDesc(null, null, null, null).Type); } else { generic_params[i].WriteUp(null); if (mandatory_generic_param_count < i) { // TODO: resource throw new ReflectionException("Invalid signature"); } else mandatory_generic_param_count++; } } parms_offset += generic_param_count; parms_length -= generic_param_count; // set up genericParams, aliasMask, typeHints, and mandatoryParamCount: BitArray alias_mask = new BitArray(parms_length, false); DType[] type_hints = new DType[parms_length]; int mandatory_param_count = 0; for (int i = 0; i < parms_length; i++) { ParameterInfo pinfo = parms[i + parms_offset]; if (pinfo.ParameterType != Types.Object[0]) { if (pinfo.ParameterType == Types.PhpReference[0]) alias_mask[i] = true; else return null; } DTypeSpecAttribute type_hint = DTypeSpecAttribute.Reflect(pinfo); if (type_hint != null) { // TODO: // type_hints[i] = type_hint.TypeSpec.GetTypeDesc(null, null, null, null).Type; } if (!pinfo.IsOptional) { if (mandatory_param_count < i) { // invalid optional parameters throw new ReflectionException("Invalid signature"); } else mandatory_param_count++; } } return new PhpRoutineSignature(generic_params, mandatory_generic_param_count). WriteUp(alias_return, alias_mask, type_hints, mandatory_param_count); }
/// <summary> /// Create a panel for the specific parameter /// </summary> /// <param name="param">the parameter to create panel for</param> /// <param name="defaultValue">The default value for the parameter</param> /// <returns>the panel</returns> private static ParamInputPanel CreatePanelForParameter(ParameterInfo param, object defaultValue) { ParamInputPanel panel = new ParamInputPanel(); panel.Height = 50; panel.Width = 400; Point textBoxStart = new Point(100, 10); #region add the label for the parameter Label paramNameLabel = new Label(); paramNameLabel.AutoSize = true; panel.Controls.Add(paramNameLabel); paramNameLabel.Location = new Point(10, textBoxStart.Y); #endregion if (param == null) { // a generic parameter GenericParameter p = defaultValue as GenericParameter; paramNameLabel.Text = ""; String[] options = Array.ConvertAll <Type, String>(p.AvailableTypes, delegate(Type t) { return(t.Name); }); ComboBox combo = new ComboBox(); panel.Controls.Add(combo); combo.Location = textBoxStart; combo.Items.AddRange(options); combo.SelectedIndex = Array.FindIndex <String>(options, p.SelectedType.ToString().Equals); panel.GetParamFunction = delegate() { return (new GenericParameter( p.AvailableTypes[Array.FindIndex <String>(options, combo.Text.ToString().Equals)], p.AvailableTypes)); }; } else { Type paramType = param.ParameterType; paramNameLabel.Text = String.Format("{0}:", ParseParameterName(param)); if (paramType.IsEnum) { ComboBox combo = new ComboBox(); panel.Controls.Add(combo); combo.Location = textBoxStart; combo.Items.AddRange(Enum.GetNames(paramType)); combo.SelectedIndex = 0; combo.Width = 240; panel.GetParamFunction = delegate { return(Enum.Parse(paramType, combo.SelectedItem.ToString(), true)); }; } else if (paramType == typeof(bool)) { ComboBox combo = new ComboBox(); panel.Controls.Add(combo); combo.Location = textBoxStart; combo.Items.AddRange(new String[] { "True", "False" }); combo.SelectedIndex = 0; panel.GetParamFunction = delegate() { return(combo.SelectedItem.ToString().Equals("True")); }; } else if (paramType == typeof(UInt64) || paramType == typeof(int) || paramType == typeof(double)) { //Create inpout box for the int paramater TextBox inputTextBox = new TextBox(); panel.Controls.Add(inputTextBox); inputTextBox.Location = textBoxStart; inputTextBox.Text = defaultValue == null ? "0" : defaultValue.ToString(); panel.GetParamFunction = delegate() { return(Convert.ChangeType(inputTextBox.Text, paramType)); }; } else if (paramType == typeof(MCvScalar)) { TextBox[] inputBoxes = new TextBox[4]; int boxWidth = 40; //Create input boxes for the scalar value for (int i = 0; i < inputBoxes.Length; i++) { inputBoxes[i] = new TextBox(); panel.Controls.Add(inputBoxes[i]); inputBoxes[i].Location = new Point(textBoxStart.X + i * (boxWidth + 5), textBoxStart.Y); inputBoxes[i].Width = boxWidth; inputBoxes[i].Text = "0.0"; } panel.GetParamFunction = delegate() { double[] values = new double[4]; for (int i = 0; i < inputBoxes.Length; i++) { values[i] = Convert.ToDouble(inputBoxes[i].Text); } return(new MCvScalar(values[0], values[1], values[2], values[3])); }; } else if (paramType == typeof(PointF)) { TextBox[] inputBoxes = new TextBox[2]; int boxWidth = 40; //Create input boxes for the scalar value for (int i = 0; i < 2; i++) { inputBoxes[i] = new TextBox(); panel.Controls.Add(inputBoxes[i]); inputBoxes[i].Location = new Point(textBoxStart.X + i * (boxWidth + 5), textBoxStart.Y); inputBoxes[i].Width = boxWidth; inputBoxes[i].Text = "0.0"; } panel.GetParamFunction = delegate() { float[] values = new float[inputBoxes.Length]; for (int i = 0; i < inputBoxes.Length; i++) { values[i] = Convert.ToSingle(inputBoxes[i].Text); } return(new PointF(values[0], values[1])); }; } else if (paramType.GetInterface("IColor") == typeof(IColor)) { IColor t = Activator.CreateInstance(paramType) as IColor; //string[] channelNames = ReflectColorType.GetNamesOfChannels(t); TextBox[] inputBoxes = new TextBox[t.Dimension]; int boxWidth = 40; //Create input boxes for the scalar value for (int i = 0; i < inputBoxes.Length; i++) { inputBoxes[i] = new TextBox(); panel.Controls.Add(inputBoxes[i]); inputBoxes[i].Location = new Point(textBoxStart.X + i * (boxWidth + 5), textBoxStart.Y); inputBoxes[i].Width = boxWidth; inputBoxes[i].Text = "0.0"; } panel.GetParamFunction = delegate() { double[] values = new double[4]; for (int i = 0; i < inputBoxes.Length; i++) { values[i] = Convert.ToDouble(inputBoxes[i].Text); } IColor color = Activator.CreateInstance(paramType) as IColor; color.MCvScalar = new MCvScalar(values[0], values[1], values[2], values[3]); return(color); }; } else { throw new NotSupportedException(String.Format(Properties.StringTable.ParameterTypeIsNotSupported, paramType.Name)); } } return(panel); }
internal ITypeReference/*?*/ GetTypeReferenceForGenericConstraintRowId( GenericParameter genParam, uint interfaceRowId ) { uint constraintTypeToken = this.PEFileReader.GenericParamConstraintTable.GetConstraint(interfaceRowId); return this.GetTypeReferenceForToken(genParam, constraintTypeToken); }
protected void TypeReferenceInternal(GenericParameter gp, TypeReferenceContext context) { var ownerType = gp.Owner as TypeReference; var ownerMethod = gp.Owner as MethodReference; if (context != null) { if (ownerType != null) { if (TypeUtil.TypesAreAssignable(TypeInfo, ownerType, context.SignatureMethodType)) { var resolved = JSIL.Internal.MethodSignature.ResolveGenericParameter(gp, context.SignatureMethodType); if (resolved != null) { if (resolved != gp) { context.Push(); context.SignatureMethod = null; try { TypeReference(resolved, context); } finally { context.Pop(); } return; } else { TypeIdentifier(resolved, context, false); return; } } } if (TypeUtil.TypesAreEqual(ownerType, context.EnclosingMethodType)) { TypeIdentifier(gp, context, false); return; } if (TypeUtil.TypesAreEqual(ownerType, context.EnclosingType)) { LocalOpenGenericParameter(gp); return; } var ownerTypeResolved = ownerType.Resolve(); if (ownerTypeResolved != null) { // Is it a generic parameter of a compiler-generated class (i.e. enumerator function, delegate, etc) // nested inside our EnclosingType? If so, uhhhh, shit. if ( TypeUtil.TypesAreEqual(context.EnclosingType, ownerTypeResolved.DeclaringType) && ownerTypeResolved.CustomAttributes.Any( (ca) => ca.AttributeType.FullName == "System.Runtime.CompilerServices.CompilerGeneratedAttribute" ) ) { // FIXME: I HAVE NO IDEA WHAT I AM DOING OpenGenericParameter(gp, Util.DemangleCecilTypeName(ownerTypeResolved.FullName)); return; } } if (TypeUtil.TypesAreEqual(ownerType, context.AttributesMethodType)) { LocalOpenGenericParameter(gp); return; } if (TypeUtil.TypesAreEqual(ownerType, context.DefiningMethodType)) { OpenGenericParameter(gp, Util.DemangleCecilTypeName(context.DefiningMethodType.FullName)); return; } if (TypeUtil.TypesAreEqual(ownerType, context.DefiningType)) { OpenGenericParameter(gp, Util.DemangleCecilTypeName(context.DefiningType.FullName)); return; } throw new NotImplementedException(String.Format( "Unimplemented form of generic type parameter: '{0}'.", gp )); } else if (ownerMethod != null) { Func <MethodReference, int> getPosition = (mr) => { for (var i = 0; i < mr.GenericParameters.Count; i++) { if (mr.GenericParameters[i].Name == gp.Name) { return(i); } } throw new NotImplementedException(String.Format( "Generic parameter '{0}' not found in method '{1}' parameter list", gp, ownerMethod )); }; var ownerMethodIdentifier = new QualifiedMemberIdentifier( new TypeIdentifier(ownerMethod.DeclaringType.Resolve()), new MemberIdentifier(TypeInfo, ownerMethod) ); if (ownerMethodIdentifier.Equals(ownerMethod, context.InvokingMethod, TypeInfo)) { var gim = (GenericInstanceMethod)context.InvokingMethod; TypeReference(gim.GenericArguments[getPosition(ownerMethod)], context); return; } if (ownerMethodIdentifier.Equals(ownerMethod, context.EnclosingMethod, TypeInfo)) { Identifier(gp.Name); return; } if ( ownerMethodIdentifier.Equals(ownerMethod, context.DefiningMethod, TypeInfo) || ownerMethodIdentifier.Equals(ownerMethod, context.SignatureMethod, TypeInfo) ) { Value(String.Format("!!{0}", getPosition(ownerMethod))); return; } throw new NotImplementedException(String.Format( "Unimplemented form of generic method parameter: '{0}'.", gp )); } } else { throw new NotImplementedException("Cannot resolve generic parameter without a TypeReferenceContext."); } throw new NotImplementedException(String.Format( "Unimplemented form of generic parameter: '{0}'.", gp )); }