public static FieldAttr ( Mono.CSharp.Modifiers mod_flags ) : FieldAttributes | ||
mod_flags | Mono.CSharp.Modifiers | |
return | FieldAttributes |
public override bool Define() { if (!base.Define()) { return(false); } // SYNC_MOD_CTRL if ((ModFlags & Modifiers.SYNC) == Modifiers.SYNC) { Report.Error(3661, Location, "A sync modifier cannot be used in field declaration. "); } MetaType[] required_modifier = null; if ((ModFlags & Modifiers.VOLATILE) != 0) { var mod = Module.PredefinedTypes.IsVolatile.Resolve(); if (mod != null) { required_modifier = new MetaType[] { mod.GetMetaInfo() } } ; } FieldBuilder = Parent.TypeBuilder.DefineField( Name, member_type.GetMetaInfo(), required_modifier, null, ModifiersExtensions.FieldAttr(ModFlags)); spec = new FieldSpec(Parent.Definition, this, MemberType, FieldBuilder, ModFlags); // // Don't cache inaccessible fields except for struct where we // need them for definitive assignment checks // if ((ModFlags & Modifiers.BACKING_FIELD) == 0 || Parent.Kind == MemberKind.Struct) { Parent.MemberCache.AddMember(spec); } if (initializer != null) { Parent.RegisterFieldForInitialization(this, new FieldInitializer(this, initializer, TypeExpression.Location)); } if (declarators != null) { foreach (var d in declarators) { var f = new Field(Parent, d.GetFieldTypeExpression(this), ModFlags, new MemberName(d.Name.Value, d.Name.Location), OptAttributes); if (d.Initializer != null) { f.initializer = d.Initializer; } f.Define(); Parent.PartialContainer.Members.Add(f); } } return(true); }
public override bool Define() { if (!base.Define()) { return(false); } MetaType[] required_modifier = null; if ((ModFlags & Modifiers.VOLATILE) != 0) { var mod = Module.PredefinedTypes.IsVolatile.Resolve(); if (mod != null) { required_modifier = new MetaType[] { mod.GetMetaInfo() } } ; } FieldBuilder = Parent.TypeBuilder.DefineField( Name, member_type.GetMetaInfo(), required_modifier, null, ModifiersExtensions.FieldAttr(ModFlags)); spec = new FieldSpec(Parent.Definition, this, MemberType, FieldBuilder, ModFlags); // // Don't cache inaccessible fields except for struct where we // need them for definitive assignment checks // if ((ModFlags & Modifiers.BACKING_FIELD) == 0 || Parent.Kind == MemberKind.Struct) { Parent.MemberCache.AddMember(spec); } if (initializer != null) { ((TypeContainer)Parent).RegisterFieldForInitialization(this, new FieldInitializer(spec, initializer, this)); } if (declarators != null) { var t = new TypeExpression(MemberType, TypeExpression.Location); int index = Parent.PartialContainer.Fields.IndexOf(this); foreach (var d in declarators) { var f = new Field(Parent, t, ModFlags, new MemberName(d.Name.Value, d.Name.Location), OptAttributes); if (d.Initializer != null) { f.initializer = d.Initializer; } Parent.PartialContainer.Fields.Insert(++index, f); } } return(true); }
public override bool Define() { if (!base.Define()) { return(false); } MetaType[] required_modifier = null; if ((ModFlags & Modifiers.VOLATILE) != 0) { var mod = Module.PredefinedTypes.IsVolatile.Resolve(); if (mod != null) { required_modifier = new MetaType[] { mod.GetMetaInfo() } } ; } FieldBuilder = Parent.TypeBuilder.DefineField( Name, member_type.GetMetaInfo(), required_modifier, null, ModifiersExtensions.FieldAttr(ModFlags)); spec = new FieldSpec(Parent.Definition, this, MemberType, FieldBuilder, ModFlags); // Don't cache inaccessible fields if ((ModFlags & Modifiers.BACKING_FIELD) == 0) { Parent.MemberCache.AddMember(spec); } if (initializer != null) { ((TypeContainer)Parent).RegisterFieldForInitialization(this, new FieldInitializer(spec, initializer, this)); } if (declarators != null) { var t = new TypeExpression(MemberType, TypeExpression.Location); int index = Parent.PartialContainer.Fields.IndexOf(this); foreach (var d in declarators) { var f = new Field(Parent, t, ModFlags, new MemberName(d.Name.Value, d.Name.Location), OptAttributes); if (d.Initializer != null) { f.initializer = d.Initializer; } Parent.PartialContainer.Fields.Insert(++index, f); } } /* * if ((ModFlags & (Modifiers.STATIC | Modifiers.READONLY | Modifiers.COMPILER_GENERATED)) == Modifiers.STATIC) * Console.WriteLine ("{0}: {1}", Location.ToString (), GetSignatureForError ()); */ return(true); }
/// <summary> /// Defines the constant in the @parent /// </summary> public override bool Define() { if (!base.Define()) { return(false); } if (!member_type.IsConstantCompatible) { Error_InvalidConstantType(member_type, Location, Report); } FieldAttributes field_attr = FieldAttributes.Static | ModifiersExtensions.FieldAttr(ModFlags); // Decimals cannot be emitted into the constant blob. So, convert to 'readonly'. if (member_type.BuiltinType == BuiltinTypeSpec.Type.Decimal) { field_attr |= FieldAttributes.InitOnly; } else { field_attr |= FieldAttributes.Literal; } FieldBuilder = Parent.TypeBuilder.DefineField(Name, MemberType.GetMetaInfo(), field_attr); spec = new ConstSpec(Parent.Definition, this, MemberType, FieldBuilder, ModFlags, initializer); Parent.MemberCache.AddMember(spec); if ((field_attr & FieldAttributes.InitOnly) != 0) { Parent.PartialContainer.RegisterFieldForInitialization(this, new FieldInitializer(this, initializer, Location)); } if (declarators != null) { foreach (var d in declarators) { var t = new TypeExpression(d.Type, TypeExpression.Location); var c = new Const(Parent, t, ModFlags & ~Modifiers.STATIC, new MemberName(d.Name.Value, d.Name.Location), OptAttributes); c.initializer = d.Initializer; if (d.Initializer is ConstInitializer) { ((ConstInitializer)d.Initializer).Field = c; } ((ConstInitializer)c.initializer).Name = d.Name.Value; c.Define(); Parent.PartialContainer.Members.Add(c); } } return(true); }
public override bool Define() { if (!base.Define()) { return(false); } if (!BuiltinTypeSpec.IsPrimitiveType(MemberType)) { Report.Error(1663, Location, "`{0}': Fixed size buffers type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double", GetSignatureForError()); } else if (declarators != null) { var t = new TypeExpression(MemberType, TypeExpression.Location); int index = Parent.PartialContainer.Fields.IndexOf(this); foreach (var d in declarators) { var f = new FixedField(Parent, t, ModFlags, new MemberName(d.Name.Value, d.Name.Location), OptAttributes); f.initializer = d.Initializer; ((ConstInitializer)f.initializer).Name = d.Name.Value; Parent.PartialContainer.Fields.Insert(++index, f); } } // Create nested fixed buffer container string name = String.Format("<{0}>__FixedBuffer{1}", Name, GlobalCounter++); fixed_buffer_type = Parent.TypeBuilder.DefineNestedType(name, TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, Compiler.BuiltinTypes.ValueType.GetMetaInfo()); var ffield = fixed_buffer_type.DefineField(FixedElementName, MemberType.GetMetaInfo(), FieldAttributes.Public); FieldBuilder = Parent.TypeBuilder.DefineField(Name, fixed_buffer_type, ModifiersExtensions.FieldAttr(ModFlags)); var element_spec = new FieldSpec(null, this, MemberType, ffield, ModFlags); spec = new FixedFieldSpec(Parent.Definition, this, FieldBuilder, element_spec, ModFlags); Parent.MemberCache.AddMember(spec); return(true); }
public FieldSpec DefineInitializedData(byte[] data, Location loc) { Struct size_type; if (!size_types.TryGetValue(data.Length, out size_type)) { // // Build common type for this data length. We cannot use // DefineInitializedData because it creates public type, // and its name is not unique among modules // size_type = new Struct(this, new MemberName("$ArrayType=" + data.Length, loc), Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED, null); size_type.CreateContainer(); size_type.DefineContainer(); size_types.Add(data.Length, size_type); // It has to work even if StructLayoutAttribute does not exist size_type.TypeBuilder.__SetLayout(1, data.Length); } var name = "$field-" + fields.ToString("X"); ++fields; const Modifiers fmod = Modifiers.STATIC | Modifiers.INTERNAL; var fbuilder = TypeBuilder.DefineField(name, size_type.CurrentType.GetMetaInfo(), ModifiersExtensions.FieldAttr(fmod) | FieldAttributes.HasFieldRVA); fbuilder.__SetDataAndRVA(data); return(new FieldSpec(CurrentType, null, size_type.CurrentType, fbuilder, fmod)); }
public FieldSpec DefineInitializedData(byte[] data, Location loc) { Struct size_type; if (!size_types.TryGetValue(data.Length, out size_type)) { // // Build common type for this data length. We cannot use // DefineInitializedData because it creates public type, // and its name is not unique among modules // size_type = new Struct(null, this, new MemberName("$ArrayType=" + data.Length, Location), Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED, null); size_type.CreateType(); size_type.DefineType(); size_types.Add(data.Length, size_type); var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve(Location); if (ctor != null) { var argsEncoded = new AttributeEncoder(); argsEncoded.Encode((short)LayoutKind.Explicit); var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve(Location); var pack = Module.PredefinedMembers.StructLayoutPack.Resolve(Location); if (field_size != null && pack != null) { argsEncoded.EncodeNamedArguments( new[] { field_size, pack }, new[] { new IntConstant(Compiler.BuiltinTypes, (int)data.Length, Location), new IntConstant(Compiler.BuiltinTypes, 1, Location) } ); size_type.TypeBuilder.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), argsEncoded.ToArray()); } } } var name = "$field-" + fields.ToString("X"); ++fields; const Modifiers fmod = Modifiers.STATIC | Modifiers.INTERNAL; var fbuilder = TypeBuilder.DefineField(name, size_type.CurrentType.GetMetaInfo(), ModifiersExtensions.FieldAttr(fmod) | FieldAttributes.HasFieldRVA); fbuilder.__SetDataAndRVA(data); return(new FieldSpec(CurrentType, null, size_type.CurrentType, fbuilder, fmod)); }
public FieldSpec DefineInitializedData(byte[] data, Location loc) { Struct size_type; if (!size_types.TryGetValue(data.Length, out size_type)) { // // Build common type for this data length. We cannot use // DefineInitializedData because it creates public type, // and its name is not unique among modules // size_type = new Struct(null, this, new MemberName("$ArrayType=" + data.Length, Location), Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED, null); size_type.CreateType(); size_type.DefineType(); size_types.Add(data.Length, size_type); var pa = Module.PredefinedAttributes.StructLayout; if (pa.Constructor != null || pa.ResolveConstructor(Location, TypeManager.short_type)) { var argsEncoded = new AttributeEncoder(); argsEncoded.Encode((short)LayoutKind.Explicit); var field_size = pa.GetField("Size", TypeManager.int32_type, Location); var pack = pa.GetField("Pack", TypeManager.int32_type, Location); if (field_size != null) { argsEncoded.EncodeNamedArguments( new[] { field_size, pack }, new[] { new IntConstant((int)data.Length, Location), new IntConstant(1, Location) } ); } pa.EmitAttribute(size_type.TypeBuilder, argsEncoded); } } var name = "$field-" + fields.ToString("X"); ++fields; const Modifiers fmod = Modifiers.STATIC | Modifiers.INTERNAL; var fbuilder = TypeBuilder.DefineField(name, size_type.CurrentType.GetMetaInfo(), ModifiersExtensions.FieldAttr(fmod) | FieldAttributes.HasFieldRVA); #if STATIC fbuilder.__SetDataAndRVA(data); #else if (set_data == null) { set_data = typeof(FieldBuilder).GetMethod("SetRVAData", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); } try { set_data.Invoke(fbuilder, new object[] { data }); } catch { Report.RuntimeMissingSupport(loc, "SetRVAData"); } #endif return(new FieldSpec(CurrentType, null, size_type.CurrentType, fbuilder, fmod)); }