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