internal static ClrMethod Create(DesktopRuntimeBase runtime, IMethodDescData mdData)
{
if (mdData == null)
return null;
DesktopModule module = runtime.GetModule(mdData.Module);
return Create(runtime, module != null ? module.GetMetadataImport() : null, mdData);
}
internal static ClrMethod Create(DesktopRuntimeBase runtime, IMethodDescData mdData)
{
if (mdData == null)
{
return(null);
}
DesktopModule module = runtime.GetModule(mdData.Module);
return(Create(runtime, module?.GetMetadataImport(), mdData));
}
private void InitEnumData()
{
if (!IsEnum)
{
throw new InvalidOperationException("Type is not an Enum.");
}
_enumData = new EnumData();
MetaDataImport import = DesktopModule?.GetMetadataImport();
if (import == null)
{
return;
}
IntPtr hnd = IntPtr.Zero;
List <string> names = new List <string>();
foreach (int token in import.EnumerateFields((int)_token))
{
if (import.GetFieldProps(token, out string name, out FieldAttributes attr, out IntPtr ppvSigBlob, out int pcbSigBlob, out int pdwCPlusTypeFlag, out IntPtr ppValue))
{
if ((int)attr == 0x606 && name == "value__")
{
SigParser parser = new SigParser(ppvSigBlob, pcbSigBlob);
if (parser.GetCallingConvInfo(out int sigType) && parser.GetElemType(out int elemType))
{
_enumData.ElementType = (ClrElementType)elemType;
}
}
// public, static, literal, has default
int intAttr = (int)attr;
if ((int)attr == 0x8056)
{
names.Add(name);
SigParser parser = new SigParser(ppvSigBlob, pcbSigBlob);
parser.GetCallingConvInfo(out int ccinfo);
parser.GetElemType(out int elemType);
Type type = ClrRuntime.GetTypeForElementType((ClrElementType)pdwCPlusTypeFlag);
if (type != null)
{
object o = System.Runtime.InteropServices.Marshal.PtrToStructure(ppValue, type);
_enumData.NameToValue[name] = o;
_enumData.ValueToName[o] = name;
}
}
}
}
}
public List <ClrInterface> InitInterfaces()
{
if (DesktopModule == null)
{
_interfaces = DesktopHeap.EmptyInterfaceList;
return(null);
}
BaseDesktopHeapType baseType = BaseType as BaseDesktopHeapType;
List <ClrInterface> interfaces = baseType != null ? new List <ClrInterface>(baseType.Interfaces) : null;
MetaDataImport import = DesktopModule.GetMetadataImport();
if (import == null)
{
_interfaces = DesktopHeap.EmptyInterfaceList;
return(null);
}
foreach (int token in import.EnumerateInterfaceImpls((int)_token))
{
if (import.GetInterfaceImplProps(token, out int mdClass, out int mdIFace))
{
if (interfaces == null)
{
interfaces = new List <ClrInterface>();
}
var result = GetInterface(import, mdIFace);
if (result != null && !interfaces.Contains(result))
{
interfaces.Add(result);
}
}
}
if (interfaces == null)
{
_interfaces = DesktopHeap.EmptyInterfaceList;
}
else
{
_interfaces = interfaces.ToArray();
}
return(interfaces);
}
private void InitFlags()
{
if (_attributes != 0 || DesktopModule == null)
{
return;
}
MetaDataImport import = DesktopModule.GetMetadataImport();
if (import == null)
{
_attributes = (TypeAttributes)0x70000000;
return;
}
if (!import.GetTypeDefAttributes((int)_token, out _attributes) || _attributes == 0)
{
_attributes = (TypeAttributes)0x70000000;
}
}
private void InitFields()
{
if (_fields != null)
{
return;
}
if (IsFree)
{
_fields = new List <ClrInstanceField>();
return;
}
DesktopRuntimeBase runtime = DesktopHeap.DesktopRuntime;
IFieldInfo fieldInfo = runtime.GetFieldInfo(_constructedMT);
if (fieldInfo == null)
{
// Fill fields so we don't repeatedly try to init these fields on error.
_fields = new List <ClrInstanceField>();
return;
}
_fields = new List <ClrInstanceField>((int)fieldInfo.InstanceFields);
// Add base type's fields.
if (BaseType != null)
{
foreach (var field in BaseType.Fields)
{
_fields.Add(field);
}
}
int count = (int)(fieldInfo.InstanceFields + fieldInfo.StaticFields) - _fields.Count;
ulong nextField = fieldInfo.FirstField;
int i = 0;
MetaDataImport import = null;
if (nextField != 0 && DesktopModule != null)
{
import = DesktopModule.GetMetadataImport();
}
while (i < count && nextField != 0)
{
IFieldData field = runtime.GetFieldData(nextField);
if (field == null)
{
break;
}
// We don't handle context statics.
if (field.IsContextLocal)
{
nextField = field.NextField;
continue;
}
// Get the name of the field.
string name = null;
FieldAttributes attr = FieldAttributes.PrivateScope;
int sigLen = 0;
IntPtr ppValue = IntPtr.Zero;
IntPtr fieldSig = IntPtr.Zero;
if (import != null)
{
import.GetFieldProps((int)field.FieldToken, out name, out attr, out fieldSig, out sigLen, out int pdwCPlusTypeFlab, out ppValue);
}
// If we couldn't figure out the name, at least give the token.
if (import == null || name == null)
{
name = string.Format("<ERROR:{0:X}>", field.FieldToken);
}
// construct the appropriate type of field.
if (field.IsThreadLocal)
{
if (_threadStatics == null)
{
_threadStatics = new List <ClrThreadStaticField>((int)fieldInfo.ThreadStaticFields);
}
// TODO: Renable when thread statics are fixed.
//m_threadStatics.Add(new RealTimeMemThreadStaticField(m_heap, field, name));
}
else if (field.IsStatic)
{
if (_statics == null)
{
_statics = new List <ClrStaticField>();
}
// TODO: Enable default values.
/*
* object defaultValue = null;
*
*
* FieldAttributes sdl = FieldAttributes.Static | FieldAttributes.HasDefault | FieldAttributes.Literal;
* if ((attr & sdl) == sdl)
* Debugger.Break();
*/
_statics.Add(new DesktopStaticField(DesktopHeap, field, this, name, attr, null, fieldSig, sigLen));
}
else // instance variable
{
_fields.Add(new DesktopInstanceField(DesktopHeap, field, name, attr, fieldSig, sigLen));
}
i++;
nextField = field.NextField;
}
_fields.Sort((a, b) => a.Offset.CompareTo(b.Offset));
}
