internal TcAdsSymbolInfo CreateReferenceSymbol(TcAdsSymbolInfo parent, int subIndex) { if (parent == null) { throw new ArgumentNullException("parent"); } TcAdsSymbolInfo subSymbol = null; if (subIndex == 0) { TcAdsDataType dataType = (TcAdsDataType)parent.DataType; string referencedType = string.Empty; if (DataTypeStringParser.TryParseReference(parent.DataType.Name, out referencedType)) { TcAdsDataType typeByName = (TcAdsDataType)this._parser.GetTypeByName(referencedType); if (typeByName != null) { subSymbol = new TcAdsSymbolInfo(this._parser, parent, subIndex, typeByName); this.calcFieldAddress(parent, subSymbol, null, out subSymbol.indexGroup, out subSymbol.indexOffset); } else { object[] args = new object[] { referencedType }; Module.Trace.TraceWarning("Cannot create Reference Symbol. Dereferenced Type '{0}' not found!", args); } } } return(subSymbol); }
protected override int OnMarshalParameter(int i, RpcMethodParameterCollection inParameters, IList <IDataType> inParameterTypes, object[] parameterValues, byte[] buffer, int offset) { ITcAdsDataType type = (ITcAdsDataType)inParameterTypes[i]; object val = parameterValues[i]; AdsDatatypeId dataTypeId = type.DataTypeId; int num = 0; if (PrimitiveTypeConverter.CanMarshal(type.Category)) { byte[] data = null; PrimitiveTypeConverter.Marshal(dataTypeId, val, out data); num = copyHelper(buffer, offset, data); } else { if (type.Category != DataTypeCategory.String) { throw new MarshalException($"Cannot marshal complex type '{type.Name}'"); } int length = -1; bool isUnicode = false; DataTypeStringParser.TryParseString(type.Name, out length, out isUnicode); string str = (string)val; byte[] source = null; PlcStringConverter converter = isUnicode ? PlcStringConverter.UnicodeVariableLength : PlcStringConverter.DefaultVariableLength; if (converter.MarshalSize(str) > type.ByteSize) { throw new MarshalException("String size mismatch"); } source = converter.Marshal(str); num = copyHelper(buffer, offset, source); } return(num); }
internal ITcAdsDataType ResolveType(ITcAdsDataType dataType, DataTypeResolveStrategy strategy) { ITcAdsDataType ret = dataType; if (strategy == DataTypeResolveStrategy.Alias) { while ((ret != null) && (ret.Category == DataTypeCategory.Alias)) { this.TryGetDataType(ret.BaseTypeName, out ret); } } else if (strategy == DataTypeResolveStrategy.AliasReference) { while ((ret != null) && ((ret.Category == DataTypeCategory.Alias) || (ret.Category == DataTypeCategory.Reference))) { if (ret.Category == DataTypeCategory.Alias) { this.TryGetDataType(ret.BaseTypeName, out ret); } else { string str; if (DataTypeStringParser.TryParseReference(ret.Name, out str)) { this.TryGetDataType(str, out ret); } else { ret = null; } } } } return(ret); }
internal static DataTypeCategory FromId(AdsDatatypeId id, string typeName) { DataTypeCategory pointer = FromId(id); if (!string.IsNullOrEmpty(typeName) && (pointer == DataTypeCategory.Unknown)) { if (DataTypeStringParser.IsPointer(typeName)) { pointer = DataTypeCategory.Pointer; } else if (DataTypeStringParser.IsReference(typeName)) { pointer = DataTypeCategory.Reference; } else if (DataTypeStringParser.IsArray(typeName)) { pointer = DataTypeCategory.Array; } else if (DataTypeStringParser.IsSubRange(typeName)) { pointer = DataTypeCategory.SubRange; } else if (DataTypeStringParser.IsIntrinsicType(typeName)) { pointer = DataTypeCategory.Primitive; } else if (DataTypeStringParser.IsString(typeName)) { pointer = DataTypeCategory.String; } } return(pointer); }
private int GetSizeByName(string type) { ITcAdsDataType typeByName = this.GetTypeByName(type); if (typeByName != null) { return(typeByName.Size); } ITcAdsDataType type3 = null; if ((this._defaultTypes != null) && this._defaultTypes.TryGetDataType(type, out type3)) { return(type3.Size); } int length = -1; bool isUnicode = false; if (DataTypeStringParser.TryParseString(type, out length, out isUnicode)) { int num2 = 1; if (isUnicode) { num2 = 2; } length = (length + 1) * num2; } return(length); }
public IDataType ResolveType(DataTypeResolveStrategy type) { TcAdsDataType baseType = this; TcAdsDataType type3 = this; if (type == DataTypeResolveStrategy.Alias) { while (true) { if ((baseType == null) || (baseType.Category != DataTypeCategory.Alias)) { if ((baseType == null) && (this.Category == DataTypeCategory.Alias)) { object[] args = new object[] { type3.Name }; Module.Trace.TraceWarning("Cannot resolve type '{0}", args); } break; } type3 = baseType; baseType = (TcAdsDataType)baseType.BaseType; } } else if (type == DataTypeResolveStrategy.AliasReference) { while (true) { if ((baseType == null) || ((baseType.Category != DataTypeCategory.Alias) && (baseType.Category != DataTypeCategory.Reference))) { if ((baseType == null) && ((this.Category == DataTypeCategory.Alias) || (this.Category == DataTypeCategory.Reference))) { object[] args = new object[] { type3.Name }; Module.Trace.TraceWarning("Cannot resolve type '{0}", args); } break; } if (baseType.Category == DataTypeCategory.Alias) { type3 = baseType; baseType = (TcAdsDataType)baseType.BaseType; } else { string str; if (!DataTypeStringParser.TryParseReference(baseType.Name, out str)) { type3 = baseType; baseType = null; } else { type3 = baseType; IDataType type4 = null; this._table.TryResolveType(str, out type4); baseType = (TcAdsDataType)type4; } } } } return(baseType); }
internal TcAdsSymbolInfo GetSubSymbol(TcAdsSymbolInfo parent, int subIndex, bool dereference) { if (parent == null) { throw new ArgumentNullException("parent"); } TcAdsSymbolInfo info = null; try { ITcAdsDataType dataType = parent.DataType; ITcAdsDataType type2 = null; if (dataType != null) { type2 = (ITcAdsDataType)dataType.ResolveType(DataTypeResolveStrategy.AliasReference); } if (type2 != null) { int count = parent.SubSymbols.Count; if (((type2 != null) && (type2.SubItems.Count > 0)) && (subIndex < type2.SubItems.Count)) { info = this._subSymbolFactory.CreateSubSymbol(parent, subIndex); } else if ((type2 != null) && ((type2.Dimensions.Count > 0) || DataTypeStringParser.IsArray(type2.Name))) { info = this._subSymbolFactory.CreateArrayElement(parent, (TcAdsDataType)type2, subIndex); } else if ((type2 != null) && type2.IsReference) { this.SetPlatformPointerSize(type2.Size); } else if ((subIndex == 0) && type2.IsPointer) { this.SetPlatformPointerSize(type2.Size); if (dereference) { string str; DataTypeStringParser.TryParsePointer(type2.Name, out str); TcAdsDataType referencedType = (TcAdsDataType)this.ResolveDataType(str); if ((referencedType != null) & dereference) { bool flag = (referencedType.Flags & AdsDataTypeFlags.AnySizeArray) == AdsDataTypeFlags.AnySizeArray; if ((referencedType.Size > 0) | flag) { info = this._subSymbolFactory.CreatePointerSymbol(parent, referencedType); } } } } } } catch (Exception exception) { Module.Trace.TraceError($"ParentSymbol: {parent.Name}", exception); throw; } return(info); }
private static bool TryParseSubRange(IDataType baseType, TypeAttributeCollection attributes, IBinder binder, out ISubRangeType subRange) { string str; string str2; if (((attributes != null) && ((attributes.Count >= 2) && (baseType.Category == DataTypeCategory.Primitive))) && (attributes.TryGetValue("LowerBorder", out str2) & attributes.TryGetValue("UpperBorder", out str))) { object obj2; object obj3; IManagedMappableType type = (IManagedMappableType)baseType; System.Type managedType = type.ManagedType; System.Type type3 = type.ManagedType; if (managedType == typeof(byte)) { type3 = typeof(sbyte); } else if (managedType == typeof(ushort)) { type3 = typeof(short); } else if (managedType == typeof(uint)) { type3 = typeof(int); } else if (managedType == typeof(ulong)) { type3 = typeof(long); } if (DataTypeStringParser.TryParse(str, type3, out obj3) & DataTypeStringParser.TryParse(str2, type3, out obj2)) { object obj4; object obj5; if (managedType == type3) { obj4 = obj2; obj5 = obj3; } else { PrimitiveTypeConverter converter = PrimitiveTypeConverter.Default; byte[] data = converter.Marshal(obj2); byte[] buffer2 = converter.Marshal(obj3); converter.UnmarshalPrimitive(managedType, data, 0, data.Length, out obj4); converter.UnmarshalPrimitive(managedType, buffer2, 0, buffer2.Length, out obj5); } string name = $"{baseType.Name} ({obj4}..{obj5})"; IDataType type4 = null; if (binder.TryResolveType(name, out type4)) { subRange = (ISubRangeType)type4; return(true); } } } subRange = null; return(false); }
public bool TryGetReference(out string referencedType) { ITcAdsDataType type = this.ResolveType(DataTypeResolveStrategy.AliasReference); string typeName = this.typeName; if (type != null) { typeName = type.Name; } return(DataTypeStringParser.TryParseReference(typeName, out referencedType)); }
public bool TryResolveType(string name, out IDataType ret) { if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException("typeName"); } ITcAdsDataType type = null; if ((this._dataTypes != null) && !this._dataTypes.TryGetDataType(name, out type)) { int length = 0; bool isUnicode = false; AdsDatatypeArrayInfo[] dims = null; if (DataTypeStringParser.TryParseString(name, out length, out isUnicode)) { AdsDatatypeId dataType = isUnicode ? AdsDatatypeId.ADST_WSTRING : AdsDatatypeId.ADST_STRING; type = new TcAdsDataType(name, dataType, isUnicode ? ((uint)((length + 1) * 2)) : ((uint)(length + 1)), AdsDataTypeFlags.DataType, DataTypeCategory.String, typeof(string), this); } else { string str; if (DataTypeStringParser.TryParsePointer(name, out str)) { ITcAdsDataType type2 = (ITcAdsDataType)this.ResolveDataType(str); type = new TcAdsDataType(name, AdsDatatypeId.ADST_BIGTYPE, (uint)this.PlatformPointerSize, AdsDataTypeFlags.DataType, DataTypeCategory.Pointer, null, this); } else if (DataTypeStringParser.TryParseReference(name, out str)) { ITcAdsDataType type3 = (ITcAdsDataType)this.ResolveDataType(str); type = new TcAdsDataType(name, AdsDatatypeId.ADST_BIGTYPE, (uint)this.PlatformPointerSize, AdsDataTypeFlags.DataType, DataTypeCategory.Reference, null, this); } else if (DataTypeStringParser.TryParseArray(name, out dims, out str)) { ITcAdsDataType type4 = (ITcAdsDataType)this.ResolveDataType(str); if (type4 != null) { type = new TcAdsDataType(name, str, (uint)type4.Size, dims, this); } } } if (type == null) { this.OnTypeResolveError(name); } else { this._dataTypes.Add(type); this.OnTypeCreated(type); } } ret = type; return(ret != null); }
internal static ISubRangeType Create(string name, IDataTypeResolver resolver) { string baseType = null; if (DataTypeStringParser.TryParseSubRange(name, out baseType)) { IDataType type = null; if (resolver.TryResolveType(baseType, out type)) { Create(name, type); } } return(null); }
internal static ISubRangeType Create(AdsDataTypeEntry entry, IDataTypeResolver resolver) { ISubRangeType type = null; string baseType = null; if (DataTypeStringParser.TryParseSubRange(entry.entryName, out baseType)) { IDataType type2 = null; if (resolver.TryResolveType(baseType, out type2)) { type = Create(entry.entryName, type2); } } return(type); }
private AdsDatatypeId GetDataTypeId(string type) { ITcAdsDataType typeByName = this.GetTypeByName(type); if (typeByName != null) { return(typeByName.DataTypeId); } ITcAdsDataType type3 = null; if ((this._defaultTypes != null) && this._defaultTypes.TryGetDataType(type, out type3)) { return(type3.DataTypeId); } int length = -1; bool isUnicode = false; return(!DataTypeStringParser.TryParseString(type, out length, out isUnicode) ? AdsDatatypeId.ADST_BIGTYPE : (!isUnicode ? AdsDatatypeId.ADST_STRING : AdsDatatypeId.ADST_WSTRING)); }
public ArrayType(AdsDataTypeEntry entry) : base(DataTypeCategory.Array, entry) { string str2; AdsDatatypeArrayInfo[] arrayInfos = entry.arrayInfos; AdsDatatypeArrayInfo[] dims = null; AdsDatatypeArrayInfo[] infoArray3 = null; string baseType = null; if (DataTypeStringParser.TryParseArray(base.name, out dims, out baseType) && DataTypeStringParser.TryParseArray(baseType, out infoArray3, out str2)) { this._dimensions = new DimensionCollection(dims); this.elementTypeName = baseType; this.elementTypeId = entry.baseTypeId; } else { this._dimensions = new DimensionCollection(arrayInfos); this.elementTypeName = entry.typeName; this.elementTypeId = entry.baseTypeId; } this._oversampled = (entry.flags & (AdsDataTypeFlags.None | AdsDataTypeFlags.Oversample)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.Oversample); }
private static ISubRangeType Create(string name, IDataType baseType) { ISubRangeType type = null; string str; Type managedType = ((IManagedMappableType)baseType).ManagedType; if (managedType == typeof(sbyte)) { sbyte num; sbyte num2; DataTypeStringParser.TryParseSubRange <sbyte>(name, out str, out num, out num2); type = new SubRangeType <sbyte>(name, baseType.Name, 1, num, num2); } else if (managedType == typeof(byte)) { byte num3; byte num4; DataTypeStringParser.TryParseSubRange <byte>(name, out str, out num3, out num4); type = new SubRangeType <byte>(name, baseType.Name, 1, num3, num4); } else if (managedType == typeof(short)) { short num5; short num6; DataTypeStringParser.TryParseSubRange <short>(name, out str, out num5, out num6); type = new SubRangeType <short>(name, baseType.Name, 2, num5, num6); } else if (managedType == typeof(ushort)) { ushort num7; ushort num8; DataTypeStringParser.TryParseSubRange <ushort>(name, out str, out num7, out num8); type = new SubRangeType <ushort>(name, baseType.Name, 2, num7, num8); } else if (managedType == typeof(int)) { int num9; int num10; DataTypeStringParser.TryParseSubRange <int>(name, out str, out num9, out num10); type = new SubRangeType <int>(name, baseType.Name, 4, num9, num10); } else if (managedType == typeof(uint)) { uint num11; uint num12; DataTypeStringParser.TryParseSubRange <uint>(name, out str, out num11, out num12); type = new SubRangeType <uint>(name, baseType.Name, 4, num11, num12); } else if (managedType == typeof(long)) { long num13; long num14; DataTypeStringParser.TryParseSubRange <long>(name, out str, out num13, out num14); type = new SubRangeType <long>(name, baseType.Name, 8, num13, num14); } else { ulong num15; ulong num16; if (managedType != typeof(ulong)) { throw new AdsException($"Could not create range type '{name}'"); } DataTypeStringParser.TryParseSubRange <ulong>(name, out str, out num15, out num16); type = new SubRangeType <ulong>(name, baseType.Name, 8, num15, num16); } return(type); }
internal static bool TryParseType(string typeName, IBinder resolver, out IDataType type) { if (typeName == null) { throw new ArgumentNullException("typeName"); } if (resolver == null) { throw new ArgumentNullException("resolver"); } if (typeName == string.Empty) { throw new ArgumentException(); } DataType type2 = null; int length = -1; bool isUnicode = false; if (DataTypeStringParser.TryParseString(typeName, out length, out isUnicode)) { type2 = !isUnicode ? ((DataType) new StringType(length)) : ((DataType) new WStringType(length)); resolver.RegisterType(type2); resolver.OnTypeGenerated(type2); type = type2; return(true); } DimensionCollection dims = null; string baseType = null; if (DataTypeStringParser.TryParseArray(typeName, out dims, out baseType)) { IDataType type3 = null; if (resolver.TryResolveType(baseType, out type3)) { type2 = new ArrayType(typeName, (DataType)type3, dims, AdsDataTypeFlags.DataType); resolver.RegisterType(type2); resolver.OnTypeGenerated(type2); type = type2; return(true); } resolver.OnTypeResolveError(typeName); object[] args = new object[] { typeName }; Module.Trace.TraceWarning("Array Type '{0}' could not be resolved. Not in DataType tables. Ignoring Type!", args); type = null; return(false); } string referencedType = null; if (DataTypeStringParser.TryParsePointer(typeName, out referencedType)) { type2 = new PointerType(typeName, referencedType); resolver.RegisterType(type2); resolver.OnTypeGenerated(type2); type = type2; return(true); } if (DataTypeStringParser.TryParseReference(typeName, out referencedType)) { type2 = new ReferenceType(typeName, referencedType, resolver.PlatformPointerSize); resolver.RegisterType(type2); resolver.OnTypeGenerated(type2); type = type2; return(true); } type2 = (DataType)SubRangeTypeFactory.Create(typeName, resolver); if (type2 == null) { type = null; resolver.OnTypeResolveError(typeName); return(false); } resolver.RegisterType(type2); resolver.OnTypeGenerated(type2); type = type2; return(true); }
internal static DataTypeCategory FromType(ITcAdsDataType type) => (!DataTypeStringParser.IsReference(type.Name) ? (!DataTypeStringParser.IsPointer(type.Name) ? (!DataTypeStringParser.IsSubRange(type.Name) ? (!type.HasSubItemInfo ? (!type.HasArrayInfo ? (!type.HasEnumInfo ? (string.IsNullOrEmpty(type.BaseTypeName) ? (!DataTypeStringParser.IsString(type.Name) ? FromId(type.DataTypeId, type.Name) : DataTypeCategory.String) : DataTypeCategory.Alias) : DataTypeCategory.Enum) : DataTypeCategory.Array) : DataTypeCategory.Struct) : DataTypeCategory.SubRange) : DataTypeCategory.Pointer) : DataTypeCategory.Reference);
public static void ParseTypes(AdsStream dataTypeStream, Encoding encoding, IBinder binder, bool buildInTypesInStream, DataTypeCollection <IDataType> buildInTypes) { AdsBinaryReader reader = new AdsBinaryReader(dataTypeStream); string referencedType = null; while (dataTypeStream.Position < dataTypeStream.Length) { AdsDataTypeEntry entry = new AdsDataTypeEntry(true, encoding, reader); try { IDataType type = null; bool flag1 = buildInTypes.TryGetType(entry.entryName, out type); DataType type2 = (DataType)type; if (buildInTypesInStream && flag1) { continue; } DataType type3 = null; int length = 0; if (DataTypeStringParser.TryParseReference(entry.entryName, out referencedType)) { type3 = new ReferenceType(entry, referencedType); } else if (DataTypeStringParser.TryParsePointer(entry.entryName, out referencedType)) { type3 = new PointerType(entry, referencedType); } else { bool flag2; if (DataTypeStringParser.TryParseString(entry.entryName, out length, out flag2)) { type3 = !flag2 ? ((DataType) new StringType(length)) : ((DataType) new WStringType(length)); } else if (entry.methodCount > 0) { type3 = new RpcStructType(entry); } else if (entry.subItems > 0) { bool flag3 = false; bool flag4 = false; if (entry.subItems > 1) { int num2 = 0; AdsFieldEntry[] subEntries = entry.subEntries; int index = 0; while (true) { if (index >= subEntries.Length) { flag3 = entry.BitSize < num2; break; } AdsFieldEntry entry2 = subEntries[index]; if (!entry2.IsStatic && !entry2.IsProperty) { int num4 = 0; num4 = !entry2.IsBitType ? (entry2.Offset * 8) : entry2.Offset; flag4 |= num4 < num2; num2 += entry2.BitSize; } index++; } } type3 = !flag3 ? ((DataType) new StructType(entry)) : ((DataType) new UnionType(entry)); } else if (entry.arrayDim > 0) { type3 = new ArrayType(entry); } else if (entry.enumInfoCount <= 0) { if (DataTypeStringParser.TryParseSubRange(entry.entryName, out referencedType)) { type3 = (DataType)SubRangeTypeFactory.Create(entry, binder); } else if (((entry.baseTypeId > AdsDatatypeId.ADST_VOID) && (entry.typeName != null)) && (entry.typeName != string.Empty)) { type3 = new AliasType(entry); } else { DataTypeCategory cat = CategoryConverter.FromId(entry.DataTypeId); if (cat != DataTypeCategory.Unknown) { Type tp = null; if (PrimitiveTypeConverter.TryGetManagedType(entry.DataTypeId, out tp)) { if (cat == DataTypeCategory.Primitive) { type3 = new PrimitiveType(entry, PrimitiveTypeConverter.GetPrimitiveFlags(entry.DataTypeId), tp); } else if (cat == DataTypeCategory.String) { type3 = new StringType(entry); } } } if (type3 == null) { type3 = new DataType(cat, entry); } } } else { AdsDatatypeId baseTypeId = entry.baseTypeId; if (baseTypeId == AdsDatatypeId.ADST_INT16) { type3 = new EnumType <short>(entry); } else if (baseTypeId == AdsDatatypeId.ADST_INT32) { type3 = new EnumType <int>(entry); } else { switch (baseTypeId) { case AdsDatatypeId.ADST_INT8: type3 = new EnumType <sbyte>(entry); break; case AdsDatatypeId.ADST_UINT8: type3 = new EnumType <byte>(entry); break; case AdsDatatypeId.ADST_UINT16: type3 = new EnumType <ushort>(entry); break; case AdsDatatypeId.ADST_UINT32: type3 = new EnumType <uint>(entry); break; case AdsDatatypeId.ADST_INT64: type3 = new EnumType <long>(entry); break; case AdsDatatypeId.ADST_UINT64: type3 = new EnumType <ulong>(entry); break; default: throw new AdsException("Enum base type mismatch!"); } } } } binder.RegisterType(type3); } catch (Exception exception) { Module.Trace.TraceWarning($"Cannot parse DataTypeEntry. Skipping dataType '{entry.entryName}'!", exception); } } }
public override bool TryGetReference(out string referenceType) => DataTypeStringParser.TryParseReference(base.typeName, out referenceType);
public override bool TryGetPointerRef(out string referenceType) => DataTypeStringParser.TryParsePointer(base.typeName, out referenceType);
public virtual bool TryGetReference(out string referenceType) => DataTypeStringParser.TryParseReference(this.entryName, out referenceType);
internal TcAdsDataType(AdsDataTypeEntry entry, IDataTypeResolver table) : this() { if (entry == null) { throw new ArgumentNullException("entry"); } if (table == null) { throw new ArgumentNullException("table"); } this._table = table; this._size = entry.size; this._typeName = entry.entryName; this._typeHashValue = entry.typeHashValue; this._comment = entry.Comment; this._flags = entry.flags; this._offset = entry.offset; this._dataTypeId = entry.baseTypeId; if (entry.nameLength > 0) { bool isUnicode = false; int length = 0; string referencedType = null; AdsDatatypeArrayInfo[] dims = null; string baseType = null; if (entry.IsArray) { if (DataTypeStringParser.TryParseArray(this._typeName, out dims, out baseType)) { this._category = DataTypeCategory.Array; this._arrayInfo = dims; this._baseTypeName = baseType; } else { this._arrayInfo = entry.arrayInfos; this._category = DataTypeCategory.Array; this._baseTypeName = entry.Name; } } else if (DataTypeStringParser.TryParseString(this._typeName, out length, out isUnicode)) { this._category = DataTypeCategory.String; } else if (DataTypeStringParser.TryParseReference(this._typeName, out referencedType)) { this._baseTypeName = referencedType; this._category = DataTypeCategory.Reference; } else if (DataTypeStringParser.TryParsePointer(this._typeName, out referencedType)) { this._baseTypeName = referencedType; this._category = DataTypeCategory.Pointer; } else if (DataTypeStringParser.TryParseSubRange(this._typeName, out referencedType)) { this._baseTypeName = entry.Name; this._category = DataTypeCategory.SubRange; } else if (!string.IsNullOrEmpty(entry.Name)) { this._baseTypeName = entry.Name; this._category = DataTypeCategory.Alias; } } if (entry.subItems <= 0) { if (entry.IsEnum) { this._enumInfos = entry.enums; this._category = DataTypeCategory.Enum; bool flag3 = PrimitiveTypeConverter.TryGetManagedType(this._dataTypeId, out this._managedType); } } else { this._subItems = new TcAdsSubItem[entry.subItems]; bool flag2 = false; int num2 = 0; int index = 0; while (true) { int num1; if (index < entry.subItems) { if (entry.subEntries[index] != null) { this._subItems[index] = new TcAdsSubItem(entry.subEntries[index], table); if (!this._subItems[index].IsStatic && !this._subItems[index].IsProperty) { int num4 = 0; num4 = !this._subItems[index].IsBitType ? (this._subItems[index].Offset * 8) : this._subItems[index].Offset; flag2 |= num4 < num2; num2 += this._subItems[index].BitSize; } index++; continue; } object[] args = new object[] { index, entry.Name }; Module.Trace.TraceError("SubEntry '{0}' missing in TcAdsDataType '{1}'", args); } if ((entry.subItems <= 1) || (entry.BitSize >= num2)) { num1 = 0; } else { num1 = (int)!entry.IsBitType; } this._category = ((num1 & flag2) == 0) ? DataTypeCategory.Struct : DataTypeCategory.Union; break; } } if (entry.HasAttributes) { this._attributes = entry.attributes; } if (entry.HasRpcMethods) { this._rpcMethodInfos = entry.methods; } if (this._category == DataTypeCategory.Unknown) { this._category = (entry.DataTypeId != AdsDatatypeId.ADST_BIGTYPE) ? DataTypeCategory.Primitive : DataTypeCategory.Interface; } if ((this._category == DataTypeCategory.Array) && string.IsNullOrEmpty(this._baseTypeName)) { string message = $"Base type of ARRAY '{this._typeName}' not defined!"; Module.Trace.TraceWarning(message); } }
public AdsErrorCode TryLoadType(string name, bool lookup, out ITcAdsDataType type) { if (string.IsNullOrEmpty(name)) { throw new ArgumentOutOfRangeException("name"); } if (lookup) { DataTypeInfoTable table = this; lock (table) { if (this._dataTypes.TryGetDataType(name, out type)) { return(AdsErrorCode.NoError); } } } int length = 0; bool isUnicode = false; if (DataTypeStringParser.TryParseString(name, out length, out isUnicode)) { int byteCount = 0; AdsDatatypeId dataType = AdsDatatypeId.ADST_VOID; if (isUnicode) { char[] chars = new char[] { 'a' }; byteCount = Encoding.Unicode.GetByteCount(chars); dataType = AdsDatatypeId.ADST_WSTRING; } else { char[] chars = new char[] { 'a' }; byteCount = Encoding.ASCII.GetByteCount(chars); dataType = AdsDatatypeId.ADST_STRING; } type = new TcAdsDataType(name, dataType, (uint)((length + 1) * byteCount), DataTypeCategory.String, typeof(string)); DataTypeInfoTable table2 = this; lock (table2) { this._dataTypes.Add(type); } this.OnTypeGenerated(type); return(AdsErrorCode.NoError); } AdsStream stream = new AdsStream(name.Length + 1); using (AdsBinaryWriter writer = new AdsBinaryWriter(stream)) { writer.WritePlcString(name, name.Length + 1, this._encoding); AdsStream rdDataStream = new AdsStream(0xffff); try { int num3 = this._adsClient.ReadWrite(0xf011, 0, rdDataStream, stream); } catch (AdsErrorException exception1) { if (exception1.ErrorCode != AdsErrorCode.DeviceSymbolNotFound) { throw; } type = null; } using (AdsBinaryReader reader = new AdsBinaryReader(rdDataStream)) { AdsDataTypeEntry entry = new AdsDataTypeEntry(true, this._encoding, reader); type = new TcAdsDataType(entry, this); DataTypeInfoTable table3 = this; lock (table3) { this._dataTypes.Add(type); } } } if (type != null) { return(AdsErrorCode.NoError); } this.OnResolveError(name); return(AdsErrorCode.DeviceSymbolNotFound); }
public virtual bool TryGetPointerRef(out string referenceType) => DataTypeStringParser.TryParsePointer(this.entryName, out referenceType);