public override void Init(IScriptExportManager manager) { m_return = CreateReturnType(manager); m_parameters = CreateParameterTypes(manager); if (Type.IsNested) { m_declaringType = manager.RetrieveType(Type.DeclaringType); AddAsNestedDelegate(); } }
public override void Init(IScriptExportManager manager) { m_declaringType = manager.RetrieveType(Method.DeclaringType); m_returnType = manager.RetrieveType(Method.ReturnType); m_parameters = new ScriptExportParameter[Method.Parameters.Count]; for (int i = 0; i < m_parameters.Length; i++) { ParameterDefinition argument = Method.Parameters[i]; m_parameters[i] = manager.RetrieveParameter(argument); } }
private ScriptExportType CreateReturnType(IScriptExportManager manager) { foreach (MethodDefinition method in Type.Methods) { if (method.Name == InvokeMethodName) { return(manager.RetrieveType(method.ReturnType)); } } throw new Exception($"Invoke method '{InvokeMethodName}' wasn't found"); }
private ScriptExportAttribute CreateAttribute(IScriptExportManager manager) { CustomAttribute attribute = GetSerializeFieldAttribute(Field); if (attribute == null) { return(null); } else { return(manager.RetrieveAttribute(attribute)); } }
public override void Init(IScriptExportManager manager) { m_owner = manager.RetrieveType(Type.ElementType); List <ScriptExportType> arguments = new List <ScriptExportType>(); foreach (TypeReference argument in Type.GenericArguments) { ScriptExportType exportParameter = manager.RetrieveType(argument); arguments.Add(exportParameter); } m_arguments = arguments.ToArray(); }
public override void Init(IScriptExportManager manager) { if (Definition != null && Definition.BaseType != null) { m_base = manager.RetrieveType(Definition.BaseType); } m_fields = CreateFields(manager); if (Type.IsNested) { m_declaringType = manager.RetrieveType(Type.DeclaringType); AddAsNestedType(manager); } }
private IReadOnlyList <ScriptExportField> CreateFields(IScriptExportManager manager) { if (Definition == null) { return(new ScriptExportField[0]); } List <ScriptExportField> fields = new List <ScriptExportField>(); foreach (FieldDefinition field in Definition.Fields) { if (field.IsPublic) { if (field.IsNotSerialized) { continue; } } else { if (!ScriptExportMonoField.HasSerializeFieldAttribute(field)) { continue; } } if (field.FieldType.Module == null) { // if field has unknown type then consider it as serializable } else { TypeDefinition fieldTypeDefinition = field.FieldType.Resolve(); if (fieldTypeDefinition.IsInterface) { continue; } if (!MonoType.IsSerializableType(field.FieldType)) { continue; } } ScriptExportField efield = manager.RetrieveField(field); fields.Add(efield); } return(fields.ToArray()); }
private IReadOnlyList <ScriptExportParameter> CreateParameterTypes(IScriptExportManager manager) { foreach (MethodDefinition method in Type.Methods) { if (method.Name == InvokeMethodName) { ScriptExportParameter[] parameters = new ScriptExportParameter[method.Parameters.Count]; for (int i = 0; i < parameters.Length; i++) { parameters[i] = manager.RetrieveParameter(method.Parameters[i]); } return(parameters); } } throw new Exception($"Invoke method '{InvokeMethodName}' wasn't found"); }
private IReadOnlyList <ScriptExportField> CreateFields(IScriptExportManager manager) { List <ScriptExportField> fields = new List <ScriptExportField>(); foreach (FieldDefinition field in Definition.Fields) { if (field.Name == "value__") { continue; } ScriptExportField enumField = manager.RetrieveField(field); fields.Add(enumField); } return(fields); }
public override void Init(IScriptExportManager manager) { if (Type.Module == null) { m_fields = new ScriptExportField[0]; } else { m_fields = CreateFields(manager); } if (Type.IsNested) { m_declaringType = manager.RetrieveType(Type.DeclaringType); AddAsNestedEnum(); } }
private IReadOnlyList <ScriptExportField> CreateFields(IScriptExportManager manager) { if (Definition == null) { return(new ScriptExportField[0]); } List <ScriptExportField> fields = new List <ScriptExportField>(); foreach (FieldDefinition field in Definition.Fields) { if (!MonoField.IsSerializableModifier(field)) { continue; } if (field.FieldType.Module == null) { // if field has unknown type then consider it as serializable } else if (field.FieldType.ContainsGenericParameter) { // if field type has generic parameter then consider it as serializable } else { TypeDefinition definition = field.FieldType.Resolve(); if (definition == null) { // if field has unknown type then consider it as serializable } else { MonoSerializableScope scope = new MonoSerializableScope(field); if (!MonoField.IsFieldTypeSerializable(scope)) { continue; } } } ScriptExportField efield = manager.RetrieveField(field); fields.Add(efield); } return(fields.ToArray()); }
private ScriptExportAttribute[] CreateAttributes(IScriptExportManager manager) { List <CustomAttribute> attributes = GetExportAttributes(Field); if (attributes == null || attributes.Count == 0) { return(null); } else { ScriptExportAttribute[] result = new ScriptExportAttribute[attributes.Count]; for (int i = 0; i < attributes.Count; i++) { result[i] = manager.RetrieveAttribute(attributes[i]); } return(result); } }
public override void Init(IScriptExportManager manager) { if (Definition != null && Definition.BaseType != null) { m_base = manager.RetrieveType(Definition.BaseType); } m_methods = CreateMethods(manager); m_properties = CreateProperties(manager); m_fields = CreateFields(manager); if (Type.IsNested) { m_declaringType = manager.RetrieveType(Type.DeclaringType); if (!Type.IsGenericParameter) { AddAsNestedType(); } } }
public override void Init(IScriptExportManager manager) { m_type = manager.RetrieveType(Parameter.ParameterType.IsByReference ? Parameter.ParameterType.GetElementType() : Parameter.ParameterType); }
protected void AddAsNestedType(IScriptExportManager manager) { DeclaringType.m_nestedTypes.Add(this); }
public override void Init(IScriptExportManager manager) { m_declaringType = manager.RetrieveType(Field.DeclaringType); m_type = manager.RetrieveType(Field.FieldType); m_attributes = CreateAttributes(manager); }
public override void Init(IScriptExportManager manager) { TypeSpecification specification = (TypeSpecification)Type; m_element = manager.RetrieveType(specification.ElementType); }
public abstract void Init(IScriptExportManager manager);
protected void AddAsNestedDelegate(IScriptExportManager manager) { DeclaringType.m_nestedDelegates.Add((ScriptExportDelegate)this); }
protected void AddAsNestedEnum(IScriptExportManager manager) { DeclaringType.m_nestedEnums.Add((ScriptExportEnum)this); }
public override void Init(IScriptExportManager manager) { m_type = manager.RetrieveType(Attribute.AttributeType); }
public override void Init(IScriptExportManager manager) { m_declaringType = manager.RetrieveType(Property.DeclaringType); m_type = manager.RetrieveType(Property.PropertyType); }
public override void Init(IScriptExportManager manager) { m_type = manager.RetrieveType(Parameter.ParameterType); }
private IReadOnlyList <ScriptExportProperty> CreateProperties(IScriptExportManager manager) { if (Definition == null || Definition.BaseType == null || Definition.BaseType.Module == null) { return(Array.Empty <ScriptExportProperty>()); } // we need to export only such properties that are declared as asbtract inside builin assemblies // and not overridden anywhere except current type List <PropertyDefinition> overrides = new List <PropertyDefinition>(); foreach (PropertyDefinition property in Definition.Properties) { MethodDefinition method = property.GetMethod == null ? property.SetMethod : property.GetMethod; if (method.IsVirtual && method.IsReuseSlot) { overrides.Add(property); } } List <ScriptExportProperty> properties = new List <ScriptExportProperty>(); MonoTypeContext context = new MonoTypeContext(Definition); TypeDefinition definition = Definition; while (true) { if (overrides.Count == 0) { break; } if (definition.BaseType == null || definition.BaseType.Module == null) { break; } context = context.GetBase(); definition = context.Type.Resolve(); if (definition == null) { break; } string module = GetModuleName(context.Type); bool isBuiltIn = ScriptExportManager.IsBuiltinLibrary(module); foreach (PropertyDefinition property in definition.Properties) { MethodDefinition method = property.GetMethod == null ? property.SetMethod : property.GetMethod; if (method.IsVirtual && (method.IsNewSlot || method.IsReuseSlot)) { for (int i = 0; i < overrides.Count; i++) { PropertyDefinition @override = overrides[i]; if (@override.Name == property.Name) { if (isBuiltIn && method.IsAbstract) { ScriptExportProperty exportProperty = manager.RetrieveProperty(@override); properties.Add(exportProperty); } overrides.RemoveAt(i); break; } } } } } return(properties.ToArray()); }
private IReadOnlyList <ScriptExportMethod> CreateMethods(IScriptExportManager manager) { if (Definition == null || Definition.BaseType == null || Definition.BaseType.Module == null) { return(Array.Empty <ScriptExportMethod>()); } // we need to export only such properties that are declared as asbtract inside builin assemblies // and not overridden anywhere except current type List <MethodDefinition> overrides = new List <MethodDefinition>(); foreach (MethodDefinition method in Definition.Methods) { if (method.IsVirtual && method.IsReuseSlot && !method.IsGetter && !method.IsSetter) { overrides.Add(method); } } List <ScriptExportMethod> methods = new List <ScriptExportMethod>(); MonoTypeContext context = new MonoTypeContext(Definition); TypeDefinition definition = Definition; while (true) { if (overrides.Count == 0) { break; } if (definition.BaseType == null || definition.BaseType.Module == null) { break; } context = context.GetBase(); definition = context.Type.Resolve(); if (definition == null) { break; } string module = GetModuleName(definition); bool isBuiltIn = ScriptExportManager.IsBuiltinLibrary(module); IReadOnlyDictionary <GenericParameter, TypeReference> arguments = context.GetContextArguments(); // definition is a Template for GenericInstance, so we must recreate context MonoTypeContext definitionContext = new MonoTypeContext(definition, arguments); foreach (MethodDefinition method in definition.Methods) { if (method.IsVirtual && (method.IsNewSlot || method.IsReuseSlot)) { for (int i = 0; i < overrides.Count; i++) { MethodDefinition @override = overrides[i]; if (MonoUtils.AreSame(@override, definitionContext, method)) { if (isBuiltIn && method.IsAbstract) { ScriptExportMethod exportMethod = manager.RetrieveMethod(@override); methods.Add(exportMethod); } overrides.RemoveAt(i); break; } } } } } return(methods.ToArray()); }