Ros-diffs December 2009

ros-diffs@reactos.org

22 participants
501 discussions

[mjmartin] 44469: [ntoskrnl\config] - CmpSplitLeaf: When the leaf to insert is not the last leaf: Don't copy the leaf data from the location where the new leaf will be inserted to the next leaf. There may be more leafs following (registry corruption), the leafs may be different sizes (memory corruption) and a simpler solution exists. - Just shift all the indexes of the root to the right of the insertion point. - Fixes bug check when leafs are split more than once.
by mjmartin＠svn.reactos.org 08 Dec '09

08 Dec '09

Author: mjmartin Date: Tue Dec 8 17:04:03 2009 New Revision: 44469 URL: http://svn.reactos.org/svn/reactos?rev=44469&view=rev Log: [ntoskrnl\config] - CmpSplitLeaf: When the leaf to insert is not the last leaf: Don't copy the leaf data from the location where the new leaf will be inserted to the next leaf. There may be more leafs following (registry corruption), the leafs may be different sizes (memory corruption) and a simpler solution exists. - Just shift all the indexes of the root to the right of the insertion point. - Fixes bug check when leafs are split more than once. Modified: trunk/reactos/ntoskrnl/config/cmindex.c Modified: trunk/reactos/ntoskrnl/config/cmindex.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/config/cmindex.c?… ============================================================================== --- trunk/reactos/ntoskrnl/config/cmindex.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/config/cmindex.c [iso-8859-1] Tue Dec 8 17:04:03 2009 @@ -1289,13 +1289,14 @@ LastHalf * EntrySize); } - /* Shift the data inside the root key */ + /* If RootSelect is not the last index */ if (RootSelect < (IndexKey->Count - 1)) { - RtlMoveMemory(&IndexKey->List[RootSelect + 2], - &IndexKey->List[RootSelect + 1], - IndexKey->Count - - (RootSelect + 1) * sizeof(HCELL_INDEX)); + /* Shift indexes to the right */ + ULONG IndexCount; + /* IndexKey->Count will be incremented below */ + for (IndexCount = IndexKey->Count; IndexCount > RootSelect + 1; IndexCount --) + IndexKey->List[IndexCount] = IndexKey->List[IndexCount -1]; } /* Make sure both old and new computed counts are valid */

1 0

[tkreuzer] 44468: Fix 2nd try.
by tkreuzer＠svn.reactos.org 08 Dec '09

08 Dec '09

Author: tkreuzer Date: Tue Dec 8 15:32:39 2009 New Revision: 44468 URL: http://svn.reactos.org/svn/reactos?rev=44468&view=rev Log: Fix 2nd try. Modified: branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def Modified: branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/reactos/lib/3… ============================================================================== --- branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def [iso-8859-1] (original) +++ branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def [iso-8859-1] Tue Dec 8 15:32:39 2009 @@ -1,4 +1,4 @@ -LIBRARY msvcrt.dll +LIBRARY crtdll.dll EXPORTS access

1 0

[tkreuzer] 44467: Try to fix encoded's broken apps.
by tkreuzer＠svn.reactos.org 08 Dec '09

08 Dec '09

Author: tkreuzer Date: Tue Dec 8 15:00:42 2009 New Revision: 44467 URL: http://svn.reactos.org/svn/reactos?rev=44467&view=rev Log: Try to fix encoded's broken apps. Modified: branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def Modified: branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/reactos/lib/3… ============================================================================== --- branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def [iso-8859-1] (original) +++ branches/ros-amd64-bringup/reactos/lib/3rdparty/mingw/moldname-msvcrt.def [iso-8859-1] Tue Dec 8 15:00:42 2009 @@ -1,3 +1,5 @@ +LIBRARY msvcrt.dll + EXPORTS access chdir

1 0

[tkreuzer] 44466: Fix regressions.
by tkreuzer＠svn.reactos.org 08 Dec '09

08 Dec '09

Author: tkreuzer Date: Tue Dec 8 04:06:40 2009 New Revision: 44466 URL: http://svn.reactos.org/svn/reactos?rev=44466&view=rev Log: Fix regressions. Modified: trunk/reactos/lib/rtl/bitmap.c Modified: trunk/reactos/lib/rtl/bitmap.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/rtl/bitmap.c?rev=44466… ============================================================================== --- trunk/reactos/lib/rtl/bitmap.c [iso-8859-1] (original) +++ trunk/reactos/lib/rtl/bitmap.c [iso-8859-1] Tue Dec 8 04:06:40 2009 @@ -417,7 +417,7 @@ IN ULONG NumberToFind, IN ULONG HintIndex) { - ULONG CurrentBit, CurrentLength; + ULONG CurrentBit, Margin, CurrentLength; /* Check for valid parameters */ if (!BitMapHeader || NumberToFind > BitMapHeader->SizeOfBitMap) @@ -431,12 +431,15 @@ return HintIndex; } + /* First margin is end of bitmap */ + Margin = BitMapHeader->SizeOfBitMap; + +retry: /* Start with hint index, length is 0 */ CurrentBit = HintIndex; - CurrentLength = 0; /* Loop until something is found or the end is reached */ - while (CurrentBit + NumberToFind < BitMapHeader->SizeOfBitMap) + while (CurrentBit + NumberToFind < Margin) { /* Search for the next clear run, by skipping a set run */ CurrentBit += RtlpGetLengthOfRunSet(BitMapHeader, @@ -458,6 +461,15 @@ CurrentBit += CurrentLength; } + /* Did we start at a hint? */ + if (HintIndex) + { + /* Retry at the start */ + Margin = min(HintIndex + NumberToFind, BitMapHeader->SizeOfBitMap); + HintIndex = 0; + goto retry; + } + /* Nothing found */ return MAXULONG; } @@ -571,10 +583,10 @@ /* Assume a set run first, count it's length */ Length = RtlpGetLengthOfRunSet(BitMapHeader, FromIndex, MAXULONG); - *StartingRunIndex = FromIndex; + *StartingRunIndex = FromIndex + Length; /* Now return the length of the run */ - return RtlpGetLengthOfRunClear(BitMapHeader, FromIndex, MAXULONG); + return RtlpGetLengthOfRunClear(BitMapHeader, FromIndex + Length, MAXULONG); } ULONG @@ -647,7 +659,7 @@ } /* Advance bits */ - FromIndex += NumberOfBits; + FromIndex = StartingIndex + NumberOfBits; } /* Check if we are finished */

1 0

[tkreuzer] 44465: Cleanup test code, improve comments.
by tkreuzer＠svn.reactos.org 08 Dec '09

08 Dec '09

Author: tkreuzer Date: Tue Dec 8 03:18:42 2009 New Revision: 44465 URL: http://svn.reactos.org/svn/reactos?rev=44465&view=rev Log: Cleanup test code, improve comments. Modified: trunk/reactos/lib/rtl/bitmap.c Modified: trunk/reactos/lib/rtl/bitmap.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/rtl/bitmap.c?rev=44465… ============================================================================== --- trunk/reactos/lib/rtl/bitmap.c [iso-8859-1] (original) +++ trunk/reactos/lib/rtl/bitmap.c [iso-8859-1] Tue Dec 8 03:18:42 2009 @@ -83,11 +83,12 @@ /* Calculate length up to where we read */ Length = (Buffer - BitMapHeader->Buffer) * 32 - StartingIndex; Length += BitPos - 32; - + + /* Make sure we don't go past the last bit */ if (Length > BitMapHeader->SizeOfBitMap - StartingIndex) Length = BitMapHeader->SizeOfBitMap - StartingIndex; - /* The result is guaranteed to be < BitMapHeader->SizeOfBitMap */ + /* Return the result */ return Length; } @@ -132,10 +133,11 @@ Length = (Buffer - BitMapHeader->Buffer) * 32 - StartingIndex; Length += BitPos - 32; + /* Make sure we don't go past the last bit */ if (Length > BitMapHeader->SizeOfBitMap - StartingIndex) Length = BitMapHeader->SizeOfBitMap - StartingIndex; - /* The result is guaranteed to be < BitMapHeader->SizeOfBitMap */ + /* Return the result */ return Length; } @@ -436,12 +438,10 @@ /* Loop until something is found or the end is reached */ while (CurrentBit + NumberToFind < BitMapHeader->SizeOfBitMap) { - ULONG test; /* Search for the next clear run, by skipping a set run */ - test = RtlpGetLengthOfRunSet(BitMapHeader, + CurrentBit += RtlpGetLengthOfRunSet(BitMapHeader, CurrentBit, MAXULONG); - CurrentBit += test; /* Get length of the clear bit run */ CurrentLength = RtlpGetLengthOfRunClear(BitMapHeader,

1 0

[tkreuzer] 44464: [RTL] Rewrite the rtl bitmap implementation. The old one was a little .... suboptimal. The new one should outperform the old one by several orders of magnitude, especially RtlFindClearBits that was literally searching bit by bit.
by tkreuzer＠svn.reactos.org 08 Dec '09

08 Dec '09

Author: tkreuzer Date: Tue Dec 8 02:02:36 2009 New Revision: 44464 URL: http://svn.reactos.org/svn/reactos?rev=44464&view=rev Log: [RTL] Rewrite the rtl bitmap implementation. The old one was a little .... suboptimal. The new one should outperform the old one by several orders of magnitude, especially RtlFindClearBits that was literally searching bit by bit. Modified: trunk/reactos/lib/rtl/bitmap.c trunk/reactos/tools/mkhive/mkhive.h trunk/reactos/tools/mkhive/rtl.c Modified: trunk/reactos/lib/rtl/bitmap.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/rtl/bitmap.c?rev=44464… ============================================================================== --- trunk/reactos/lib/rtl/bitmap.c [iso-8859-1] (original) +++ trunk/reactos/lib/rtl/bitmap.c [iso-8859-1] Tue Dec 8 02:02:36 2009 @@ -1,8 +1,9 @@ -/* COPYRIGHT: See COPYING in the top level directory +/* + * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS system libraries * FILE: lib/rtl/bitmap.c * PURPOSE: Bitmap functions - * PROGRAMMER: Eric Kohl + * PROGRAMMER: Timo Kreuzer (timo.kreuzer(a)reactos.org) */ /* INCLUDES *****************************************************************/ @@ -12,965 +13,749 @@ #define NDEBUG #include <debug.h> -/* MACROS *******************************************************************/ - -/* Bits set from LSB to MSB; used as mask for runs < 8 bits */ -static const BYTE NTDLL_maskBits[8] = { 0, 1, 3, 7, 15, 31, 63, 127 }; - -/* Number of set bits for each value of a nibble; used for counting */ -static const BYTE NTDLL_nibbleBitCount[16] = { - 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 + +/* DATA *********************************************************************/ + +/* Number of set bits per byte value */ +static const +UCHAR +BitCountTable[256] = +{ + /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, /* 0x */ + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, /* 1x */ + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, /* 2x */ + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, /* 3x */ + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, /* 4x */ + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, /* 5x */ + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, /* 6c */ + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, /* 7x */ + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, /* 8x */ + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, /* 9x */ + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, /* Ax */ + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, /* Bx */ + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, /* Cx */ + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, /* Dx */ + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, /* Ex */ + 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 /* Fx */ }; -/* First set bit in a nibble; used for determining least significant bit */ -static const BYTE NTDLL_leastSignificant[16] = { - 0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 -}; - -/* Last set bit in a nibble; used for determining most significant bit */ -static const signed char NTDLL_mostSignificant[16] = { - -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 -}; - -/* PRIVATE FUNCTIONS *********************************************************/ - -static -int -__cdecl -NTDLL_RunSortFn(const void *lhs, - const void *rhs) -{ - if (((const RTL_BITMAP_RUN*)lhs)->NumberOfBits > ((const RTL_BITMAP_RUN*)rhs)->NumberOfBits) + +/* PRIVATE FUNCTIONS ********************************************************/ + +static __inline__ +ULONG +RtlpGetLengthOfRunClear( + IN PRTL_BITMAP BitMapHeader, + IN ULONG StartingIndex, + IN ULONG MaxLength) +{ + ULONG Value, BitPos, Length; + PULONG Buffer, MaxBuffer; + + /* Calculate positions */ + Buffer = BitMapHeader->Buffer + StartingIndex / 32; + BitPos = StartingIndex & 31; + + /* Calculate the maximum length */ + MaxLength = min(MaxLength, BitMapHeader->SizeOfBitMap - StartingIndex); + MaxBuffer = Buffer + (BitPos + MaxLength + 31) / 32; + + /* Clear the bits that don't belong to this run */ + Value = *Buffer++ >> BitPos << BitPos; + + /* Skip all clear ULONGs */ + while (Value == 0 && Buffer < MaxBuffer) + { + Value = *Buffer++; + } + + /* Did we reach the end? */ + if (Value == 0) + { + /* Return maximum length */ + return MaxLength; + } + + /* We hit a set bit, check how many clear bits are left */ + BitScanForward(&BitPos, Value); + + /* Calculate length up to where we read */ + Length = (Buffer - BitMapHeader->Buffer) * 32 - StartingIndex; + Length += BitPos - 32; + + if (Length > BitMapHeader->SizeOfBitMap - StartingIndex) + Length = BitMapHeader->SizeOfBitMap - StartingIndex; + + /* The result is guaranteed to be < BitMapHeader->SizeOfBitMap */ + return Length; +} + +static __inline__ +ULONG +RtlpGetLengthOfRunSet( + IN PRTL_BITMAP BitMapHeader, + IN ULONG StartingIndex, + IN ULONG MaxLength) +{ + ULONG InvValue, BitPos, Length; + PULONG Buffer, MaxBuffer; + + /* Calculate positions */ + Buffer = BitMapHeader->Buffer + StartingIndex / 32; + BitPos = StartingIndex & 31; + + /* Calculate the maximum length */ + MaxLength = min(MaxLength, BitMapHeader->SizeOfBitMap - StartingIndex); + MaxBuffer = Buffer + (BitPos + MaxLength + 31) / 32; + + /* Get the inversed value, clear bits that don't belong to the run */ + InvValue = ~(*Buffer++) >> BitPos << BitPos; + + /* Skip all set ULONGs */ + while (InvValue == 0 && Buffer < MaxBuffer) + { + InvValue = ~(*Buffer++); + } + + /* Did we reach the end? */ + if (InvValue == 0) + { + /* Yes, return maximum */ + return MaxLength; + } + + /* We hit a clear bit, check how many set bits are left */ + BitScanForward(&BitPos, InvValue); + + /* Calculate length up to where we read */ + Length = (Buffer - BitMapHeader->Buffer) * 32 - StartingIndex; + Length += BitPos - 32; + + if (Length > BitMapHeader->SizeOfBitMap - StartingIndex) + Length = BitMapHeader->SizeOfBitMap - StartingIndex; + + /* The result is guaranteed to be < BitMapHeader->SizeOfBitMap */ + return Length; +} + + +/* PUBLIC FUNCTIONS **********************************************************/ + +CCHAR +NTAPI +RtlFindMostSignificantBit(ULONGLONG Value) +{ + ULONG Position; + + if (BitScanReverse(&Position, Value >> 32)) + { + return Position + 32; + } + else if (BitScanReverse(&Position, (ULONG)Value)) + { + return Position; + } + return -1; - return 1; -} - -static -ULONG -WINAPI -NTDLL_FindRuns(PRTL_BITMAP lpBits, - PRTL_BITMAP_RUN lpSeries, - ULONG ulCount, - BOOLEAN bLongest, - ULONG (*fn)(PRTL_BITMAP,ULONG,PULONG)) -{ - BOOL bNeedSort = ulCount > 1 ? TRUE : FALSE; - ULONG ulPos = 0, ulRuns = 0; - - if (!ulCount) - return MAXULONG; - - while (ulPos < lpBits->SizeOfBitMap) - { - /* Find next set/clear run */ - ULONG ulSize, ulNextPos = fn(lpBits, ulPos, &ulSize); - - if (ulNextPos == MAXULONG) - break; - - if (bLongest && ulRuns == ulCount) - { - /* Sort runs with shortest at end, if they are out of order */ - if (bNeedSort) - qsort(lpSeries, ulRuns, sizeof(RTL_BITMAP_RUN), NTDLL_RunSortFn); - - /* Replace last run if this one is bigger */ - if (ulSize > lpSeries[ulRuns - 1].NumberOfBits) - { - lpSeries[ulRuns - 1].StartingIndex = ulNextPos; - lpSeries[ulRuns - 1].NumberOfBits = ulSize; - - /* We need to re-sort the array, _if_ we didn't leave it sorted */ - if (ulRuns > 1 && ulSize > lpSeries[ulRuns - 2].NumberOfBits) - bNeedSort = TRUE; - } - } - else - { - /* Append to found runs */ - lpSeries[ulRuns].StartingIndex = ulNextPos; - lpSeries[ulRuns].NumberOfBits = ulSize; - ulRuns++; - - if (!bLongest && ulRuns == ulCount) - break; - } - ulPos = ulNextPos + ulSize; - } - return ulRuns; -} - -static -ULONG -NTDLL_FindSetRun(PRTL_BITMAP lpBits, - ULONG ulStart, - PULONG lpSize) -{ - LPBYTE lpOut; - ULONG ulFoundAt = 0, ulCount = 0; - - /* FIXME: It might be more efficient/cleaner to manipulate four bytes - * at a time. But beware of the pointer arithmetics... - */ - lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u); - - while (1) - { - /* Check bits in first byte */ - const BYTE bMask = (0xff << (ulStart & 7)) & 0xff; - const BYTE bFirst = *lpOut & bMask; - - if (bFirst) - { - /* Have a set bit in first byte */ - if (bFirst != bMask) - { - /* Not every bit is set */ - ULONG ulOffset; - - if (bFirst & 0x0f) - ulOffset = NTDLL_leastSignificant[bFirst & 0x0f]; - else - ulOffset = 4 + NTDLL_leastSignificant[bFirst >> 4]; - ulStart += ulOffset; - ulFoundAt = ulStart; - for (;ulOffset < 8; ulOffset++) - { - if (!(bFirst & (1 << ulOffset))) - { - *lpSize = ulCount; - return ulFoundAt; /* Set from start, but not until the end */ - } - ulCount++; - ulStart++; - } - /* Set to the end - go on to count further bits */ - lpOut++; - break; - } - /* every bit from start until the end of the byte is set */ - ulFoundAt = ulStart; - ulCount = 8 - (ulStart & 7); - ulStart = (ulStart & ~7u) + 8; - lpOut++; - break; - } - ulStart = (ulStart & ~7u) + 8; - lpOut++; - if (ulStart >= lpBits->SizeOfBitMap) - return MAXULONG; - } - - /* Count blocks of 8 set bits */ - while (*lpOut == 0xff) - { - ulCount += 8; - ulStart += 8; - if (ulStart >= lpBits->SizeOfBitMap) - { - *lpSize = ulCount - (ulStart - lpBits->SizeOfBitMap); - return ulFoundAt; - } - lpOut++; - } - - /* Count remaining contiguous bits, if any */ - if (*lpOut & 1) - { - ULONG ulOffset = 0; - - for (;ulOffset < 7u; ulOffset++) - { - if (!(*lpOut & (1 << ulOffset))) - break; - ulCount++; - } - } - *lpSize = ulCount; - return ulFoundAt; -} - -static -ULONG -NTDLL_FindClearRun(PRTL_BITMAP lpBits, - ULONG ulStart, - PULONG lpSize) -{ - LPBYTE lpOut; - ULONG ulFoundAt = 0, ulCount = 0; - - /* FIXME: It might be more efficient/cleaner to manipulate four bytes - * at a time. But beware of the pointer arithmetics... - */ - lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u); - - while (1) - { - /* Check bits in first byte */ - const BYTE bMask = (0xff << (ulStart & 7)) & 0xff; - const BYTE bFirst = (~*lpOut) & bMask; - - if (bFirst) - { - /* Have a clear bit in first byte */ - if (bFirst != bMask) - { - /* Not every bit is clear */ - ULONG ulOffset; - - if (bFirst & 0x0f) - ulOffset = NTDLL_leastSignificant[bFirst & 0x0f]; - else - ulOffset = 4 + NTDLL_leastSignificant[bFirst >> 4]; - ulStart += ulOffset; - ulFoundAt = ulStart; - for (;ulOffset < 8; ulOffset++) - { - if (!(bFirst & (1 << ulOffset))) - { - *lpSize = ulCount; - return ulFoundAt; /* Clear from start, but not until the end */ - } - ulCount++; - ulStart++; - } - /* Clear to the end - go on to count further bits */ - lpOut++; - break; - } - /* Every bit from start until the end of the byte is clear */ - ulFoundAt = ulStart; - ulCount = 8 - (ulStart & 7); - ulStart = (ulStart & ~7u) + 8; - lpOut++; - break; - } - ulStart = (ulStart & ~7u) + 8; - lpOut++; - if (ulStart >= lpBits->SizeOfBitMap) - return MAXULONG; - } - - /* Count blocks of 8 clear bits */ - while (!*lpOut) - { - ulCount += 8; - ulStart += 8; - if (ulStart >= lpBits->SizeOfBitMap) - { - *lpSize = ulCount - (ulStart - lpBits->SizeOfBitMap); - return ulFoundAt; - } - lpOut++; - } - - /* Count remaining contiguous bits, if any */ - if (!(*lpOut & 1)) - { - ULONG ulOffset = 0; - - for (;ulOffset < 7u; ulOffset++) - { - if (*lpOut & (1 << ulOffset)) - break; - ulCount++; - } - } - *lpSize = ulCount; - return ulFoundAt; -} - -/* FUNCTIONS ****************************************************************/ - -/* - * @implemented - */ +} + +CCHAR +NTAPI +RtlFindLeastSignificantBit(ULONGLONG Value) +{ + ULONG Position; + + if (BitScanForward(&Position, (ULONG)Value)) + { + return Position; + } + else if (BitScanForward(&Position, Value >> 32)) + { + return Position + 32; + } + + return -1; +} + VOID NTAPI -RtlInitializeBitMap(IN PRTL_BITMAP BitMapHeader, - IN PULONG BitMapBuffer, - IN ULONG SizeOfBitMap) -{ +RtlInitializeBitMap( + IN PRTL_BITMAP BitMapHeader, + IN PULONG BitMapBuffer, + IN ULONG SizeOfBitMap) +{ + // FIXME: some bugger here! + //ASSERT(SizeOfBitMap > 0); + /* Setup the bitmap header */ BitMapHeader->SizeOfBitMap = SizeOfBitMap; BitMapHeader->Buffer = BitMapBuffer; } -/* - * @implemented - */ +VOID +NTAPI +RtlClearAllBits( + IN OUT PRTL_BITMAP BitMapHeader) +{ + ULONG LengthInUlongs; + + LengthInUlongs = (BitMapHeader->SizeOfBitMap + 31) >> 5; + RtlFillMemoryUlong(BitMapHeader->Buffer, LengthInUlongs << 2, 0); +} + +VOID +NTAPI +RtlSetAllBits( + IN OUT PRTL_BITMAP BitMapHeader) +{ + ULONG LengthInUlongs; + + LengthInUlongs = (BitMapHeader->SizeOfBitMap + 31) >> 5; + RtlFillMemoryUlong(BitMapHeader->Buffer, LengthInUlongs << 2, ~0); +} + +VOID +NTAPI +RtlClearBit( + IN PRTL_BITMAP BitMapHeader, + IN ULONG BitNumber) +{ + ASSERT(BitNumber <= BitMapHeader->SizeOfBitMap); + BitMapHeader->Buffer[BitNumber >> 5] &= ~(1 << (BitNumber & 31)); +} + +VOID +NTAPI +RtlSetBit( + IN PRTL_BITMAP BitMapHeader, + IN ULONG BitNumber) +{ + ASSERT(BitNumber <= BitMapHeader->SizeOfBitMap); + BitMapHeader->Buffer[BitNumber >> 5] |= (1 << (BitNumber & 31)); +} + +VOID +NTAPI +RtlClearBits( + IN PRTL_BITMAP BitMapHeader, + IN ULONG StartingIndex, + IN ULONG NumberToClear) +{ + ULONG Bits, Mask; + PULONG Buffer; + + ASSERT(StartingIndex + NumberToClear <= BitMapHeader->SizeOfBitMap); + + /* Calculate buffer start and first bit index */ + Buffer = &BitMapHeader->Buffer[StartingIndex >> 5]; + Bits = StartingIndex & 31; + + /* Are we unaligned? */ + if (Bits) + { + /* Create an inverse mask by shifting MAXULONG */ + Mask = MAXULONG << Bits; + + /* This is what's left in the first ULONG */ + Bits = 32 - Bits; + + /* Even less bits to clear? */ + if (NumberToClear < Bits) + { + /* Calculate how many bits are left */ + Bits -= NumberToClear; + + /* Fixup the mask on the high side */ + Mask = Mask << Bits >> Bits; + + /* Clear bits and return */ + *Buffer &= ~Mask; + return; + } + + /* Clear bits */ + *Buffer &= ~Mask; + + /* Update buffer and left bits */ + Buffer++; + NumberToClear -= Bits; + } + + /* Clear all full ULONGs */ + RtlFillMemoryUlong(Buffer, NumberToClear >> 3, 0); + Buffer += NumberToClear >> 5; + + /* Clear what's left */ + NumberToClear &= 31; + Mask = MAXULONG << NumberToClear; + *Buffer &= Mask; +} + +VOID +NTAPI +RtlSetBits( + IN PRTL_BITMAP BitMapHeader, + IN ULONG StartingIndex, + IN ULONG NumberToSet) +{ + ULONG Bits, Mask; + PULONG Buffer; + + ASSERT(StartingIndex + NumberToSet <= BitMapHeader->SizeOfBitMap); + + /* Calculate buffer start and first bit index */ + Buffer = &BitMapHeader->Buffer[StartingIndex >> 5]; + Bits = StartingIndex & 31; + + /* Are we unaligned? */ + if (Bits) + { + /* Create a mask by shifting MAXULONG */ + Mask = MAXULONG << Bits; + + /* This is what's left in the first ULONG */ + Bits = 32 - Bits; + + /* Even less bits to clear? */ + if (NumberToSet < Bits) + { + /* Calculate how many bits are left */ + Bits -= NumberToSet; + + /* Fixup the mask on the high side */ + Mask = Mask << Bits >> Bits; + + /* Set bits and return */ + *Buffer |= Mask; + return; + } + + /* Set bits */ + *Buffer |= Mask; + + /* Update buffer and left bits */ + Buffer++; + NumberToSet -= Bits; + } + + /* Set all full ULONGs */ + RtlFillMemoryUlong(Buffer, NumberToSet >> 3, MAXULONG); + Buffer += NumberToSet >> 5; + + /* Set what's left */ + NumberToSet &= 31; + Mask = MAXULONG << NumberToSet; + *Buffer |= ~Mask; +} + BOOLEAN NTAPI -RtlAreBitsClear(IN PRTL_BITMAP BitMapHeader, - IN ULONG StartingIndex, - IN ULONG Length) -{ - LPBYTE lpOut; - ULONG ulRemainder; - - if (!BitMapHeader || !Length || - StartingIndex >= BitMapHeader->SizeOfBitMap || - Length > BitMapHeader->SizeOfBitMap - StartingIndex) - return FALSE; - - /* FIXME: It might be more efficient/cleaner to manipulate four bytes - * at a time. But beware of the pointer arithmetics... - */ - lpOut = ((BYTE*)BitMapHeader->Buffer) + (StartingIndex >> 3u); - - /* Check bits in first byte, if StartingIndex isn't a byte boundary */ - if (StartingIndex & 7) - { - if (Length > 7) - { - /* Check from start bit to the end of the byte */ - if (*lpOut & ((0xff << (StartingIndex & 7)) & 0xff)) - return FALSE; - lpOut++; - Length -= (8 - (StartingIndex & 7)); - } - else - { - /* Check from the start bit, possibly into the next byte also */ - USHORT initialWord = NTDLL_maskBits[Length] << (StartingIndex & 7); - - if (*lpOut & (initialWord & 0xff)) - return FALSE; - if ((initialWord & 0xff00) && (lpOut[1] & (initialWord >> 8))) - return FALSE; - return TRUE; - } - } - - /* Check bits in blocks of 8 bytes */ - ulRemainder = Length & 7; - Length >>= 3; - while (Length--) - { - if (*lpOut++) - return FALSE; - } - - /* Check remaining bits, if any */ - if (ulRemainder && *lpOut & NTDLL_maskBits[ulRemainder]) - return FALSE; - return TRUE; -} - - -/* - * @implemented - */ -BOOLEAN NTAPI -RtlAreBitsSet(PRTL_BITMAP BitMapHeader, - ULONG StartingIndex, - ULONG Length) -{ - LPBYTE lpOut; - ULONG ulRemainder; - - - if (!BitMapHeader || !Length || - StartingIndex >= BitMapHeader->SizeOfBitMap || - Length > BitMapHeader->SizeOfBitMap - StartingIndex) - return FALSE; - - /* FIXME: It might be more efficient/cleaner to manipulate four bytes - * at a time. But beware of the pointer arithmetics... - */ - lpOut = ((BYTE*)BitMapHeader->Buffer) + (StartingIndex >> 3u); - - /* Check bits in first byte, if StartingIndex isn't a byte boundary */ - if (StartingIndex & 7) - { - if (Length > 7) - { - /* Check from start bit to the end of the byte */ - if ((*lpOut & - ((0xff << (StartingIndex & 7))) & 0xff) != ((0xff << (StartingIndex & 7) & 0xff))) - return FALSE; - lpOut++; - Length -= (8 - (StartingIndex & 7)); - } - else - { - /* Check from the start bit, possibly into the next byte also */ - USHORT initialWord = NTDLL_maskBits[Length] << (StartingIndex & 7); - - if ((*lpOut & (initialWord & 0xff)) != (initialWord & 0xff)) - return FALSE; - if ((initialWord & 0xff00) && - ((lpOut[1] & (initialWord >> 8)) != (initialWord >> 8))) - return FALSE; - return TRUE; - } - } - - /* Check bits in blocks of 8 bytes */ - ulRemainder = Length & 7; - Length >>= 3; - while (Length--) - { - if (*lpOut++ != 0xff) - return FALSE; - } - - /* Check remaining bits, if any */ - if (ulRemainder && - (*lpOut & NTDLL_maskBits[ulRemainder]) != NTDLL_maskBits[ulRemainder]) - return FALSE; - return TRUE; -} - - -/* - * @implemented - */ -VOID NTAPI -RtlClearAllBits(IN OUT PRTL_BITMAP BitMapHeader) -{ - memset(BitMapHeader->Buffer, 0, ((BitMapHeader->SizeOfBitMap + 31) & ~31) >> 3); -} - -/* - * @implemented - */ -VOID -NTAPI -RtlClearBit(PRTL_BITMAP BitMapHeader, - ULONG BitNumber) -{ - PUCHAR Ptr; - - if (BitNumber >= BitMapHeader->SizeOfBitMap) return; - - Ptr = (PUCHAR)BitMapHeader->Buffer + (BitNumber / 8); - *Ptr &= ~(1 << (BitNumber % 8)); -} - -/* - * @implemented - */ -VOID -NTAPI -RtlClearBits(IN PRTL_BITMAP BitMapHeader, - IN ULONG StartingIndex, - IN ULONG NumberToClear) -{ - LPBYTE lpOut; - - if (!BitMapHeader || !NumberToClear || - StartingIndex >= BitMapHeader->SizeOfBitMap || - NumberToClear > BitMapHeader->SizeOfBitMap - StartingIndex) - return; - - /* FIXME: It might be more efficient/cleaner to manipulate four bytes - * at a time. But beware of the pointer arithmetics... - */ - lpOut = ((BYTE*)BitMapHeader->Buffer) + (StartingIndex >> 3u); - - /* Clear bits in first byte, if StartingIndex isn't a byte boundary */ - if (StartingIndex & 7) - { - if (NumberToClear > 7) - { - /* Clear from start bit to the end of the byte */ - *lpOut++ &= ~(0xff << (StartingIndex & 7)); - NumberToClear -= (8 - (StartingIndex & 7)); - } - else - { - /* Clear from the start bit, possibly into the next byte also */ - USHORT initialWord = ~(NTDLL_maskBits[NumberToClear] << (StartingIndex & 7)); - - *lpOut++ &= (initialWord & 0xff); - *lpOut &= (initialWord >> 8); - return; - } - } - - /* Clear bits (in blocks of 8) on whole byte boundaries */ - if (NumberToClear >> 3) - { - memset(lpOut, 0, NumberToClear >> 3); - lpOut = lpOut + (NumberToClear >> 3); - } - - /* Clear remaining bits, if any */ - if (NumberToClear & 0x7) - *lpOut &= ~NTDLL_maskBits[NumberToClear & 0x7]; -} - - -/* - * @implemented - */ -ULONG NTAPI -RtlFindClearBits(PRTL_BITMAP BitMapHeader, - ULONG NumberToFind, - ULONG HintIndex) -{ - ULONG ulPos, ulEnd; - - if (!BitMapHeader || !NumberToFind || NumberToFind > BitMapHeader->SizeOfBitMap) +RtlTestBit( + IN PRTL_BITMAP BitMapHeader, + IN ULONG BitNumber) +{ + ASSERT(BitNumber < BitMapHeader->SizeOfBitMap); + return (BitMapHeader->Buffer[BitNumber >> 5] >> (BitNumber & 31)) & 1; +} + +BOOLEAN +NTAPI +RtlAreBitsClear( + IN PRTL_BITMAP BitMapHeader, + IN ULONG StartingIndex, + IN ULONG Length) +{ + return RtlpGetLengthOfRunClear(BitMapHeader, StartingIndex, Length) >= Length; +} + +BOOLEAN +NTAPI +RtlAreBitsSet( + IN PRTL_BITMAP BitMapHeader, + IN ULONG StartingIndex, + IN ULONG Length) +{ + return RtlpGetLengthOfRunSet(BitMapHeader, StartingIndex, Length) >= Length; +} + +ULONG +NTAPI +RtlNumberOfSetBits( + IN PRTL_BITMAP BitMapHeader) +{ + PUCHAR Byte, MaxByte; + ULONG BitCount = 0; + + Byte = (PUCHAR)BitMapHeader->Buffer; + MaxByte = Byte + (BitMapHeader->SizeOfBitMap + 7) / 8; + + do + { + BitCount += BitCountTable[*Byte++]; + } + while (Byte <= MaxByte); + + return BitCount; +} + +ULONG +NTAPI +RtlNumberOfClearBits( + IN PRTL_BITMAP BitMapHeader) +{ + /* Do some math */ + return BitMapHeader->SizeOfBitMap - RtlNumberOfSetBits(BitMapHeader); +} + +ULONG +NTAPI +RtlFindClearBits( + IN PRTL_BITMAP BitMapHeader, + IN ULONG NumberToFind, + IN ULONG HintIndex) +{ + ULONG CurrentBit, CurrentLength; + + /* Check for valid parameters */ + if (!BitMapHeader || NumberToFind > BitMapHeader->SizeOfBitMap) + { + return MAXULONG; + } + + /* Check for trivial case */ + if (NumberToFind == 0) + { + return HintIndex; + } + + /* Start with hint index, length is 0 */ + CurrentBit = HintIndex; + CurrentLength = 0; + + /* Loop until something is found or the end is reached */ + while (CurrentBit + NumberToFind < BitMapHeader->SizeOfBitMap) + { + ULONG test; + /* Search for the next clear run, by skipping a set run */ + test = RtlpGetLengthOfRunSet(BitMapHeader, + CurrentBit, + MAXULONG); + CurrentBit += test; + + /* Get length of the clear bit run */ + CurrentLength = RtlpGetLengthOfRunClear(BitMapHeader, + CurrentBit, + NumberToFind); + + /* Is this long enough? */ + if (CurrentLength >= NumberToFind) + { + /* It is */ + return CurrentBit; + } + + CurrentBit += CurrentLength; + } + + /* Nothing found */ return MAXULONG; - - ulEnd = BitMapHeader->SizeOfBitMap; - - if (HintIndex + NumberToFind > BitMapHeader->SizeOfBitMap) - HintIndex = 0; - - ulPos = HintIndex; - - while (ulPos < ulEnd) - { - /* FIXME: This could be made a _lot_ more efficient */ - if (RtlAreBitsClear(BitMapHeader, ulPos, NumberToFind)) - return ulPos; - - /* Start from the beginning if we hit the end and started from HintIndex */ - if (ulPos == ulEnd - 1 && HintIndex) - { - ulEnd = HintIndex; - ulPos = HintIndex = 0; - } - else - ulPos++; - } - return MAXULONG; -} - -/* - * @implemented - */ -ULONG NTAPI -RtlFindClearRuns(PRTL_BITMAP BitMapHeader, - PRTL_BITMAP_RUN RunArray, - ULONG SizeOfRunArray, - BOOLEAN LocateLongestRuns) -{ - return NTDLL_FindRuns(BitMapHeader, RunArray, SizeOfRunArray, LocateLongestRuns, NTDLL_FindClearRun); -} - -/* - * @unimplemented - */ -ULONG NTAPI -RtlFindLastBackwardRunClear(IN PRTL_BITMAP BitMapHeader, - IN ULONG FromIndex, - IN PULONG StartingRunIndex) -{ - UNIMPLEMENTED; - return 0; -} - -/* - * @implemented - */ -ULONG NTAPI -RtlFindNextForwardRunClear(IN PRTL_BITMAP BitMapHeader, - IN ULONG FromIndex, - IN PULONG StartingRunIndex) -{ - ULONG ulSize = 0; - - if (BitMapHeader && FromIndex < BitMapHeader->SizeOfBitMap && StartingRunIndex) - *StartingRunIndex = NTDLL_FindClearRun(BitMapHeader, FromIndex, &ulSize); - - return ulSize; -} - -/* - * @implemented - */ -ULONG NTAPI -RtlFindFirstRunSet(IN PRTL_BITMAP BitMapHeader, - IN PULONG StartingIndex) -{ - ULONG Size; - ULONG Index; - ULONG Count; - PULONG Ptr; - ULONG Mask; - - Size = BitMapHeader->SizeOfBitMap; - if (*StartingIndex > Size) - { - *StartingIndex = MAXULONG; +} + +ULONG +NTAPI +RtlFindSetBits( + IN PRTL_BITMAP BitMapHeader, + IN ULONG NumberToFind, + IN ULONG HintIndex) +{ + ULONG CurrentBit, CurrentLength; + + /* Check for valid parameters */ + if (!BitMapHeader || NumberToFind > BitMapHeader->SizeOfBitMap) + { + return MAXULONG; + } + + /* Check for trivial case */ + if (NumberToFind == 0) + { + return HintIndex; + } + + /* Start with hint index, length is 0 */ + CurrentBit = HintIndex; + CurrentLength = 0; + + /* Loop until something is found or the end is reached */ + while (CurrentBit + NumberToFind <= BitMapHeader->SizeOfBitMap) + { + /* Search for the next set run, by skipping a clear run */ + CurrentBit += RtlpGetLengthOfRunClear(BitMapHeader, + CurrentBit, + MAXULONG); + + /* Get length of the set bit run */ + CurrentLength = RtlpGetLengthOfRunSet(BitMapHeader, + CurrentBit, + NumberToFind); + + /* Is this long enough? */ + if (CurrentLength >= NumberToFind) + { + /* It is */ + return CurrentBit; + } + + CurrentBit += CurrentLength; + } + + /* Nothing found */ + return MAXULONG; +} + +ULONG +NTAPI +RtlFindClearBitsAndSet( + PRTL_BITMAP BitMapHeader, + ULONG NumberToFind, + ULONG HintIndex) +{ + ULONG Position; + + /* Try to find clear bits */ + Position = RtlFindClearBits(BitMapHeader, NumberToFind, HintIndex); + + /* Did we get something? */ + if (Position != MAXULONG) + { + /* Yes, set the bits */ + RtlSetBits(BitMapHeader, Position, NumberToFind); + } + + /* Return what we found */ + return Position; +} + +ULONG +NTAPI +RtlFindSetBitsAndClear( + IN PRTL_BITMAP BitMapHeader, + IN ULONG NumberToFind, + IN ULONG HintIndex) +{ + ULONG Position; + + /* Try to find set bits */ + Position = RtlFindSetBits(BitMapHeader, NumberToFind, HintIndex); + + /* Did we get something? */ + if (Position != MAXULONG) + { + /* Yes, clear the bits */ + RtlClearBits(BitMapHeader, Position, NumberToFind); + } + + /* Return what we found */ + return Position; +} + +ULONG +NTAPI +RtlFindNextForwardRunClear( + IN PRTL_BITMAP BitMapHeader, + IN ULONG FromIndex, + IN PULONG StartingRunIndex) +{ + ULONG Length; + + /* Assume a set run first, count it's length */ + Length = RtlpGetLengthOfRunSet(BitMapHeader, FromIndex, MAXULONG); + *StartingRunIndex = FromIndex; + + /* Now return the length of the run */ + return RtlpGetLengthOfRunClear(BitMapHeader, FromIndex, MAXULONG); +} + +ULONG +NTAPI +RtlFindNextForwardRunSet( + IN PRTL_BITMAP BitMapHeader, + IN ULONG FromIndex, + IN PULONG StartingRunIndex) +{ + ULONG Length; + + /* Assume a clear run first, count it's length */ + Length = RtlpGetLengthOfRunClear(BitMapHeader, FromIndex, MAXULONG); + *StartingRunIndex = FromIndex; + + /* Now return the length of the run */ + return RtlpGetLengthOfRunSet(BitMapHeader, FromIndex, MAXULONG); +} + +ULONG +NTAPI +RtlFindFirstRunClear( + IN PRTL_BITMAP BitMapHeader, + IN PULONG StartingIndex) +{ + return RtlFindNextForwardRunClear(BitMapHeader, 0, StartingIndex); +} + +ULONG +NTAPI +RtlFindLastBackwardRunClear( + IN PRTL_BITMAP BitMapHeader, + IN ULONG FromIndex, + IN PULONG StartingRunIndex) +{ + UNIMPLEMENTED; return 0; - } - - Index = *StartingIndex; - Ptr = (PULONG)BitMapHeader->Buffer + (Index / 32); - Mask = 1 << (Index & 0x1F); - - /* Skip clear bits */ - for (; Index < Size && ~*Ptr & Mask; Index++) - { - Mask <<= 1; - - if (Mask == 0) - { - Mask = 1; - Ptr++; - } - } - - /* Return index of first set bit */ - if (Index >= Size) - { - *StartingIndex = MAXULONG; - return 0; - } - else - { - *StartingIndex = Index; - } - - /* Count set bits */ - for (Count = 0; Index < Size && *Ptr & Mask; Index++) - { - Count++; - Mask <<= 1; - - if (Mask == 0) - { - Mask = 1; - Ptr++; - } - } - - return Count; -} - - -/* - * @implemented - */ -ULONG NTAPI -RtlFindLongestRunClear(PRTL_BITMAP BitMapHeader, - PULONG StartingIndex) -{ - /* GCC complaints that it may be used uninitialized */ - RTL_BITMAP_RUN br = { 0, 0 }; - - if (RtlFindClearRuns(BitMapHeader, &br, 1, TRUE) == 1) - { - if (StartingIndex) - *StartingIndex = br.StartingIndex; - return br.NumberOfBits; - } - return 0; -} - - -/* - * @implemented - */ -ULONG NTAPI -RtlFindLongestRunSet(PRTL_BITMAP BitMapHeader, - PULONG StartingIndex) -{ - /* GCC complaints that it may be used uninitialized */ - RTL_BITMAP_RUN br = { 0, 0 }; - - if (NTDLL_FindRuns(BitMapHeader, &br, 1, TRUE, NTDLL_FindSetRun) == 1) - { - if (StartingIndex) - *StartingIndex = br.StartingIndex; - return br.NumberOfBits; - } - return 0; -} - - -/* - * @implemented - */ -ULONG NTAPI -RtlFindSetBits(PRTL_BITMAP BitMapHeader, - ULONG NumberToFind, - ULONG HintIndex) -{ - ULONG ulPos, ulEnd; - - if (!BitMapHeader || !NumberToFind || NumberToFind > BitMapHeader->SizeOfBitMap) - return MAXULONG; - - ulEnd = BitMapHeader->SizeOfBitMap; - - if (HintIndex + NumberToFind > BitMapHeader->SizeOfBitMap) - HintIndex = 0; - - ulPos = HintIndex; - - while (ulPos < ulEnd) - { - /* FIXME: This could be made a _lot_ more efficient */ - if (RtlAreBitsSet(BitMapHeader, ulPos, NumberToFind)) - return ulPos; - - /* Start from the beginning if we hit the end and had a hint */ - if (ulPos == ulEnd - 1 && HintIndex) - { - ulEnd = HintIndex; - ulPos = HintIndex = 0; - } - else - ulPos++; - } - return MAXULONG; -} - - -/* - * @implemented - */ -ULONG NTAPI -RtlFindSetBitsAndClear(PRTL_BITMAP BitMapHeader, - ULONG NumberToFind, - ULONG HintIndex) -{ - ULONG ulPos; - - ulPos = RtlFindSetBits(BitMapHeader, NumberToFind, HintIndex); - if (ulPos != MAXULONG) - RtlClearBits(BitMapHeader, ulPos, NumberToFind); - return ulPos; -} - - -/* - * @implemented - */ -ULONG NTAPI -RtlNumberOfSetBits(PRTL_BITMAP BitMapHeader) -{ - ULONG ulSet = 0; - - if (BitMapHeader) - { - LPBYTE lpOut = (BYTE *)BitMapHeader->Buffer; - ULONG Length, ulRemainder; - BYTE bMasked; - - Length = BitMapHeader->SizeOfBitMap >> 3; - ulRemainder = BitMapHeader->SizeOfBitMap & 0x7; - - while (Length--) - { - ulSet += NTDLL_nibbleBitCount[*lpOut >> 4]; - ulSet += NTDLL_nibbleBitCount[*lpOut & 0xf]; - lpOut++; - } - - if (ulRemainder) - { - bMasked = *lpOut & NTDLL_maskBits[ulRemainder]; - ulSet += NTDLL_nibbleBitCount[bMasked >> 4]; - ulSet += NTDLL_nibbleBitCount[bMasked & 0xf]; - } - } - return ulSet; -} - - -/* - * @implemented - */ -VOID NTAPI -RtlSetAllBits(IN OUT PRTL_BITMAP BitMapHeader) -{ - memset(BitMapHeader->Buffer, 0xff, ((BitMapHeader->SizeOfBitMap + 31) & ~31) >> 3); -} - - -/* - * @implemented - */ -VOID NTAPI -RtlSetBit(PRTL_BITMAP BitMapHeader, - ULONG BitNumber) -{ - PUCHAR Ptr; - - if (BitNumber >= BitMapHeader->SizeOfBitMap) - return; - - Ptr = (PUCHAR)BitMapHeader->Buffer + (BitNumber / 8); - - *Ptr |= (1 << (BitNumber % 8)); -} - - -/* - * @implemented - */ -VOID NTAPI -RtlSetBits(PRTL_BITMAP BitMapHeader, - ULONG StartingIndex, - ULONG NumberToSet) -{ - LPBYTE lpOut; - - if (!BitMapHeader || !NumberToSet || - StartingIndex >= BitMapHeader->SizeOfBitMap || - NumberToSet > BitMapHeader->SizeOfBitMap - StartingIndex) - return; - - /* FIXME: It might be more efficient/cleaner to manipulate four bytes - * at a time. But beware of the pointer arithmetics... - */ - lpOut = ((BYTE*)BitMapHeader->Buffer) + (StartingIndex >> 3u); - - /* Set bits in first byte, if StartingIndex isn't a byte boundary */ - if (StartingIndex & 7) - { - if (NumberToSet > 7) - { - /* Set from start bit to the end of the byte */ - *lpOut++ |= 0xff << (StartingIndex & 7); - NumberToSet -= (8 - (StartingIndex & 7)); - } - else - { - /* Set from the start bit, possibly into the next byte also */ - USHORT initialWord = NTDLL_maskBits[NumberToSet] << (StartingIndex & 7); - - *lpOut++ |= (initialWord & 0xff); - *lpOut |= (initialWord >> 8); - return; - } - } - - /* Set bits up to complete byte count */ - if (NumberToSet >> 3) - { - memset(lpOut, 0xff, NumberToSet >> 3); - lpOut = lpOut + (NumberToSet >> 3); - } - - /* Set remaining bits, if any */ - if (NumberToSet & 0x7) - *lpOut |= NTDLL_maskBits[NumberToSet & 0x7]; -} - - -/* - * @implemented - */ -BOOLEAN NTAPI -RtlTestBit(PRTL_BITMAP BitMapHeader, - ULONG BitNumber) -{ - PUCHAR Ptr; - - if (BitNumber >= BitMapHeader->SizeOfBitMap) - return FALSE; - - Ptr = (PUCHAR)BitMapHeader->Buffer + (BitNumber / 8); - - return (BOOLEAN)(*Ptr & (1 << (BitNumber % 8))); -} - -/* - * @implemented - */ -ULONG NTAPI -RtlFindFirstRunClear(PRTL_BITMAP BitMapHeader, - PULONG StartingIndex) -{ - return RtlFindNextForwardRunClear(BitMapHeader, 0, StartingIndex); -} - -/* - * @implemented - */ -ULONG NTAPI -RtlNumberOfClearBits(PRTL_BITMAP BitMapHeader) -{ - - if (BitMapHeader) - return BitMapHeader->SizeOfBitMap - RtlNumberOfSetBits(BitMapHeader); - return 0; -} - -/* - * @implemented - */ -ULONG NTAPI -RtlFindClearBitsAndSet(PRTL_BITMAP BitMapHeader, - ULONG NumberToFind, - ULONG HintIndex) -{ - ULONG ulPos; - - ulPos = RtlFindClearBits(BitMapHeader, NumberToFind, HintIndex); - if (ulPos != MAXULONG) - RtlSetBits(BitMapHeader, ulPos, NumberToFind); - return ulPos; -} - -/* - * @implemented - */ -CCHAR WINAPI RtlFindMostSignificantBit(ULONGLONG ulLong) -{ - signed char ret = 32; - DWORD dw; - - if (!(dw = (DWORD)(ulLong >> 32))) - { - ret = 0; - dw = (DWORD)ulLong; - } - if (dw & 0xffff0000) - { - dw >>= 16; - ret += 16; - } - if (dw & 0xff00) - { - dw >>= 8; - ret += 8; - } - if (dw & 0xf0) - { - dw >>= 4; - ret += 4; - } - return ret + NTDLL_mostSignificant[dw]; -} - -/* - * @implemented - */ -CCHAR WINAPI RtlFindLeastSignificantBit(ULONGLONG ulLong) -{ - signed char ret = 0; - DWORD dw; - - if (!(dw = (DWORD)ulLong)) - { - ret = 32; - if (!(dw = (DWORD)(ulLong >> 32))) return -1; - } - if (!(dw & 0xffff)) - { - dw >>= 16; - ret += 16; - } - if (!(dw & 0xff)) - { - dw >>= 8; - ret += 8; - } - if (!(dw & 0x0f)) - { - dw >>= 4; - ret += 4; - } - return ret + NTDLL_leastSignificant[dw & 0x0f]; -} - -/* EOF */ +} + + +ULONG +NTAPI +RtlFindClearRuns( + IN PRTL_BITMAP BitMapHeader, + IN PRTL_BITMAP_RUN RunArray, + IN ULONG SizeOfRunArray, + IN BOOLEAN LocateLongestRuns) +{ + ULONG StartingIndex, NumberOfBits, Run, FromIndex = 0, SmallestRun = 0; + + /* Loop the runs */ + for (Run = 0; Run < SizeOfRunArray; Run++) + { + /* Look for a run */ + NumberOfBits = RtlFindNextForwardRunClear(BitMapHeader, + FromIndex, + &StartingIndex); + + /* Nothing more found? Quit looping. */ + if (NumberOfBits == 0) break; + + /* Add another run */ + RunArray[Run].StartingIndex = StartingIndex; + RunArray[Run].NumberOfBits = NumberOfBits; + + /* Update smallest run */ + if (NumberOfBits < RunArray[SmallestRun].NumberOfBits) + { + SmallestRun = Run; + } + + /* Advance bits */ + FromIndex += NumberOfBits; + } + + /* Check if we are finished */ + if (Run < SizeOfRunArray || !LocateLongestRuns) + { + /* Return the number of found runs */ + return Run; + } + + while (1) + { + /* Look for a run */ + NumberOfBits = RtlFindNextForwardRunClear(BitMapHeader, + FromIndex, + &StartingIndex); + + /* Nothing more found? Quit looping. */ + if (NumberOfBits == 0) break; + + /* Check if we have something to update */ + if (NumberOfBits > RunArray[SmallestRun].NumberOfBits) + { + /* Update smallest run */ + RunArray[SmallestRun].StartingIndex = StartingIndex; + RunArray[SmallestRun].NumberOfBits = NumberOfBits; + + /* Loop all runs */ + for (Run = 0; Run < SizeOfRunArray; Run++) + { + /*Is this the new smallest run? */ + if (NumberOfBits < RunArray[SmallestRun].NumberOfBits) + { + /* Set it as new smallest run */ + SmallestRun = Run; + } + } + } + + /* Advance bits */ + FromIndex += NumberOfBits; + } + + return Run; +} + +ULONG +NTAPI +RtlFindLongestRunClear( + IN PRTL_BITMAP BitMapHeader, + IN PULONG StartingIndex) +{ + ULONG NumberOfBits, Index, MaxNumberOfBits = 0, FromIndex = 0; + + while (1) + { + /* Look for a run */ + NumberOfBits = RtlFindNextForwardRunClear(BitMapHeader, + FromIndex, + &Index); + + /* Nothing more found? Quit looping. */ + if (NumberOfBits == 0) break; + + /* Was that the longest run? */ + if (NumberOfBits > MaxNumberOfBits) + { + /* Update values */ + MaxNumberOfBits = NumberOfBits; + *StartingIndex = Index; + } + + /* Advance bits */ + FromIndex += NumberOfBits; + } + + return MaxNumberOfBits; +} + +ULONG +NTAPI +RtlFindLongestRunSet( + IN PRTL_BITMAP BitMapHeader, + IN PULONG StartingIndex) +{ + ULONG NumberOfBits, Index, MaxNumberOfBits = 0, FromIndex = 0; + + while (1) + { + /* Look for a run */ + NumberOfBits = RtlFindNextForwardRunSet(BitMapHeader, + FromIndex, + &Index); + + /* Nothing more found? Quit looping. */ + if (NumberOfBits == 0) break; + + /* Was that the longest run? */ + if (NumberOfBits > MaxNumberOfBits) + { + /* Update values */ + MaxNumberOfBits = NumberOfBits; + *StartingIndex = Index; + } + + /* Advance bits */ + FromIndex += NumberOfBits; + } + + return MaxNumberOfBits; +} + Modified: trunk/reactos/tools/mkhive/mkhive.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/tools/mkhive/mkhive.h?rev=… ============================================================================== --- trunk/reactos/tools/mkhive/mkhive.h [iso-8859-1] (original) +++ trunk/reactos/tools/mkhive/mkhive.h [iso-8859-1] Tue Dec 8 02:02:36 2009 @@ -46,6 +46,10 @@ #define STATUS_OBJECT_NAME_NOT_FOUND ((NTSTATUS)0xC0000034) #define STATUS_INVALID_PARAMETER_2 ((NTSTATUS)0xC00000F0) #define STATUS_BUFFER_OVERFLOW ((NTSTATUS)0x80000005) + +unsigned char BitScanForward(ULONG * Index, const unsigned long Mask); +unsigned char BitScanReverse(ULONG * const Index, const unsigned long Mask); +#define RtlFillMemoryUlong(dst, len, val) memset(dst, val, len) NTSTATUS NTAPI RtlAnsiStringToUnicodeString( Modified: trunk/reactos/tools/mkhive/rtl.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/tools/mkhive/rtl.c?rev=444… ============================================================================== --- trunk/reactos/tools/mkhive/rtl.c [iso-8859-1] (original) +++ trunk/reactos/tools/mkhive/rtl.c [iso-8859-1] Tue Dec 8 02:02:36 2009 @@ -185,3 +185,25 @@ //DbgBreakPoint(); } + +unsigned char BitScanForward(ULONG * Index, unsigned long Mask) +{ + *Index = 0; + while (Mask && ((Mask & 1) == 0)) + { + Mask >>= 1; + ++(*Index); + } + return Mask ? 1 : 0; +} + +unsigned char BitScanReverse(ULONG * const Index, unsigned long Mask) +{ + *Index = 0; + while (Mask && ((Mask & (1 << 31)) == 0)) + { + Mask <<= 1; + ++(*Index); + } + return Mask ? 1 : 0; +}

1 0

[sserapion] 44463: Fix building some modules.
by sserapion＠svn.reactos.org 07 Dec '09

07 Dec '09

Author: sserapion Date: Tue Dec 8 00:11:49 2009 New Revision: 44463 URL: http://svn.reactos.org/svn/reactos?rev=44463&view=rev Log: Fix building some modules. Modified: branches/ros-amd64-bringup/rosapps/applications/devutils/gdihv/handlelist.c branches/ros-amd64-bringup/rosapps/applications/screensavers/cylfrac/cylfrac.c branches/ros-amd64-bringup/rosapps/applications/screensavers/mazescr/scrnsave.c branches/ros-amd64-bringup/rosapps/applications/sysutils/ctm/ctm.c branches/ros-amd64-bringup/rosapps/applications/sysutils/pedump/pedump.c Modified: branches/ros-amd64-bringup/rosapps/applications/devutils/gdihv/handlelist.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rosapps/appli… ============================================================================== --- branches/ros-amd64-bringup/rosapps/applications/devutils/gdihv/handlelist.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rosapps/applications/devutils/gdihv/handlelist.c [iso-8859-1] Tue Dec 8 00:11:49 2009 @@ -87,9 +87,9 @@ (ProcessId == (HANDLE)2) ) { if (ProcessId == (HANDLE)1 || ProcessId == (HANDLE)2 || - ((LONG)ProcessId & 0xfffc) == ((ULONG)pEntry->ProcessId & 0xfffc)) + ((LONG_PTR)ProcessId & 0xfffc) == ((ULONG_PTR)pEntry->ProcessId & 0xfffc)) { - handle = GDI_HANDLE_CREATE(i, pEntry->Type); + handle = GDI_HANDLE_CREATE(i, (ULONG_PTR)pEntry->Type); index = ListView_GetItemCount(hHandleListCtrl); item.iItem = index; item.iSubItem = 0; @@ -107,13 +107,13 @@ str2 = GetTypeName(handle); ListView_SetItemText(hHandleListCtrl, index, 3, str2); - wsprintf(strText, L"%#08x", (UINT)pEntry->ProcessId); + wsprintf(strText, L"%#08x", (UINT_PTR)pEntry->ProcessId); ListView_SetItemText(hHandleListCtrl, index, 4, strText); - wsprintf(strText, L"%#08x", (UINT)pEntry->KernelData); + wsprintf(strText, L"%#08x", (UINT_PTR)pEntry->KernelData); ListView_SetItemText(hHandleListCtrl, index, 5, strText); - wsprintf(strText, L"%#08x", (UINT)pEntry->UserData); + wsprintf(strText, L"%#08x", (UINT_PTR)pEntry->UserData); ListView_SetItemText(hHandleListCtrl, index, 6, strText); wsprintf(strText, L"%#08x", (UINT)pEntry->Type); Modified: branches/ros-amd64-bringup/rosapps/applications/screensavers/cylfrac/cylfrac.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rosapps/appli… ============================================================================== --- branches/ros-amd64-bringup/rosapps/applications/screensavers/cylfrac/cylfrac.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rosapps/applications/screensavers/cylfrac/cylfrac.c [iso-8859-1] Tue Dec 8 00:11:49 2009 @@ -111,7 +111,7 @@ EndPaint(hwnd, &ps); } -void CALLBACK TimeProc(UINT uID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2) +void CALLBACK TimeProc(UINT uID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) { InvalidateRect((HWND)dwUser, NULL, 0); } @@ -155,7 +155,7 @@ GetCursorPos(&initpoint); InitGL(hwnd); oldticks = GetTickCount(); - TimerID = timeSetEvent (timerdelay, 0, TimeProc, (DWORD)hwnd, TIME_PERIODIC); + TimerID = timeSetEvent (timerdelay, 0, TimeProc, (DWORD_PTR)hwnd, TIME_PERIODIC); break; case WM_PAINT: { @@ -268,7 +268,7 @@ if(isdigit(ch)) { unsigned int i = _wtoi(szCmdLine - 1); - *hwndParent = (HWND)i; + *hwndParent = (HWND)(ULONG_PTR)i; } else *hwndParent = NULL; Modified: branches/ros-amd64-bringup/rosapps/applications/screensavers/mazescr/scrnsave.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rosapps/appli… ============================================================================== --- branches/ros-amd64-bringup/rosapps/applications/screensavers/mazescr/scrnsave.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rosapps/applications/screensavers/mazescr/scrnsave.c [iso-8859-1] Tue Dec 8 00:11:49 2009 @@ -167,7 +167,7 @@ if(isdigit(ch)) { unsigned int i = atoi(szCmdLine - 1); - *hwndParent = (HWND)i; + *hwndParent = (HWND)(ULONG_PTR)i; } else *hwndParent = 0; Modified: branches/ros-amd64-bringup/rosapps/applications/sysutils/ctm/ctm.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rosapps/appli… ============================================================================== --- branches/ros-amd64-bringup/rosapps/applications/sysutils/ctm/ctm.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rosapps/applications/sysutils/ctm/ctm.c [iso-8859-1] Tue Dec 8 00:11:49 2009 @@ -493,7 +493,7 @@ // so that we can establish delta values pPDOld = NULL; for (Idx2=0; Idx2<ProcessCountOld; Idx2++) { - if (pPerfDataOld[Idx2].ProcessId == (ULONG)(pSPI->UniqueProcessId) && + if (pPerfDataOld[Idx2].ProcessId == (ULONG_PTR)(pSPI->UniqueProcessId) && /* check also for the creation time, a new process may have an id of an old one */ pPerfDataOld[Idx2].CreateTime.QuadPart == pSPI->CreateTime.QuadPart) { pPDOld = &pPerfDataOld[Idx2]; @@ -517,7 +517,7 @@ #endif } - pPerfData[Idx].ProcessId = (ULONG)(pSPI->UniqueProcessId); + pPerfData[Idx].ProcessId = (ULONG_PTR)(pSPI->UniqueProcessId); pPerfData[Idx].CreateTime = pSPI->CreateTime; if (pPDOld) { Modified: branches/ros-amd64-bringup/rosapps/applications/sysutils/pedump/pedump.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rosapps/appli… ============================================================================== --- branches/ros-amd64-bringup/rosapps/applications/sysutils/pedump/pedump.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rosapps/applications/sysutils/pedump/pedump.c [iso-8859-1] Tue Dec 8 00:11:49 2009 @@ -1011,7 +1011,7 @@ PIMAGE_OPTIONAL_HEADER poh = (PIMAGE_OPTIONAL_HEADER) OPTHDROFFSET (lpFile); if (poh != NULL) - return (LPVOID) (poh->AddressOfEntryPoint); + return (LPVOID)(ULONG_PTR)(poh->AddressOfEntryPoint); else return NULL; }

1 0

[sserapion] 44462: Fix building some modules. special thanks to Basil Gello.
by sserapion＠svn.reactos.org 07 Dec '09

07 Dec '09

Author: sserapion Date: Tue Dec 8 00:09:35 2009 New Revision: 44462 URL: http://svn.reactos.org/svn/reactos?rev=44462&view=rev Log: Fix building some modules. special thanks to Basil Gello. Modified: branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_io.c branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_ob.c branches/ros-amd64-bringup/rostests/drivers/kmtest/reghelper.c branches/ros-amd64-bringup/rostests/tests/global_mem/global_mem.c branches/ros-amd64-bringup/rostests/tests/isotest/isotest.c branches/ros-amd64-bringup/rostests/tests/map_dup_inherit/map_dup_inherit.c branches/ros-amd64-bringup/rostests/tests/mdi/mdi.c branches/ros-amd64-bringup/rostests/tests/miditest/miditest.c branches/ros-amd64-bringup/rostests/tests/multithrdwin/multithrdwin.c branches/ros-amd64-bringup/rostests/tests/p_dup_handle/p_dup_handle.c branches/ros-amd64-bringup/rostests/win32/user32/kbdlayout/kbdlayout.c branches/ros-amd64-bringup/rostests/winetests/msvcrt/printf.c Modified: branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_io.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/driv… ============================================================================== --- branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_io.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_io.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -48,7 +48,7 @@ ok(Mdl == NULL, "IoAllocateMdl should fail allocation of 2Gb or more, but got Mdl=0x%X", - (UINT32)Mdl); + (UINT_PTR)Mdl); if (Mdl) IoFreeMdl(Mdl); @@ -59,10 +59,10 @@ ok(Mdl != NULL, "Mdl allocation failed"); // Check fields of the allocated struct ok(Mdl->Next == NULL, "Mdl->Next should be NULL, but is 0x%X", - (UINT32)Mdl->Next); + (UINT_PTR)Mdl->Next); ok(Mdl->ByteCount == MdlSize, "Mdl->ByteCount should be equal to MdlSize, but is 0x%X", - (UINT32)Mdl->ByteCount); + (UINT_PTR)Mdl->ByteCount); // TODO: Check other fields of MDL struct IoFreeMdl(Mdl); @@ -72,7 +72,7 @@ Mdl = IoAllocateMdl(VirtualAddress, MdlSize, FALSE, FALSE, Irp); ok(Mdl != NULL, "Mdl allocation failed"); ok(Irp->MdlAddress == Mdl, "Irp->MdlAddress should be 0x%X, but is 0x%X", - (UINT32)Mdl, (UINT32)Irp->MdlAddress); + (UINT_PTR)Mdl, (UINT_PTR)Irp->MdlAddress); IoFreeMdl(Mdl); Modified: branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_ob.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/driv… ============================================================================== --- branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_ob.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/drivers/kmtest/ntos_ob.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -324,7 +324,7 @@ "Object insertion should have failed, but got 0x%lX", Status); ok(ObBody[0] == ObBody1[1], "Object bodies doesn't match, 0x%p != 0x%p", ObBody[0], ObBody1[1]); - ok(ObHandle2[0] != NULL, "Bad handle returned 0x%lX", (ULONG)ObHandle2[0]); + ok(ObHandle2[0] != NULL, "Bad handle returned 0x%lX", (ULONG_PTR)ObHandle2[0]); DPRINT1("%d %d %d %d %d %d %d\n", DumpCount, OpenCount, // deletecount+1 CloseCount, DeleteCount, ParseCount, OkayToCloseCount, QueryNameCount); Modified: branches/ros-amd64-bringup/rostests/drivers/kmtest/reghelper.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/driv… ============================================================================== --- branches/ros-amd64-bringup/rostests/drivers/kmtest/reghelper.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/drivers/kmtest/reghelper.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -75,7 +75,7 @@ /* Remove the current driver name from the string */ /* FIXME: Dont use hard coded driver name, determine it from the string returned from the above Query */ Length = (wcslen((PWCHAR)ValuePartialInfo->Data) * 2) - (wcslen(L"kmtest.sys") * 2); - RtlZeroMemory((PVOID)((ULONG)ValuePartialInfo->Data + Length), + RtlZeroMemory((PVOID)((ULONG_PTR)ValuePartialInfo->Data + Length), wcslen(L"drvtests.sys") * 2); ZwClose(ServiceKey); Modified: branches/ros-amd64-bringup/rostests/tests/global_mem/global_mem.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/test… ============================================================================== --- branches/ros-amd64-bringup/rostests/tests/global_mem/global_mem.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/tests/global_mem/global_mem.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -139,7 +139,7 @@ /*--------------------------------------------------------------------------- ** */ -void OUTPUT_HexDword(DWORD dw) +void OUTPUT_HexDword(ULONG_PTR dw) { char buffer[32]; sprintf(buffer, "0x%lX",dw); @@ -412,9 +412,9 @@ else { OUTPUT_Line("Alloced Handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); OUTPUT_Line("ReAlloced Handle: "); - OUTPUT_HexDword((DWORD)hReAlloced); + OUTPUT_HexDword((ULONG_PTR)hReAlloced); if (hMem == hReAlloced) { OUTPUT_Line("GlobalReAlloc returned the same pointer. The documentation states that this is wrong, but Windows NT works this way."); @@ -455,9 +455,9 @@ else { OUTPUT_Line("Alloced Handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); OUTPUT_Line("ReAlloced Handle: "); - OUTPUT_HexDword((DWORD)hReAlloced); + OUTPUT_HexDword((ULONG_PTR)hReAlloced); if (hMem != hReAlloced) { OUTPUT_Line("GlobalReAlloc returned a different."); @@ -516,9 +516,9 @@ else { OUTPUT_Line("Alloced Handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); OUTPUT_Line("ReAlloced Handle: "); - OUTPUT_HexDword((DWORD)hReAlloced); + OUTPUT_HexDword((ULONG_PTR)hReAlloced); pMem = GlobalLock(hReAlloced); hMem = hReAlloced; @@ -559,9 +559,9 @@ else { OUTPUT_Line("Alloced Handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); OUTPUT_Line("ReAlloced Handle: "); - OUTPUT_HexDword((DWORD)hReAlloced); + OUTPUT_HexDword((ULONG_PTR)hReAlloced); if (hMem != hReAlloced) { OUTPUT_Line("GlobalReAlloc returned a different block."); @@ -638,7 +638,7 @@ OUTPUT_Result(result); OUTPUT_Line("Pointer from handle: "); - OUTPUT_HexDword((DWORD)GlobalLock(hMem)); + OUTPUT_HexDword((ULONG_PTR)GlobalLock(hMem)); OUTPUT_Line("Testing after a lock"); OUTPUT_Line("Testing for a lock of 1"); @@ -679,7 +679,7 @@ if (0 != hMem) { OUTPUT_Line("Allocation handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); OUTPUT_Line("Testing for a discarded flag"); uFlags = GlobalFlags(hMem); if (0 != (uFlags & GMEM_DISCARDED)) /*discarded*/ @@ -720,7 +720,7 @@ { OUTPUT_Line("Allocation handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); OUTPUT_Line("Testing initial allocation"); OUTPUT_Line("Testing for non-discarded and lock of 0"); @@ -737,7 +737,7 @@ OUTPUT_Result(result); OUTPUT_Line("Pointer from handle: "); - OUTPUT_HexDword((DWORD)GlobalLock(hMem)); + OUTPUT_HexDword((ULONG_PTR)GlobalLock(hMem)); OUTPUT_Line("Testing after a lock"); OUTPUT_Line("Testing for non-discarded and lock of 0"); uFlags = GlobalFlags(hMem); @@ -796,7 +796,7 @@ { OUTPUT_Line("Allocation handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); hTest = GlobalHandle(hMem); if (hMem == hTest) @@ -806,7 +806,7 @@ else { OUTPUT_Line("GlobalHandle returned:"); - OUTPUT_HexDword((DWORD)hTest); + OUTPUT_HexDword((ULONG_PTR)hTest); subtest = TEST_CombineStatus(subtest, FAILED); } @@ -830,7 +830,7 @@ { OUTPUT_Line("Allocation handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); pMem = GlobalLock(hMem); hTest = GlobalHandle(pMem); if (hMem == hTest) @@ -840,7 +840,7 @@ else { OUTPUT_Line("GlobalHandle returned:"); - OUTPUT_HexDword((DWORD)hTest); + OUTPUT_HexDword((ULONG_PTR)hTest); subtest = TEST_CombineStatus(subtest, FAILED); } @@ -979,7 +979,7 @@ if (0 != hMem) { OUTPUT_Line("Allocation handle: "); - OUTPUT_HexDword((DWORD)hMem); + OUTPUT_HexDword((ULONG_PTR)hMem); hTest = GlobalDiscard(hMem); if (0 == hTest) Modified: branches/ros-amd64-bringup/rostests/tests/isotest/isotest.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/test… ============================================================================== --- branches/ros-amd64-bringup/rostests/tests/isotest/isotest.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/tests/isotest/isotest.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -21,7 +21,7 @@ while (offset < (size & ~15)) { - ptr = (unsigned char*)((ULONG)buffer + offset); + ptr = (unsigned char*)((ULONG_PTR)buffer + offset); printf("%08lx %02hx %02hx %02hx %02hx %02hx %02hx %02hx %02hx-%02hx %02hx %02hx %02hx %02hx %02hx %02hx %02hx", offset, ptr[0], @@ -62,7 +62,7 @@ offset += 16; } - ptr = (unsigned char*)((ULONG)buffer + offset); + ptr = (unsigned char*)((ULONG_PTR)buffer + offset); if (offset < size) { printf("%08lx ", offset); Modified: branches/ros-amd64-bringup/rostests/tests/map_dup_inherit/map_dup_inherit.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/test… ============================================================================== --- branches/ros-amd64-bringup/rostests/tests/map_dup_inherit/map_dup_inherit.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/tests/map_dup_inherit/map_dup_inherit.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -17,7 +17,7 @@ if( argc == 2 ) { #ifdef WIN64 - file_map = (void *)atoi64(argv[1]); + file_map = (void *)_atoi64(argv[1]); #else file_map = (void *)UlongToPtr(atoi(argv[1])); #endif Modified: branches/ros-amd64-bringup/rostests/tests/mdi/mdi.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/test… ============================================================================== --- branches/ros-amd64-bringup/rostests/tests/mdi/mdi.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/tests/mdi/mdi.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -160,7 +160,7 @@ mcs.y = mcs.cy = CW_USEDEFAULT; mcs.style = MDIS_ALLCHILDSTYLES; - hChild = (HWND)SendMessage(hMDIClient, WM_MDICREATE, 0, (LONG)&mcs); + hChild = (HWND)SendMessage(hMDIClient, WM_MDICREATE, 0, (LPARAM)&mcs); if(!hChild) { MessageBox(hMDIClient, "MDI Child creation failed.", "Oh Oh...", Modified: branches/ros-amd64-bringup/rostests/tests/miditest/miditest.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/test… ============================================================================== --- branches/ros-amd64-bringup/rostests/tests/miditest/miditest.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/tests/miditest/miditest.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -36,7 +36,7 @@ printf("Opening MIDI output #0\n"); Result = midiOutOpen(&Handle, 0, 0, 0, CALLBACK_NULL); - printf("Result == %d Handle == %d\n", Result, (int)Handle); + printf("Result == %d Handle == %x\n", Result, Handle); // play something: midiOutShortMsg(Handle, 0x007f3090); Modified: branches/ros-amd64-bringup/rostests/tests/multithrdwin/multithrdwin.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/test… ============================================================================== --- branches/ros-amd64-bringup/rostests/tests/multithrdwin/multithrdwin.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/tests/multithrdwin/multithrdwin.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -157,7 +157,7 @@ HDC hDC; RECT Client; HBRUSH Brush; - DWORD Ret; + DWORD_PTR Ret; static COLORREF Colors[] = { Modified: branches/ros-amd64-bringup/rostests/tests/p_dup_handle/p_dup_handle.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/test… ============================================================================== --- branches/ros-amd64-bringup/rostests/tests/p_dup_handle/p_dup_handle.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/tests/p_dup_handle/p_dup_handle.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -15,7 +15,7 @@ fprintf( stderr, "%lu: Starting\n", GetCurrentProcessId() ); if( argc == 2 ) { - h_process = (HANDLE)atoi(argv[1]); + h_process = (HANDLE)(ULONG_PTR)atoi(argv[1]); } else { if( !DuplicateHandle( GetCurrentProcess(), GetCurrentProcess(), @@ -38,7 +38,7 @@ memset( &si, 0, sizeof( si ) ); memset( &pi, 0, sizeof( pi ) ); - sprintf( cmdline, "%s %lu", argv[0], (DWORD)h_process ); + sprintf( cmdline, "%s %x", argv[0], h_process ); if( !CreateProcess(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi ) ) { fprintf( stderr, "%lu: Could not create child process.\n", Modified: branches/ros-amd64-bringup/rostests/win32/user32/kbdlayout/kbdlayout.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/win3… ============================================================================== --- branches/ros-amd64-bringup/rostests/win32/user32/kbdlayout/kbdlayout.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/win32/user32/kbdlayout/kbdlayout.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -122,7 +122,7 @@ LRESULT CALLBACK WndSubclassProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { - WND_DATA *data = (WND_DATA*)GetWindowLong(hwnd, GWL_USERDATA); + WND_DATA *data = (WND_DATA*)GetWindowLongPtr(hwnd, GWL_USERDATA); if(uMsg == WM_INPUTLANGCHANGE) { @@ -143,9 +143,9 @@ void SubclassWnd(HWND hWnd, WCHAR* Name) { WND_DATA *data = HeapAlloc(GetProcessHeap(), 0, sizeof(WND_DATA)); - data->OrigProc = (WNDPROC)SetWindowLong( hWnd, GWL_WNDPROC, (LONG)WndSubclassProc); + data->OrigProc = (WNDPROC)SetWindowLongPtr( hWnd, GWL_WNDPROC, (LONG_PTR)WndSubclassProc); wcsncpy(data->WndName, Name, 25); - SetWindowLong(hWnd, GWL_USERDATA, (LONG)data); + SetWindowLong(hWnd, GWL_USERDATA, (LONG_PTR)data); return; } Modified: branches/ros-amd64-bringup/rostests/winetests/msvcrt/printf.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/wine… ============================================================================== --- branches/ros-amd64-bringup/rostests/winetests/msvcrt/printf.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/winetests/msvcrt/printf.c [iso-8859-1] Tue Dec 8 00:09:35 2009 @@ -23,8 +23,10 @@ /* With Visual Studio >= 2005, swprintf() takes an extra parameter unless * the following macro is defined. */ +#ifdef _MSC_VER #define _CRT_NON_CONFORMING_SWPRINTFS - +#endif + #include <stdio.h> #include "windef.h"

1 0

[sserapion] 44461: enable user32 generated winetest.
by sserapion＠svn.reactos.org 07 Dec '09

07 Dec '09

Author: sserapion Date: Mon Dec 7 23:30:42 2009 New Revision: 44461 URL: http://svn.reactos.org/svn/reactos?rev=44461&view=rev Log: enable user32 generated winetest. Modified: branches/ros-amd64-bringup/rostests/winetests/user32/testlist.c branches/ros-amd64-bringup/rostests/winetests/user32/user32.rbuild Modified: branches/ros-amd64-bringup/rostests/winetests/user32/testlist.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/wine… ============================================================================== --- branches/ros-amd64-bringup/rostests/winetests/user32/testlist.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/winetests/user32/testlist.c [iso-8859-1] Mon Dec 7 23:30:42 2009 @@ -41,7 +41,7 @@ { "dde", func_dde }, { "dialog", func_dialog }, { "edit", func_edit }, -// { "generated", func_generated }, + { "generated", func_generated }, { "input", func_input }, { "listbox", func_listbox }, { "menu", func_menu }, Modified: branches/ros-amd64-bringup/rostests/winetests/user32/user32.rbuild URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/rostests/wine… ============================================================================== --- branches/ros-amd64-bringup/rostests/winetests/user32/user32.rbuild [iso-8859-1] (original) +++ branches/ros-amd64-bringup/rostests/winetests/user32/user32.rbuild [iso-8859-1] Mon Dec 7 23:30:42 2009 @@ -17,7 +17,7 @@ <file>dde.c</file> <file>dialog.c</file> <file>edit.c</file> -  + <file>generated.c</file> <file>input.c</file> <file>listbox.c</file> <file>menu.c</file>

1 0

[sserapion] 44460: Define PHDEVNOTIFY, PDLGITEMTEMPLATEA/W, LPDLGITEMTEMPLATEA/W, PPAINTSTRUCT, PMENUITEMTEMPLATE, PUSEROBJECTFLAGS, PMINIMIZEDMETRICS, PNONCLIENTMETRICSA/W, LPMOUSEINPUT, LPKEYBDINPUT, LPHARDWAREINPUT. Add HARDWAREHOOKSTRUCT structure.
by sserapion＠svn.reactos.org 07 Dec '09

07 Dec '09

Author: sserapion Date: Mon Dec 7 23:29:45 2009 New Revision: 44460 URL: http://svn.reactos.org/svn/reactos?rev=44460&view=rev Log: Define PHDEVNOTIFY, PDLGITEMTEMPLATEA/W, LPDLGITEMTEMPLATEA/W, PPAINTSTRUCT, PMENUITEMTEMPLATE, PUSEROBJECTFLAGS, PMINIMIZEDMETRICS, PNONCLIENTMETRICSA/W, LPMOUSEINPUT, LPKEYBDINPUT, LPHARDWAREINPUT. Add HARDWAREHOOKSTRUCT structure. Modified: branches/ros-amd64-bringup/reactos/include/psdk/winuser.h Modified: branches/ros-amd64-bringup/reactos/include/psdk/winuser.h URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/reactos/inclu… ============================================================================== --- branches/ros-amd64-bringup/reactos/include/psdk/winuser.h [iso-8859-1] (original) +++ branches/ros-amd64-bringup/reactos/include/psdk/winuser.h [iso-8859-1] Mon Dec 7 23:29:45 2009 @@ -2782,6 +2782,7 @@ DECLARE_HANDLE(HHOOK); DECLARE_HANDLE(HDWP); DECLARE_HANDLE(HDEVNOTIFY); +typedef HDEVNOTIFY *PHDEVNOTIFY; typedef struct tagACCEL { BYTE fVirt; @@ -2859,7 +2860,7 @@ UINT itemID2; ULONG_PTR itemData2; DWORD dwLocaleId; -} COMPAREITEMSTRUCT,*LPCOMPAREITEMSTRUCT; +} COMPAREITEMSTRUCT, *PCOMPAREITEMSTRUCT,*LPCOMPAREITEMSTRUCT; typedef struct tagCOPYDATASTRUCT { ULONG_PTR dwData; @@ -2931,6 +2932,12 @@ typedef const DLGTEMPLATE *LPCDLGTEMPLATEA; typedef const DLGTEMPLATE *LPCDLGTEMPLATEW; +typedef DLGITEMTEMPLATE *PDLGITEMTEMPLATEA; +typedef DLGITEMTEMPLATE *PDLGITEMTEMPLATEW; +DECL_WINELIB_TYPE_AW(PDLGITEMTEMPLATE) +typedef DLGITEMTEMPLATE *LPDLGITEMTEMPLATEA; +typedef DLGITEMTEMPLATE *LPDLGITEMTEMPLATEW; + #ifdef UNICODE typedef LPCDLGTEMPLATEW LPCDLGTEMPLATE; @@ -2966,7 +2973,7 @@ BOOL fRestore; BOOL fIncUpdate; BYTE rgbReserved[32]; -} PAINTSTRUCT,*LPPAINTSTRUCT; +} PAINTSTRUCT, *PPAINTSTRUCT,*LPPAINTSTRUCT; typedef struct tagMSG { HWND hwnd; @@ -3107,13 +3114,13 @@ typedef struct { WORD versionNumber; WORD offset; -} MENUITEMTEMPLATEHEADER; +} MENUITEMTEMPLATEHEADER, *PMENUITEMTEMPLATEHEADER; typedef struct { WORD mtOption; WORD mtID; WCHAR mtString[1]; -} MENUITEMTEMPLATE; +} MENUITEMTEMPLATE, *PMENUITEMTEMPLATE; typedef void MENUTEMPLATE,MENUTEMPLATEA,MENUTEMPLATEW,*LPMENUTEMPLATEA,*LPMENUTEMPLATEW,*LPMENUTEMPLATE; @@ -3158,7 +3165,7 @@ BOOL fInherit; BOOL fReserved; DWORD dwFlags; -} USEROBJECTFLAGS; +} USEROBJECTFLAGS, *PUSEROBJECTFLAGS; typedef struct tagFILTERKEYS { UINT cbSize; @@ -3211,7 +3218,7 @@ int iHorzGap; int iVertGap; int iArrange; -} MINIMIZEDMETRICS,*LPMINIMIZEDMETRICS; +} MINIMIZEDMETRICS, *PMINIMIZEDMETRICS,*LPMINIMIZEDMETRICS; typedef struct tagMOUSEKEYS{ UINT cbSize; @@ -3240,7 +3247,7 @@ LOGFONTA lfMenuFont; LOGFONTA lfStatusFont; LOGFONTA lfMessageFont; -} NONCLIENTMETRICSA,*LPNONCLIENTMETRICSA; +} NONCLIENTMETRICSA, *PNONCLIENTMETRICSA,*LPNONCLIENTMETRICSA; typedef struct tagNONCLIENTMETRICSW { UINT cbSize; @@ -3258,7 +3265,7 @@ LOGFONTW lfMenuFont; LOGFONTW lfStatusFont; LOGFONTW lfMessageFont; -} NONCLIENTMETRICSW,*LPNONCLIENTMETRICSW; +} NONCLIENTMETRICSW, *PNONCLIENTMETRICSW,*LPNONCLIENTMETRICSW; #ifdef UNICODE typedef NONCLIENTMETRICSW NONCLIENTMETRICS,*LPNONCLIENTMETRICS; @@ -3334,6 +3341,13 @@ ULONG_PTR dwExtraInfo; } MOUSEHOOKSTRUCT,*LPMOUSEHOOKSTRUCT,*PMOUSEHOOKSTRUCT; +typedef struct tagHARDWAREHOOKSTRUCT { + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +} HARDWAREHOOKSTRUCT, *PHARDWAREHOOKSTRUCT, *LPHARDWAREHOOKSTRUCT; + #if ( _WIN32_WINNT >= 0x0500 ) #ifdef __cplusplus typedef struct tagMOUSEHOOKSTRUCTEX : public tagMOUSEHOOKSTRUCT @@ -3633,7 +3647,7 @@ DWORD dwFlags; DWORD time; ULONG_PTR dwExtraInfo; -} MOUSEINPUT,*PMOUSEINPUT; +} MOUSEINPUT,*PMOUSEINPUT, *LPMOUSEINPUT; typedef struct tagKEYBDINPUT { WORD wVk; @@ -3641,13 +3655,13 @@ DWORD dwFlags; DWORD time; ULONG_PTR dwExtraInfo; -} KEYBDINPUT,*PKEYBDINPUT; +} KEYBDINPUT, *PKEYBDINPUT, *LPKEYBDINPUT; typedef struct tagHARDWAREINPUT { DWORD uMsg; WORD wParamL; WORD wParamH; -} HARDWAREINPUT,*PHARDWAREINPUT; +} HARDWAREINPUT, *PHARDWAREINPUT, *LPHARDWAREINPUT; typedef struct tagINPUT { DWORD type;

1 0

← Newer
1
...
35
36
37
38
39
40
41
...
51
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs December 2009