private static string GetNameForField(_FieldInfo inf)
{
// First we need to separate out the
// actual name of field from the type of the field.
int loc = inf.Id.IndexOf(' ');
if (loc >= 0)
{
string fName = inf.Id.Substring(loc, inf.Id.Length - loc);
return(inf.DeclaringType.AssemblyQualifiedName + fName);
}
return(inf.Id);
}
private static void DoGetFieldsInfo(Type aType, List <_FieldInfo> aFields, bool includeStatic)
{
var xCurList = new Dictionary <string, _FieldInfo>();
var xBindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
if (includeStatic)
{
xBindingFlags |= BindingFlags.Static;
}
var xFields = (from item in aType.GetFields(xBindingFlags)
orderby item.Name, item.DeclaringType.ToString()
select item).ToArray();
for (int i = 0; i < xFields.Length; i++)
{
var xField = xFields[i];
// todo: should be possible to have GetFields only return fields from a given type, thus removing need of next statement
if (xField.DeclaringType != aType)
{
continue;
}
string xId = xField.GetFullName();
var xInfo = new _FieldInfo(xId, SizeOfType(xField.FieldType), aType, xField.FieldType);
xInfo.IsStatic = xField.IsStatic;
xInfo.Field = xField;
var xFieldOffsetAttrib =
xField.GetCustomAttributes <FieldOffsetAttribute>(true).FirstOrDefault();
if (xFieldOffsetAttrib != null)
{
xInfo.Offset = (uint)xFieldOffsetAttrib.Value;
}
aFields.Add(xInfo);
xCurList.Add(xId, xInfo);
}
// now check plugs
IDictionary <string, PlugFieldAttribute> xPlugFields;
if (mPlugManager.PlugFields.TryGetValue(aType, out xPlugFields))
{
foreach (var xPlugField in xPlugFields)
{
_FieldInfo xPluggedField = null;
if (xCurList.TryGetValue(xPlugField.Key, out xPluggedField))
{
// plugfield modifies an already existing field
// TODO: improve.
if (xPlugField.Value.IsExternalValue)
{
xPluggedField.IsExternalValue = true;
xPluggedField.FieldType = xPluggedField.FieldType.MakePointerType();
xPluggedField.Size = 4;
}
}
else
{
xPluggedField = new _FieldInfo(xPlugField.Value.FieldId, SizeOfType(xPlugField.Value.FieldType), aType,
xPlugField.Value.FieldType);
aFields.Add(xPluggedField);
}
}
}
Type xBase = aType.GetTypeInfo().BaseType;
if (xBase != null)
{
DoGetFieldsInfo(xBase, aFields, includeStatic);
}
}
private static List <_FieldInfo> GetValueTypeFieldsInfo(Type type)
{
var structLayoutAttribute = type.StructLayoutAttribute;
var fieldInfos = new List <_FieldInfo>();
var fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
switch (structLayoutAttribute.Value)
{
case LayoutKind.Auto:
case LayoutKind.Sequential:
var offset = 0;
var pack = structLayoutAttribute.Pack;
if (pack == 0)
{
pack = (int)SizeOfType(typeof(IntPtr));
}
if (fields.Length > 0)
{
var typeAlignment = Math.Min(pack, fields.Max(f => SizeOfType(f.FieldType)));
Array.Sort(fields, (x, y) => x.MetadataToken.CompareTo(y.MetadataToken));
foreach (var field in fields)
{
var fieldSize = SizeOfType(field.FieldType);
var fieldAlignment = Math.Min(typeAlignment, fieldSize);
offset = (int)Align((uint)offset, (uint)fieldAlignment);
var fieldInfo = new _FieldInfo(
field.GetFullName(), SizeOfType(field.FieldType), type, field.FieldType);
fieldInfo.Offset = (uint)offset;
fieldInfo.Field = field;
fieldInfos.Add(fieldInfo);
offset += (int)fieldSize;
}
}
break;
case LayoutKind.Explicit:
foreach (var field in fields)
{
var fieldInfo = new _FieldInfo(field.GetFullName(), SizeOfType(field.FieldType), type, field.FieldType);
fieldInfo.Offset = (uint)(field.GetCustomAttribute <FieldOffsetAttribute>()?.Value ?? 0);
fieldInfo.Field = field;
fieldInfos.Add(fieldInfo);
}
break;
default:
throw new NotSupportedException();
}
return(fieldInfos);
}
