[ion] 23573: - KEY_CELL => CM_KEY_NODE

Author: ion
Date: Mon Aug 14 15:57:47 2006
New Revision: 23573

URL: http://svn.reactos.org/svn/reactos?rev=23573&view=rev
Log:
- KEY_CELL => CM_KEY_NODE

Modified:
    trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c
    trunk/reactos/lib/cmlib/cmdata.h
    trunk/reactos/lib/cmlib/cminit.c
    trunk/reactos/lib/cmlib/hivedata.h
    trunk/reactos/ntoskrnl/cm/cm.h
    trunk/reactos/ntoskrnl/cm/ntfunc.c
    trunk/reactos/ntoskrnl/cm/regfile.c
    trunk/reactos/ntoskrnl/cm/registry.c
    trunk/reactos/ntoskrnl/cm/regobj.c

Modified: trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/reacto...
==============================================================================
--- trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c (original)
+++ trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c Mon Aug 14 15:57:47 2006
@@ -67,16 +67,16 @@

static BOOLEAN
 CmiAddKeyToParentHashTable (PHHIVE Hive,
-			    HCELL_INDEX ParentKeyOffset,
-			    PKEY_CELL NewKeyCell,
+			    HCELL_INDEX Parent,
+			    PCM_KEY_NODE NewKeyCell,
    		    HCELL_INDEX NKBOffset)
 {
   PHASH_TABLE_CELL HashBlock;
-  PKEY_CELL ParentKeyCell;
+  PCM_KEY_NODE ParentKeyCell;
   ULONG i;

-  ParentKeyCell = HvGetCell (Hive, ParentKeyOffset);
-  HashBlock = HvGetCell (Hive, ParentKeyCell->HashTableOffset[HvStable]);
+  ParentKeyCell = HvGetCell (Hive, Parent);
+  HashBlock = HvGetCell (Hive, ParentKeyCell->SubKeyLists[HvStable]);

for (i = 0; i < HashBlock->HashTableSize; i++)
     {
@@ -86,7 +86,7 @@
      memcpy (&HashBlock->Table[i].HashValue,
    	  NewKeyCell->Name,
    	  min(NewKeyCell->NameSize, sizeof(ULONG)));
-	  ParentKeyCell->NumberOfSubKeys[HvStable]++;
+	  ParentKeyCell->SubKeyCounts[HvStable]++;
      return TRUE;
    }
     }
@@ -180,7 +180,7 @@
    		  HCELL_INDEX ValueCellOffset)
 {
   PVALUE_LIST_CELL ValueListCell;
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE KeyCell;

KeyCell = HvGetCell (Hive, KeyCellOffset);
   if (KeyCell == NULL)
@@ -189,15 +189,15 @@
       return FALSE;
     }

-  ValueListCell = HvGetCell (Hive, KeyCell->ValueListOffset);
+  ValueListCell = HvGetCell (Hive, KeyCell->ValueList.List);
   if (ValueListCell == NULL)
     {
       DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n"));
       return FALSE;
     }

-  ValueListCell->ValueOffset[KeyCell->NumberOfValues] = ValueCellOffset;
-  KeyCell->NumberOfValues++;
+  ValueListCell->ValueOffset[KeyCell->ValueList.Count] = ValueCellOffset;
+  KeyCell->ValueList.Count++;

return TRUE;
 }
@@ -278,12 +278,12 @@

static BOOLEAN
 CmiExportSubKey (PHHIVE Hive,
-		 HCELL_INDEX ParentKeyOffset,
+		 HCELL_INDEX Parent,
    	 FRLDRHKEY ParentKey,
    	 FRLDRHKEY Key)
 {
   HCELL_INDEX NKBOffset;
-  PKEY_CELL NewKeyCell;
+  PCM_KEY_NODE NewKeyCell;
   ULONG KeyCellSize;
   ULONG SubKeyCount;
   ULONG ValueCount;
@@ -312,7 +312,7 @@
     }

/* Allocate key cell */
-  KeyCellSize = sizeof(KEY_CELL) + NameSize;
+  KeyCellSize = sizeof(CM_KEY_NODE) + NameSize;
   NKBOffset = HvAllocateCell (Hive, KeyCellSize, HvStable);
   if (NKBOffset == HCELL_NULL)
     {
@@ -321,15 +321,15 @@
     }

/* Initialize key cell */
-  NewKeyCell = (PKEY_CELL) HvGetCell (Hive, NKBOffset);
+  NewKeyCell = (PCM_KEY_NODE) HvGetCell (Hive, NKBOffset);
   NewKeyCell->Id = REG_KEY_CELL_ID;
   NewKeyCell->Flags = 0;
   NewKeyCell->LastWriteTime.QuadPart = 0ULL;
-  NewKeyCell->ParentKeyOffset = ParentKeyOffset;
-  NewKeyCell->NumberOfSubKeys[HvStable] = 0;
-  NewKeyCell->HashTableOffset[HvStable] = -1;
-  NewKeyCell->NumberOfValues = 0;
-  NewKeyCell->ValueListOffset = -1;
+  NewKeyCell->Parent = Parent;
+  NewKeyCell->SubKeyCounts[HvStable] = 0;
+  NewKeyCell->SubKeyLists[HvStable] = -1;
+  NewKeyCell->ValueList.Count = 0;
+  NewKeyCell->ValueList.List = -1;
   NewKeyCell->SecurityKeyOffset = -1;
   NewKeyCell->ClassNameOffset = -1;
   NewKeyCell->NameSize = NameSize;
@@ -352,7 +352,7 @@

/* Add key cell to the parent key's hash table */
   if (!CmiAddKeyToParentHashTable (Hive,
-				   ParentKeyOffset,
+				   Parent,
    			   NewKeyCell,
    			   NKBOffset))
     {
@@ -366,7 +366,7 @@
     {
       /* Allocate value list cell */
       if (!CmiAllocateValueListCell (Hive,
-				     &NewKeyCell->ValueListOffset,
+				     &NewKeyCell->ValueList.List,
    			     ValueCount))
    {
      DbgPrint((DPRINT_REGISTRY, "CmiAllocateValueListCell() failed\n"));
@@ -400,7 +400,7 @@
     {
       /* Allocate hash table cell */
       if (!CmiAllocateHashTableCell (Hive,
-				     &NewKeyCell->HashTableOffset[HvStable],
+				     &NewKeyCell->SubKeyLists[HvStable],
    			     SubKeyCount))
    {
      DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n"));
@@ -430,7 +430,7 @@
 CmiExportHive (PHHIVE Hive,
           PCWSTR KeyName)
 {
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE KeyCell;
   FRLDRHKEY Key;
   ULONG SubKeyCount;
   ULONG ValueCount;
@@ -459,7 +459,7 @@
     {
       /* Allocate value list cell */
       if (!CmiAllocateValueListCell (Hive,
-				     &KeyCell->ValueListOffset,
+				     &KeyCell->ValueList.List,
    			     ValueCount))
    {
      DbgPrint((DPRINT_REGISTRY, "CmiAllocateValueListCell() failed\n"));
@@ -493,7 +493,7 @@
     {
       /* Allocate hash table cell */
       if (!CmiAllocateHashTableCell (Hive,
-				     &KeyCell->HashTableOffset[HvStable],
+				     &KeyCell->SubKeyLists[HvStable],
    			     SubKeyCount))
    {
      DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n"));
@@ -600,11 +600,11 @@

static BOOLEAN
 RegImportSubKey(PHHIVE Hive,
-		PKEY_CELL KeyCell,
+		PCM_KEY_NODE KeyCell,
    	FRLDRHKEY ParentKey)
 {
   PHASH_TABLE_CELL HashCell;
-  PKEY_CELL SubKeyCell;
+  PCM_KEY_NODE SubKeyCell;
   PVALUE_LIST_CELL ValueListCell;
   PVALUE_CELL ValueCell = NULL;
   PWCHAR wName;
@@ -651,16 +651,16 @@
       DbgPrint((DPRINT_REGISTRY, "RegCreateKey() failed!\n"));
       return FALSE;
     }
-  DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->NumberOfSubKeys));
-  DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->NumberOfValues));
+  DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->SubKeyCounts));
+  DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->ValueList.Count));

/* Enumerate and add values */
-  if (KeyCell->NumberOfValues > 0)
-    {
-      ValueListCell = (PVALUE_LIST_CELL) HvGetCell (Hive, KeyCell->ValueListOffset);
+  if (KeyCell->ValueList.Count > 0)
+    {
+      ValueListCell = (PVALUE_LIST_CELL) HvGetCell (Hive, KeyCell->ValueList.List);
       DbgPrint((DPRINT_REGISTRY, "ValueListCell: %x\n", ValueListCell));

-      for (i = 0; i < KeyCell->NumberOfValues; i++)
+      for (i = 0; i < KeyCell->ValueList.Count; i++)
    {
      DbgPrint((DPRINT_REGISTRY, "ValueOffset[%d]: %x\n", i, ValueListCell->ValueOffset[i]));

@@ -674,17 +674,17 @@
     }

/* Enumerate and add subkeys */
-  if (KeyCell->NumberOfSubKeys[HvStable] > 0)
-    {
-      HashCell = (PHASH_TABLE_CELL) HvGetCell (Hive, KeyCell->HashTableOffset[HvStable]);
+  if (KeyCell->SubKeyCounts[HvStable] > 0)
+    {
+      HashCell = (PHASH_TABLE_CELL) HvGetCell (Hive, KeyCell->SubKeyLists[HvStable]);
       DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell));
-      DbgPrint((DPRINT_REGISTRY, "NumberOfSubKeys: %x\n", KeyCell->NumberOfSubKeys));
-
-      for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++)
+      DbgPrint((DPRINT_REGISTRY, "SubKeyCounts: %x\n", KeyCell->SubKeyCounts));
+
+      for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
    {
      DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i, HashCell->Table[i].KeyOffset));

-	  SubKeyCell = (PKEY_CELL) HvGetCell (Hive, HashCell->Table[i].KeyOffset);
+	  SubKeyCell = (PCM_KEY_NODE) HvGetCell (Hive, HashCell->Table[i].KeyOffset);

DbgPrint((DPRINT_REGISTRY, "SubKeyCell[%d]: %x\n", i, SubKeyCell));

@@ -701,9 +701,9 @@
 RegImportBinaryHive(PCHAR ChunkBase,
    	    ULONG ChunkSize)
 {
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE KeyCell;
   PHASH_TABLE_CELL HashCell;
-  PKEY_CELL SubKeyCell;
+  PCM_KEY_NODE SubKeyCell;
   FRLDRHKEY SystemKey;
   ULONG i;
   LONG Error;
@@ -731,8 +731,8 @@
       return FALSE;
     }

-  DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->NumberOfSubKeys));
-  DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->NumberOfValues));
+  DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->SubKeyCounts));
+  DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->ValueList.Count));

/* Open 'System' key */
   Error = RegOpenKey(NULL,
@@ -745,13 +745,13 @@
     }

/* Enumerate and add subkeys */
-  if (KeyCell->NumberOfSubKeys[HvStable] > 0)
-    {
-      HashCell = HvGetCell (Hive, KeyCell->HashTableOffset[HvStable]);
+  if (KeyCell->SubKeyCounts[HvStable] > 0)
+    {
+      HashCell = HvGetCell (Hive, KeyCell->SubKeyLists[HvStable]);
       DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell));
-      DbgPrint((DPRINT_REGISTRY, "NumberOfSubKeys: %x\n", KeyCell->NumberOfSubKeys[HvStable]));
-
-      for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++)
+      DbgPrint((DPRINT_REGISTRY, "SubKeyCounts: %x\n", KeyCell->SubKeyCounts[HvStable]));
+
+      for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
    {
      DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i, HashCell->Table[i].KeyOffset));

Modified: trunk/reactos/lib/cmlib/cmdata.h
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cmdata.h?rev=2357...
==============================================================================
--- trunk/reactos/lib/cmlib/cmdata.h (original)
+++ trunk/reactos/lib/cmlib/cmdata.h Mon Aug 14 15:57:47 2006
@@ -31,7 +31,13 @@
     ULONG UseCount;
 } CM_VIEW_OF_FILE, *PCM_VIEW_OF_FILE;

-typedef struct _KEY_CELL
+typedef struct _CHILD_LIST
+{
+    ULONG Count;
+    HCELL_INDEX List;
+} CHILD_LIST, *PCHILD_LIST;
+
+typedef struct _CM_KEY_NODE
 {
    /* Key cell identifier "kn" (0x6b6e) */
    USHORT Id;
@@ -42,23 +48,18 @@
    /* Time of last flush */
    LARGE_INTEGER LastWriteTime;

-   /* ? */
-   ULONG UnUsed1;
+   ULONG Spare;

/* BlockAddress offset of parent key cell */
-   HCELL_INDEX ParentKeyOffset;
+   HCELL_INDEX Parent;

/* Count of sub keys for the key in this key cell (stable & volatile) */
-   ULONG NumberOfSubKeys[HvMaxStorageType];
+   ULONG SubKeyCounts[HvMaxStorageType];

/* BlockAddress offset of has table for FIXME: subkeys/values? (stable & volatile) */
-   HCELL_INDEX HashTableOffset[HvMaxStorageType];
+   HCELL_INDEX SubKeyLists[HvMaxStorageType];

-   /* Count of values contained in this key cell */
-   ULONG NumberOfValues;
-
-   /* BlockAddress offset of VALUE_LIST_CELL */
-   HCELL_INDEX ValueListOffset;
+   CHILD_LIST ValueList;

/* BlockAddress offset of security cell */
    HCELL_INDEX SecurityKeyOffset;
@@ -66,8 +67,11 @@
    /* BlockAddress offset of registry key class */
    HCELL_INDEX ClassNameOffset;

-   /* ? */
-   ULONG Unused4[5];
+   ULONG MaxNameLen;
+   ULONG MaxClassLen;
+   ULONG MaxValueNameLen;
+   ULONG MaxValueDataLen;
+   ULONG WorkVar;

/* Size in bytes of key name */
    USHORT NameSize;
@@ -77,9 +81,9 @@

/* Name of key (not zero terminated) */
    UCHAR Name[0];
-} KEY_CELL, *PKEY_CELL;
+} CM_KEY_NODE, *PCM_KEY_NODE;

-/* KEY_CELL.Flags constants */
+/* CM_KEY_NODE.Flags constants */
 #define  REG_KEY_VOLATILE_CELL             0x01
 #define  REG_KEY_ROOT_CELL                 0x0C
 #define  REG_KEY_LINK_CELL                 0x10

Modified: trunk/reactos/lib/cmlib/cminit.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cminit.c?rev=2357...
==============================================================================
--- trunk/reactos/lib/cmlib/cminit.c (original)
+++ trunk/reactos/lib/cmlib/cminit.c Mon Aug 14 15:57:47 2006
@@ -12,29 +12,29 @@
    PHHIVE Hive,
    PCWSTR Name)
 {
-   PKEY_CELL KeyCell;
+   PCM_KEY_NODE KeyCell;
    HCELL_INDEX RootCellIndex;
    ULONG NameSize;

NameSize = wcslen(Name) * sizeof(WCHAR);
-   RootCellIndex = HvAllocateCell(Hive, sizeof(KEY_CELL) + NameSize, HvStable);
+   RootCellIndex = HvAllocateCell(Hive, sizeof(CM_KEY_NODE) + NameSize, HvStable);
    if (RootCellIndex == HCELL_NULL)
       return FALSE;

Hive->HiveHeader->RootCell = RootCellIndex;
    Hive->HiveHeader->Checksum = HvpHiveHeaderChecksum(Hive->HiveHeader);

-   KeyCell = (PKEY_CELL)HvGetCell(Hive, RootCellIndex);
+   KeyCell = (PCM_KEY_NODE)HvGetCell(Hive, RootCellIndex);
    KeyCell->Id = REG_KEY_CELL_ID;
    KeyCell->Flags = REG_KEY_ROOT_CELL;
    KeyCell->LastWriteTime.QuadPart = 0;
-   KeyCell->ParentKeyOffset = HCELL_NULL;
-   KeyCell->NumberOfSubKeys[0] = 0;
-   KeyCell->NumberOfSubKeys[1] = 0;
-   KeyCell->HashTableOffset[0] = HCELL_NULL;
-   KeyCell->HashTableOffset[1] = HCELL_NULL;
-   KeyCell->NumberOfValues = 0;
-   KeyCell->ValueListOffset = HCELL_NULL;
+   KeyCell->Parent = HCELL_NULL;
+   KeyCell->SubKeyCounts[0] = 0;
+   KeyCell->SubKeyCounts[1] = 0;
+   KeyCell->SubKeyLists[0] = HCELL_NULL;
+   KeyCell->SubKeyLists[1] = HCELL_NULL;
+   KeyCell->ValueList.Count = 0;
+   KeyCell->ValueList.List = HCELL_NULL;
    KeyCell->SecurityKeyOffset = HCELL_NULL;
    KeyCell->ClassNameOffset = HCELL_NULL; 
    KeyCell->NameSize = NameSize;
@@ -47,23 +47,23 @@
 static VOID CMAPI
 CmpPrepareKey(
    PHHIVE RegistryHive,
-   PKEY_CELL KeyCell)
+   PCM_KEY_NODE KeyCell)
 {
-   PKEY_CELL SubKeyCell;
+   PCM_KEY_NODE SubKeyCell;
    PHASH_TABLE_CELL HashCell;
    ULONG i;

ASSERT(KeyCell->Id == REG_KEY_CELL_ID);

-   KeyCell->HashTableOffset[HvVolatile] = HCELL_NULL;
-   KeyCell->NumberOfSubKeys[HvVolatile] = 0;
+   KeyCell->SubKeyLists[HvVolatile] = HCELL_NULL;
+   KeyCell->SubKeyCounts[HvVolatile] = 0;

/* Enumerate and add subkeys */
-   if (KeyCell->NumberOfSubKeys[HvStable] > 0)
+   if (KeyCell->SubKeyCounts[HvStable] > 0)
    {
-      HashCell = HvGetCell(RegistryHive, KeyCell->HashTableOffset[HvStable]);
+      HashCell = HvGetCell(RegistryHive, KeyCell->SubKeyLists[HvStable]);

-      for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++)
+      for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
       {
          SubKeyCell = HvGetCell(RegistryHive, HashCell->Table[i].KeyOffset);
          CmpPrepareKey(RegistryHive, SubKeyCell);
@@ -75,7 +75,7 @@
 CmPrepareHive(
    PHHIVE RegistryHive)
 { 
-   PKEY_CELL RootCell;
+   PCM_KEY_NODE RootCell;

RootCell = HvGetCell(RegistryHive, RegistryHive->HiveHeader->RootCell);
    CmpPrepareKey(RegistryHive, RootCell);

Modified: trunk/reactos/lib/cmlib/hivedata.h
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hivedata.h?rev=23...
==============================================================================
--- trunk/reactos/lib/cmlib/hivedata.h (original)
+++ trunk/reactos/lib/cmlib/hivedata.h Mon Aug 14 15:57:47 2006
@@ -77,7 +77,7 @@
    ULONG Format;

/* Offset into file from the byte after the end of the base block.
-      If the hive is volatile, this is the actual pointer to the KEY_CELL */
+      If the hive is volatile, this is the actual pointer to the CM_KEY_NODE */
    HCELL_INDEX RootCell;

/* Size of each hive block ? */

Modified: trunk/reactos/ntoskrnl/cm/cm.h
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/cm.h?rev=23573&...
==============================================================================
--- trunk/reactos/ntoskrnl/cm/cm.h (original)
+++ trunk/reactos/ntoskrnl/cm/cm.h Mon Aug 14 15:57:47 2006
@@ -85,8 +85,8 @@
   /* Block offset of the key cell this key belongs in */
   HCELL_INDEX KeyCellOffset;

-  /* KEY_CELL this key belong in */
-  PKEY_CELL KeyCell;
+  /* CM_KEY_NODE this key belong in */
+  PCM_KEY_NODE KeyCell;

/* Link to the parent KEY_OBJECT for this key */
   struct _KEY_OBJECT *ParentKey;
@@ -95,7 +95,7 @@
   LIST_ENTRY ListEntry;

/* Subkeys loaded in SubKeys */
-  ULONG NumberOfSubKeys;
+  ULONG SubKeyCounts;

/* Space allocated in SubKeys */
   ULONG SizeOfSubKeys;
@@ -236,16 +236,16 @@

ULONG
 CmiGetMaxValueNameLength(IN PEREGISTRY_HIVE RegistryHive,
-			 IN PKEY_CELL KeyCell);
+			 IN PCM_KEY_NODE KeyCell);

ULONG
 CmiGetMaxValueDataLength(IN PEREGISTRY_HIVE RegistryHive,
-			 IN PKEY_CELL KeyCell);
+			 IN PCM_KEY_NODE KeyCell);

NTSTATUS
 CmiScanForSubKey(IN PEREGISTRY_HIVE RegistryHive,
-		 IN PKEY_CELL KeyCell,
-		 OUT PKEY_CELL *SubKeyCell,
+		 IN PCM_KEY_NODE KeyCell,
+		 OUT PCM_KEY_NODE *SubKeyCell,
    	 OUT HCELL_INDEX *BlockOffset,
    	 IN PUNICODE_STRING KeyName,
    	 IN ACCESS_MASK DesiredAccess,
@@ -267,20 +267,20 @@

NTSTATUS
 CmiScanKeyForValue(IN PEREGISTRY_HIVE RegistryHive,
-		   IN PKEY_CELL KeyCell,
+		   IN PCM_KEY_NODE KeyCell,
    	   IN PUNICODE_STRING ValueName,
    	   OUT PVALUE_CELL *ValueCell,
    	   OUT HCELL_INDEX *VBOffset);

NTSTATUS
 CmiGetValueFromKeyByIndex(IN PEREGISTRY_HIVE RegistryHive,
-			  IN PKEY_CELL KeyCell,
+			  IN PCM_KEY_NODE KeyCell,
    		  IN ULONG Index,
    		  OUT PVALUE_CELL *ValueCell);

NTSTATUS
 CmiAddValueToKey(IN PEREGISTRY_HIVE RegistryHive,
-		 IN PKEY_CELL KeyCell,
+		 IN PCM_KEY_NODE KeyCell,
    	 IN HCELL_INDEX KeyCellOffset,
    	 IN PUNICODE_STRING ValueName,
    	 OUT PVALUE_CELL *pValueCell,
@@ -288,7 +288,7 @@

NTSTATUS
 CmiDeleteValueFromKey(IN PEREGISTRY_HIVE RegistryHive,
-		      IN PKEY_CELL KeyCell,
+		      IN PCM_KEY_NODE KeyCell,
    	      IN HCELL_INDEX KeyCellOffset,
    	      IN PUNICODE_STRING ValueName);

@@ -299,7 +299,7 @@
    		 IN ULONG HashTableSize,
    		 IN HV_STORAGE_TYPE Storage);

-PKEY_CELL
+PCM_KEY_NODE
 CmiGetKeyFromHashByIndex(PEREGISTRY_HIVE RegistryHive,
    		 PHASH_TABLE_CELL HashBlock,
    		 ULONG Index);
@@ -307,9 +307,9 @@
 NTSTATUS
 CmiAddKeyToHashTable(PEREGISTRY_HIVE RegistryHive,
    	     PHASH_TABLE_CELL HashCell,
-		     PKEY_CELL KeyCell,
+		     PCM_KEY_NODE KeyCell,
    	     HV_STORAGE_TYPE StorageType,
-		     PKEY_CELL NewKeyCell,
+		     PCM_KEY_NODE NewKeyCell,
    	     HCELL_INDEX NKBOffset);

NTSTATUS
@@ -365,11 +365,11 @@

BOOLEAN
 CmiCompareKeyNames(PUNICODE_STRING KeyName,
-		   PKEY_CELL KeyCell);
+		   PCM_KEY_NODE KeyCell);

BOOLEAN
 CmiCompareKeyNamesI(PUNICODE_STRING KeyName,
-		    PKEY_CELL KeyCell);
+		    PCM_KEY_NODE KeyCell);

VOID
@@ -381,9 +381,9 @@

NTSTATUS
 CmiCopyKey (PEREGISTRY_HIVE DstHive,
-	    PKEY_CELL DstKeyCell,
+	    PCM_KEY_NODE DstKeyCell,
        PEREGISTRY_HIVE SrcHive,
-	    PKEY_CELL SrcKeyCell);
+	    PCM_KEY_NODE SrcKeyCell);

NTSTATUS
 CmiSaveTempHive (PEREGISTRY_HIVE Hive,

Modified: trunk/reactos/ntoskrnl/cm/ntfunc.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/ntfunc.c?rev=23...
==============================================================================
--- trunk/reactos/ntoskrnl/cm/ntfunc.c (original)
+++ trunk/reactos/ntoskrnl/cm/ntfunc.c Mon Aug 14 15:57:47 2006
@@ -487,7 +487,7 @@
   KeyObject->ParentKey = Object;
   KeyObject->RegistryHive = KeyObject->ParentKey->RegistryHive;
   KeyObject->Flags = 0;
-  KeyObject->NumberOfSubKeys = 0;
+  KeyObject->SubKeyCounts = 0;
   KeyObject->SizeOfSubKeys = 0;
   KeyObject->SubKeys = NULL;

@@ -531,7 +531,7 @@
       RtlpCreateUnicodeString(&KeyObject->Name, Start, NonPagedPool);
     }

-  KeyObject->KeyCell->ParentKeyOffset = KeyObject->ParentKey->KeyCellOffset;
+  KeyObject->KeyCell->Parent = KeyObject->ParentKey->KeyCellOffset;
   KeyObject->KeyCell->SecurityKeyOffset = KeyObject->ParentKey->KeyCell->SecurityKeyOffset;

DPRINT("RemainingPath: %wZ\n", &RemainingPath);
@@ -628,8 +628,8 @@
   VERIFY_KEY_OBJECT(KeyObject);

/* Check for subkeys */
-  if (KeyObject->KeyCell->NumberOfSubKeys[HvStable] != 0 ||
-      KeyObject->KeyCell->NumberOfSubKeys[HvVolatile] != 0)
+  if (KeyObject->KeyCell->SubKeyCounts[HvStable] != 0 ||
+      KeyObject->KeyCell->SubKeyCounts[HvVolatile] != 0)
     {
       Status = STATUS_CANNOT_DELETE;
     }
@@ -682,7 +682,7 @@
 {
   PKEY_OBJECT KeyObject;
   PEREGISTRY_HIVE  RegistryHive;
-  PKEY_CELL  KeyCell, SubKeyCell;
+  PCM_KEY_NODE  KeyCell, SubKeyCell;
   PHASH_TABLE_CELL  HashTableBlock;
   PKEY_BASIC_INFORMATION  BasicInformation;
   PKEY_NODE_INFORMATION  NodeInformation;
@@ -746,8 +746,8 @@
   RegistryHive = KeyObject->RegistryHive;

/* Check for hightest possible sub key index */
-  if (Index >= KeyCell->NumberOfSubKeys[HvStable] +
-               KeyCell->NumberOfSubKeys[HvVolatile])
+  if (Index >= KeyCell->SubKeyCounts[HvStable] +
+               KeyCell->SubKeyCounts[HvVolatile])
     {
       ExReleaseResourceLite(&CmiRegistryLock);
       KeLeaveCriticalRegion();
@@ -759,10 +759,10 @@
     }

/* Get pointer to SubKey */
-  if (Index >= KeyCell->NumberOfSubKeys[HvStable])
+  if (Index >= KeyCell->SubKeyCounts[HvStable])
     {
       Storage = HvVolatile;
-      BaseIndex = Index - KeyCell->NumberOfSubKeys[HvStable];
+      BaseIndex = Index - KeyCell->SubKeyCounts[HvStable];
     }
   else
     {
@@ -770,7 +770,7 @@
       BaseIndex = Index;
     }

-  if (KeyCell->HashTableOffset[Storage] == HCELL_NULL)
+  if (KeyCell->SubKeyLists[Storage] == HCELL_NULL)
     {
       ExReleaseResourceLite(&CmiRegistryLock);
       KeLeaveCriticalRegion();
@@ -780,8 +780,8 @@
       return STATUS_NO_MORE_ENTRIES;
     }

-  ASSERT(KeyCell->HashTableOffset[Storage] != HCELL_NULL);
-  HashTableBlock = HvGetCell (RegistryHive->Hive, KeyCell->HashTableOffset[Storage]);
+  ASSERT(KeyCell->SubKeyLists[Storage] != HCELL_NULL);
+  HashTableBlock = HvGetCell (RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);

SubKeyCell = CmiGetKeyFromHashByIndex(RegistryHive,
                                         HashTableBlock,
@@ -929,10 +929,10 @@
        FullInformation->ClassOffset = sizeof(KEY_FULL_INFORMATION) -
          sizeof(WCHAR);
        FullInformation->ClassLength = SubKeyCell->ClassSize;
-	    FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject); //SubKeyCell->NumberOfSubKeys;
+	    FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject); //SubKeyCell->SubKeyCounts;
        FullInformation->MaxNameLen = CmiGetMaxNameLength(KeyObject);
        FullInformation->MaxClassLen = CmiGetMaxClassLength(KeyObject);
-	    FullInformation->Values = SubKeyCell->NumberOfValues;
+	    FullInformation->Values = SubKeyCell->ValueList.Count;
        FullInformation->MaxValueNameLen =
          CmiGetMaxValueNameLength(RegistryHive, SubKeyCell);
        FullInformation->MaxValueDataLen =
@@ -986,7 +986,7 @@
   NTSTATUS  Status;
   PKEY_OBJECT  KeyObject;
   PEREGISTRY_HIVE  RegistryHive;
-  PKEY_CELL  KeyCell;
+  PCM_KEY_NODE  KeyCell;
   PVALUE_CELL  ValueCell;
   PVOID  DataCell;
   ULONG NameSize, DataSize;
@@ -1441,7 +1441,7 @@
   PEREGISTRY_HIVE RegistryHive;
   PVOID ClassCell;
   PKEY_OBJECT KeyObject;
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE KeyCell;
   ULONG NameSize, ClassSize;
   NTSTATUS Status;
   REG_QUERY_KEY_INFORMATION QueryKeyInfo;
@@ -1603,10 +1603,10 @@
        FullInformation->TitleIndex = 0;
        FullInformation->ClassOffset = sizeof(KEY_FULL_INFORMATION) - sizeof(WCHAR);
        FullInformation->ClassLength = KeyCell->ClassSize;
-	    FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject); //KeyCell->NumberOfSubKeys;
+	    FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject); //KeyCell->SubKeyCounts;
        FullInformation->MaxNameLen = CmiGetMaxNameLength(KeyObject);
        FullInformation->MaxClassLen = CmiGetMaxClassLength(KeyObject);
-	    FullInformation->Values = KeyCell->NumberOfValues;
+	    FullInformation->Values = KeyCell->ValueList.Count;
        FullInformation->MaxValueNameLen =
          CmiGetMaxValueNameLength(RegistryHive, KeyCell);
        FullInformation->MaxValueDataLen =
@@ -1666,7 +1666,7 @@
   ULONG NameSize, DataSize;
   PKEY_OBJECT  KeyObject;
   PEREGISTRY_HIVE  RegistryHive;
-  PKEY_CELL  KeyCell;
+  PCM_KEY_NODE  KeyCell;
   PVALUE_CELL  ValueCell;
   PVOID  DataCell;
   PKEY_VALUE_BASIC_INFORMATION  ValueBasicInformation;
@@ -1926,7 +1926,7 @@
   NTSTATUS  Status;
   PKEY_OBJECT  KeyObject;
   PEREGISTRY_HIVE  RegistryHive;
-  PKEY_CELL  KeyCell;
+  PCM_KEY_NODE  KeyCell;
   PVALUE_CELL  ValueCell;
   HCELL_INDEX ValueCellOffset;
   PVOID DataCell;
@@ -2378,7 +2378,7 @@
   PKEY_OBJECT KeyObject;
   PVOID DataCell;
   ULONG BufferLength = 0;
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE KeyCell;
   NTSTATUS Status;
   PUCHAR DataPtr;
   ULONG i;

Modified: trunk/reactos/ntoskrnl/cm/regfile.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/regfile.c?rev=2...
==============================================================================
--- trunk/reactos/ntoskrnl/cm/regfile.c (original)
+++ trunk/reactos/ntoskrnl/cm/regfile.c Mon Aug 14 15:57:47 2006
@@ -832,7 +832,7 @@
 ULONG
 CmiGetNumberOfSubKeys(PKEY_OBJECT KeyObject)
 {
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE KeyCell;
   ULONG SubKeyCount;

VERIFY_KEY_OBJECT(KeyObject);
@@ -841,8 +841,8 @@
   VERIFY_KEY_CELL(KeyCell);

SubKeyCount = (KeyCell == NULL) ? 0 :
-                KeyCell->NumberOfSubKeys[HvStable] +
-                KeyCell->NumberOfSubKeys[HvVolatile];
+                KeyCell->SubKeyCounts[HvStable] +
+                KeyCell->SubKeyCounts[HvVolatile];

return SubKeyCount;
 }
@@ -852,8 +852,8 @@
 CmiGetMaxNameLength(PKEY_OBJECT KeyObject)
 {
   PHASH_TABLE_CELL HashBlock;
-  PKEY_CELL CurSubKeyCell;
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE CurSubKeyCell;
+  PCM_KEY_NODE KeyCell;
   ULONG MaxName;
   ULONG NameSize;
   ULONG i;
@@ -867,12 +867,12 @@
   MaxName = 0;
   for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
     {
-      if (KeyCell->HashTableOffset[Storage] != HCELL_NULL)
+      if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
         {
-          HashBlock = HvGetCell (KeyObject->RegistryHive->Hive, KeyCell->HashTableOffset[Storage]);
+          HashBlock = HvGetCell (KeyObject->RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
           ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);

-          for (i = 0; i < KeyCell->NumberOfSubKeys[Storage]; i++)
+          for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
             {
               CurSubKeyCell = HvGetCell (KeyObject->RegistryHive->Hive,
                                          HashBlock->Table[i].KeyOffset);
@@ -895,8 +895,8 @@
 CmiGetMaxClassLength(PKEY_OBJECT  KeyObject)
 {
   PHASH_TABLE_CELL HashBlock;
-  PKEY_CELL CurSubKeyCell;
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE CurSubKeyCell;
+  PCM_KEY_NODE KeyCell;
   ULONG MaxClass;
   ULONG i;
   ULONG Storage;
@@ -909,13 +909,13 @@
   MaxClass = 0;
   for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
     {
-      if (KeyCell->HashTableOffset[Storage] != HCELL_NULL)
+      if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
         {
           HashBlock = HvGetCell (KeyObject->RegistryHive->Hive,
-                                 KeyCell->HashTableOffset[Storage]);
+                                 KeyCell->SubKeyLists[Storage]);
           ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);

-          for (i = 0; i < KeyCell->NumberOfSubKeys[Storage]; i++)
+          for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
             {
               CurSubKeyCell = HvGetCell (KeyObject->RegistryHive->Hive,
                                          HashBlock->Table[i].KeyOffset);
@@ -934,7 +934,7 @@

ULONG
 CmiGetMaxValueNameLength(PEREGISTRY_HIVE RegistryHive,
-			 PKEY_CELL KeyCell)
+			 PCM_KEY_NODE KeyCell)
 {
   PVALUE_LIST_CELL ValueListCell;
   PVALUE_CELL CurValueCell;
@@ -944,16 +944,16 @@

VERIFY_KEY_CELL(KeyCell);

-  if (KeyCell->ValueListOffset == HCELL_NULL)
+  if (KeyCell->ValueList.List == HCELL_NULL)
     {
       return 0;
     }

MaxValueName = 0;
   ValueListCell = HvGetCell (RegistryHive->Hive,
-			     KeyCell->ValueListOffset);
-
-  for (i = 0; i < KeyCell->NumberOfValues; i++)
+			     KeyCell->ValueList.List);
+
+  for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
       CurValueCell = HvGetCell (RegistryHive->Hive,
    			ValueListCell->ValueOffset[i]);
@@ -982,7 +982,7 @@

ULONG
 CmiGetMaxValueDataLength(PEREGISTRY_HIVE RegistryHive,
-			 PKEY_CELL KeyCell)
+			 PCM_KEY_NODE KeyCell)
 {
   PVALUE_LIST_CELL ValueListCell;
   PVALUE_CELL CurValueCell;
@@ -991,15 +991,15 @@

VERIFY_KEY_CELL(KeyCell);

-  if (KeyCell->ValueListOffset == HCELL_NULL)
+  if (KeyCell->ValueList.List == HCELL_NULL)
     {
       return 0;
     }

MaxValueData = 0;
-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
-
-  for (i = 0; i < KeyCell->NumberOfValues; i++)
+  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
+
+  for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
       CurValueCell = HvGetCell (RegistryHive->Hive,
                                 ValueListCell->ValueOffset[i]);
@@ -1015,15 +1015,15 @@

NTSTATUS
 CmiScanForSubKey(IN PEREGISTRY_HIVE RegistryHive,
-		 IN PKEY_CELL KeyCell,
-		 OUT PKEY_CELL *SubKeyCell,
+		 IN PCM_KEY_NODE KeyCell,
+		 OUT PCM_KEY_NODE *SubKeyCell,
    	 OUT HCELL_INDEX *BlockOffset,
    	 IN PUNICODE_STRING KeyName,
    	 IN ACCESS_MASK DesiredAccess,
    	 IN ULONG Attributes)
 {
   PHASH_TABLE_CELL HashBlock;
-  PKEY_CELL CurSubKeyCell;
+  PCM_KEY_NODE CurSubKeyCell;
   ULONG Storage;
   ULONG i;

@@ -1038,16 +1038,16 @@
   for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
     {
       /* The key does not have any subkeys */
-      if (KeyCell->HashTableOffset[Storage] == HCELL_NULL)
+      if (KeyCell->SubKeyLists[Storage] == HCELL_NULL)
         {
           continue;
         }

/* Get hash table */
-      HashBlock = HvGetCell (RegistryHive->Hive, KeyCell->HashTableOffset[Storage]);
+      HashBlock = HvGetCell (RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
       ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);

-      for (i = 0; i < KeyCell->NumberOfSubKeys[Storage]; i++)
+      for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
         {
           if (Attributes & OBJ_CASE_INSENSITIVE)
             {
@@ -1099,9 +1099,9 @@
 {
   PHASH_TABLE_CELL HashBlock;
   HCELL_INDEX NKBOffset;
-  PKEY_CELL NewKeyCell;
+  PCM_KEY_NODE NewKeyCell;
   ULONG NewBlockSize;
-  PKEY_CELL ParentKeyCell;
+  PCM_KEY_NODE ParentKeyCell;
   PVOID ClassCell;
   NTSTATUS Status;
   USHORT NameSize;
@@ -1148,7 +1148,7 @@
   Status = STATUS_SUCCESS;

Storage = (CreateOptions & REG_OPTION_VOLATILE) ? HvVolatile : HvStable;
-  NewBlockSize = sizeof(KEY_CELL) + NameSize;
+  NewBlockSize = sizeof(CM_KEY_NODE) + NameSize;
   NKBOffset = HvAllocateCell (RegistryHive->Hive, NewBlockSize, Storage);
   if (NKBOffset == HCELL_NULL)
     {
@@ -1167,13 +1167,13 @@
           NewKeyCell->Flags = 0;
         }
       KeQuerySystemTime(&NewKeyCell->LastWriteTime);
-      NewKeyCell->ParentKeyOffset = HCELL_NULL;
-      NewKeyCell->NumberOfSubKeys[HvStable] = 0;
-      NewKeyCell->NumberOfSubKeys[HvVolatile] = 0;
-      NewKeyCell->HashTableOffset[HvStable] = HCELL_NULL;
-      NewKeyCell->HashTableOffset[HvVolatile] = HCELL_NULL;
-      NewKeyCell->NumberOfValues = 0;
-      NewKeyCell->ValueListOffset = HCELL_NULL;
+      NewKeyCell->Parent = HCELL_NULL;
+      NewKeyCell->SubKeyCounts[HvStable] = 0;
+      NewKeyCell->SubKeyCounts[HvVolatile] = 0;
+      NewKeyCell->SubKeyLists[HvStable] = HCELL_NULL;
+      NewKeyCell->SubKeyLists[HvVolatile] = HCELL_NULL;
+      NewKeyCell->ValueList.Count = 0;
+      NewKeyCell->ValueList.List = HCELL_NULL;
       NewKeyCell->SecurityKeyOffset = HCELL_NULL;
       NewKeyCell->ClassNameOffset = HCELL_NULL;

@@ -1218,11 +1218,11 @@
   SubKey->KeyCell = NewKeyCell;
   SubKey->KeyCellOffset = NKBOffset;

-  if (ParentKeyCell->HashTableOffset[Storage] == HCELL_NULL)
+  if (ParentKeyCell->SubKeyLists[Storage] == HCELL_NULL)
     {
       Status = CmiAllocateHashTableCell (RegistryHive,
    				 &HashBlock,
-					 &ParentKeyCell->HashTableOffset[Storage],
+					 &ParentKeyCell->SubKeyLists[Storage],
    				 REG_INIT_HASH_TABLE_SIZE,
    				 Storage);
       if (!NT_SUCCESS(Status))
@@ -1233,10 +1233,10 @@
   else
     {
       HashBlock = HvGetCell (RegistryHive->Hive,
-			     ParentKeyCell->HashTableOffset[Storage]);
+			     ParentKeyCell->SubKeyLists[Storage]);
       ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);

-      if (((ParentKeyCell->NumberOfSubKeys[Storage] + 1) >= HashBlock->HashTableSize))
+      if (((ParentKeyCell->SubKeyCounts[Storage] + 1) >= HashBlock->HashTableSize))
    {
      PHASH_TABLE_CELL NewHashBlock;
      HCELL_INDEX HTOffset;
@@ -1258,8 +1258,8 @@
      RtlCopyMemory(&NewHashBlock->Table[0],
    		&HashBlock->Table[0],
    		sizeof(NewHashBlock->Table[0]) * HashBlock->HashTableSize);
-	  HvFreeCell (RegistryHive->Hive, ParentKeyCell->HashTableOffset[Storage]);
-	  ParentKeyCell->HashTableOffset[Storage] = HTOffset;
+	  HvFreeCell (RegistryHive->Hive, ParentKeyCell->SubKeyLists[Storage]);
+	  ParentKeyCell->SubKeyLists[Storage] = HTOffset;
      HashBlock = NewHashBlock;
    }
     }
@@ -1272,7 +1272,7 @@
    			NKBOffset);
   if (NT_SUCCESS(Status))
     {
-      ParentKeyCell->NumberOfSubKeys[Storage]++;
+      ParentKeyCell->SubKeyCounts[Storage]++;
     }

KeQuerySystemTime (&ParentKeyCell->LastWriteTime);
@@ -1298,13 +1298,13 @@
   Storage = (SubKey->KeyCell->Flags & REG_KEY_VOLATILE_CELL) ? HvVolatile : HvStable;

/* Remove all values */
-  if (SubKey->KeyCell->NumberOfValues != 0)
+  if (SubKey->KeyCell->ValueList.Count != 0)
     {
       /* Get pointer to the value list cell */
-      ValueList = HvGetCell (RegistryHive->Hive, SubKey->KeyCell->ValueListOffset);
+      ValueList = HvGetCell (RegistryHive->Hive, SubKey->KeyCell->ValueList.List);

/* Enumerate all values */
-      for (i = 0; i < SubKey->KeyCell->NumberOfValues; i++)
+      for (i = 0; i < SubKey->KeyCell->ValueList.Count; i++)
    {
      /* Get pointer to value cell */
      ValueCell = HvGetCell(RegistryHive->Hive,
@@ -1323,51 +1323,51 @@
    }

/* Destroy value list cell */
-      HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->ValueListOffset);
-
-      SubKey->KeyCell->NumberOfValues = 0;
-      SubKey->KeyCell->ValueListOffset = (HCELL_INDEX)-1;
+      HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->ValueList.List);
+
+      SubKey->KeyCell->ValueList.Count = 0;
+      SubKey->KeyCell->ValueList.List = (HCELL_INDEX)-1;

HvMarkCellDirty(RegistryHive->Hive, SubKey->KeyCellOffset);
     }

/* Remove the key from the parent key's hash block */
-  if (ParentKey->KeyCell->HashTableOffset[Storage] != HCELL_NULL)
-    {
-      DPRINT("ParentKey HashTableOffset %lx\n", ParentKey->KeyCell->HashTableOffset[Storage]);
+  if (ParentKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+    {
+      DPRINT("ParentKey SubKeyLists %lx\n", ParentKey->KeyCell->SubKeyLists[Storage]);
       HashBlock = HvGetCell (ParentKey->RegistryHive->Hive,
-			     ParentKey->KeyCell->HashTableOffset[Storage]);
+			     ParentKey->KeyCell->SubKeyLists[Storage]);
       ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
       DPRINT("ParentKey HashBlock %p\n", HashBlock);
       CmiRemoveKeyFromHashTable(ParentKey->RegistryHive,
    			HashBlock,
    			SubKey->KeyCellOffset);
       HvMarkCellDirty(ParentKey->RegistryHive->Hive,
-                      ParentKey->KeyCell->HashTableOffset[Storage]);
+                      ParentKey->KeyCell->SubKeyLists[Storage]);
     }

/* Remove the key's hash block */
-  if (SubKey->KeyCell->HashTableOffset[Storage] != HCELL_NULL)
-    {
-      DPRINT("SubKey HashTableOffset %lx\n", SubKey->KeyCell->HashTableOffset[Storage]);
-      HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->HashTableOffset[Storage]);
-      SubKey->KeyCell->HashTableOffset[Storage] = HCELL_NULL;
+  if (SubKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+    {
+      DPRINT("SubKey SubKeyLists %lx\n", SubKey->KeyCell->SubKeyLists[Storage]);
+      HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->SubKeyLists[Storage]);
+      SubKey->KeyCell->SubKeyLists[Storage] = HCELL_NULL;
     }

/* Decrement the number of the parent key's sub keys */
   if (ParentKey != NULL)
     {
       DPRINT("ParentKey %p\n", ParentKey);
-      ParentKey->KeyCell->NumberOfSubKeys[Storage]--;
+      ParentKey->KeyCell->SubKeyCounts[Storage]--;

/* Remove the parent key's hash table */
-      if (ParentKey->KeyCell->NumberOfSubKeys[Storage] == 0 &&
-          ParentKey->KeyCell->HashTableOffset[Storage] != HCELL_NULL)
-	{
-	  DPRINT("ParentKey HashTableOffset %lx\n", ParentKey->KeyCell->HashTableOffset);
+      if (ParentKey->KeyCell->SubKeyCounts[Storage] == 0 &&
+          ParentKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+	{
+	  DPRINT("ParentKey SubKeyLists %lx\n", ParentKey->KeyCell->SubKeyLists);
      HvFreeCell (ParentKey->RegistryHive->Hive,
-		      ParentKey->KeyCell->HashTableOffset[Storage]);
-	  ParentKey->KeyCell->HashTableOffset[Storage] = HCELL_NULL;
+		      ParentKey->KeyCell->SubKeyLists[Storage]);
+	  ParentKey->KeyCell->SubKeyLists[Storage] = HCELL_NULL;
    }

KeQuerySystemTime(&ParentKey->KeyCell->LastWriteTime);
@@ -1388,7 +1388,7 @@

NTSTATUS
 CmiScanKeyForValue(IN PEREGISTRY_HIVE RegistryHive,
-		   IN PKEY_CELL KeyCell,
+		   IN PCM_KEY_NODE KeyCell,
    	   IN PUNICODE_STRING ValueName,
    	   OUT PVALUE_CELL *ValueCell,
    	   OUT HCELL_INDEX *ValueCellOffset)
@@ -1402,16 +1402,16 @@
     *ValueCellOffset = (HCELL_INDEX)-1;

/* The key does not have any values */
-  if (KeyCell->ValueListOffset == (HCELL_INDEX)-1)
+  if (KeyCell->ValueList.List == (HCELL_INDEX)-1)
     {
       return STATUS_OBJECT_NAME_NOT_FOUND;
     }

-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
+  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);

VERIFY_VALUE_LIST_CELL(ValueListCell);

-  for (i = 0; i < KeyCell->NumberOfValues; i++)
+  for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
       CurValueCell = HvGetCell (RegistryHive->Hive,
    			ValueListCell->ValueOffset[i]);
@@ -1435,7 +1435,7 @@

NTSTATUS
 CmiGetValueFromKeyByIndex(IN PEREGISTRY_HIVE RegistryHive,
-			  IN PKEY_CELL KeyCell,
+			  IN PCM_KEY_NODE KeyCell,
    		  IN ULONG Index,
    		  OUT PVALUE_CELL *ValueCell)
 {
@@ -1444,18 +1444,18 @@

*ValueCell = NULL;

-  if (KeyCell->ValueListOffset == (HCELL_INDEX)-1)
+  if (KeyCell->ValueList.List == (HCELL_INDEX)-1)
     {
       return STATUS_NO_MORE_ENTRIES;
     }

-  if (Index >= KeyCell->NumberOfValues)
+  if (Index >= KeyCell->ValueList.Count)
     {
       return STATUS_NO_MORE_ENTRIES;
     }

-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
+  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);

VERIFY_VALUE_LIST_CELL(ValueListCell);

@@ -1469,7 +1469,7 @@

NTSTATUS
 CmiAddValueToKey(IN PEREGISTRY_HIVE RegistryHive,
-		 IN PKEY_CELL KeyCell,
+		 IN PCM_KEY_NODE KeyCell,
    	 IN HCELL_INDEX KeyCellOffset,
    	 IN PUNICODE_STRING ValueName,
    	 OUT PVALUE_CELL *pValueCell,
@@ -1483,10 +1483,10 @@
   HV_STORAGE_TYPE Storage;
   NTSTATUS Status;

-  DPRINT("KeyCell->ValuesOffset %lu\n", (ULONG)KeyCell->ValueListOffset);
+  DPRINT("KeyCell->ValuesOffset %lu\n", (ULONG)KeyCell->ValueList.List);

Storage = (KeyCell->Flags & REG_KEY_VOLATILE_CELL) ? HvVolatile : HvStable;
-  if (KeyCell->ValueListOffset == HCELL_NULL)
+  if (KeyCell->ValueList.List == HCELL_NULL)
     {
       CellSize = sizeof(VALUE_LIST_CELL) +
    	 (3 * sizeof(HCELL_INDEX));
@@ -1497,33 +1497,33 @@
    }

ValueListCell = HvGetCell (RegistryHive->Hive, ValueListCellOffset);
-      KeyCell->ValueListOffset = ValueListCellOffset;
+      KeyCell->ValueList.List = ValueListCellOffset;
       HvMarkCellDirty(RegistryHive->Hive, KeyCellOffset);
     }
   else
     {
-      ValueListCell = (PVALUE_LIST_CELL) HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
+      ValueListCell = (PVALUE_LIST_CELL) HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
       CellSize = ABS_VALUE(HvGetCellSize(RegistryHive->Hive, ValueListCell));

-      if (KeyCell->NumberOfValues >=
+      if (KeyCell->ValueList.Count >=
       (CellSize / sizeof(HCELL_INDEX)))
         {
           CellSize *= 2;
-          ValueListCellOffset = HvReallocateCell (RegistryHive->Hive, KeyCell->ValueListOffset, CellSize);
+          ValueListCellOffset = HvReallocateCell (RegistryHive->Hive, KeyCell->ValueList.List, CellSize);
           if (ValueListCellOffset == HCELL_NULL)
             {
               return STATUS_INSUFFICIENT_RESOURCES;
             }

ValueListCell = HvGetCell (RegistryHive->Hive, ValueListCellOffset);
-          KeyCell->ValueListOffset = ValueListCellOffset;
+          KeyCell->ValueList.List = ValueListCellOffset;
           HvMarkCellDirty (RegistryHive->Hive, KeyCellOffset);
         }
     }

#if 0
-  DPRINT("KeyCell->NumberOfValues %lu, ValueListCell->CellSize %lu (%lu %lx)\n",
-	 KeyCell->NumberOfValues,
+  DPRINT("KeyCell->ValueList.Count %lu, ValueListCell->CellSize %lu (%lu %lx)\n",
+	 KeyCell->ValueList.Count,
     (ULONG)ABS_VALUE(ValueListCell->CellSize),
     ((ULONG)ABS_VALUE(ValueListCell->CellSize) - sizeof(CELL_HEADER)) / sizeof(HCELL_INDEX),
     ((ULONG)ABS_VALUE(ValueListCell->CellSize) - sizeof(CELL_HEADER)) / sizeof(HCELL_INDEX));
@@ -1539,11 +1539,11 @@
       return Status;
     }

-  ValueListCell->ValueOffset[KeyCell->NumberOfValues] = NewValueCellOffset;
-  KeyCell->NumberOfValues++;
+  ValueListCell->ValueOffset[KeyCell->ValueList.Count] = NewValueCellOffset;
+  KeyCell->ValueList.Count++;

HvMarkCellDirty(RegistryHive->Hive, KeyCellOffset);
-  HvMarkCellDirty(RegistryHive->Hive, KeyCell->ValueListOffset);
+  HvMarkCellDirty(RegistryHive->Hive, KeyCell->ValueList.List);
   HvMarkCellDirty(RegistryHive->Hive, NewValueCellOffset);

*pValueCell = NewValueCell;
@@ -1555,7 +1555,7 @@

NTSTATUS
 CmiDeleteValueFromKey(IN PEREGISTRY_HIVE RegistryHive,
-		      IN PKEY_CELL KeyCell,
+		      IN PCM_KEY_NODE KeyCell,
    	      IN HCELL_INDEX KeyCellOffset,
    	      IN PUNICODE_STRING ValueName)
 {
@@ -1564,16 +1564,16 @@
   ULONG i;
   NTSTATUS Status;

-  if (KeyCell->ValueListOffset == -1)
+  if (KeyCell->ValueList.List == -1)
     {
       return STATUS_OBJECT_NAME_NOT_FOUND;
     }

-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
+  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);

VERIFY_VALUE_LIST_CELL(ValueListCell);

-  for (i = 0; i < KeyCell->NumberOfValues; i++)
+  for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
       CurValueCell = HvGetCell (RegistryHive->Hive, ValueListCell->ValueOffset[i]);

@@ -1591,26 +1591,26 @@
          return Status;
        }

-	  if (i < (KeyCell->NumberOfValues - 1))
+	  if (i < (KeyCell->ValueList.Count - 1))
        {
          RtlMoveMemory(&ValueListCell->ValueOffset[i],
    		    &ValueListCell->ValueOffset[i + 1],
-			    sizeof(HCELL_INDEX) * (KeyCell->NumberOfValues - 1 - i));
+			    sizeof(HCELL_INDEX) * (KeyCell->ValueList.Count - 1 - i));
        }
-	  ValueListCell->ValueOffset[KeyCell->NumberOfValues - 1] = 0;
-
-
-	  KeyCell->NumberOfValues--;
-
-	  if (KeyCell->NumberOfValues == 0)
+	  ValueListCell->ValueOffset[KeyCell->ValueList.Count - 1] = 0;
+
+
+	  KeyCell->ValueList.Count--;
+
+	  if (KeyCell->ValueList.Count == 0)
        {
-	      HvFreeCell(RegistryHive->Hive, KeyCell->ValueListOffset);
-	      KeyCell->ValueListOffset = -1;
+	      HvFreeCell(RegistryHive->Hive, KeyCell->ValueList.List);
+	      KeyCell->ValueList.List = -1;
        }
      else
        {
          HvMarkCellDirty(RegistryHive->Hive,
-		              KeyCell->ValueListOffset);
+		              KeyCell->ValueList.List);
        }

HvMarkCellDirty(RegistryHive->Hive,
@@ -1660,13 +1660,13 @@
 }

-PKEY_CELL
+PCM_KEY_NODE
 CmiGetKeyFromHashByIndex(PEREGISTRY_HIVE RegistryHive,
    		 PHASH_TABLE_CELL HashBlock,
    		 ULONG Index)
 {
   HCELL_INDEX KeyOffset;
-  PKEY_CELL KeyCell;
+  PCM_KEY_NODE KeyCell;

KeyOffset =  HashBlock->Table[Index].KeyOffset;
   KeyCell = HvGetCell (RegistryHive->Hive, KeyOffset);
@@ -1678,12 +1678,12 @@
 NTSTATUS
 CmiAddKeyToHashTable(PEREGISTRY_HIVE RegistryHive,
    	     PHASH_TABLE_CELL HashCell,
-		     PKEY_CELL KeyCell,
+		     PCM_KEY_NODE KeyCell,
    	     HV_STORAGE_TYPE StorageType,
-		     PKEY_CELL NewKeyCell,
+		     PCM_KEY_NODE NewKeyCell,
    	     HCELL_INDEX NKBOffset)
 {
-  ULONG i = KeyCell->NumberOfSubKeys[StorageType];
+  ULONG i = KeyCell->SubKeyCounts[StorageType];

HashCell->Table[i].KeyOffset = NKBOffset;
   HashCell->Table[i].HashValue = 0;
@@ -1693,7 +1693,7 @@
                     NewKeyCell->Name,
                     min(NewKeyCell->NameSize, sizeof(ULONG)));
     }
-  HvMarkCellDirty(RegistryHive->Hive, KeyCell->HashTableOffset[StorageType]);
+  HvMarkCellDirty(RegistryHive->Hive, KeyCell->SubKeyLists[StorageType]);
   return STATUS_SUCCESS;
 }

@@ -1907,7 +1907,7 @@

BOOLEAN
 CmiCompareKeyNames(PUNICODE_STRING KeyName,
-		   PKEY_CELL KeyCell)
+		   PCM_KEY_NODE KeyCell)
 {
   PWCHAR UnicodeName;
   USHORT i;
@@ -1944,7 +1944,7 @@

BOOLEAN
 CmiCompareKeyNamesI(PUNICODE_STRING KeyName,
-		    PKEY_CELL KeyCell)
+		    PCM_KEY_NODE KeyCell)
 {
   PWCHAR UnicodeName;
   USHORT i;
@@ -1983,11 +1983,11 @@

NTSTATUS
 CmiCopyKey (PEREGISTRY_HIVE DstHive,
-	    PKEY_CELL DstKeyCell,
+	    PCM_KEY_NODE DstKeyCell,
        PEREGISTRY_HIVE SrcHive,
-	    PKEY_CELL SrcKeyCell)
-{
-  PKEY_CELL NewKeyCell;
+	    PCM_KEY_NODE SrcKeyCell)
+{
+  PCM_KEY_NODE NewKeyCell;
   ULONG NewKeyCellSize;
   HCELL_INDEX NewKeyCellOffset;
   PHASH_TABLE_CELL NewHashTableCell;
@@ -2001,7 +2001,7 @@
   if (DstKeyCell == NULL)
     {
       /* Allocate and copy key cell */
-      NewKeyCellSize = sizeof(KEY_CELL) + SrcKeyCell->NameSize;
+      NewKeyCellSize = sizeof(CM_KEY_NODE) + SrcKeyCell->NameSize;
       NewKeyCellOffset = HvAllocateCell (DstHive->Hive, NewKeyCellSize, HvStable);
       if (NewKeyCellOffset == HCELL_NULL)
    {
@@ -2046,9 +2046,9 @@
     }

/* Allocate hash table */
-  if (SrcKeyCell->NumberOfSubKeys[HvStable] > 0)
-    {
-      NewHashTableSize = ROUND_UP(SrcKeyCell->NumberOfSubKeys[HvStable] + 1, 4) - 1;
+  if (SrcKeyCell->SubKeyCounts[HvStable] > 0)
+    {
+      NewHashTableSize = ROUND_UP(SrcKeyCell->SubKeyCounts[HvStable] + 1, 4) - 1;
       Status = CmiAllocateHashTableCell (DstHive,
    				 &NewHashTableCell,
    				 &NewHashTableOffset,
@@ -2059,7 +2059,7 @@
      DPRINT1 ("CmiAllocateHashTableBlock() failed (Status %lx)\n", Status);
      return Status;
    }
-      NewKeyCell->HashTableOffset[HvStable] = NewHashTableOffset;
+      NewKeyCell->SubKeyLists[HvStable] = NewHashTableOffset;
     }
   else
     {
@@ -2067,7 +2067,7 @@
     }

/* Allocate and copy value list and values */
-  if (SrcKeyCell->NumberOfValues != 0)
+  if (SrcKeyCell->ValueList.Count != 0)
     {
       PVALUE_LIST_CELL NewValueListCell;
       PVALUE_LIST_CELL SrcValueListCell;
@@ -2082,24 +2082,24 @@

NewValueListCellSize =
-	ROUND_UP(SrcKeyCell->NumberOfValues, 4) * sizeof(HCELL_INDEX);
-      NewKeyCell->ValueListOffset = HvAllocateCell (DstHive->Hive,
+	ROUND_UP(SrcKeyCell->ValueList.Count, 4) * sizeof(HCELL_INDEX);
+      NewKeyCell->ValueList.List = HvAllocateCell (DstHive->Hive,
    			                    NewValueListCellSize,
    			                    HvStable);
-      if (NewKeyCell->ValueListOffset == HCELL_NULL)
+      if (NewKeyCell->ValueList.List == HCELL_NULL)
    {
      DPRINT1 ("HvAllocateCell() failed\n");
      return STATUS_INSUFFICIENT_RESOURCES;
    }
-      DPRINT1("KeyCell->ValueListOffset: %x\n", NewKeyCell->ValueListOffset);
-
-      NewValueListCell = HvGetCell (DstHive->Hive, NewKeyCell->ValueListOffset);
+      DPRINT1("KeyCell->ValueList.List: %x\n", NewKeyCell->ValueList.List);
+
+      NewValueListCell = HvGetCell (DstHive->Hive, NewKeyCell->ValueList.List);
       RtlZeroMemory (NewValueListCell,
    	     NewValueListCellSize);

/* Copy values */
-      SrcValueListCell = HvGetCell (SrcHive->Hive, SrcKeyCell->ValueListOffset);
-      for (i = 0; i < SrcKeyCell->NumberOfValues; i++)
+      SrcValueListCell = HvGetCell (SrcHive->Hive, SrcKeyCell->ValueList.List);
+      for (i = 0; i < SrcKeyCell->ValueList.Count; i++)
    {
      /* Copy value cell */
      SrcValueCell = HvGetCell (SrcHive->Hive, SrcValueListCell->ValueOffset[i]);
@@ -2139,24 +2139,24 @@
     }

/* Copy subkeys */
-  if (SrcKeyCell->NumberOfSubKeys[HvStable] > 0)
+  if (SrcKeyCell->SubKeyCounts[HvStable] > 0)
     {
       PHASH_TABLE_CELL SrcHashTableCell;
-      PKEY_CELL SrcSubKeyCell;
-      PKEY_CELL NewSubKeyCell;
+      PCM_KEY_NODE SrcSubKeyCell;
+      PCM_KEY_NODE NewSubKeyCell;
       ULONG NewSubKeyCellSize;
       HCELL_INDEX NewSubKeyCellOffset;
       PHASH_RECORD SrcHashRecord;

-      SrcHashTableCell = HvGetCell (SrcHive->Hive, SrcKeyCell->HashTableOffset[HvStable]);
-
-      for (i = 0; i < SrcKeyCell->NumberOfSubKeys[HvStable]; i++)
+      SrcHashTableCell = HvGetCell (SrcHive->Hive, SrcKeyCell->SubKeyLists[HvStable]);
+
+      for (i = 0; i < SrcKeyCell->SubKeyCounts[HvStable]; i++)
    {
      SrcHashRecord = &SrcHashTableCell->Table[i];
      SrcSubKeyCell = HvGetCell (SrcHive->Hive, SrcHashRecord->KeyOffset);

/* Allocate and copy key cell */
-	  NewSubKeyCellSize = sizeof(KEY_CELL) + SrcSubKeyCell->NameSize;
+	  NewSubKeyCellSize = sizeof(CM_KEY_NODE) + SrcSubKeyCell->NameSize;
      NewSubKeyCellOffset = HvAllocateCell (DstHive->Hive, NewSubKeyCellSize, HvStable);
      if (NewSubKeyCellOffset == HCELL_NULL)
        {

Modified: trunk/reactos/ntoskrnl/cm/registry.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/registry.c?rev=...
==============================================================================
--- trunk/reactos/ntoskrnl/cm/registry.c (original)
+++ trunk/reactos/ntoskrnl/cm/registry.c Mon Aug 14 15:57:47 2006
@@ -255,7 +255,7 @@
   RootKey->KeyCell = HvGetCell (CmiVolatileHive->Hive, RootKey->KeyCellOffset);
   RootKey->ParentKey = RootKey;
   RootKey->Flags = 0;
-  RootKey->NumberOfSubKeys = 0;
+  RootKey->SubKeyCounts = 0;
   RootKey->SubKeys = NULL;
   RootKey->SizeOfSubKeys = 0;
   InsertTailList(&CmiKeyObjectListHead, &RootKey->ListEntry);
@@ -608,7 +608,7 @@
                              NULL);
   DPRINT("Status %x\n", Status);
   NewKey->Flags = 0;
-  NewKey->NumberOfSubKeys = 0;
+  NewKey->SubKeyCounts = 0;
   NewKey->SubKeys = NULL;
   NewKey->SizeOfSubKeys = 0;
   InsertTailList(&CmiKeyObjectListHead, &NewKey->ListEntry);

Modified: trunk/reactos/ntoskrnl/cm/regobj.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/regobj.c?rev=23...
==============================================================================
--- trunk/reactos/ntoskrnl/cm/regobj.c (original)
+++ trunk/reactos/ntoskrnl/cm/regobj.c Mon Aug 14 15:57:47 2006
@@ -23,7 +23,7 @@

static NTSTATUS
 CmiGetLinkTarget(PEREGISTRY_HIVE RegistryHive,
-		 PKEY_CELL KeyCell,
+		 PCM_KEY_NODE KeyCell,
    	 PUNICODE_STRING TargetPath);

/* FUNCTONS *****************************************************************/
@@ -240,7 +240,7 @@
   HCELL_INDEX BlockOffset;
   PKEY_OBJECT FoundObject;
   PKEY_OBJECT ParsedKey;
-  PKEY_CELL SubKeyCell;
+  PCM_KEY_NODE SubKeyCell;
   NTSTATUS Status;
   PWSTR StartPtr;
   PWSTR EndPtr;
@@ -523,7 +523,7 @@

ObDereferenceObject (ParentKeyObject);

-  if (KeyObject->NumberOfSubKeys)
+  if (KeyObject->SubKeyCounts)
     {
       KEBUGCHECK(REGISTRY_ERROR);
     }
@@ -766,28 +766,28 @@
   DPRINT("ParentKey %.08x\n", ParentKey);

-  if (ParentKey->SizeOfSubKeys <= ParentKey->NumberOfSubKeys)
+  if (ParentKey->SizeOfSubKeys <= ParentKey->SubKeyCounts)
     {
       PKEY_OBJECT *tmpSubKeys = ExAllocatePool(NonPagedPool,
-	(ParentKey->NumberOfSubKeys + 1) * sizeof(ULONG));
-
-      if (ParentKey->NumberOfSubKeys > 0)
+	(ParentKey->SubKeyCounts + 1) * sizeof(ULONG));
+
+      if (ParentKey->SubKeyCounts > 0)
    {
      RtlCopyMemory (tmpSubKeys,
    		 ParentKey->SubKeys,
-			 ParentKey->NumberOfSubKeys * sizeof(ULONG));
+			 ParentKey->SubKeyCounts * sizeof(ULONG));
    }

if (ParentKey->SubKeys)
    ExFreePool(ParentKey->SubKeys);

ParentKey->SubKeys = tmpSubKeys;
-      ParentKey->SizeOfSubKeys = ParentKey->NumberOfSubKeys + 1;
+      ParentKey->SizeOfSubKeys = ParentKey->SubKeyCounts + 1;
     }

/* FIXME: Please maintain the list in alphabetic order */
   /*      to allow a dichotomic search */
-  ParentKey->SubKeys[ParentKey->NumberOfSubKeys++] = NewKey;
+  ParentKey->SubKeys[ParentKey->SubKeyCounts++] = NewKey;

DPRINT("Reference parent key: 0x%p\n", ParentKey);

@@ -807,15 +807,15 @@

ParentKey = KeyToRemove->ParentKey;
   /* FIXME: If list maintained in alphabetic order, use dichotomic search */
-  for (Index = 0; Index < ParentKey->NumberOfSubKeys; Index++)
+  for (Index = 0; Index < ParentKey->SubKeyCounts; Index++)
     {
       if (ParentKey->SubKeys[Index] == KeyToRemove)
    {
-	  if (Index < ParentKey->NumberOfSubKeys-1)
+	  if (Index < ParentKey->SubKeyCounts-1)
        RtlMoveMemory(&ParentKey->SubKeys[Index],
    		  &ParentKey->SubKeys[Index + 1],
-			  (ParentKey->NumberOfSubKeys - Index - 1) * sizeof(PKEY_OBJECT));
-	  ParentKey->NumberOfSubKeys--;
+			  (ParentKey->SubKeyCounts - Index - 1) * sizeof(PKEY_OBJECT));
+	  ParentKey->SubKeyCounts--;

DPRINT("Dereference parent key: 0x%x\n", ParentKey);

@@ -841,7 +841,7 @@
     KeyName, &Parent->Name);

/* FIXME: if list maintained in alphabetic order, use dichotomic search */
-  for (Index=0; Index < Parent->NumberOfSubKeys; Index++)
+  for (Index=0; Index < Parent->SubKeyCounts; Index++)
     {
       CurKey = Parent->SubKeys[Index];
       if (Attributes & OBJ_CASE_INSENSITIVE)
@@ -863,7 +863,7 @@
    }
     }

-  if (Index < Parent->NumberOfSubKeys)
+  if (Index < Parent->SubKeyCounts)
   {
      if (CurKey->Flags & KO_MARKED_FOR_DELETE)
      {
@@ -884,7 +884,7 @@

static NTSTATUS
 CmiGetLinkTarget(PEREGISTRY_HIVE RegistryHive,
-		 PKEY_CELL KeyCell,
+		 PCM_KEY_NODE KeyCell,
    	 PUNICODE_STRING TargetPath)
 {
   UNICODE_STRING LinkName = RTL_CONSTANT_STRING(L"SymbolicLinkValue");