private TcAdsDataType()
{
this._flags = AdsDataTypeFlags.DataType;
this._baseTypeName = string.Empty;
this._comment = string.Empty;
this._id = ++s_id;
}
internal TcAdsSymbol(AdsSymbolEntry symbolEntry, TcAdsDataType typeEntry)
{
if (symbolEntry == null)
{
throw new ArgumentNullException("symbolEntry");
}
if (typeEntry == null)
{
object[] args = new object[] { symbolEntry.name };
Module.Trace.TraceWarning("No data type found for AdsSymbolEntry '{0}'", args);
}
this._indexGroup = symbolEntry.indexGroup;
this._indexOffset = symbolEntry.indexOffset;
this._size = symbolEntry.size;
this._typeId = (AdsDatatypeId)symbolEntry.dataType;
this._typeEntryFlags = typeEntry.Flags;
this._flags = symbolEntry.flags;
this._name = symbolEntry.name;
this._typeName = symbolEntry.type;
this._comment = symbolEntry.comment;
this._arrayDimensions = symbolEntry.arrayDim;
this._arrayInfos = symbolEntry.array;
this._attributeCount = symbolEntry.attributeCount;
this._attributes = symbolEntry.attributes;
this._dataType = typeEntry;
}
internal static AdsSymbolFlags Convert(AdsDataTypeFlags dataTypeFlags)
{
AdsSymbolFlags none = AdsSymbolFlags.None;
if ((dataTypeFlags & (AdsDataTypeFlags.None | AdsDataTypeFlags.ReferenceTo)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.ReferenceTo))
{
none |= AdsSymbolFlags.None | AdsSymbolFlags.ReferenceTo;
}
if ((dataTypeFlags & (AdsDataTypeFlags.None | AdsDataTypeFlags.TComInterfacePtr)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.TComInterfacePtr))
{
none |= AdsSymbolFlags.None | AdsSymbolFlags.TComInterfacePtr;
}
if ((dataTypeFlags & AdsDataTypeFlags.BitValues) == AdsDataTypeFlags.BitValues)
{
none |= AdsSymbolFlags.BitValue;
}
if ((dataTypeFlags & (AdsDataTypeFlags.None | AdsDataTypeFlags.TypeGuid)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.TypeGuid))
{
none |= AdsSymbolFlags.None | AdsSymbolFlags.TypeGuid;
}
if ((dataTypeFlags & (AdsDataTypeFlags.None | AdsDataTypeFlags.Persistent)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.Persistent))
{
none |= AdsSymbolFlags.None | AdsSymbolFlags.Persistent;
}
return(none);
}
public AdsDataTypeEntry(Type t)
{
EntryLength = (uint)new AdsDataTypeEntry().GetSize();
Version = 1;
HashValue = 1;
TypeHashValue = 10;
Size = 1;
Offset = 0;
BaseTypeId = AdsDatatypeId.ADST_UINT8;
Flags = AdsDataTypeFlags.None;
ArrayDim = 0;
NameLength = 4;
TypeLength = 4;
CommentLength = 0;
SubItems = 0;
EntryName = new byte[5];
TypeName = new byte[5];
Comment = new byte[81];
var typeBytes = Encoding.ASCII.GetBytes("BYTE");
Array.Copy(typeBytes, EntryName, typeBytes.Length);
Array.Copy(typeBytes, TypeName, typeBytes.Length);
}
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);
}
}
private void calcAccess(ISymbol parent, Member member, out uint indexGroup, out uint indexOffset)
{
DataType dataType = (DataType)member.DataType;
AdsDataTypeFlags memberFlags = member.MemberFlags;
bool flag = memberFlags.HasFlag(AdsDataTypeFlags.None | AdsDataTypeFlags.Static);
this.calcAccess(parent, dataType, member.Offset, member.Flags, memberFlags, out indexGroup, out indexOffset);
if (indexGroup == 0xf017)
{
indexOffset = member.TypeHashValue;
}
}
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;
}
internal TcAdsSymbolInfo(AdsParseSymbols symbolParser, TcAdsSymbolInfo parent, int subIndex, AdsSymbolEntry symbolEntry, TcAdsDataType typeEntry) : this(symbolParser, parent, subIndex)
{
if (symbolEntry == null)
{
throw new ArgumentNullException("symbolEntry");
}
this.indexGroup = symbolEntry.indexGroup;
this.indexOffset = symbolEntry.indexOffset;
this.size = symbolEntry.size;
this.dataTypeId = (AdsDatatypeId)symbolEntry.dataType;
if (typeEntry != null)
{
this.typeEntryFlags = typeEntry.Flags;
}
if (this.typeEntryFlags.HasFlag(AdsDataTypeFlags.None | AdsDataTypeFlags.Static))
{
this.indexGroup = 0xf019;
this.indexOffset = 0;
}
this.flags = symbolEntry.flags;
this.instancePath = symbolEntry.name;
this.shortName = symbolEntry.name;
this.typeName = symbolEntry.type;
this.comment = symbolEntry.comment;
this.dataType = typeEntry;
if (((symbolEntry.array != null) || (typeEntry == null)) || !typeEntry.IsArray)
{
this.arrayInfo = symbolEntry.array;
}
else
{
this.arrayInfo = typeEntry.Dimensions.ToArray();
if (typeEntry.Size != this.size)
{
this.size = (uint)typeEntry.Size;
}
}
if (symbolEntry.attributes != null)
{
this.attributes = new TypeAttributeCollection(symbolEntry.attributes).AsReadOnly();
}
else
{
this.attributes = null;
}
}
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 TcAdsSymbolInfo(AdsParseSymbols symbolParser, TcAdsSymbolInfo parent, int subIndex, TcAdsDataType typeEntry) : this(symbolParser, parent, subIndex)
{
if (typeEntry == null)
{
throw new ArgumentNullException("typeEntry");
}
this.indexGroup = (uint)parent.IndexGroup;
this.indexOffset = (uint)parent.IndexOffset;
this.size = (uint)typeEntry.Size;
this.dataTypeId = typeEntry.DataTypeId;
this.typeEntryFlags = typeEntry.Flags;
this.flags = DataTypeFlagConverter.Convert(typeEntry.Flags);
this.instancePath = parent.Name;
this.shortName = parent.ShortName;
this.typeName = typeEntry.Name;
this.comment = typeEntry.Comment;
this.dataType = typeEntry;
this.arrayInfo = typeEntry.ArrayInfo;
this.attributes = typeEntry.Attributes;
}
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;
}
private void calcAccess(ISymbol parent, DataType memberType, int offset, AdsSymbolFlags symbolFlags, AdsDataTypeFlags flags, out uint indexGroup, out uint indexOffset)
{
ISymbol symbol = Unwrap(parent);
bool isBitType = false;
if (memberType != null)
{
isBitType = memberType.IsBitType;
}
bool flag2 = flags.HasFlag(AdsDataTypeFlags.None | AdsDataTypeFlags.Static);
if ((flags & (AdsDataTypeFlags.None | AdsDataTypeFlags.PropItem)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.PropItem))
{
indexGroup = 0xf017;
indexOffset = 0;
}
else if (flag2)
{
indexGroup = 0xf019;
indexOffset = 0;
}
else if (symbol.IsBitType | isBitType)
{
this.calcBitAccess(symbol, offset, symbolFlags, flags, out indexGroup, out indexOffset);
}
else if (this.IsDereferencedPointer)
{
indexGroup = !isBitType ? 0xf014 : 0xf01a;
indexOffset = 0;
}
else if (base.IsReference || this.IsDereferencedReference)
{
indexGroup = !isBitType ? 0xf016 : 0xf01b;
indexOffset = 0;
}
else
{
indexGroup = ((IAdsSymbol)symbol).IndexGroup;
indexOffset = ((IAdsSymbol)symbol).IndexOffset + ((uint)offset);
}
}
public void Read(long parentEndPosition, Encoding encoding, AdsBinaryReader reader)
{
long position = reader.BaseStream.Position;
this.entryLength = reader.ReadUInt32();
long num2 = position + this.entryLength;
this.version = reader.ReadUInt32();
this.hashValue = reader.ReadUInt32();
this.typeHashValue = reader.ReadUInt32();
this.size = reader.ReadUInt32();
this.offset = reader.ReadUInt32();
this.baseTypeId = (AdsDatatypeId)reader.ReadUInt32();
this.flags = (AdsDataTypeFlags)reader.ReadUInt32();
this.nameLength = reader.ReadUInt16();
this.typeLength = reader.ReadUInt16();
this.commentLength = reader.ReadUInt16();
this.arrayDim = reader.ReadUInt16();
this.subItems = reader.ReadUInt16();
this.entryName = reader.ReadPlcString(this.nameLength + 1, encoding);
this.typeName = reader.ReadPlcString(this.typeLength + 1, encoding);
this.comment = reader.ReadPlcString(this.commentLength + 1, encoding);
this.arrayInfos = SubStructureReader <AdsDatatypeArrayInfo> .Read(this.arrayDim, num2, encoding, reader);
this.subEntries = SubStructureReader <AdsFieldEntry> .Read(this.subItems, num2, encoding, reader);
if ((this.subEntries != null) && (this.subEntries.Length != this.subItems))
{
object[] args = new object[] { this.entryName, this.typeName, this.subItems, this.subEntries.Length };
Module.Trace.TraceWarning("Entry name '{0}', type '{1}' indicates {2} subentries but only {3} subentries found!", args);
this.subItems = (ushort)this.subEntries.Length;
}
if (this.flags.HasFlag(AdsDataTypeFlags.None | AdsDataTypeFlags.TypeGuid))
{
this.typeGuid = reader.ReadGuid();
}
if (this.flags.HasFlag(AdsDataTypeFlags.CopyMask))
{
this.copyMask = reader.ReadBytes((int)this.size);
}
if (this.flags.HasFlag(AdsDataTypeFlags.MethodInfos))
{
this.methodCount = reader.ReadUInt16();
this.methods = SubStructureReader <AdsMethodEntry> .Read(this.methodCount, num2, encoding, reader);
}
if (this.flags.HasFlag(AdsDataTypeFlags.Attributes))
{
this.attributeCount = reader.ReadUInt16();
this.attributes = SubStructureReader <AdsAttributeEntry> .Read(this.attributeCount, num2, encoding, reader);
}
if (this.flags.HasFlag(AdsDataTypeFlags.EnumInfos))
{
this.enumInfoCount = reader.ReadUInt16();
this.enums = EnumSubStructureReader <AdsEnumInfoEntry> .Read(this.enumInfoCount, this.size, num2, encoding, reader);
}
if (reader.BaseStream.Position <= num2)
{
this.reserved = reader.ReadBytes((int)(num2 - reader.BaseStream.Position));
}
else if (reader.BaseStream.Position > num2)
{
object[] args = new object[] { this.entryName };
Module.Trace.TraceError("Reading DataType entry for '{0}' failed!", args);
reader.BaseStream.Position = num2;
}
}
protected DataType(DataType copy) : this(copy.Name, copy.dataTypeId, copy.Category, copy.size, copy.dotnetType)
{
this.flags = copy.flags;
this.ns = copy.ns;
this.resolver = copy.resolver;
}
public Member(DataType parent, AdsFieldEntry subEntry) : base(parent, subEntry)
{
this.offset = (int)subEntry.offset;
this._memberFlags = subEntry.Flags;
this._typeHashValue = subEntry.typeHashValue;
}
public ArrayType(string typeName, DataType elementType, DimensionCollection dims, AdsDataTypeFlags flags) : base(typeName, AdsDatatypeId.ADST_BIGTYPE, DataTypeCategory.Array, dims.ElementCount * elementType.ByteSize, null, flags)
{
this.elementType = elementType;
this.elementTypeName = elementType.Name;
this._dimensions = dims;
}
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);
}
}
private void calcBitAccess(ISymbol parent, int bitOffset, AdsSymbolFlags symbolFlags, AdsDataTypeFlags flags, out uint indexGroup, out uint indexOffset)
{
ISymbol symbol = Unwrap(parent);
uint num = ((IAdsSymbol)symbol).IndexGroup;
uint num2 = ((IAdsSymbol)symbol).IndexOffset;
if (!this.IsDereferencedPointer)
{
if (base.IsReference)
{
goto TR_0002;
}
else if (!this.IsDereferencedReference)
{
if (num > 0x4020)
{
if (num > 0x4040)
{
if ((num != 0xf020) && (num != 0xf030))
{
goto TR_0003;
}
}
else if ((num != 0x4030) && (num != 0x4040))
{
goto TR_0003;
}
goto TR_0004;
}
else if (((num == 0x4000) || (num == 0x4010)) || (num == 0x4020))
{
goto TR_0004;
}
}
else
{
goto TR_0002;
}
}
else
{
num = 0xf01a;
num2 = 0;
goto TR_0000;
}
goto TR_0003;
TR_0000:
indexGroup = num;
indexOffset = num2;
return;
TR_0002:
num = 0xf01b;
num2 = 0;
goto TR_0000;
TR_0003:
num2 = (num <= 0x100000) ? (num2 + ((uint)bitOffset)) : calcPidBitAddressing(num2, bitOffset);
goto TR_0000;
TR_0004:
num++;
num2 = (num2 * 8) + ((uint)bitOffset);
goto TR_0000;
}
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)
{
}
