internal CultureInfo(String name, bool useUserOverride)
{
if (name == null)
{
throw new ArgumentNullException("name",
SR.ArgumentNull_String);
}
#if CORERT
// CORERT-TODO CultureInfo
if (s_InvariantCultureInfo == null)
{
m_cultureData = CultureData.GetCultureData("", useUserOverride);
}
else
{
m_cultureData = s_InvariantCultureInfo.m_cultureData;
}
m_name = _sortName = _nonSortName = name;
m_isInherited = false;
#else
// Get our data providing record
this.m_cultureData = CultureData.GetCultureData(name, useUserOverride);
if (this.m_cultureData == null)
{
throw new CultureNotFoundException(
"name", name, SR.Argument_CultureNotSupported);
}
this.m_name = this.m_cultureData.CultureName;
this.m_isInherited = !this.EETypePtr.FastEquals(EETypePtr.EETypePtrOf <CultureInfo>());
#endif // CORERT
}
internal static Action GetCompletionAction <TStateMachine>(ref Action cachedMoveNextAction, ref TStateMachine stateMachine, Task taskIfDebuggingEnabled)
where TStateMachine : IAsyncStateMachine
{
return(GetCompletionActionHelper(
ref cachedMoveNextAction,
ref Unsafe.As <TStateMachine, byte>(ref stateMachine),
EETypePtr.EETypePtrOf <TStateMachine>(),
taskIfDebuggingEnabled));
}
internal EEType *GetArrayEEType()
{
#if INPLACE_RUNTIME
return(EETypePtr.EETypePtrOf <Array>().ToPointer());
#else
fixed(EEType *pThis = &this)
return(InternalCalls.RhpGetArrayBaseType(pThis));
#endif
}
//==============================================================================================
// Access to the underlying execution engine's object allocation routines.
//==============================================================================================
//
// Perform the equivalent of a "newobj", but without invoking any constructors. Other than the EEType, the result object is zero-initialized.
//
// Special cases:
//
// Strings: The .ctor performs both the construction and initialization
// and compiler special cases these.
//
// Nullable<T>: the boxed result is the underlying type rather than Nullable so the constructor
// cannot truly initialize it.
//
// In these cases, this helper returns "null" and ConstructorInfo.Invoke() must deal with these specially.
//
public static object NewObject(RuntimeTypeHandle typeHandle)
{
EETypePtr eeType = typeHandle.ToEETypePtr();
if (eeType.IsNullable ||
eeType == EETypePtr.EETypePtrOf <string>()
)
{
return(null);
}
return(RuntimeImports.RhNewObject(eeType));
}
#pragma warning disable CA1822
internal MethodTable *GetArrayEEType()
{
#if INPLACE_RUNTIME
return(EETypePtr.EETypePtrOf <Array>().ToPointer());
#else
fixed(MethodTable *pThis = &this)
{
void *pGetArrayEEType = InternalCalls.RhpGetClasslibFunctionFromEEType(new IntPtr(pThis), ClassLibFunctionId.GetSystemArrayEEType);
return(((delegate * < MethodTable * >)pGetArrayEEType)());
}
#endif
}
internal EEType *GetArrayEEType()
{
#if INPLACE_RUNTIME
return(EETypePtr.EETypePtrOf <Array>().ToPointer());
#else
fixed(EEType *pThis = &this)
{
IntPtr pGetArrayEEType = (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(new IntPtr(pThis), ClassLibFunctionId.GetSystemArrayEEType);
return((EEType *)CalliIntrinsics.Call <IntPtr>(pGetArrayEEType));
}
#endif
}
//==============================================================================================
// Access to the underlying execution engine's object allocation routines.
//==============================================================================================
//
// Perform the equivalent of a "newobj", but without invoking any constructors. Other than the EEType, the result object is zero-initialized.
//
// Special cases:
//
// Strings: The .ctor performs both the construction and initialization
// and compiler special cases these.
//
// IntPtr/UIntPtr: These have intrinsic constructors and it happens, special-casing these in the class library
// is the lesser evil compared to special-casing them in the toolchain.
//
// Nullable<T>: the boxed result is the underlying type rather than Nullable so the constructor
// cannot truly initialize it.
//
// In these cases, this helper returns "null" and ConstructorInfo.Invoke() must deal with these specially.
//
public static Object NewObject(RuntimeTypeHandle typeHandle)
{
EETypePtr eeType = typeHandle.ToEETypePtr();
if (RuntimeImports.RhIsNullable(eeType) ||
eeType == EETypePtr.EETypePtrOf <String>() ||
eeType == EETypePtr.EETypePtrOf <IntPtr>() ||
eeType == EETypePtr.EETypePtrOf <UIntPtr>()
)
{
return(null);
}
return(RuntimeImports.RhNewObject(eeType));
}
private static Lock GetLock(Object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
// TODO: Fix framework code to not call Monitor methods on Lock objects and replace this check with an assertion.
// The Lock class is sealed and never cloned, therefore it is safe to use raw pointer equality.
if (obj.EETypePtr.RawValue == EETypePtr.EETypePtrOf <Lock>().RawValue)
{
return(RuntimeHelpers.UncheckedCast <Lock>(obj));
}
return(s_lockTable.GetValue(obj, s_createLock));
}
//==============================================================================================
// Access to the underlying execution engine's object allocation routines.
//==============================================================================================
//
// Perform the equivalent of a "newobj", but without invoking any constructors. Other than the MethodTable, the result object is zero-initialized.
//
// Special cases:
//
// Strings: The .ctor performs both the construction and initialization
// and compiler special cases these.
//
// Nullable<T>: the boxed result is the underlying type rather than Nullable so the constructor
// cannot truly initialize it.
//
// In these cases, this helper returns "null" and ConstructorInfo.Invoke() must deal with these specially.
//
public static object NewObject(RuntimeTypeHandle typeHandle)
{
EETypePtr eeType = typeHandle.ToEETypePtr();
if (eeType.IsNullable ||
eeType == EETypePtr.EETypePtrOf <string>()
)
{
return(null);
}
if (eeType.IsByRefLike)
{
throw new System.Reflection.TargetException();
}
return(RuntimeImports.RhNewObject(eeType));
}
internal CultureInfo(String name, bool useUserOverride)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name),
SR.ArgumentNull_String);
}
// Get our data providing record
this.m_cultureData = CultureData.GetCultureData(name, useUserOverride);
if (this.m_cultureData == null)
{
throw new CultureNotFoundException(
nameof(name), name, SR.Argument_CultureNotSupported);
}
this.m_name = this.m_cultureData.CultureName;
this.m_isInherited = !this.EETypePtr.FastEquals(EETypePtr.EETypePtrOf <CultureInfo>());
}
public static object ToObject(TypedReference value)
{
RuntimeTypeHandle typeHandle = value._typeHandle;
if (typeHandle.IsNull)
{
throw new ArgumentNullException(); // For compatibility.
}
EETypePtr eeType = typeHandle.ToEETypePtr();
if (eeType.IsValueType)
{
return(RuntimeImports.RhBox(eeType, ref value.Value));
}
else if (eeType.IsPointer)
{
return(RuntimeImports.RhBox(EETypePtr.EETypePtrOf <UIntPtr>(), ref value.Value));
}
else
{
return(Unsafe.As <byte, object>(ref value.Value));
}
}
private static unsafe void InitializeStringTable(IntPtr stringTableStart, int length)
{
IntPtr stringTableEnd = (IntPtr)((byte *)stringTableStart + length);
for (IntPtr *tab = (IntPtr *)stringTableStart; tab < (IntPtr *)stringTableEnd; tab++)
{
byte *bytes = (byte *)*tab;
int len = (int)NativePrimitiveDecoder.DecodeUnsigned(ref bytes);
int count = LowLevelUTF8Encoding.GetCharCount(bytes, len);
Contract.Assert(count >= 0);
string newStr = RuntimeImports.RhNewArrayAsString(EETypePtr.EETypePtrOf <string>(), count);
fixed(char *dest = newStr)
{
int newCount = LowLevelUTF8Encoding.GetChars(bytes, len, dest, count);
Contract.Assert(newCount == count);
}
GCHandle handle = GCHandle.Alloc(newStr);
* tab = (IntPtr)handle;
}
}
public static RuntimeTypeHandle RuntimeTypeHandleOf <T>()
{
return(new RuntimeTypeHandle(EETypePtr.EETypePtrOf <T>()));
}
public static bool IsReferenceOrContainsReferences <T>()
{
var pEEType = EETypePtr.EETypePtrOf <T>();
return(!pEEType.IsValueType || pEEType.HasPointers);
}
internal EEType *GetArrayEEType()
{
return(EETypePtr.EETypePtrOf <Array>().ToPointer());
}
public unsafe object?Invoke(
object?thisPtr,
IntPtr methodToCall,
object?[]?parameters,
BinderBundle?binderBundle,
bool wrapInTargetInvocationException)
{
int argCount = parameters?.Length ?? 0;
if (argCount != _argumentCount)
{
if (_argumentCount < 0)
{
if (_argumentCount == ArgumentCount_NotSupported_ByRefLike)
{
throw new NotSupportedException(SR.NotSupported_ByRefLike);
}
throw new NotSupportedException();
}
throw new TargetParameterCountException(SR.Arg_ParmCnt);
}
object?returnObject = null;
scoped ref byte thisArg = ref Unsafe.NullRef <byte>();
if (!_isStatic)
{
// The caller is expected to validate this
Debug.Assert(thisPtr != null);
// See TODO comment in DynamicInvokeMethodThunk.NormalizeSignature
// if (_isValueTypeInstanceMethod)
// {
// // thisArg is a raw data byref for valuetype instance methods
// thisArg = ref thisPtr.GetRawData();
// }
// else
{
thisArg = ref Unsafe.As <object?, byte>(ref thisPtr);
}
}
scoped ref byte ret = ref Unsafe.As <object?, byte>(ref returnObject);
if ((_returnTransform & Transform.AllocateReturnBox) != 0)
{
returnObject = RuntimeImports.RhNewObject(
(_returnTransform & Transform.Pointer) != 0 ?
EETypePtr.EETypePtrOf <IntPtr>() : _returnType);
ret = ref returnObject.GetRawData();
}
if (argCount == 0)
{
try
{
ret = ref RawCalliHelper.Call(InvokeThunk, (void *)methodToCall, ref thisArg, ref ret, null);
DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
catch (Exception e) when(wrapInTargetInvocationException)
{
throw new TargetInvocationException(e);
}
}
else if (argCount > MaxStackAllocArgCount)
{
ret = ref InvokeWithManyArguments(methodToCall, ref thisArg, ref ret,
parameters, binderBundle, wrapInTargetInvocationException);
}
else
{
StackAllocedArguments argStorage = default;
StackAllocatedByRefs byrefStorage = default;
CheckArguments(ref argStorage._arg0 !, (ByReference *)&byrefStorage, parameters, binderBundle);
try
{
ret = ref RawCalliHelper.Call(InvokeThunk, (void *)methodToCall, ref thisArg, ref ret, &byrefStorage);
DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
catch (Exception e) when(wrapInTargetInvocationException)
{
throw new TargetInvocationException(e);
}
finally
{
if (_needsCopyBack)
{
CopyBack(ref argStorage._arg0 !, parameters);
}
}
}
return(((_returnTransform & (Transform.Nullable | Transform.Pointer | Transform.ByRef)) != 0) ?
ReturnTransform(ref ret, wrapInTargetInvocationException) : returnObject);
}
public static bool IsReference <T>()
{
var pEEType = EETypePtr.EETypePtrOf <T>();
return(!pEEType.IsValueType);
}
private static int s_maxSpinCount = -1; // -1 means the spin count has not yet beeen determined.
//
// IsLock is faster that "obj as Lock()", as it avoids the overhead of the full
// casting logic in the runtime. This is only safe because a) EETypePtr
// overloads operator == to do the right thing, and b) Lock is sealed, so we
// don't need to waste time traversing the inheritence heirarchy.
//
internal static bool IsLock(object obj)
{
return(obj.EETypePtr == EETypePtr.EETypePtrOf <Lock>());
}
internal MethodTable *GetArrayEEType()
{
return(EETypePtr.EETypePtrOf <Array>().ToPointer());
}