[DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegDeleteValue")]
private static extern int RegDeleteValue (IntPtr keyHandle, string valueName);
- [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegEnumKey")]
- private static extern int RegEnumKey (IntPtr keyBase, int index, StringBuilder nameBuffer, int bufferLength);
+ [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegEnumKeyExW")]
+ internal unsafe static extern int RegEnumKeyEx (IntPtr keyHandle, int dwIndex,
+ char* lpName, ref int lpcbName, int[] lpReserved,
+ [Out]StringBuilder lpClass, int[] lpcbClass,
+ long[] lpftLastWriteTime);
[DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegEnumValue")]
- private static extern int RegEnumValue (IntPtr keyBase,
- int index, StringBuilder nameBuffer,
- ref int nameLength, IntPtr reserved,
- ref RegistryValueKind type, IntPtr data, IntPtr dataLength);
+ internal unsafe static extern int RegEnumValue (IntPtr hKey, int dwIndex,
+ char* lpValueName, ref int lpcbValueName,
+ IntPtr lpReserved_MustBeZero, int[] lpType, byte[] lpData,
+ int[] lpcbData);
// [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegSetValueEx")]
// private static extern int RegSetValueEx (IntPtr keyBase,
string valueName, IntPtr reserved, ref RegistryValueKind type,
ref long data, ref int dataSize);
+ [DllImport ("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint="RegQueryInfoKeyW")]
+ internal static extern int RegQueryInfoKey (IntPtr hKey, [Out]StringBuilder lpClass,
+ int[] lpcbClass, IntPtr lpReserved_MustBeZero, ref int lpcSubKeys,
+ int[] lpcbMaxSubKeyLen, int[] lpcbMaxClassLen,
+ ref int lpcValues, int[] lpcbMaxValueNameLen,
+ int[] lpcbMaxValueLen, int[] lpcbSecurityDescriptor,
+ int[] lpftLastWriteTime);
+
// Returns our handle from the RegistryKey
public IntPtr GetHandle (RegistryKey key)
{
return result;
}
-
- // Arbitrary max size for key/values names that can be fetched.
- // .NET framework SDK docs say that the max name length that can
- // be used is 255 characters, we'll allow for a bit more.
- const int BufferMaxLength = 1024;
+ // MSDN defines the following limits for registry key names & values:
+ // Key Name: 255 characters
+ // Value name: 16,383 Unicode characters
+ // Value: either 1 MB or current available memory, depending on registry format.
+ private const int MaxKeyLength = 255;
+ private const int MaxValueLength = 16383;
public int SubKeyCount (RegistryKey rkey)
{
- int index;
- StringBuilder stringBuffer = new StringBuilder (BufferMaxLength);
- IntPtr handle = GetHandle (rkey);
-
- for (index = 0; true; index ++) {
- int result = RegEnumKey (handle, index, stringBuffer,
- stringBuffer.Capacity);
-
- if (result == Win32ResultCode.Success)
- continue;
-
- if (result == Win32ResultCode.NoMoreEntries)
- break;
-
- // something is wrong!!
- GenerateException (result);
- }
- return index;
+ int subkeys = 0;
+ int junk = 0;
+ int ret = RegQueryInfoKey (GetHandle (rkey),
+ null,
+ null,
+ IntPtr.Zero,
+ ref subkeys, // subkeys
+ null,
+ null,
+ ref junk, // values
+ null,
+ null,
+ null,
+ null);
+
+ if (ret != Win32ResultCode.Success)
+ GenerateException (ret);
+ return subkeys;
}
public int ValueCount (RegistryKey rkey)
{
- int index, result, bufferCapacity;
- RegistryValueKind type;
- StringBuilder buffer = new StringBuilder (BufferMaxLength);
-
- IntPtr handle = GetHandle (rkey);
- for (index = 0; true; index ++) {
- type = 0;
- bufferCapacity = buffer.Capacity;
- result = RegEnumValue (handle, index,
- buffer, ref bufferCapacity,
- IntPtr.Zero, ref type,
- IntPtr.Zero, IntPtr.Zero);
-
- if (result == Win32ResultCode.Success || result == Win32ResultCode.MoreData)
- continue;
-
- if (result == Win32ResultCode.NoMoreEntries)
- break;
-
- // something is wrong
- GenerateException (result);
- }
- return index;
+ int values = 0;
+ int junk = 0;
+ int ret = RegQueryInfoKey (GetHandle (rkey),
+ null,
+ null,
+ IntPtr.Zero,
+ ref junk, // subkeys
+ null,
+ null,
+ ref values, // values
+ null,
+ null,
+ null,
+ null);
+ if (ret != Win32ResultCode.Success)
+ GenerateException (ret);
+ return values;
}
public RegistryKey OpenRemoteBaseKey (RegistryHive hKey, string machineName)
GenerateException (result);
}
- public string [] GetSubKeyNames (RegistryKey rkey)
+ public unsafe string [] GetSubKeyNames (RegistryKey rkey)
{
- IntPtr handle = GetHandle (rkey);
- StringBuilder buffer = new StringBuilder (BufferMaxLength);
- var keys = new List<string> ();
-
- for (int index = 0; true; index ++) {
- int result = RegEnumKey (handle, index, buffer, buffer.Capacity);
-
- if (result == Win32ResultCode.Success) {
- keys.Add (buffer.ToString ());
- buffer.Length = 0;
- continue;
+ int subkeys = SubKeyCount (rkey);
+ var names = new string [subkeys]; // Returns 0-length array if empty.
+
+ if (subkeys > 0) {
+ var hkey = GetHandle (rkey);
+ char[] name = new char [MaxKeyLength + 1];
+ int namelen;
+
+ fixed (char* namePtr = &name [0]) {
+ for (int i = 0; i < subkeys; i++) {
+ namelen = name.Length; // Don't remove this. The API's doesn't work if this is not properly initialised.
+ int ret = RegEnumKeyEx (hkey,
+ i,
+ namePtr,
+ ref namelen,
+ null,
+ null,
+ null,
+ null);
+
+ if (ret != 0)
+ GenerateException (ret);
+ names [i] = new String (namePtr);
+ }
}
-
- if (result == Win32ResultCode.NoMoreEntries)
- break;
-
- // should not be here!
- GenerateException (result);
}
- return keys.ToArray ();
- }
+ return names;
+ }
- public string [] GetValueNames (RegistryKey rkey)
+ public unsafe string [] GetValueNames (RegistryKey rkey)
{
- IntPtr handle = GetHandle (rkey);
- var values = new List<string> ();
-
- for (int index = 0; true; index ++)
- {
- StringBuilder buffer = new StringBuilder (BufferMaxLength);
- int bufferCapacity = buffer.Capacity;
- RegistryValueKind type = 0;
-
- int result = RegEnumValue (handle, index, buffer, ref bufferCapacity,
- IntPtr.Zero, ref type, IntPtr.Zero, IntPtr.Zero);
-
- if (result == Win32ResultCode.Success || result == Win32ResultCode.MoreData) {
- values.Add (buffer.ToString ());
- continue;
+ int values = ValueCount (rkey);
+ String[] names = new String [values];
+
+ if (values > 0) {
+ IntPtr hkey = GetHandle (rkey);
+ char[] name = new char [MaxValueLength + 1];
+ int namelen;
+
+ fixed (char* namePtr = &name [0]) {
+ for (int i = 0; i < values; i++) {
+ namelen = name.Length;
+
+ int ret = RegEnumValue (hkey,
+ i,
+ namePtr,
+ ref namelen,
+ IntPtr.Zero,
+ null,
+ null,
+ null);
+
+ if (ret != Win32ResultCode.Success && ret != Win32Native.ERROR_MORE_DATA)
+ GenerateException (ret);
+
+ names [i] = new String (namePtr);
+ }
}
-
- if (result == Win32ResultCode.NoMoreEntries)
- break;
-
- GenerateException (result);
}
- return values.ToArray ();
+ return names;
}
private void CheckResult (int result)
interface IFoo {
}
+
+ [Test]
+ public void GenericFieldInCreatedType () {
+ /*
+ * Regression test for #47867.
+ * We construct the following, but only call CreateType on R.
+ *
+ * public class S<T> {
+ * public T t;
+ * }
+ * public class R {
+ * public static S<R> sr;
+ * }
+ */
+ var aname = new AssemblyName ("example1");
+ var ab = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.Run);
+ var mb = ab.DefineDynamicModule (aname.Name);
+ var tbS = mb.DefineType ("S", TypeAttributes.Public);
+ tbS.DefineGenericParameters (new String [] { "T" });
+ var tbR = mb.DefineType ("R", TypeAttributes.Public);
+ tbR.DefineField ("sr", tbS.MakeGenericType(new Type[] { tbR }), FieldAttributes.Public | FieldAttributes.Static);
+
+ Type r = tbR.CreateType ();
+
+ Assert.IsNotNull (r);
+ }
+
+ [Test]
+ public void GenericFieldInCreatedTypeIncompleteTypeTLE () {
+ /*
+ * Regression test for #47867.
+ * We construct the following, but only call CreateType on R.
+ * Then we try to use R.sr which is expected throw a
+ * TLE because S hasn't been created yet.
+ *
+ * public class S<T> {
+ * public T t;
+ * }
+ * public class R {
+ * public static S<R> sr;
+ * }
+ */
+ var aname = new AssemblyName ("example1");
+ var ab = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.Run);
+ var mb = ab.DefineDynamicModule (aname.Name);
+ var tbS = mb.DefineType ("S", TypeAttributes.Public);
+ tbS.DefineGenericParameters (new String [] { "T" });
+ var tbR = mb.DefineType ("R", TypeAttributes.Public);
+ tbR.DefineField ("sr", tbS.MakeGenericType(new Type[] { tbR }), FieldAttributes.Public | FieldAttributes.Static);
+
+ Type r = tbR.CreateType ();
+
+ Assert.IsNotNull (r);
+
+ // N.B. tbS has not had CreateType called yet, so expect this to fail.
+ Assert.Throws<TypeLoadException> (delegate { var ft = r.GetField("sr").FieldType; });
+ }
+
}
}
return res;
}
- /* This MonoGenericClass hack is no longer necessary. Let's leave it here until we finish with the 2-stage type-builder setup.*/
- if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_class->is_dynamic && !type->data.generic_class->container_class->wastypebuilder)
- g_assert (0);
+ if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_class->is_dynamic && !type->data.generic_class->container_class->wastypebuilder) {
+ /* This can happen if a TypeBuilder for a generic class K<T,U>
+ * had reflection_create_generic_class) called on it, but not
+ * ves_icall_TypeBuilder_create_runtime_class. This can happen
+ * if the K`2 is refernced from a generic instantiation
+ * (e.g. K<int,string>) that appears as type argument
+ * (e.g. Dict<string,K<int,string>>), field (e.g. K<int,string>
+ * Foo) or method signature, parent class or any of the above
+ * in a nested class of some other TypeBuilder. Such an
+ * occurrence caused mono_reflection_type_get_handle to be
+ * called on the sre generic instance (K<int,string>) which
+ * required the container_class for the generic class K`2 to be
+ * set up, but the remainder of class construction for K`2 has
+ * not been done. */
+ char * full_name = mono_type_get_full_name (klass);
+ /* I would have expected ReflectionTypeLoadException, but evidently .NET throws TLE in this case. */
+ mono_error_set_type_load_class (error, klass, "TypeBuilder.CreateType() not called for generic class %s", full_name);
+ g_free (full_name);
+ mono_domain_unlock (domain);
+ mono_loader_unlock ();
+ return NULL;
+ }
if (mono_class_get_ref_info (klass) && !klass->wastypebuilder && !type->byref) {
mono_domain_unlock (domain);
if (mono_is_sre_type_builder (mono_object_class (type))) {
is_dynamic = TRUE;
} else if (mono_is_sre_generic_instance (mono_object_class (type))) {
+ /* Does this ever make sense? what does instantiating a generic instance even mean? */
+ g_assert_not_reached ();
MonoReflectionGenericClass *rgi = (MonoReflectionGenericClass *) type;
MonoReflectionType *gtd = rgi->generic_type;
projects / mono.git / commitdiff