internal DataType(DataTypeCategory cat, AdsDataTypeEntry entry) { s_idCounter++; this.id = s_idCounter; this.comment = string.Empty; this.flags = AdsDataTypeFlags.DataType; this.attributes = new TypeAttributeCollection(); this.category = cat; this.comment = entry.comment; this.name = entry.entryName; this.flags = entry.flags; this.size = (int)entry.size; this.dataTypeId = entry.baseTypeId; if ((this.dataTypeId == AdsDatatypeId.ADST_BIGTYPE) && (this.category == DataTypeCategory.Unknown)) { this.category = DataTypeCategory.Interface; } else if (this.category == DataTypeCategory.Unknown) { this.category = DataTypeCategory.Primitive; } this.typeHashValue = entry.typeHashValue; if (entry.HasAttributes) { this.attributes = new TypeAttributeCollection(entry.attributes); } }
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); }
internal Symbol(ISymbol parent, IDataType type, string instanceName, int fieldOffset, ISymbolFactoryServices factoryServices) : this(0, 0, parent, type, instanceName, null, factoryServices) { DataType type2 = (DataType)type; this.calcAccess(parent, (DataType)type, fieldOffset, DataTypeFlagConverter.Convert(type2.Flags), type2.Flags, out this.indexGroup, out this.indexOffset); DataTypeCategory category = base.category; }
private void expandDataType(IDataType type) { if (type == null) { throw new ArgumentNullException("type"); } DataTypeCategory category = type.Category; if (category > DataTypeCategory.Array) { if (category == DataTypeCategory.Pointer) { DataType referencedType = (DataType)((PointerType)type).ReferencedType; if (referencedType != null) { this.expandDataType(referencedType); } } else if (category == DataTypeCategory.Reference) { DataType referencedType = (DataType)((ReferenceType)type).ReferencedType; if (referencedType != null) { this.expandDataType(referencedType); } } } else if (category != DataTypeCategory.Alias) { if (category == DataTypeCategory.Array) { DataType elementType = (DataType)((ArrayType)type).ElementType; if (elementType != null) { this.expandDataType(elementType); } } } else { AliasType type2 = (AliasType)type; DataType baseType = (DataType)type2.BaseType; if (baseType != null) { this.expandDataType(baseType); } if ((type2.Size <= 0) && (baseType != null)) { type2.SetSize(baseType.Size, baseType.ManagedType); } } }
public AnyTypeSpecifier(object prototype) { System.Type type = prototype.GetType(); this.Type = type; if (!type.IsArray) { if (type != typeof(string)) { this.Category = DataTypeCategory.Primitive; this.StrLen = -1; this.DimLengths = null; this.ElementType = null; } else { string str = (string)prototype; this.Category = DataTypeCategory.String; this.StrLen = str.Length; this.DimLengths = null; this.ElementType = null; } } else { Array array = (Array)prototype; int rank = array.Rank; int[] indices = new int[rank]; int[] numArray2 = new int[rank]; DimensionCollection dimensions = new DimensionCollection(); for (int i = 0; i < rank; i++) { indices[i] = array.GetLowerBound(i); numArray2[i] = array.GetLength(i); dimensions.Add(new Dimension(indices[i], numArray2[i])); } this.Category = DataTypeCategory.Array; this.StrLen = -1; this.DimLengths = new List <IDimensionCollection> { dimensions.AsReadOnly() }.AsReadOnly(); System.Type elementType = this.Type.GetElementType(); if (array.Length <= 0) { this.ElementType = new AnyTypeSpecifier(elementType); } else { object obj2 = array.GetValue(indices); this.ElementType = new AnyTypeSpecifier(obj2); } } }
internal DataType(string name, AdsDatatypeId typeId, DataTypeCategory cat, int size, Type dotnetType, AdsDataTypeFlags flags) { s_idCounter++; this.id = s_idCounter; this.comment = string.Empty; this.flags = AdsDataTypeFlags.DataType; this.attributes = new TypeAttributeCollection(); this.name = name; this.dataTypeId = typeId; this.category = cat; this.flags = flags | AdsDataTypeFlags.DataType; this.size = size; this.dotnetType = dotnetType; }
public DataTypeSchema(DataTypeSchema dt) : base(dt) { this.isComplex = dt.isComplex; this.isNullable = dt.isNullable; this.isAutoincrementable = dt.isAutoincrementable; this.isFixedLength = dt.isFixedLength; this.category = dt.category; this.dotNetType = dt.dotNetType; this.createFormat = dt.createFormat; this.createParameters = dt.createParameters; this.lengthRange = new Range(dt.lengthRange); this.precisionRange = new Range(dt.precisionRange); this.scaleRange = new Range(dt.scaleRange); }
public DataTypeSchema (DataTypeSchema dt) : base (dt) { this.isComplex = dt.isComplex; this.isNullable = dt.isNullable; this.isAutoincrementable = dt.isAutoincrementable; this.isFixedLength = dt.isFixedLength; this.category = dt.category; this.dataType = dt.dataType; this.createFormat = dt.createFormat; this.createParameters = dt.createParameters; this.lengthRange = new Range (dt.lengthRange); this.precisionRange = new Range (dt.precisionRange); this.scaleRange = new Range (dt.scaleRange); }
internal Symbol(int[] indices, bool oversampleElement, ISymbol parent) { this.accessRights = SymbolAccessRights.All; if (parent == null) { throw new ArgumentNullException("parent"); } this.factoryServices = ((ISymbolFactoryServicesProvider)parent).FactoryServices; this.parent = parent; base.Bind(((IBinderProvider)parent).Binder); string str = string.Empty; ArrayType type = (ArrayType)((DataType)parent.DataType).ResolveType(DataTypeResolveStrategy.AliasReference); type.CheckIndices(indices, oversampleElement); str = !oversampleElement?ArrayIndexConverter.IndicesToString(indices) : ArrayIndexConverter.OversamplingSubElementToString(type.Dimensions.ElementCount); base.instanceName = parent.InstanceName + str; this.instancePath = parent.InstancePath + str; DataType elementType = (DataType)type.ElementType; base.resolvedDataType = elementType; base.flags = this.getSymbolFlags(parent, elementType); if (base.resolvedDataType != null) { base.size = base.resolvedDataType.Size; base.dataTypeId = ((DataType)base.resolvedDataType).DataTypeId; base.category = base.resolvedDataType.Category; base.typeName = base.resolvedDataType.Name; } else { base.size = !base.IsBitType ? type.ElementSize : 1; base.dataTypeId = type.ElementTypeId; base.category = DataTypeCategory.Unknown; base.typeName = type.ElementTypeName; } if (!oversampleElement) { this.calcAccess(parent, elementType, ArrayType.GetElementOffset(indices, (IArrayType)((DataType)parent.DataType).ResolveType(DataTypeResolveStrategy.AliasReference)), base.flags, elementType.Flags, out this.indexGroup, out this.indexOffset); } else { this.indexGroup = 0xf019; this.indexOffset = 0; } base.SetContextMask(((IContextMaskProvider)parent).ContextMask); DataTypeCategory category = base.category; }
public AnyTypeSpecifier(System.Type type) { this.StrLen = -1; this.DimLengths = null; this.ElementType = null; if (!type.IsArray) { this.Category = (type != typeof(string)) ? DataTypeCategory.Primitive : DataTypeCategory.String; } else { this.Category = DataTypeCategory.Array; this.ElementType = new AnyTypeSpecifier(type.GetElementType()); } this.Type = type; }
internal void WriteArray(object value, ITcAdsDataType arrayType, AdsBinaryWriter writer, int writerOffset) { Array array = value as Array; if (array == null) { throw new ArgumentException($"Cannot convert data type of symbol to this type. Expected an array, actual type is {value.GetType()}", "type"); } AdsDatatypeArrayInfo[] arrayInfo = ((TcAdsDataType)arrayType).ArrayInfo; checkArrayDimensions(array, arrayInfo, false); AdsArrayDimensionsInfo info = new AdsArrayDimensionsInfo(arrayInfo); int elements = info.Elements; int byteSize = arrayType.ByteSize / elements; DataTypeCategory category = arrayType.BaseType.Category; int num3 = 0; foreach (int[] numArray in new ArrayIndexIterator(info.LowerBounds, info.UpperBounds, true)) { if ((array.Rank == 1) && (num3 >= array.Length)) { break; } if (category == DataTypeCategory.Primitive) { this.WritePrimitiveValue(arrayType.BaseType.Name, array.GetValue(numArray), ((TcAdsDataType)arrayType.BaseType).ManagedType, arrayType.DataTypeId, byteSize, writer, writerOffset); } else if (category == DataTypeCategory.Enum) { this.WriteEnumValue(arrayType.BaseType.Name, array.GetValue(numArray), (TcAdsDataType)arrayType, writer, writerOffset); } else if (category == DataTypeCategory.Struct) { this.WriteStruct(array.GetValue(numArray), arrayType.BaseType.SubItems, writer, writerOffset); } else { if (category != DataTypeCategory.Array) { throw new ArgumentException("Cannot convert ads array type of symbol to this type.", "type"); } this.WriteArray(array.GetValue(numArray), arrayType.BaseType, writer, writerOffset); } writerOffset += byteSize; num3++; } }
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance) { IDataType type = ((DataType)base.DataType).ResolveType(DataTypeResolveStrategy.AliasReference); ISymbolCollection symbols = base.OnCreateSubSymbols(parentInstance); try { ISymbolFactory symbolFactory = this.FactoryServices.SymbolFactory; if (type != null) { DataTypeCategory category = type.Category; if (category <= DataTypeCategory.Struct) { if (category == DataTypeCategory.Array) { symbols = symbolFactory.CreateArrayElementInstances(parentInstance, (IArrayType)type); } else if (category == DataTypeCategory.Struct) { symbols = symbolFactory.CreateFieldInstances(parentInstance, (IStructType)type); } } else if (category != DataTypeCategory.Pointer) { if (category == DataTypeCategory.Union) { symbols = symbolFactory.CreateFieldInstances(parentInstance, (IUnionType)type); } } else { ISymbol item = symbolFactory.CreateReferenceInstance((IPointerType)type, parentInstance); if (item != null) { symbols.Add(item); } } } } catch (Exception exception) { Module.Trace.TraceError(exception); } return(symbols); }
public int MarshalSize(IAttributedInstance symbol, object value) { Type type = value.GetType(); DataTypeCategory category = symbol.DataType.Category; if (category != DataTypeCategory.Primitive) { if (category == DataTypeCategory.Alias) { return(this._internalConverter.MarshalSize(symbol, value)); } else if (category != DataTypeCategory.String) { return(symbol.ByteSize); } } return(this._internalConverter.MarshalSize(symbol, value)); }
internal Symbol(Member member, ISymbol parent) { this.accessRights = SymbolAccessRights.All; if (member == null) { throw new ArgumentNullException("member"); } if (parent == null) { throw new ArgumentNullException("parent"); } this.factoryServices = ((ISymbolFactoryServicesProvider)parent).FactoryServices; this.parent = parent; base.Bind(((IBinderProvider)parent).Binder); string instanceName = member.InstanceName; base.instanceName = instanceName; this.instancePath = parent.InstancePath + "." + instanceName; base.resolvedDataType = (DataType)member.DataType; base.flags = this.getSymbolFlags(parent, member); this._memberFlags = member.MemberFlags; this.staticAddress = parent.IsStatic || this._memberFlags.HasFlag(AdsDataTypeFlags.None | AdsDataTypeFlags.Static); base.attributes = (member.Attributes.Count <= 0) ? null : new TypeAttributeCollection(member.Attributes); base.comment = member.Comment; if (base.resolvedDataType != null) { base.size = base.resolvedDataType.Size; base.dataTypeId = ((DataType)base.resolvedDataType).DataTypeId; base.category = base.resolvedDataType.Category; base.typeName = base.resolvedDataType.Name; } else { base.size = member.Size; base.dataTypeId = member.DataTypeId; base.category = member.Category; base.typeName = member.TypeName; } this.calcAccess(parent, member, out this.indexGroup, out this.indexOffset); base.SetContextMask(((IContextMaskProvider)parent).ContextMask); DataTypeCategory category = base.category; }
internal TcAdsDataType(string name, AdsDatatypeId dataType, uint size, AdsDataTypeFlags flags, DataTypeCategory cat, string baseTypeName, Type managedType, IDataTypeResolver resolver) : this() { if (string.IsNullOrEmpty(name)) { throw new ArgumentOutOfRangeException("name"); } this._table = resolver; this._typeName = name; this._size = size; this._flags = flags; this._dataTypeId = dataType; this._category = cat; this._managedType = managedType; if ((this._category == DataTypeCategory.Array) && string.IsNullOrEmpty(baseTypeName)) { string message = $"Base type of ARRAY '{name}' not defined!"; Module.Trace.TraceWarning(message); } this._baseTypeName = baseTypeName; }
protected virtual bool TryResolveType() { bool flag = false; if (((this.resolver != null) && ((this.resolvedDataType == null) && (this.typeName != null))) && (this.typeName != string.Empty)) { IDataType type = null; flag = this.resolver.TryResolveType(this.typeName, out type); if (flag) { this.resolvedDataType = (TwinCAT.Ads.TypeSystem.DataType)type; DataTypeCategory category = this.category; this.category = this.resolvedDataType.Category; } if (this.resolvedDataType == null) { object[] args = new object[] { this.typeName }; Trace.TraceWarning("Cannot resolve DataType '{0}'", args); } } return(flag); }
internal override int OnGetSubSymbolCount(ISymbol parentSymbol) { int elementCount = 0; IDataType type = ((DataType)base.DataType).ResolveType(DataTypeResolveStrategy.AliasReference); if (type != null) { DataTypeCategory category = type.Category; if (category <= DataTypeCategory.Struct) { if (category == DataTypeCategory.Array) { elementCount = ((IArrayType)type).Dimensions.ElementCount; } else if (category == DataTypeCategory.Struct) { elementCount = ((IStructType)type).AllMembers.Count; } } else if (category != DataTypeCategory.Pointer) { if (category == DataTypeCategory.Union) { elementCount = ((IUnionType)type).Fields.Count; } } else { IDataType referencedType = ((IPointerType)type).ReferencedType; if ((referencedType.Category != DataTypeCategory.Array) && (referencedType.Size == 0)) { return(0); } elementCount = 1; } } return(elementCount); }
internal static AdsDatatypeId FromCategory(DataTypeCategory cat) { switch (cat) { case DataTypeCategory.Unknown: case DataTypeCategory.Primitive: case DataTypeCategory.Alias: return(AdsDatatypeId.ADST_VOID); case DataTypeCategory.Enum: case DataTypeCategory.Array: case DataTypeCategory.Struct: case DataTypeCategory.FunctionBlock: case DataTypeCategory.Program: case DataTypeCategory.Function: case DataTypeCategory.SubRange: return(AdsDatatypeId.ADST_BIGTYPE); case DataTypeCategory.Bitset: return(AdsDatatypeId.ADST_BIT); } return(AdsDatatypeId.ADST_VOID); }
internal TcAdsDataType(string name, AdsDatatypeId dataType, uint size, AdsDataTypeFlags flags, DataTypeCategory cat, Type managedType, IDataTypeResolver resolver) : this(name, dataType, size, flags, cat, string.Empty, managedType, resolver) { }
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); } } }
internal int InitializeArray(Type managedType, TcAdsDataType adsType, AdsBinaryReader reader, int readerOffset, int jagLevel, out object value) { int num2; if (managedType == null) { throw new ArgumentNullException("managedType"); } if (adsType == null) { throw new ArgumentNullException("adsType"); } if (reader == null) { throw new ArgumentNullException("reader"); } int num = readerOffset; if (!managedType.IsArray) { throw new ArgumentException($"Cannot convert datatype of symbol to this type. Expected an array, actual type is {managedType.ToString()}", "type"); } Type elementType = managedType.GetElementType(); AdsDatatypeArrayInfo[] arrayInfo = adsType.ArrayInfo; Type baseElementType = null; bool flag = PrimitiveTypeConverter.TryJaggedArray(managedType, out num2, out baseElementType); int arrayElementCount = AdsArrayDimensionsInfo.GetArrayElementCount(arrayInfo); int byteLength = adsType.ByteSize / arrayElementCount; if (flag) { if (arrayInfo.Length != 1) { throw new ArgumentException($"Cannot convert datatype of symbol to this type. Expected an array rank of {arrayInfo.Length}, actual rank is {num2}", "type"); } } else { int length = arrayInfo.Length; if (length != managedType.GetArrayRank()) { throw new ArgumentException($"Cannot convert datatype of symbol to this type. Expected an array rank of {length}, actual rank is {managedType.GetArrayRank()}", "type"); } } AdsArrayDimensionsInfo info = new AdsArrayDimensionsInfo(arrayInfo); Array array = null; if (flag) { jagLevel++; array = Array.CreateInstance(elementType, info.DimensionElements[jagLevel]); int[] lowerBounds = new int[] { info.LowerBounds[jagLevel] }; int[] upperBounds = new int[] { info.UpperBounds[jagLevel] }; foreach (int[] numArray in new ArrayIndexIterator(lowerBounds, upperBounds, true)) { object obj2 = null; readerOffset += this.InitializeArray(elementType, (TcAdsDataType)adsType.BaseType, reader, readerOffset, jagLevel, out obj2); array.SetValue(obj2, numArray); } } else { DataTypeCategory category = adsType.BaseType.Category; array = Array.CreateInstance(elementType, info.DimensionElements); foreach (int[] numArray2 in new ArrayIndexIterator(info.LowerBounds, info.UpperBounds, true)) { object obj3 = null; if (category == DataTypeCategory.Primitive) { if (elementType != ((TcAdsDataType)adsType.BaseType).ManagedType) { throw new ArgumentException("Cannot convert data type of symbol to this type.", "type"); } readerOffset += this.InitializePrimitiveType(adsType.BaseType.Name, elementType, adsType.DataTypeId, byteLength, reader, readerOffset, out obj3); array.SetValue(obj3, numArray2); continue; } if (category == DataTypeCategory.Enum) { if (elementType != ((TcAdsDataType)adsType.BaseType).ManagedType) { throw new ArgumentException("Cannot convert data type of symbol to this type.", "type"); } readerOffset += this.InitializeEnum(adsType.BaseType.Name, elementType, adsType.DataTypeId, byteLength, reader, readerOffset, out obj3); array.SetValue(obj3, numArray2); continue; } if (adsType.BaseType.Category == DataTypeCategory.Struct) { readerOffset += this.InitializeStruct(adsType.BaseType.SubItems, elementType, reader, readerOffset, out obj3); array.SetValue(obj3, numArray2); continue; } if (adsType.BaseType.Category == DataTypeCategory.Array) { readerOffset += this.InitializeArray(elementType, (TcAdsDataType)adsType.BaseType, reader, readerOffset, jagLevel, out obj3); array.SetValue(obj3, numArray2); } } } value = array; return(readerOffset - num); }
public static bool CanMarshal(DataTypeCategory category) => (category == DataTypeCategory.String);
internal Symbol(string instanceName, string instancePath, ISymbolFactoryServices factoryServices) : this(0, 0, null, null, instanceName, instancePath, factoryServices) { DataTypeCategory category = base.category; }
private IValueSymbol create(IValueSymbol symbol) { if (symbol == null) { throw new ArgumentNullException("symbol"); } DataTypeCategory category = symbol.Category; switch (category) { case DataTypeCategory.Alias: { IAliasInstance aliasInstance = symbol as IAliasInstance; if (aliasInstance != null) { return(new DynamicAliasInstance(aliasInstance)); } Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to alias"); return(new DynamicSymbol(symbol)); } case DataTypeCategory.Enum: break; case DataTypeCategory.Array: if (symbol is IArrayInstance) { return(!(symbol is IOversamplingArrayInstance) ? new DynamicArrayInstance((IArrayInstance)symbol) : new DynamicOversamplingArrayInstance((IOversamplingArrayInstance)symbol)); } Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to array"); return(new DynamicSymbol(symbol)); case DataTypeCategory.Struct: { IStructInstance instance3 = symbol as IStructInstance; if (instance3 != null) { return(!instance3.HasRpcMethods ? new DynamicStructInstance((IStructInstance)symbol) : new DynamicRpcStructInstance((IRpcStructInstance)symbol)); } Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to struct"); return(new DynamicSymbol(symbol)); } default: switch (category) { case DataTypeCategory.Pointer: { IPointerInstance pointerInstance = symbol as IPointerInstance; if (pointerInstance != null) { return(new DynamicPointerInstance(pointerInstance)); } Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to pointer"); return(new DynamicSymbol(symbol)); } case DataTypeCategory.Union: { IUnionInstance unionInstance = symbol as IUnionInstance; if (unionInstance != null) { return(new DynamicUnionInstance(unionInstance)); } Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to union"); return(new DynamicSymbol(symbol)); } case DataTypeCategory.Reference: { IReferenceInstance refInstance = symbol as IReferenceInstance; if (refInstance != null) { return(new DynamicReferenceInstance(refInstance)); } Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to reference"); return(new DynamicSymbol(symbol)); } default: break; } break; } return(new DynamicSymbol(symbol)); }
private Symbol createArrayElement(int[] currentIndex, bool oversample, ISymbol parent, ArrayType arrType, DataType elementType) { bool flag = true; DataTypeCategory unknown = DataTypeCategory.Unknown; if (elementType != null) { unknown = elementType.Category; } Symbol symbol = null; if (unknown == DataTypeCategory.Bitset) { symbol = new Symbol(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Primitive) { symbol = new Symbol(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Array) { symbol = !arrType.IsOversampled ? new ArrayInstance(currentIndex, false, parent) : new OversamplingArrayInstance(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Struct) { symbol = !((IStructType)elementType).HasRpcMethods ? new StructInstance(currentIndex, oversample, parent) : new RpcStructInstance(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Union) { symbol = new UnionInstance(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Reference) { symbol = new ReferenceInstance(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Pointer) { symbol = new PointerInstance(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Union) { symbol = new Symbol(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Enum) { symbol = new Symbol(currentIndex, oversample, parent); } else if (unknown == DataTypeCategory.Alias) { AliasType type3 = (AliasType)elementType; symbol = new AliasInstance(currentIndex, oversample, parent); } else if (unknown != DataTypeCategory.String) { symbol = new Symbol(currentIndex, oversample, parent); } else { IStringType type4 = (IStringType)elementType; symbol = new StringInstance(currentIndex, oversample, parent); } if (flag) { symbol.SetComment(parent.Comment); } return(symbol); }
internal Symbol(string instanceName, ISymbol parent, ISymbolFactoryServices factoryServices) : this(0, 0, parent, null, instanceName, null, factoryServices) { DataTypeCategory category = base.category; }
public static bool IsReferenceType(DataTypeCategory cat) => (cat == DataTypeCategory.Reference);
public static bool IsPointerType(DataTypeCategory cat) => (cat == DataTypeCategory.Pointer);
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); } }
internal DataType(string name, AdsDatatypeId typeId, DataTypeCategory cat, int size, Type dotnetType) : this(name, typeId, cat, size, dotnetType, AdsDataTypeFlags.DataType) { }
internal TcAdsDataType(string name, AdsDatatypeId dataType, uint size, DataTypeCategory cat, string baseType, Type managedType) : this(name, dataType, size, AdsDataTypeFlags.DataType, cat, baseType, managedType, null) { }