private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 7001: fLichSX frm = new fLichSX(); frm.Text = si.MenuName; //frm.ShowDialog(); return(frm); case 7002: fNhapTP frm1 = new fNhapTP(); frm1.Text = si.MenuName; //frm.ShowDialog(); return(frm1); case 7003: fTaoPhieuXuatLSX frm2 = new fTaoPhieuXuatLSX(); frm2.Text = si.MenuName; //frm.ShowDialog(); return(frm2); } return(f); }
private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 5001: Coster cost = new Coster(); return(cost.Co); case 5002: UpdateddFilter f1 = new UpdateddFilter(); return(f1); //f.ShowDialog(); break; case 5003: CopyCondition fa = new CopyCondition(); return(fa); //fa.ShowDialog(); break; case 5004: CoPhanBoCP cocp = new CoPhanBoCP(); return(cocp); break; } return(f); }
public static TypeInfo GetTypeInfo(TypeSpec type, IMemberContext context) { if (!type.IsStruct) { return(simple_type); } TypeInfo info; if (type_hash.TryGetValue(type, out info)) { return(info); } var struct_info = StructInfo.GetStructInfo(type, context); if (struct_info != null) { info = new TypeInfo(struct_info, 0); } else { info = simple_type; } type_hash.Add(type, info); return(info); }
private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 7001: Filter frm = new Filter(); return(frm); //frm.Text = si.MenuName; //frm.ShowDialog(); break; case 7002: fKyHoaDon frm1 = new fKyHoaDon(); return(frm1); //frm.Text = si.MenuName; //frm.ShowDialog(); break; case 7003: fSelectMau frm2 = new fSelectMau(); return(frm2); } return(f); }
private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 16005: fRoomList RList = new fRoomList(); return(RList); case 16004: ReadCall rc = new ReadCall(); return(rc); case 16003: fTTPhong frm3 = new fTTPhong(); //frm.ShowDialog(); return(frm3); case 16002: fFO frm2 = new fFO(); //frm.ShowDialog(); return(frm2); case 16001: fPOS frm1 = new fPOS(); //frm.ShowDialog(); return(frm1); } return(f); }
private static StructInfo GetStructInfo(Type typeClass, Dictionary <string, StructInfo> allStructs, Dictionary <string, EnumInfo> allEnums) { var res = new StructInfo(); res.FullName = typeClass.FullName; res.Name = typeClass.Name; object defaultObject = Activator.CreateInstance(typeClass); PropertyInfo[] properties = typeClass.GetProperties(BindingFlags.Instance | BindingFlags.Public); foreach (PropertyInfo p in properties) { Type t = p.PropertyType; bool ignore = p.GetCustomAttribute <Ignore>() != null; if (ignore) { continue; } Dimension dim = GetDimensionFromPropertyType(t); if (t.IsGenericType) // Nullable or List { t = t.GetGenericArguments()[0]; } else if (t.IsArray) { t = t.GetElementType(); } DataType type = DataValue.TypeToDataType(t); string typeConstraints = ""; if (type == DataType.Enum || type == DataType.Struct) { typeConstraints = t.FullName; } if (type == DataType.Struct) { if (!allStructs.ContainsKey(t.FullName)) { allStructs[t.FullName] = new StructInfo(); allStructs[t.FullName] = GetStructInfo(t, allStructs, allEnums); } } else if (type == DataType.Enum) { if (!allEnums.ContainsKey(t.FullName)) { allEnums[t.FullName] = GetEnumInfo(t); } } object value = p.GetValue(defaultObject, null); DataValue?defaultValue = null; if (value != null) { defaultValue = DataValue.FromObject(value); } res.Member.Add(new SimpleMember(p.Name, type, typeConstraints, dim, defaultValue, false, "")); } return(res); }
public string ResolveNameConflict(UField field, string name) { UFunction function = field as UFunction; if (function != null) { // Functions are a special case and must use the base-most function for name resolving. // See above for more info on this. UFunction originalFunction; UClass originalOwner = codeGenerator.GetOriginalFunctionOwner(function, out originalFunction); if (originalOwner != Class) { StructInfo originalOwnerStructInfo = codeGenerator.GetStructInfo(originalOwner); return(originalOwnerStructInfo.ResolveNameConflict(originalFunction, name)); } } string resolvedName; if (conflictInfo.ResolvedName.TryGetValue(field, out resolvedName)) { return(resolvedName); } return(name); }
private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 7003: Filter frm = new Filter(); return(frm); break; case 7004: fNhapKho frm1 = new fNhapKho(); return(frm1); break; case 7005: fUpdateTile frm2 = new fUpdateTile(); return(frm2); break; case 7006: fUpdateGia frm3 = new fUpdateGia(); return(frm3); break; } return(f); }
/// <summary> /// Serialize struct to NetDataWriter (fast) /// </summary> /// <param name="writer">Serialization target NetDataWriter</param> /// <param name="obj">Struct to serialize</param> public void Serialize <T>(NetDataWriter writer, T obj) where T : class, new() { StructInfo info = RegisterInternal <T>(); _hasher.WriteHash(info.Hash, writer); info.Write(writer, obj); }
private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 3501: fTaoHoadon frm = new fTaoHoadon(); frm.Text = si.MenuName; //frm.ShowDialog(); return(frm); case 3502: fDieuXe frm1 = new fDieuXe(); frm1.Text = si.MenuName; //frm.ShowDialog(); return(frm1); case 3503: fTaoPhieuXuatLSX frm2 = new fTaoPhieuXuatLSX(); frm2.Text = si.MenuName; //frm.ShowDialog(); return(frm2); case 3504: fNhapTP frm3 = new fNhapTP(); frm3.Text = si.MenuName; //frm.ShowDialog(); return(frm3); } return(f); }
private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 1003: FormHTK frm = new FormHTK(); return(frm); case 1004: fKiemkedinhky frm1 = new fKiemkedinhky(); return(frm1); //frm.Text = si.MenuName; //frm.ShowDialog(); case 1005: fBtKhuKho frm2 = new fBtKhuKho(); return(frm2); //frm.Text = si.MenuName; //frm.ShowDialog(); case 1006: fTiendoduan frm3 = new fTiendoduan(); return(frm3); case 1007: fTiendoThanhtoan frm4 = new fTiendoThanhtoan(); return(frm4); } return(f); }
public static bool SupportsType(Type type) { if (!type.IsValueType || string.IsNullOrEmpty(type.AssemblyQualifiedName) || type.FullName == SYSTEM_VOID) { return(false); } if (typeSupportCache.TryGetValue(type.AssemblyQualifiedName, out var info)) { return(info.IsSupported); } var supported = false; var fields = type.GetFields(INSTANCE_FLAGS); if (fields.Length > 0) { if (fields.Any(it => !ParseUtility.CanParse(it.FieldType))) { supported = false; info = new StructInfo(supported, null); } else { supported = true; info = new StructInfo(supported, fields); } } typeSupportCache.Add(type.AssemblyQualifiedName, info); return(supported); }
private JObject?GetStructDefaultValue(SimpleMember m) { if (m.Type != DataType.Struct) { return(null); } string structName = m.TypeConstraints; StructInfo structInfo = structTypes[structName]; JObject obj = new JObject(); foreach (var sm in structInfo.Member) { string dv; if (sm.DefaultValue.HasValue) { dv = sm.DefaultValue.Value.JSON; } else if (sm.Dimension == Dimension.Optional) { dv = "null"; } else { dv = DataValue.FromDataType(sm.Type, 1).JSON; } obj[sm.Name] = new JRaw(dv); } return(obj); }
} // <Member, ResolvedName> public NameConflictInfo(StructInfo structInfo) { this.structInfo = structInfo; BaseMembersByName = new Dictionary <string, NameConflictFieldInfo>(); MembersByName = new Dictionary <string, NameConflictFieldInfo>(); ResolvedName = new Dictionary <UField, string>(); }
TypeInfo(StructInfo struct_info, int offset) { this.struct_info = struct_info; this.Offset = offset; this.Length = struct_info.Length; this.TotalLength = struct_info.TotalLength; this.SubStructInfo = struct_info.StructFields; this.IsStruct = true; }
public EocStruct(ProjectConverter p, StructInfo rawInfo) { P = p ?? throw new ArgumentNullException(nameof(p)); RawInfo = rawInfo ?? throw new ArgumentNullException(nameof(rawInfo)); Name = P.GetUserDefinedName_SimpleCppName(RawInfo.Id); RawName = "raw_" + Name; RawCppName = $"{P.TypeNamespace}::eoc_internal::{RawName}"; CppName = P.GetCppTypeName(rawInfo.Id).ToString(); }
TypeInfo (StructInfo struct_info, int offset) { this.struct_info = struct_info; this.Offset = offset; this.Length = struct_info.Length; this.TotalLength = struct_info.TotalLength; this.SubStructInfo = struct_info.StructFields; this.IsStruct = true; }
public static void StructType(INamedTypeSymbol symbol) { var nfo = StructInfo.FromSymbol(symbol); Test.Assert(nfo.TypeInfo.AsStruct() != null, "Type should be convertable to struct."); Test.Assert(nfo.TypeInfo.Kind == CodeGeneration.CSharp.TypeInfo.TypeKind.Struct, "Type kind should be 'Struct'"); Test.Assert(nfo.DataTypeInfo != null, "DataTypeInfo must not be null."); Test.Assert(nfo.DataTypeInfo.TypeInfo.Name == "StructType", "Struct name was wrongly detected."); }
/// <summary> /// Register and subscribe to packet receive event /// This metod will overwrite last received packet class on receive (less garbage) /// </summary> /// <param name="onReceive">event that will be called when packet deserialized with ReadPacket method</param> public void SubscribeReusable <T, TUserData>(Action <T, TUserData> onReceive) where T : class, new() { StructInfo structInfo = RegisterInternal <T>(); structInfo.Reference = new T(); structInfo.OnReceive = delegate(object o, object userData) { onReceive((T)o, (TUserData)userData); }; }
private void ExecuteFunctions(StructInfo si) { switch (si.MenuId) { case 6000: TicketPrint frm = new TicketPrint(); frm.ShowDialog(); break; } }
/// <summary> /// Register and subscribe to packet receive event (with userData) /// </summary> /// <param name="onReceive">event that will be called when packet deserialized with ReadPacket method</param> /// <param name="packetConstructor">Method that constructs packet intead of slow Activator.CreateInstance</param> public void Subscribe <T, TUserData>(Action <T, TUserData> onReceive, Func <T> packetConstructor) where T : class, new() { StructInfo structInfo = RegisterInternal <T>(); structInfo.CreatorFunc = (() => packetConstructor()); structInfo.OnReceive = delegate(object o, object userData) { onReceive((T)o, (TUserData)userData); }; }
private void ExecuteFunctions(StructInfo si) { switch (si.MenuId) { case 10001: Filter f = new Filter(); f.ShowDialog(); break; } }
/// <summary>Assigns given struct variable. Returs ture if the info was already defined.</summary> public static bool getDefinition(Type t, out StructInfo info) { if (structs.ContainsKey(t)) { info = structs[t]; return(true); } info = new StructInfo(); structs.Add(t, info); return(false); }
private StructInfo GetStructInfo(UStruct unrealStruct, bool isBlueprintType) { StructInfo structInfo; if (structInfos.TryGetValue(unrealStruct, out structInfo)) { return(structInfo); } structInfo = new StructInfo(this, unrealStruct, isBlueprintType); foreach (UFunction function in unrealStruct.GetFields <UFunction>(false, true, true)) { // We need to include interface functions as otherwise some interface functions wont be implemented. // If the interface function already has an implementation skip that function (as otherwise there will be duplicates). if (!structInfo.IsClass || !function.GetOwnerClass().IsChildOf <UInterface>() || structInfo.Class.FindFunctionByName(function.GetFName(), true).GetOwnerClass().IsChildOf <UInterface>()) { structInfo.AddFunction(function, CanExportFunction(function, isBlueprintType)); } } if (isBlueprintType) { UUserDefinedStruct userDefinedStruct = unrealStruct as UUserDefinedStruct; if (userDefinedStruct != null) { Dictionary <UProperty, string> variableNames = GetStructBPVariableNames(userDefinedStruct); foreach (UProperty property in unrealStruct.GetFields <UProperty>(false)) { structInfo.AddProperty(property, variableNames[property], CanExportProperty(property, unrealStruct, isBlueprintType)); } } else { foreach (UProperty property in unrealStruct.GetProperties <UProperty>(false)) { structInfo.AddProperty(property, null, CanExportProperty(property, unrealStruct, isBlueprintType)); } } } else { foreach (UProperty property in unrealStruct.GetFields <UProperty>(false)) { structInfo.AddProperty(property, null, CanExportProperty(property, unrealStruct, isBlueprintType)); } } structInfo.ResolveCollapsedMembers(); structInfo.PostProcess(); structInfos.Add(unrealStruct, structInfo); return(structInfo); }
/// <summary> /// Reads one packet from NetDataReader and calls OnReceive delegate /// </summary> /// <param name="reader">NetDataReader with packet</param> /// <param name="userData">Argument that passed to OnReceivedEvent</param> public void ReadPacket(NetDataReader reader, object userData) { StructInfo info = ReadInfo(reader); if (info.CreatorFunc != null) { info.Reference = info.CreatorFunc(); } info.Read(reader); info.OnReceive(info.Reference, userData); }
/// <summary> /// Sets the IsValid state for the given struct based on the state of all properties IsValid state /// (used when generating with safeguards enabled) /// </summary> private void AppendStructIsValid(CSharpTextBuilder builder, string structTypeName, StructInfo structInfo, UStruct parentStruct) { if (!Settings.GenerateIsValidSafeguards) { return; } List <UProperty> allProperties = new List <UProperty>(); foreach (UProperty property in structInfo.GetProperties()) { if (!structInfo.IsCollapsedProperty(property)) { allProperties.Add(property); } } if (parentStruct != null && (Settings.InlineBaseStruct || structInfo.StructAsClass)) { UScriptStruct tempParentStruct = parentStruct as UScriptStruct; while (tempParentStruct != null) { StructInfo tempParentStructInfo = GetStructInfo(tempParentStruct); if (tempParentStructInfo != null) { foreach (UProperty property in tempParentStructInfo.GetProperties()) { if (!tempParentStructInfo.IsCollapsedProperty(property)) { allProperties.Add(property); } } } tempParentStruct = tempParentStruct.GetSuperStruct() as UScriptStruct; } } StringBuilder isValidCheck = new StringBuilder(); isValidCheck.Append(Settings.VarNames.ClassAddress + " != IntPtr.Zero"); foreach (UProperty property in allProperties) { string propertyName = GetMemberName(property, structInfo.GetPropertyName(property)); isValidCheck.Append(" && " + propertyName + Settings.VarNames.IsValid); } isValidCheck.Insert(0, structTypeName + Settings.VarNames.IsValid + " = "); isValidCheck.Append(";"); builder.AppendLine(isValidCheck.ToString()); builder.AppendLine(Names.NativeReflection_LogStructIsValid + "(\"" + structInfo.Struct.GetPathName() + "\", " + structTypeName + Settings.VarNames.IsValid + ");"); }
/// <summary> /// Reads packet with known type /// </summary> /// <param name="reader">NetDataReader with packet</param> /// <returns>Returns packet if packet in reader is matched type</returns> public T ReadKnownPacket <T>(NetDataReader reader) where T : class, new() { StructInfo info = ReadInfo(reader); if (_hasher.GetHash(typeof(T).Name) != info.Hash) { return(null); } info.Reference = ((info.CreatorFunc != null) ? info.CreatorFunc() : new T()); info.Read(reader); return((T)info.Reference); }
// // We only need one instance per type // StructInfo(TypeSpec type, IMemberContext context) { field_type_hash.Add(type, this); fields = MemberCache.GetAllFieldsForDefiniteAssignment(type, context); struct_field_hash = new Dictionary <string, TypeInfo> (); field_hash = new Dictionary <string, int> (fields.Count); StructFields = new TypeInfo[fields.Count]; StructInfo[] sinfo = new StructInfo[fields.Count]; InTransit = true; for (int i = 0; i < fields.Count; i++) { var field = fields [i]; if (field.MemberType.IsStruct) { sinfo [i] = GetStructInfo(field.MemberType, context); } if (sinfo [i] == null) { field_hash.Add(field.Name, ++Length); } else if (sinfo [i].InTransit) { sinfo [i] = null; return; } } InTransit = false; TotalLength = Length + 1; for (int i = 0; i < fields.Count; i++) { var field = fields [i]; if (sinfo [i] == null) { continue; } field_hash.Add(field.Name, TotalLength); StructFields [i] = new TypeInfo(sinfo [i], TotalLength); struct_field_hash.Add(field.Name, StructFields [i]); TotalLength += sinfo [i].TotalLength; } }
/// <summary> /// Reads packet with known type (non alloc variant) /// </summary> /// <param name="reader">NetDataReader with packet</param> /// <param name="target">Deserialization target</param> /// <returns>Returns true if packet in reader is matched type</returns> public bool ReadKnownPacket <T>(NetDataReader reader, T target) where T : class, new() { StructInfo info = ReadInfo(reader); if (_hasher.GetHash(typeof(T).Name) != info.Hash) { return(false); } info.Reference = target; info.Read(reader); return(true); }
/// <summary> /// Register packet type for direct reading (ReadKnownPacket) /// </summary> /// <param name="packetConstructor">Method that constructs packet intead of slow Activator.CreateInstance</param> public void Register <T>(Func <T> packetConstructor = null) where T : class, new() { StructInfo info = RegisterInternal <T>(); if (packetConstructor != null) { info.CreatorFunc = (() => packetConstructor()); } info.OnReceive = delegate { }; }
private Form ExecuteFunctions(StructInfo si) { Form f = new Form(); switch (si.MenuId) { case 3500: fPhanboHoaDon frm = new fPhanboHoaDon(); frm.Text = si.MenuName; //frm.ShowDialog(); return(frm); } return(f); }
private IEnumerable<IEmitVal> DeclareInputElementsImpl( IEmitBlock block, string name, StructInfo info) { foreach (var f in info.Fields) { var fieldElements = (DeclareInputElements( block, name, f.Info)).ToArray(); foreach (var fe in fieldElements) yield return fe; } }
// Private constructor. To save memory usage, we only need to create one instance // of this class per struct type. private StructInfo (TypeSpec type) { this.Type = type; field_type_hash.Add (type, this); fields = MemberCache.GetAllFieldsForDefiniteAssignment (type); struct_field_hash = new Dictionary<string, TypeInfo> (); field_hash = new Dictionary<string, int> (fields.Count); StructFields = new TypeInfo[fields.Count]; StructInfo[] sinfo = new StructInfo[fields.Count]; InTransit = true; for (int i = 0; i < fields.Count; i++) { var field = fields [i]; if (field.MemberType.IsStruct) sinfo [i] = GetStructInfo (field.MemberType); if (sinfo [i] == null) field_hash.Add (field.Name, ++Length); else if (sinfo [i].InTransit) { sinfo [i] = null; return; } } InTransit = false; TotalLength = Length + 1; for (int i = 0; i < fields.Count; i++) { var field = fields [i]; if (sinfo [i] == null) continue; field_hash.Add (field.Name, TotalLength); StructFields [i] = new TypeInfo (sinfo [i], TotalLength); struct_field_hash.Add (field.Name, StructFields [i]); TotalLength += sinfo [i].TotalLength; } }
// Private constructor. To save memory usage, we only need to create one instance // of this class per struct type. private StructInfo (TypeSpec type) { this.Type = type; field_type_hash.Add (type, this); TypeContainer tc = type.MemberDefinition as TypeContainer; var public_fields = new List<FieldSpec> (); var non_public_fields = new List<FieldSpec> (); if (tc != null) { var fields = tc.Fields; if (fields != null) { foreach (FieldBase field in fields) { if ((field.ModFlags & Modifiers.STATIC) != 0) continue; if ((field.ModFlags & Modifiers.PUBLIC) != 0) public_fields.Add (field.Spec); else non_public_fields.Add (field.Spec); } } } CountPublic = public_fields.Count; CountNonPublic = non_public_fields.Count; Count = CountPublic + CountNonPublic; Fields = new FieldSpec[Count]; public_fields.CopyTo (Fields, 0); non_public_fields.CopyTo (Fields, CountPublic); struct_field_hash = new Dictionary<string, TypeInfo> (); field_hash = new Dictionary<string, int> (); Length = 0; StructFields = new TypeInfo [Count]; StructInfo[] sinfo = new StructInfo [Count]; InTransit = true; for (int i = 0; i < Count; i++) { var field = Fields [i]; sinfo [i] = GetStructInfo (field.MemberType); if (sinfo [i] == null) field_hash.Add (field.Name, ++Length); else if (sinfo [i].InTransit) { sinfo [i] = null; return; } } InTransit = false; TotalLength = Length + 1; for (int i = 0; i < Count; i++) { var field = Fields [i]; if (sinfo [i] == null) continue; field_hash.Add (field.Name, TotalLength); HasStructFields = true; StructFields [i] = new TypeInfo (sinfo [i], TotalLength); struct_field_hash.Add (field.Name, StructFields [i]); TotalLength += sinfo [i].TotalLength; } }
private TypeInfo (TypeSpec type) { this.Type = type; struct_info = StructInfo.GetStructInfo (type); if (struct_info != null) { Length = struct_info.Length; TotalLength = struct_info.TotalLength; SubStructInfo = struct_info.StructFields; IsStruct = true; } else { Length = 0; TotalLength = 1; IsStruct = false; } }
private TypeInfo (TypeContainer tc) { this.Type = tc.TypeBuilder; struct_info = StructInfo.GetStructInfo (tc); if (struct_info != null) { Length = struct_info.Length; TotalLength = struct_info.TotalLength; SubStructInfo = struct_info.StructFields; IsStruct = true; } else { Length = 0; TotalLength = 1; IsStruct = false; } }
// Private constructor. To save memory usage, we only need to create one instance // of this class per struct type. private StructInfo (Type type) { this.Type = type; field_type_hash.Add (type, this); if (type.Module == CodeGen.Module.Builder) { TypeContainer tc = TypeManager.LookupTypeContainer (TypeManager.DropGenericTypeArguments (type)); ArrayList public_fields = new ArrayList (); ArrayList non_public_fields = new ArrayList (); // // TODO: tc != null is needed because FixedBuffers are not cached // if (tc != null) { ArrayList fields = tc.Fields; if (fields != null) { foreach (FieldBase field in fields) { if ((field.ModFlags & Modifiers.STATIC) != 0) continue; if ((field.ModFlags & Modifiers.PUBLIC) != 0) public_fields.Add (field.FieldBuilder); else non_public_fields.Add (field.FieldBuilder); } } if (tc.Events != null) { foreach (Event e in tc.Events) { if ((e.ModFlags & Modifiers.STATIC) != 0) continue; EventField ef = e as EventField; if (ef == null) continue; if ((ef.ModFlags & Modifiers.PUBLIC) != 0) public_fields.Add (ef.FieldBuilder); else non_public_fields.Add (ef.FieldBuilder); } } } CountPublic = public_fields.Count; CountNonPublic = non_public_fields.Count; Count = CountPublic + CountNonPublic; Fields = new FieldInfo [Count]; public_fields.CopyTo (Fields, 0); non_public_fields.CopyTo (Fields, CountPublic); #if GMCS_SOURCE } else if (type is GenericTypeParameterBuilder) { CountPublic = CountNonPublic = Count = 0; Fields = new FieldInfo [0]; #endif } else { FieldInfo[] public_fields = type.GetFields ( BindingFlags.Instance|BindingFlags.Public); FieldInfo[] non_public_fields = type.GetFields ( BindingFlags.Instance|BindingFlags.NonPublic); CountPublic = public_fields.Length; CountNonPublic = non_public_fields.Length; Count = CountPublic + CountNonPublic; Fields = new FieldInfo [Count]; public_fields.CopyTo (Fields, 0); non_public_fields.CopyTo (Fields, CountPublic); } struct_field_hash = new Hashtable (); field_hash = new Hashtable (); Length = 0; StructFields = new TypeInfo [Count]; StructInfo[] sinfo = new StructInfo [Count]; InTransit = true; for (int i = 0; i < Count; i++) { FieldInfo field = (FieldInfo) Fields [i]; sinfo [i] = GetStructInfo (field.FieldType); if (sinfo [i] == null) field_hash.Add (field.Name, ++Length); else if (sinfo [i].InTransit) { Report.Error (523, String.Format ( "Struct member `{0}.{1}' of type `{2}' causes " + "a cycle in the structure layout", type, field.Name, sinfo [i].Type)); sinfo [i] = null; return; } } InTransit = false; TotalLength = Length + 1; for (int i = 0; i < Count; i++) { FieldInfo field = (FieldInfo) Fields [i]; if (sinfo [i] == null) continue; field_hash.Add (field.Name, TotalLength); HasStructFields = true; StructFields [i] = new TypeInfo (sinfo [i], TotalLength); struct_field_hash.Add (field.Name, StructFields [i]); TotalLength += sinfo [i].TotalLength; } }