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);
