[NTOS:CM][CMLIB] Minor code styling

In particular remove some extra-parentheses around single code tokens,
and replace few "DPRINT1 + while (TRUE);" by UNIMPLEMENTED_DBGBREAK.

+ Improve some comments.

ntoskrnl/config/cmapi.c

···
         if (Hive->Frozen)
         {
             /* FIXME: TODO */
-            DPRINT1("ERROR: Hive is frozen\n");
-            while (TRUE);
+            UNIMPLEMENTED_DBGBREAK("ERROR: Hive is frozen\n");
         }
      }
 
···
             CmpLockHiveFlusherExclusive(Hive);
 
             /* Check for illegal state */
-            if ((ForceFlush) && (Hive->UseCount))
+            if (ForceFlush && Hive->UseCount)
             {
                 /* Registry needs to be locked down */
                 CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK();
-                DPRINT1("FIXME: Hive is damaged and needs fixup\n");
-                while (TRUE);
+                UNIMPLEMENTED_DBGBREAK("FIXME: Hive is damaged and needs fixup\n");
             }
 
             /* Only sync if we are forced to or if it won't cause a hive shrink */
-            if ((ForceFlush) || (!HvHiveWillShrink(&Hive->Hive)))
+            if (ForceFlush || !HvHiveWillShrink(&Hive->Hive))
             {
                 /* Do the sync */
                 Status = HvSyncHive(&Hive->Hive);
 
                 /* If something failed - set the flag and continue looping */
-                if (!NT_SUCCESS(Status)) Result = FALSE;
+                if (!NT_SUCCESS(Status))
+                    Result = FALSE;
             }
             else
             {
···
         }
 
         /* We need the exclusive KCB lock now */
-        if (!(CmpIsKcbLockedExclusive(Kcb)) &&
-            !(CmpTryToConvertKcbSharedToExclusive(Kcb)))
+        if (!CmpIsKcbLockedExclusive(Kcb) &&
+            !CmpTryToConvertKcbSharedToExclusive(Kcb))
         {
             /* Acquire exclusive lock */
             CmpConvertKcbSharedToExclusive(Kcb);
···
         Kcb->KcbLastWriteTime = Parent->LastWriteTime;
 
         /* Check if the cell is cached */
-        if ((Found) && (CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)))
+        if (Found && CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList))
         {
             /* Shouldn't happen */
             ASSERT(FALSE);
···
             CmpCleanUpKcbValueCache(Kcb);
 
             /* Sanity checks */
-            ASSERT(!(CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)));
+            ASSERT(!CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList));
             ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
 
             /* Set the value cache */
···
 
     /* Release the cells */
 Quickie:
-    if ((ParentCell != HCELL_NIL) && (Hive)) HvReleaseCell(Hive, ParentCell);
-    if ((ChildCell != HCELL_NIL) && (Hive)) HvReleaseCell(Hive, ChildCell);
+    if ((ParentCell != HCELL_NIL) && Hive) HvReleaseCell(Hive, ParentCell);
+    if ((ChildCell != HCELL_NIL) && Hive) HvReleaseCell(Hive, ChildCell);
 
     /* Release the locks */
     if (FlusherLocked) CmpUnlockHiveFlusher((PCMHIVE)Hive);
···
         if (ChildCell == HCELL_NIL) goto Quickie;
 
         /* We found the value, mark all relevant cells dirty */
-        if (!((HvMarkCellDirty(Hive, Cell, FALSE)) &&
-              (HvMarkCellDirty(Hive, Parent->ValueList.List, FALSE)) &&
-              (HvMarkCellDirty(Hive, ChildCell, FALSE))))
+        if (!(HvMarkCellDirty(Hive, Cell, FALSE) &&
+              HvMarkCellDirty(Hive, Parent->ValueList.List, FALSE) &&
+              HvMarkCellDirty(Hive, ChildCell, FALSE)))
         {
             /* Not enough log space, fail */
             Status = STATUS_NO_LOG_SPACE;
···
         CmpCleanUpKcbValueCache(Kcb);
 
         /* Sanity checks */
-        ASSERT(!(CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)));
+        ASSERT(!CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList));
         ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
 
         /* Set the value cache */

ntoskrnl/config/cmcontrl.c

···
                     }
 
                     /* Sanity check if this is a small key */
-                    ASSERT((IsSmallKey ?
-                           (Length <= CM_KEY_VALUE_SMALL) : TRUE));
+                    ASSERT(IsSmallKey ? (Length <= CM_KEY_VALUE_SMALL) : TRUE);
 
                     /* Copy the data in the buffer */
                     RtlCopyMemory(ControlVector->Buffer, Buffer, Length);

ntoskrnl/config/cminit.c

···
      * - An alternate hive that is not linked to a correct file type.
      * - A lonely alternate hive not backed up with its corresponding primary hive.
      */
-    if (((External) && ((Primary) || (Log))) ||
-        ((Log) && !(Primary)) ||
-        (!(CmpShareSystemHives) && (HiveFlags & HIVE_VOLATILE) &&
-            ((Primary) || (External) || (Log))) ||
-        ((OperationType == HINIT_MEMORY) && (!HiveData)) ||
-        ((Log) && (FileType != HFILE_TYPE_LOG)) ||
-        ((Alternate) && (FileType != HFILE_TYPE_ALTERNATE)) ||
-        ((Alternate) && !(Primary)))
+    if ((External && (Primary || Log)) ||
+        (Log && !Primary) ||
+        (!CmpShareSystemHives && (HiveFlags & HIVE_VOLATILE) &&
+            (Primary || External || Log)) ||
+        ((OperationType == HINIT_MEMORY) && !HiveData) ||
+        (Log && (FileType != HFILE_TYPE_LOG)) ||
+        (Alternate && (FileType != HFILE_TYPE_ALTERNATE)) ||
+        (Alternate && !Primary))
     {
         /* Fail the request */
         return STATUS_INVALID_PARAMETER;
···
                                NULL);
 
     /* Check if we can create the hive */
-    if ((CreateAllowed) && !(CmpShareSystemHives))
+    if (CreateAllowed && !CmpShareSystemHives)
     {
         /* Open only or create */
         CreateDisposition = FILE_OPEN_IF;
···
               (NoBuffering ? FILE_NO_INTERMEDIATE_BUFFERING : 0);
 
     /* Set share and access modes */
-    if ((CmpMiniNTBoot) && (CmpShareSystemHives))
+    if (CmpMiniNTBoot && CmpShareSystemHives)
     {
         /* We're on Live CD or otherwise sharing */
         DesiredAccess = FILE_READ_DATA;
···
                           FILE_SYNCHRONOUS_IO_NONALERT | IoFlags,
                           NULL,
                           0);
-    if ((NT_SUCCESS(Status)) && (MarkAsSystemHive))
+    if (NT_SUCCESS(Status) && MarkAsSystemHive)
     {
         /* We opened it, mark it as a system hive */
         Status = ZwFsControlFile(*Log,

ntoskrnl/config/cmkcbncb.c

···
         CMP_ASSERT_KCB_LOCK(Kcb);
 
         /* Check if we should do a direct delete */
-        if (((CmpHoldLazyFlush) &&
+        if ((CmpHoldLazyFlush &&
              !(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND) &&
              !(Kcb->Flags & KEY_SYM_LINK)) ||
             (Kcb->ExtFlags & CM_KCB_NO_DELAY_CLOSE) ||
-            (Kcb->Delete))
+             Kcb->Delete)
         {
             /* Clean up the KCB*/
             CmpCleanUpKcbCacheWithLock(Kcb, LockHeldExclusively);
···
     NodeName = *KeyName;
 
     /* Remove leading slash */
-    while ((NodeName.Length) && (*NodeName.Buffer == OBJ_NAME_PATH_SEPARATOR))
+    while (NodeName.Length && (*NodeName.Buffer == OBJ_NAME_PATH_SEPARATOR))
     {
         /* Move the buffer by one */
         NodeName.Buffer++;
···
         else
         {
             /* Check if we're not creating a fake one, but it used to be fake */
-            if ((Kcb->ExtFlags & CM_KCB_KEY_NON_EXIST) && !(IsFake))
+            if ((Kcb->ExtFlags & CM_KCB_KEY_NON_EXIST) && !IsFake)
             {
                 /* Set the hive and cell */
                 Kcb->KeyHive = Hive;
···
         {
             /* Reference the parent */
             if (((Parent->TotalLevels + 1) < 512) &&
-                (CmpReferenceKeyControlBlock(Parent)))
+                CmpReferenceKeyControlBlock(Parent))
             {
                 /* Link it */
                 Kcb->ParentKcb = Parent;
···
     }
 
     /* Check if this is a KCB inside a frozen hive */
-    if ((Kcb) && (((PCMHIVE)Hive)->Frozen) && (!(Kcb->Flags & KEY_SYM_LINK)))
+    if (Kcb && ((PCMHIVE)Hive)->Frozen && !(Kcb->Flags & KEY_SYM_LINK))
     {
         /* Don't add these to the delay close */
         Kcb->ExtFlags |= CM_KCB_NO_DELAY_CLOSE;
     }
 
     /* Sanity check */
-    ASSERT((!Kcb) || (Kcb->Delete == FALSE));
+    ASSERT(!Kcb || !Kcb->Delete);
 
     /* Check if we had locked the hashes */
     if (!HashLock)
···
         /* Sanity checks for deleted and fake keys */
         if ((!MyKcb->KeyCell && !MyKcb->Delete) ||
             !MyKcb->KeyHive ||
-            MyKcb->ExtFlags & CM_KCB_KEY_NON_EXIST)
+            (MyKcb->ExtFlags & CM_KCB_KEY_NON_EXIST))
         {
             /* Failure */
             CmpFree(KeyName, 0);
···
     for (i = 0; i < 4; i++)
     {
         /* Add it into the list */
-        if (InterlockedCompareExchangePointer((VOID*)&KeyBody->KeyControlBlock->
+        if (InterlockedCompareExchangePointer((PVOID*)&KeyBody->KeyControlBlock->
                                               KeyBodyArray[i],
                                               NULL,
                                               KeyBody) == KeyBody)

ntoskrnl/config/cmlazy.c

···
                 CmHive->FlushCount = CmpLazyFlushCount;
             }
         }
-        else if ((CmHive->Hive.DirtyCount) &&
-                 (!(CmHive->Hive.HiveFlags & HIVE_VOLATILE)) &&
-                 (!(CmHive->Hive.HiveFlags & HIVE_NOLAZYFLUSH)))
+        else if (CmHive->Hive.DirtyCount &&
+                 !(CmHive->Hive.HiveFlags & HIVE_VOLATILE) &&
+                 !(CmHive->Hive.HiveFlags & HIVE_NOLAZYFLUSH))
         {
             /* Use another lazy flusher for this hive */
             ASSERT(CmHive->FlushCount == CmpLazyFlushCount);
···
 {
     /* Check if we should queue the lazy flush worker */
     DPRINT("Flush pending: %s, Holding lazy flush: %s.\n", CmpLazyFlushPending ? "yes" : "no", CmpHoldLazyFlush ? "yes" : "no");
-    if ((!CmpLazyFlushPending) && (!CmpHoldLazyFlush))
+    if (!CmpLazyFlushPending && !CmpHoldLazyFlush)
     {
         CmpLazyFlushPending = TRUE;
         ExQueueWorkItem(&CmpLazyWorkItem, DelayedWorkQueue);
···
     PAGED_CODE();
 
     /* Check if we should set the lazy flush timer */
-    if ((!CmpNoWrite) && (!CmpHoldLazyFlush))
+    if (!CmpNoWrite && !CmpHoldLazyFlush)
     {
         /* Do it */
         DueTime.QuadPart = Int32x32To64(CmpLazyFlushIntervalInSeconds,
···
          (Status == STATUS_ACCOUNT_EXPIRED) ||
          (Status == STATUS_ACCOUNT_DISABLED) ||
          (Status == STATUS_ACCOUNT_RESTRICTION)) &&
-        (ImpersonationContext))
+        ImpersonationContext)
     {
         /* We failed due to an account/security error, impersonate SYSTEM */
         Status = SeImpersonateClientEx(ImpersonationContext, NULL);

ntoskrnl/config/cmparse.c

···
     }
 
     /* Check if we have a path separator */
-    while ((RemainingName->Length) &&
+    while (RemainingName->Length &&
            (*RemainingName->Buffer == OBJ_NAME_PATH_SEPARATOR))
     {
         /* Skip it */
···
 
     /* Start loop at where the current buffer is */
     NextName->Buffer = RemainingName->Buffer;
-    while ((RemainingName->Length) &&
+    while (RemainingName->Length &&
            (*RemainingName->Buffer != OBJ_NAME_PATH_SEPARATOR))
     {
         /* Move to the next character */
···
     PAGED_CODE();
 
     /* Loop path separators at the end */
-    while ((RemainingName->Length) &&
+    while (RemainingName->Length &&
            (RemainingName->Buffer[(RemainingName->Length / sizeof(WCHAR)) - 1] ==
             OBJ_NAME_PATH_SEPARATOR))
     {
···
     Current = *RemainingName;
 
     /* Check if this is a create */
-    if (!(ParseContext) || !(ParseContext->CreateOperation))
+    if (!ParseContext || !ParseContext->CreateOperation)
     {
         /* It isn't, so no context */
         ParseContext = NULL;
···
     {
         /* Get the next component */
         Result = CmpGetNextName(&Current, &NextName, &Last);
-        if ((Result) && (NextName.Length))
+        if (Result && NextName.Length)
         {
             /* See if this is a sym link */
             if (!(Kcb->Flags & KEY_SYM_LINK))
···
                 else
                 {
                     /* Check if this was the last key for a create */
-                    if ((Last) && (ParseContext))
+                    if (Last && ParseContext)
                     {
                         /* Check if we're doing a link node */
                         if (ParseContext->CreateLink)
···
                 break;
             }
         }
-        else if ((Result) && (Last))
+        else if (Result && Last)
         {
             /* Opening the root. Is this an exit node? */
             if (Node->Flags & KEY_HIVE_EXIT)

ntoskrnl/config/cmse.c

···
     Sid[3] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CMSD);
 
     /* Make sure all SIDs were allocated */
-    if (!(Sid[0]) || !(Sid[1]) || !(Sid[2]) || !(Sid[3]))
+    if (!Sid[0] || !Sid[1] || !Sid[2] || !Sid[3])
     {
         /* Bugcheck */
         KeBugCheckEx(REGISTRY_ERROR, 11, 1, 0, 0);

ntoskrnl/config/cmsysini.c

···
 
     /* Check if the provided buffer is too small to fit even anything */
     if ((Length <= sizeof(OBJECT_NAME_INFORMATION)) ||
-        ((Length < (*ReturnLength)) && (BytesToCopy < sizeof(WCHAR))))
+        ((Length < *ReturnLength) && (BytesToCopy < sizeof(WCHAR))))
     {
         /* Free the buffer allocated by CmpConstructName */
         ExFreePoolWithTag(KeyName, TAG_CM);
···
     }
 
     /* Check if the provided buffer can be partially written */
-    if (Length < (*ReturnLength))
+    if (Length < *ReturnLength)
     {
         /* Yes, indicate so in the return status */
         Status = STATUS_INFO_LENGTH_MISMATCH;
···
         ValueInfo = (PKEY_VALUE_FULL_INFORMATION)ValueInfoBuffer;
 
         /* Check if we failed or got a non DWORD-value */
-        if (!(NT_SUCCESS(Status)) || (ValueInfo->Type != REG_DWORD))
+        if (!NT_SUCCESS(Status) || (ValueInfo->Type != REG_DWORD))
         {
             Status = STATUS_SUCCESS;
             goto Cleanup;
···
     Status = NtOpenKey(&ProfileHandle,
                        KEY_READ | KEY_WRITE,
                        &ObjectAttributes);
-    if (!NT_SUCCESS (Status))
+    if (!NT_SUCCESS(Status))
     {
         /* Cleanup and exit */
         Status = STATUS_SUCCESS;
···
                                      &CmHive,
                                      &CmpMachineHiveList[i].Allocate,
                                      CM_CHECK_REGISTRY_PURGE_VOLATILES);
-        if (!(NT_SUCCESS(Status)) ||
-            (!(CmpShareSystemHives) && !(CmHive->FileHandles[HFILE_TYPE_LOG])))
+        if (!NT_SUCCESS(Status) ||
+            (!CmpShareSystemHives && !CmHive->FileHandles[HFILE_TYPE_LOG]))
         {
             /*
              * We failed, or could not get a log file (unless
···
                                       TRUE,
                                       FALSE,
                                       &ClusterSize);
-            if (!(NT_SUCCESS(Status)) || !(AlternateHandle))
+            if (!NT_SUCCESS(Status) || !AlternateHandle)
             {
                 /* Couldn't open the hive or its alternate file, raise a hard error */
                 ErrorParameters = &FileName;
···
     Index1 = GET_HASH_INDEX(ConvKey1);
     Index2 = GET_HASH_INDEX(ConvKey2);
     ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey2)->Owner == KeGetCurrentThread()) ||
-           (CmpTestRegistryLockExclusive()));
+           CmpTestRegistryLockExclusive());
 
     /* See which one is highest */
     if (Index1 < Index2)
     {
         /* Grab them in the proper order */
         ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1)->Owner == KeGetCurrentThread()) ||
-               (CmpTestRegistryLockExclusive()));
+               CmpTestRegistryLockExclusive());
         CmpReleaseKcbLockByKey(ConvKey2);
         CmpReleaseKcbLockByKey(ConvKey1);
     }
···
         if (Index1 != Index2)
         {
             ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1)->Owner == KeGetCurrentThread()) ||
-                   (CmpTestRegistryLockExclusive()));
+                   CmpTestRegistryLockExclusive());
             CmpReleaseKcbLockByKey(ConvKey1);
         }
         CmpReleaseKcbLockByKey(ConvKey2);

ntoskrnl/config/cmvalche.c

···
     else
     {
         /* Make sure the KCB is locked exclusive */
-        if (!(CmpIsKcbLockedExclusive(Kcb)) &&
-            !(CmpTryToConvertKcbSharedToExclusive(Kcb)))
+        if (!CmpIsKcbLockedExclusive(Kcb) &&
+            !CmpTryToConvertKcbSharedToExclusive(Kcb))
         {
             /* We need the exclusive lock */
             return SearchNeedExclusiveLock;
···
         /* Select the value list as our cell, and get the actual list array */
         CellToRelease = ChildList->ValueList;
         *CellData = (PCELL_DATA)HvGetCell(Hive, CellToRelease);
-        if (!(*CellData)) return SearchFail;
+        if (!*CellData) return SearchFail;
 
         /* FIXME: Here we would cache the value */
 
···
         if (SearchResult != SearchSuccess)
         {
             /* We either failed or need the exclusive lock */
-            ASSERT((SearchResult == SearchFail) || !(CmpIsKcbLockedExclusive(Kcb)));
+            ASSERT((SearchResult == SearchFail) || !CmpIsKcbLockedExclusive(Kcb));
             ASSERT(Cell == HCELL_NIL);
             return SearchResult;
         }
···
             if (SearchResult != SearchSuccess)
             {
                 /* We either failed or need the exclusive lock */
-                ASSERT((SearchResult == SearchFail) || !(CmpIsKcbLockedExclusive(Kcb)));
+                ASSERT((SearchResult == SearchFail) || !CmpIsKcbLockedExclusive(Kcb));
                 ASSERT(Cell == HCELL_NIL);
                 return SearchResult;
             }
···
                 }
 
                 /* Sanity check */
-                ASSERT((IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE));
+                ASSERT(IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE);
 
                 /* Make sure we have a valid buffer */
                 if (Buffer)
···
                 }
 
                 /* Sanity check */
-                ASSERT((IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE));
+                ASSERT(IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE);
 
                 /* Make sure we have a valid buffer */
                 if (Buffer)
···
     if (Kcb->Flags & KEY_SYM_LINK)
     {
         /* We need the exclusive lock */
-        if (!(CmpIsKcbLockedExclusive(Kcb)) &&
-            !(CmpTryToConvertKcbSharedToExclusive(Kcb)))
+        if (!CmpIsKcbLockedExclusive(Kcb) &&
+            !CmpTryToConvertKcbSharedToExclusive(Kcb))
         {
             /* We need the exclusive lock */
             return SearchNeedExclusiveLock;
···
         CmpCleanUpKcbValueCache(Kcb);
 
         /* Sanity checks */
-        ASSERT(!(CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)));
+        ASSERT(!CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList));
         ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
 
         /* Set the value cache */

ntoskrnl/config/ntapi.c

···
         goto Quit;
 
     /* Make sure the name is aligned properly */
-    if ((ValueNameCopy.Length & (sizeof(WCHAR) - 1)))
+    if (ValueNameCopy.Length & (sizeof(WCHAR) - 1))
     {
         /* It isn't, so we'll fail */
         Status = STATUS_INVALID_PARAMETER;
···
     }
 
     /* Ignore any null characters at the end */
-    while ((ValueNameCopy.Length) &&
+    while (ValueNameCopy.Length &&
            !(ValueNameCopy.Buffer[ValueNameCopy.Length / sizeof(WCHAR) - 1]))
     {
         /* Skip it */
···
         KeyHandle, &ValueNameCopy, TitleIndex, Type, DataSize);
 
     /* Make sure the name is aligned, not too long, and the data under 4GB */
-    if ( (ValueNameCopy.Length > 32767) ||
-         ((ValueNameCopy.Length & (sizeof(WCHAR) - 1))) ||
-         (DataSize > 0x80000000))
+    if ((ValueNameCopy.Length > 32767) ||
+        (ValueNameCopy.Length & (sizeof(WCHAR) - 1)) ||
+        (DataSize > 0x80000000))
     {
         /* Fail */
         Status = STATUS_INVALID_PARAMETER;
···
     }
 
     /* Ignore any null characters at the end */
-    while ((ValueNameCopy.Length) &&
+    while (ValueNameCopy.Length &&
            !(ValueNameCopy.Buffer[ValueNameCopy.Length / sizeof(WCHAR) - 1]))
     {
         /* Skip it */
···
         goto Quit;
 
     /* Make sure the name is aligned properly */
-    if ((ValueNameCopy.Length & (sizeof(WCHAR) - 1)))
+    if (ValueNameCopy.Length & (sizeof(WCHAR) - 1))
     {
         /* It isn't, so we'll fail */
         Status = STATUS_INVALID_PARAMETER;

sdk/lib/cmlib/hivewrt.c

···
      * The hive log we are going to write data into
      * has to be writable and with a sane storage.
      */
-    ASSERT(RegistryHive->ReadOnly == FALSE);
+    ASSERT(!RegistryHive->ReadOnly);
     ASSERT(RegistryHive->BaseBlock->Length ==
            RegistryHive->Storage[Stable].Length * HBLOCK_SIZE);
 
···
     HvpValidateBaseHeader(RegistryHive);
 
     /*
-     * The sequences can diverge in an occurrence of forced
-     * shutdown of the system such as during a power failure,
-     * the hardware crapping itself or during a system crash
-     * when one of the sequences have been modified during
-     * writing into the log or hive. In such cases the hive
-     * needs a repair.
+     * The sequences can diverge during a forced system shutdown
+     * occurrence, such as during a power failure, a hardware
+     * failure or during a system crash, and when one of the
+     * sequences have been modified during writing into the log
+     * or hive. In such cases the hive needs a repair.
      */
     if (RegistryHive->BaseBlock->Sequence1 !=
         RegistryHive->BaseBlock->Sequence2)
···
     ULONG LastIndex;
     PVOID Block;
 
-    ASSERT(RegistryHive->ReadOnly == FALSE);
+    ASSERT(!RegistryHive->ReadOnly);
     ASSERT(RegistryHive->BaseBlock->Length ==
            RegistryHive->Storage[Stable].Length * HBLOCK_SIZE);
     ASSERT(RegistryHive->BaseBlock->RootCell != HCELL_NIL);
···
     HvpValidateBaseHeader(RegistryHive);
 
     /*
-     * The sequences can diverge in an occurrence of forced
-     * shutdown of the system such as during a power failure,
-     * the hardware crapping itself or during a system crash
-     * when one of the sequences have been modified during
-     * writing into the log or hive. In such cases the hive
-     * needs a repair.
+     * The sequences can diverge during a forced system shutdown
+     * occurrence, such as during a power failure, a hardware
+     * failure or during a system crash, and when one of the
+     * sequences have been modified during writing into the log
+     * or hive. In such cases the hive needs a repair.
      */
     if (RegistryHive->BaseBlock->Sequence1 !=
         RegistryHive->BaseBlock->Sequence2)
···
     while (BlockIndex < RegistryHive->Storage[Stable].Length)
     {
         /*
-         * If we have to syncrhonize the registry hive we
+         * If we have to synchronize the registry hive we
          * want to look for dirty blocks to reflect the new
          * updates done to the hive. Otherwise just write
          * all the blocks as if we were doing a regular
-         * writing of the hive.
+         * hive write.
          */
         if (OnlyDirty)
         {
···
 
     /*
      * Increment the secondary sequence number and
-     * update the checksum. A successful transaction
-     * writing of hive is both of sequences are the
-     * same indicating the writing operation didn't
+     * update the checksum. A successful hive write
+     * transaction is when both of sequences are the
+     * same, indicating the write operation didn't
      * fail.
      */
     RegistryHive->BaseBlock->Sequence2++;
···
     BOOLEAN HardErrors;
 #endif
 
-    ASSERT(RegistryHive->ReadOnly == FALSE);
+    ASSERT(!RegistryHive->ReadOnly);
     ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
 
     /*
···
     KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
 #endif
 
-    /* Update the log file of hive if present */
-    if (RegistryHive->Log == TRUE)
+    /* Update the hive log file if present */
+    if (RegistryHive->Log)
     {
         if (!HvpWriteLog(RegistryHive))
         {
···
     }
 
     /* Update the alternate hive file if present */
-    if (RegistryHive->Alternate == TRUE)
+    if (RegistryHive->Alternate)
     {
         if (!HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_ALTERNATE))
         {
···
 HvWriteHive(
     _In_ PHHIVE RegistryHive)
 {
-    ASSERT(RegistryHive->ReadOnly == FALSE);
+    ASSERT(!RegistryHive->ReadOnly);
     ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
 
 #if !defined(_BLDR_)
···
 HvWriteAlternateHive(
     _In_ PHHIVE RegistryHive)
 {
-    ASSERT(RegistryHive->ReadOnly == FALSE);
+    ASSERT(!RegistryHive->ReadOnly);
     ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
-    ASSERT(RegistryHive->Alternate == TRUE);
+    ASSERT(RegistryHive->Alternate);
 
 #if !defined(_BLDR_)
     /* Update hive header modification time */
···
 HvSyncHiveFromRecover(
     _In_ PHHIVE RegistryHive)
 {
-    ASSERT(RegistryHive->ReadOnly == FALSE);
+    ASSERT(!RegistryHive->ReadOnly);
     ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
 
     /* Call the private API call to do the deed for us */