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)
{
}
