internal Symbol(AdsSymbolEntry entry, IDataType type, ISymbol parent, ISymbolFactoryServices factoryServices) : this(entry, parent, factoryServices)
{
base.category = type.Category;
base.resolvedDataType = type;
if ((base.attributes != null) && (base.attributes.Count >= 2))
{
ISubRangeType subRange = null;
if (TryParseSubRange(type, base.attributes, factoryServices.Binder, out subRange))
{
base.category = subRange.Category;
base.resolvedDataType = subRange;
}
}
}
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 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);
}
private void CheckType(IDataType type, Type targetType)
{
List <IDataType> list = null;
if (this._checkedTypesDict.TryGetValue(targetType, out list) && list.Contains(type))
{
return;
}
switch (type.Category)
{
case DataTypeCategory.Primitive:
case DataTypeCategory.Pointer:
case DataTypeCategory.Reference:
if (type.ByteSize > PrimitiveTypeConverter.MarshalSize(targetType))
{
throw new MarshalException($"Source type '{type.Name}' is larger than target type '{targetType.Name}'!");
}
goto TR_0007;
case DataTypeCategory.Alias:
{
IAliasType type2 = (IAliasType)type;
try
{
this.CheckType(type2.BaseType, targetType);
}
catch (MarshalException exception)
{
throw new MarshalException($"Cannot Marshal Alias '{type2.Name}' !", exception);
}
goto TR_0007;
}
case DataTypeCategory.Enum:
{
IEnumType type3 = (IEnumType)type;
if (!targetType.IsEnum)
{
IManagedMappableType baseType = type3.BaseType as IManagedMappableType;
bool flag = false;
if (baseType == null)
{
throw new MarshalException($"Type '{targetType.Name}' is not an enum type or enum base type!");
}
flag = baseType.ManagedType == targetType;
}
else
{
string[] names = type3.EnumValues.GetNames();
string[] strArray2 = Enum.GetNames(targetType);
if (names.Length > strArray2.Length)
{
throw new MarshalException($"Enum Types '{type.Name}' and '{targetType.Name}' are not compatible!");
}
StringComparer ordinalIgnoreCase = StringComparer.OrdinalIgnoreCase;
string[] strArray3 = names;
int index = 0;
while (index < strArray3.Length)
{
string x = strArray3[index];
bool flag2 = false;
string[] strArray4 = strArray2;
int num5 = 0;
while (true)
{
if (num5 < strArray4.Length)
{
string y = strArray4[num5];
if (ordinalIgnoreCase.Compare(x, y) != 0)
{
num5++;
continue;
}
flag2 = true;
}
if (!flag2)
{
throw new MarshalException($"Enum Types '{type.Name}' and '{targetType.Name}' are not compatible!");
}
index++;
break;
}
}
}
goto TR_0007;
}
case DataTypeCategory.Array:
{
IArrayType type4 = (IArrayType)type;
if (!targetType.IsArray)
{
throw new MarshalException($"Type '{targetType.Name}' is not an array type!");
}
int arrayRank = targetType.GetArrayRank();
if (type4.Dimensions.Count != arrayRank)
{
throw new MarshalException($"Array Types '{type.Name}' and '{targetType.Name}' are not compatible!");
}
Type elementType = targetType.GetElementType();
try
{
this.CheckType(type4.ElementType, elementType);
}
catch (MarshalException exception2)
{
throw new MarshalException($"Cannot Marshal Elements of Array '{type4.Name}'!", exception2);
}
goto TR_0007;
}
case DataTypeCategory.Struct:
foreach (IMember member in ((IStructType)type).AllMembers)
{
PropertyInfo property = targetType.GetProperty(member.InstanceName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (property != null)
{
this.CheckType(member.DataType, property.PropertyType);
continue;
}
FieldInfo field = targetType.GetField(member.InstanceName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (field != null)
{
Type fieldType = field.FieldType;
try
{
this.CheckType(member.DataType, fieldType);
}
catch (MarshalException exception3)
{
IStructType type6;
throw new MarshalException($"Cannot Marshal Member '{member.InstanceName}' of Source Struct '{type6.Name}' to field '{field.Name}' of target struct '{targetType.Name}'!", exception3);
}
}
}
goto TR_0007;
case DataTypeCategory.SubRange:
{
ISubRangeType type9 = (ISubRangeType)type;
try
{
this.CheckType(type9.BaseType, targetType);
}
catch (MarshalException exception4)
{
throw new MarshalException($"Cannot Marshal Subrange '{type9.Name}'!", exception4);
}
goto TR_0007;
}
case DataTypeCategory.String:
break;
case DataTypeCategory.Bitset:
case DataTypeCategory.Union:
goto TR_0007;
default:
throw new NotSupportedException();
}
if (targetType != typeof(string))
{
throw new MarshalException($"Type mismatch! Target Type '{type.Name}' is not a string (Marshalling AdsType '{targetType.Name}')!");
}
TR_0007:
if (list == null)
{
list = new List <IDataType>();
if (!this._checkedTypesDict.ContainsKey(targetType))
{
this._checkedTypesDict.Add(targetType, list);
}
}
list.Add(type);
}
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);
}
