dbghelp: When sending back information about a global symbol, only demangle the class...
[wine] / dlls / ntdll / rtlbitmap.c
1 /*
2  * NTDLL bitmap functions
3  *
4  * Copyright 2002 Jon Griffiths
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  * NOTES
21  *  Bitmaps are an efficient type for manipulating large arrays of bits. They
22  *  are commonly used by device drivers (e.g. For holding dirty/free blocks),
23  *  but are also available to applications that need this functionality.
24  *
25  *  Bits are set LSB to MSB in each consecutive byte, making this implementation
26  *  binary compatible with Win32.
27  *
28  *  Note that to avoid unexpected behaviour, the size of a bitmap should be set
29  *  to a multiple of 32.
30  */
31 #include <stdarg.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include "windef.h"
35 #include "winternl.h"
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
39
40 /* Bits set from LSB to MSB; used as mask for runs < 8 bits */
41 static const BYTE NTDLL_maskBits[8] = { 0, 1, 3, 7, 15, 31, 63, 127 };
42
43 /* Number of set bits for each value of a nibble; used for counting */
44 static const BYTE NTDLL_nibbleBitCount[16] = {
45   0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
46 };
47
48 /* First set bit in a nibble; used for determining least significant bit */
49 static const BYTE NTDLL_leastSignificant[16] = {
50   0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
51 };
52
53 /* Last set bit in a nibble; used for determining most significant bit */
54 static const signed char NTDLL_mostSignificant[16] = {
55   -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3
56 };
57
58 /*************************************************************************
59  * RtlInitializeBitMap  [NTDLL.@]
60  *
61  * Initialise a new bitmap.
62  *
63  * PARAMS
64  *  lpBits [I] Bitmap pointer
65  *  lpBuff [I] Memory for the bitmap
66  *  ulSize [I] Size of lpBuff in bits
67  *
68  * RETURNS
69  *  Nothing.
70  *
71  * NOTES
72  *  lpBuff must be aligned on a ULONG suitable boundary, to a multiple of 32 bytes
73  *  in size (irrespective of ulSize given).
74  */
75 VOID WINAPI RtlInitializeBitMap(PRTL_BITMAP lpBits, PULONG lpBuff, ULONG ulSize)
76 {
77   TRACE("(%p,%p,%d)\n", lpBits,lpBuff,ulSize);
78   lpBits->SizeOfBitMap = ulSize;
79   lpBits->Buffer = lpBuff;
80 }
81
82 /*************************************************************************
83  * RtlSetAllBits        [NTDLL.@]
84  *
85  * Set all bits in a bitmap.
86  *
87  * PARAMS
88  *  lpBits [I] Bitmap pointer
89  *
90  * RETURNS
91  *  Nothing.
92  */
93 VOID WINAPI RtlSetAllBits(PRTL_BITMAP lpBits)
94 {
95   TRACE("(%p)\n", lpBits);
96   memset(lpBits->Buffer, 0xff, ((lpBits->SizeOfBitMap + 31) & ~31) >> 3);
97 }
98
99 /*************************************************************************
100  * RtlClearAllBits      [NTDLL.@]
101  *
102  * Clear all bits in a bitmap.
103  *
104  * PARAMS
105  *  lpBit [I] Bitmap pointer
106  *
107  * RETURNS
108  *  Nothing.
109  */
110 VOID WINAPI RtlClearAllBits(PRTL_BITMAP lpBits)
111 {
112   TRACE("(%p)\n", lpBits);
113   memset(lpBits->Buffer, 0, ((lpBits->SizeOfBitMap + 31) & ~31) >> 3);
114 }
115
116 /*************************************************************************
117  * RtlSetBits   [NTDLL.@]
118  *
119  * Set a range of bits in a bitmap.
120  *
121  * PARAMS
122  *  lpBits  [I] Bitmap pointer
123  *  ulStart [I] First bit to set
124  *  ulCount [I] Number of consecutive bits to set
125  *
126  * RETURNS
127  *  Nothing.
128  */
129 VOID WINAPI RtlSetBits(PRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
130 {
131   LPBYTE lpOut;
132
133   TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
134
135   if (!lpBits || !ulCount ||
136       ulStart >= lpBits->SizeOfBitMap ||
137       ulCount > lpBits->SizeOfBitMap - ulStart)
138     return;
139
140   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
141    * at a time. But beware of the pointer arithmetics...
142    */
143   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
144
145   /* Set bits in first byte, if ulStart isn't a byte boundary */
146   if (ulStart & 7)
147   {
148     if (ulCount > 7)
149     {
150       /* Set from start bit to the end of the byte */
151       *lpOut++ |= 0xff << (ulStart & 7);
152       ulCount -= (8 - (ulStart & 7));
153     }
154     else
155     {
156       /* Set from the start bit, possibly into the next byte also */
157       USHORT initialWord = NTDLL_maskBits[ulCount] << (ulStart & 7);
158
159       *lpOut++ |= (initialWord & 0xff);
160       *lpOut |= (initialWord >> 8);
161       return;
162     }
163   }
164
165   /* Set bits up to complete byte count */
166   if (ulCount >> 3)
167   {
168     memset(lpOut, 0xff, ulCount >> 3);
169     lpOut = lpOut + (ulCount >> 3);
170   }
171
172   /* Set remaining bits, if any */
173   *lpOut |= NTDLL_maskBits[ulCount & 0x7];
174 }
175
176 /*************************************************************************
177  * RtlClearBits [NTDLL.@]
178  *
179  * Clear bits in a bitmap.
180  *
181  * PARAMS
182  *  lpBits  [I] Bitmap pointer
183  *  ulStart [I] First bit to set
184  *  ulCount [I] Number of consecutive bits to clear
185  *
186  * RETURNS
187  *  Nothing.
188  */
189 VOID WINAPI RtlClearBits(PRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
190 {
191   LPBYTE lpOut;
192
193   TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
194
195   if (!lpBits || !ulCount ||
196       ulStart >= lpBits->SizeOfBitMap ||
197       ulCount > lpBits->SizeOfBitMap - ulStart)
198     return;
199
200   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
201    * at a time. But beware of the pointer arithmetics...
202    */
203   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
204
205   /* Clear bits in first byte, if ulStart isn't a byte boundary */
206   if (ulStart & 7)
207   {
208     if (ulCount > 7)
209     {
210       /* Clear from start bit to the end of the byte */
211       *lpOut++ &= ~(0xff << (ulStart & 7));
212       ulCount -= (8 - (ulStart & 7));
213     }
214     else
215     {
216       /* Clear from the start bit, possibly into the next byte also */
217       USHORT initialWord = ~(NTDLL_maskBits[ulCount] << (ulStart & 7));
218
219       *lpOut++ &= (initialWord & 0xff);
220       *lpOut &= (initialWord >> 8);
221       return;
222     }
223   }
224
225   /* Clear bits (in blocks of 8) on whole byte boundaries */
226   if (ulCount >> 3)
227   {
228     memset(lpOut, 0, ulCount >> 3);
229     lpOut = lpOut + (ulCount >> 3);
230   }
231
232   /* Clear remaining bits, if any */
233   if (ulCount & 0x7)
234     *lpOut &= ~NTDLL_maskBits[ulCount & 0x7];
235 }
236
237 /*************************************************************************
238  * RtlAreBitsSet        [NTDLL.@]
239  *
240  * Determine if part of a bitmap is set.
241  *
242  * PARAMS
243  *  lpBits  [I] Bitmap pointer
244  *  ulStart [I] First bit to check from
245  *  ulCount [I] Number of consecutive bits to check
246  *
247  * RETURNS
248  *  TRUE,  If ulCount bits from ulStart are set.
249  *  FALSE, Otherwise.
250  */
251 BOOLEAN WINAPI RtlAreBitsSet(PCRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
252 {
253   LPBYTE lpOut;
254   ULONG ulRemainder;
255
256   TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
257
258   if (!lpBits || !ulCount ||
259       ulStart >= lpBits->SizeOfBitMap ||
260       ulCount > lpBits->SizeOfBitMap - ulStart)
261     return FALSE;
262
263   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
264    * at a time. But beware of the pointer arithmetics...
265    */
266   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
267
268   /* Check bits in first byte, if ulStart isn't a byte boundary */
269   if (ulStart & 7)
270   {
271     if (ulCount > 7)
272     {
273       /* Check from start bit to the end of the byte */
274       if ((*lpOut &
275           ((0xff << (ulStart & 7))) & 0xff) != ((0xff << (ulStart & 7) & 0xff)))
276         return FALSE;
277       lpOut++;
278       ulCount -= (8 - (ulStart & 7));
279     }
280     else
281     {
282       /* Check from the start bit, possibly into the next byte also */
283       USHORT initialWord = NTDLL_maskBits[ulCount] << (ulStart & 7);
284
285       if ((*lpOut & (initialWord & 0xff)) != (initialWord & 0xff))
286         return FALSE;
287       if ((initialWord & 0xff00) &&
288           ((lpOut[1] & (initialWord >> 8)) != (initialWord >> 8)))
289         return FALSE;
290       return TRUE;
291     }
292   }
293
294   /* Check bits in blocks of 8 bytes */
295   ulRemainder = ulCount & 7;
296   ulCount >>= 3;
297   while (ulCount--)
298   {
299     if (*lpOut++ != 0xff)
300       return FALSE;
301   }
302
303   /* Check remaining bits, if any */
304   if (ulRemainder &&
305       (*lpOut & NTDLL_maskBits[ulRemainder]) != NTDLL_maskBits[ulRemainder])
306     return FALSE;
307   return TRUE;
308 }
309
310 /*************************************************************************
311  * RtlAreBitsClear      [NTDLL.@]
312  *
313  * Determine if part of a bitmap is clear.
314  *
315  * PARAMS
316  *  lpBits  [I] Bitmap pointer
317  *  ulStart [I] First bit to check from
318  *  ulCount [I] Number of consecutive bits to check
319  *
320  * RETURNS
321  *  TRUE,  If ulCount bits from ulStart are clear.
322  *  FALSE, Otherwise.
323  */
324 BOOLEAN WINAPI RtlAreBitsClear(PCRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
325 {
326   LPBYTE lpOut;
327   ULONG ulRemainder;
328
329   TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
330
331   if (!lpBits || !ulCount ||
332       ulStart >= lpBits->SizeOfBitMap ||
333       ulCount > lpBits->SizeOfBitMap - ulStart)
334     return FALSE;
335
336   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
337    * at a time. But beware of the pointer arithmetics...
338    */
339   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
340
341   /* Check bits in first byte, if ulStart isn't a byte boundary */
342   if (ulStart & 7)
343   {
344     if (ulCount > 7)
345     {
346       /* Check from start bit to the end of the byte */
347       if (*lpOut & ((0xff << (ulStart & 7)) & 0xff))
348         return FALSE;
349       lpOut++;
350       ulCount -= (8 - (ulStart & 7));
351     }
352     else
353     {
354       /* Check from the start bit, possibly into the next byte also */
355       USHORT initialWord = NTDLL_maskBits[ulCount] << (ulStart & 7);
356
357       if (*lpOut & (initialWord & 0xff))
358         return FALSE;
359       if ((initialWord & 0xff00) && (lpOut[1] & (initialWord >> 8)))
360         return FALSE;
361       return TRUE;
362     }
363   }
364
365   /* Check bits in blocks of 8 bytes */
366   ulRemainder = ulCount & 7;
367   ulCount >>= 3;
368   while (ulCount--)
369   {
370     if (*lpOut++)
371       return FALSE;
372   }
373
374   /* Check remaining bits, if any */
375   if (ulRemainder && *lpOut & NTDLL_maskBits[ulRemainder])
376     return FALSE;
377   return TRUE;
378 }
379
380 /*************************************************************************
381  * RtlFindSetBits       [NTDLL.@]
382  *
383  * Find a block of set bits in a bitmap.
384  *
385  * PARAMS
386  *  lpBits  [I] Bitmap pointer
387  *  ulCount [I] Number of consecutive set bits to find
388  *  ulHint  [I] Suggested starting position for set bits
389  *
390  * RETURNS
391  *  The bit at which the match was found, or -1 if no match was found.
392  */
393 ULONG WINAPI RtlFindSetBits(PCRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
394 {
395   ULONG ulPos, ulEnd;
396
397   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
398
399   if (!lpBits || !ulCount || ulCount > lpBits->SizeOfBitMap)
400     return ~0U;
401
402   ulEnd = lpBits->SizeOfBitMap;
403
404   if (ulHint + ulCount > lpBits->SizeOfBitMap)
405     ulHint = 0;
406
407   ulPos = ulHint;
408
409   while (ulPos < ulEnd)
410   {
411     /* FIXME: This could be made a _lot_ more efficient */
412     if (RtlAreBitsSet(lpBits, ulPos, ulCount))
413       return ulPos;
414
415     /* Start from the beginning if we hit the end and had a hint */
416     if (ulPos == ulEnd - 1 && ulHint)
417     {
418       ulEnd = ulHint;
419       ulPos = ulHint = 0;
420     }
421     else
422       ulPos++;
423   }
424   return ~0U;
425 }
426
427 /*************************************************************************
428  * RtlFindClearBits     [NTDLL.@]
429  *
430  * Find a block of clear bits in a bitmap.
431  *
432  * PARAMS
433  *  lpBits  [I] Bitmap pointer
434  *  ulCount [I] Number of consecutive clear bits to find
435  *  ulHint  [I] Suggested starting position for clear bits
436  *
437  * RETURNS
438  *  The bit at which the match was found, or -1 if no match was found.
439  */
440 ULONG WINAPI RtlFindClearBits(PCRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
441 {
442   ULONG ulPos, ulEnd;
443
444   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
445
446   if (!lpBits || !ulCount || ulCount > lpBits->SizeOfBitMap)
447     return ~0U;
448
449   ulEnd = lpBits->SizeOfBitMap;
450
451   if (ulHint + ulCount > lpBits->SizeOfBitMap)
452     ulHint = 0;
453
454   ulPos = ulHint;
455
456   while (ulPos < ulEnd)
457   {
458     /* FIXME: This could be made a _lot_ more efficient */
459     if (RtlAreBitsClear(lpBits, ulPos, ulCount))
460       return ulPos;
461
462     /* Start from the beginning if we hit the end and started from ulHint */
463     if (ulPos == ulEnd - 1 && ulHint)
464     {
465       ulEnd = ulHint;
466       ulPos = ulHint = 0;
467     }
468     else
469       ulPos++;
470   }
471   return ~0U;
472 }
473
474 /*************************************************************************
475  * RtlFindSetBitsAndClear       [NTDLL.@]
476  *
477  * Find a block of set bits in a bitmap, and clear them if found.
478  *
479  * PARAMS
480  *  lpBits  [I] Bitmap pointer
481  *  ulCount [I] Number of consecutive set bits to find
482  *  ulHint  [I] Suggested starting position for set bits
483  *
484  * RETURNS
485  *  The bit at which the match was found, or -1 if no match was found.
486  */
487 ULONG WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
488 {
489   ULONG ulPos;
490
491   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
492
493   ulPos = RtlFindSetBits(lpBits, ulCount, ulHint);
494   if (ulPos != ~0U)
495     RtlClearBits(lpBits, ulPos, ulCount);
496   return ulPos;
497 }
498
499 /*************************************************************************
500  * RtlFindClearBitsAndSet       [NTDLL.@]
501  *
502  * Find a block of clear bits in a bitmap, and set them if found.
503  *
504  * PARAMS
505  *  lpBits  [I] Bitmap pointer
506  *  ulCount [I] Number of consecutive clear bits to find
507  *  ulHint  [I] Suggested starting position for clear bits
508  *
509  * RETURNS
510  *  The bit at which the match was found, or -1 if no match was found.
511  */
512 ULONG WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
513 {
514   ULONG ulPos;
515
516   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
517
518   ulPos = RtlFindClearBits(lpBits, ulCount, ulHint);
519   if (ulPos != ~0U)
520     RtlSetBits(lpBits, ulPos, ulCount);
521   return ulPos;
522 }
523
524 /*************************************************************************
525  * RtlNumberOfSetBits   [NTDLL.@]
526  *
527  * Find the number of set bits in a bitmap.
528  *
529  * PARAMS
530  *  lpBits [I] Bitmap pointer
531  *
532  * RETURNS
533  *  The number of set bits.
534  */
535 ULONG WINAPI RtlNumberOfSetBits(PCRTL_BITMAP lpBits)
536 {
537   ULONG ulSet = 0;
538
539   TRACE("(%p)\n", lpBits);
540
541   if (lpBits)
542   {
543     LPBYTE lpOut = (BYTE *)lpBits->Buffer;
544     ULONG ulCount, ulRemainder;
545     BYTE bMasked;
546
547     ulCount = lpBits->SizeOfBitMap >> 3;
548     ulRemainder = lpBits->SizeOfBitMap & 0x7;
549
550     while (ulCount--)
551     {
552       ulSet += NTDLL_nibbleBitCount[*lpOut >> 4];
553       ulSet += NTDLL_nibbleBitCount[*lpOut & 0xf];
554       lpOut++;
555     }
556
557     bMasked = *lpOut & NTDLL_maskBits[ulRemainder];
558     ulSet += NTDLL_nibbleBitCount[bMasked >> 4];
559     ulSet += NTDLL_nibbleBitCount[bMasked & 0xf];
560   }
561   return ulSet;
562 }
563
564 /*************************************************************************
565  * RtlNumberOfClearBits [NTDLL.@]
566  *
567  * Find the number of clear bits in a bitmap.
568  *
569  * PARAMS
570  *  lpBits [I] Bitmap pointer
571  *
572  * RETURNS
573  *  The number of clear bits.
574  */
575 ULONG WINAPI RtlNumberOfClearBits(PCRTL_BITMAP lpBits)
576 {
577   TRACE("(%p)\n", lpBits);
578
579   if (lpBits)
580     return lpBits->SizeOfBitMap - RtlNumberOfSetBits(lpBits);
581   return 0;
582 }
583
584 /*************************************************************************
585  * RtlFindMostSignificantBit    [NTDLL.@]
586  *
587  * Find the most significant bit in a 64 bit integer.
588  *
589  * RETURNS
590  *  The position of the most significant bit.
591  */
592 CCHAR WINAPI RtlFindMostSignificantBit(ULONGLONG ulLong)
593 {
594     signed char ret = 32;
595     DWORD dw;
596
597     if (!(dw = (ulLong >> 32)))
598     {
599         ret = 0;
600         dw = (DWORD)ulLong;
601     }
602     if (dw & 0xffff0000)
603     {
604         dw >>= 16;
605         ret += 16;
606     }
607     if (dw & 0xff00)
608     {
609         dw >>= 8;
610         ret += 8;
611     }
612     if (dw & 0xf0)
613     {
614         dw >>= 4;
615         ret += 4;
616     }
617     return ret + NTDLL_mostSignificant[dw];
618 }
619
620 /*************************************************************************
621  * RtlFindLeastSignificantBit   [NTDLL.@]
622  *
623  * Find the least significant bit in a 64 bit integer.
624  *
625  * RETURNS
626  *  The position of the least significant bit.
627  */
628 CCHAR WINAPI RtlFindLeastSignificantBit(ULONGLONG ulLong)
629 {
630     signed char ret = 0;
631     DWORD dw;
632
633     if (!(dw = (DWORD)ulLong))
634     {
635         ret = 32;
636         if (!(dw = ulLong >> 32)) return -1;
637     }
638     if (!(dw & 0xffff))
639     {
640         dw >>= 16;
641         ret += 16;
642     }
643     if (!(dw & 0xff))
644     {
645         dw >>= 8;
646         ret += 8;
647     }
648     if (!(dw & 0x0f))
649     {
650         dw >>= 4;
651         ret += 4;
652     }
653     return ret + NTDLL_leastSignificant[dw & 0x0f];
654 }
655
656 /*************************************************************************
657  * NTDLL_RunSortFn
658  *
659  * Internal helper: qsort comparison function for RTL_BITMAP_RUN arrays
660  */
661 static int NTDLL_RunSortFn(const void *lhs, const void *rhs)
662 {
663   if (((const RTL_BITMAP_RUN*)lhs)->NumberOfBits > ((const RTL_BITMAP_RUN*)rhs)->NumberOfBits)
664     return -1;
665   return 1;
666 }
667
668 /*************************************************************************
669  * NTDLL_FindSetRun
670  *
671  * Internal helper: Find the next run of set bits in a bitmap.
672  */
673 static ULONG NTDLL_FindSetRun(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpSize)
674 {
675   LPBYTE lpOut;
676   ULONG ulFoundAt = 0, ulCount = 0;
677
678   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
679    * at a time. But beware of the pointer arithmetics...
680    */
681   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
682
683   while (1)
684   {
685     /* Check bits in first byte */
686     const BYTE bMask = (0xff << (ulStart & 7)) & 0xff;
687     const BYTE bFirst = *lpOut & bMask;
688
689     if (bFirst)
690     {
691       /* Have a set bit in first byte */
692       if (bFirst != bMask)
693       {
694         /* Not every bit is set */
695         ULONG ulOffset;
696
697         if (bFirst & 0x0f)
698           ulOffset = NTDLL_leastSignificant[bFirst & 0x0f];
699         else
700           ulOffset = 4 + NTDLL_leastSignificant[bFirst >> 4];
701         ulStart += ulOffset;
702         ulFoundAt = ulStart;
703         for (;ulOffset < 8; ulOffset++)
704         {
705           if (!(bFirst & (1 << ulOffset)))
706           {
707             *lpSize = ulCount;
708             return ulFoundAt; /* Set from start, but not until the end */
709           }
710           ulCount++;
711           ulStart++;
712         }
713         /* Set to the end - go on to count further bits */
714         lpOut++;
715         break;
716       }
717       /* every bit from start until the end of the byte is set */
718       ulFoundAt = ulStart;
719       ulCount = 8 - (ulStart & 7);
720       ulStart = (ulStart & ~7u) + 8;
721       lpOut++;
722       break;
723     }
724     ulStart = (ulStart & ~7u) + 8;
725     lpOut++;
726     if (ulStart >= lpBits->SizeOfBitMap)
727       return ~0U;
728   }
729
730   /* Count blocks of 8 set bits */
731   while (*lpOut == 0xff)
732   {
733     ulCount += 8;
734     ulStart += 8;
735     if (ulStart >= lpBits->SizeOfBitMap)
736     {
737       *lpSize = ulCount - (ulStart - lpBits->SizeOfBitMap);
738       return ulFoundAt;
739     }
740     lpOut++;
741   }
742
743   /* Count remaining contiguous bits, if any */
744   if (*lpOut & 1)
745   {
746     ULONG ulOffset = 0;
747
748     for (;ulOffset < 7u; ulOffset++)
749     {
750       if (!(*lpOut & (1 << ulOffset)))
751         break;
752       ulCount++;
753     }
754   }
755   *lpSize = ulCount;
756   return ulFoundAt;
757 }
758
759 /*************************************************************************
760  * NTDLL_FindClearRun
761  *
762  * Internal helper: Find the next run of set bits in a bitmap.
763  */
764 static ULONG NTDLL_FindClearRun(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpSize)
765 {
766   LPBYTE lpOut;
767   ULONG ulFoundAt = 0, ulCount = 0;
768
769   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
770    * at a time. But beware of the pointer arithmetics...
771    */
772   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
773
774   while (1)
775   {
776     /* Check bits in first byte */
777     const BYTE bMask = (0xff << (ulStart & 7)) & 0xff;
778     const BYTE bFirst = (~*lpOut) & bMask;
779
780     if (bFirst)
781     {
782       /* Have a clear bit in first byte */
783       if (bFirst != bMask)
784       {
785         /* Not every bit is clear */
786         ULONG ulOffset;
787
788         if (bFirst & 0x0f)
789           ulOffset = NTDLL_leastSignificant[bFirst & 0x0f];
790         else
791           ulOffset = 4 + NTDLL_leastSignificant[bFirst >> 4];
792         ulStart += ulOffset;
793         ulFoundAt = ulStart;
794         for (;ulOffset < 8; ulOffset++)
795         {
796           if (!(bFirst & (1 << ulOffset)))
797           {
798             *lpSize = ulCount;
799             return ulFoundAt; /* Clear from start, but not until the end */
800           }
801           ulCount++;
802           ulStart++;
803         }
804         /* Clear to the end - go on to count further bits */
805         lpOut++;
806         break;
807       }
808       /* Every bit from start until the end of the byte is clear */
809       ulFoundAt = ulStart;
810       ulCount = 8 - (ulStart & 7);
811       ulStart = (ulStart & ~7u) + 8;
812       lpOut++;
813       break;
814     }
815     ulStart = (ulStart & ~7u) + 8;
816     lpOut++;
817     if (ulStart >= lpBits->SizeOfBitMap)
818       return ~0U;
819   }
820
821   /* Count blocks of 8 clear bits */
822   while (!*lpOut)
823   {
824     ulCount += 8;
825     ulStart += 8;
826     if (ulStart >= lpBits->SizeOfBitMap)
827     {
828       *lpSize = ulCount - (ulStart - lpBits->SizeOfBitMap);
829       return ulFoundAt;
830     }
831     lpOut++;
832   }
833
834   /* Count remaining contiguous bits, if any */
835   if (!(*lpOut & 1))
836   {
837     ULONG ulOffset = 0;
838
839     for (;ulOffset < 7u; ulOffset++)
840     {
841       if (*lpOut & (1 << ulOffset))
842         break;
843       ulCount++;
844     }
845   }
846   *lpSize = ulCount;
847   return ulFoundAt;
848 }
849
850 /*************************************************************************
851  * RtlFindNextForwardRunSet     [NTDLL.@]
852  *
853  * Find the next run of set bits in a bitmap.
854  *
855  * PARAMS
856  *  lpBits  [I] Bitmap pointer
857  *  ulStart [I] Bit position to start searching from
858  *  lpPos   [O] Start of run
859  *
860  * RETURNS
861  *  Success: The length of the next set run in the bitmap. lpPos is set to
862  *           the start of the run.
863  *  Failure: 0, if no run is found or any parameters are invalid.
864  */
865 ULONG WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
866 {
867   ULONG ulSize = 0;
868
869   TRACE("(%p,%d,%p)\n", lpBits, ulStart, lpPos);
870
871   if (lpBits && ulStart < lpBits->SizeOfBitMap && lpPos)
872     *lpPos = NTDLL_FindSetRun(lpBits, ulStart, &ulSize);
873
874   return ulSize;
875 }
876
877 /*************************************************************************
878  * RtlFindNextForwardRunClear   [NTDLL.@]
879  *
880  * Find the next run of clear bits in a bitmap.
881  *
882  * PARAMS
883  *  lpBits  [I] Bitmap pointer
884  *  ulStart [I] Bit position to start searching from
885  *  lpPos   [O] Start of run
886  *
887  * RETURNS
888  *  Success: The length of the next clear run in the bitmap. lpPos is set to
889  *           the start of the run.
890  *  Failure: 0, if no run is found or any parameters are invalid.
891  */
892 ULONG WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
893 {
894   ULONG ulSize = 0;
895
896   TRACE("(%p,%d,%p)\n", lpBits, ulStart, lpPos);
897
898   if (lpBits && ulStart < lpBits->SizeOfBitMap && lpPos)
899     *lpPos = NTDLL_FindClearRun(lpBits, ulStart, &ulSize);
900
901   return ulSize;
902 }
903
904 /*************************************************************************
905  * RtlFindLastBackwardRunSet    [NTDLL.@]
906  *
907  * Find a previous run of set bits in a bitmap.
908  *
909  * PARAMS
910  *  lpBits  [I] Bitmap pointer
911  *  ulStart [I] Bit position to start searching from
912  *  lpPos   [O] Start of run
913  *
914  * RETURNS
915  *  Success: The length of the previous set run in the bitmap. lpPos is set to
916  *           the start of the run.
917  *  Failure: 0, if no run is found or any parameters are invalid.
918  */
919 ULONG WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
920 {
921   FIXME("(%p,%d,%p)-stub!\n", lpBits, ulStart, lpPos);
922   return 0;
923 }
924
925 /*************************************************************************
926  * RtlFindLastBackwardRunClear  [NTDLL.@]
927  *
928  * Find a previous run of clear bits in a bitmap.
929  *
930  * PARAMS
931  *  lpBits  [I] Bitmap pointer
932  *  ulStart [I] Bit position to start searching from
933  *  lpPos   [O] Start of run
934  *
935  * RETURNS
936  *  Success: The length of the previous clear run in the bitmap. lpPos is set
937  *           to the start of the run.
938  *  Failure: 0, if no run is found or any parameters are invalid.
939  */
940 ULONG WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
941 {
942   FIXME("(%p,%d,%p)-stub!\n", lpBits, ulStart, lpPos);
943   return 0;
944 }
945
946 /*************************************************************************
947  * NTDLL_FindRuns
948  *
949  * Internal implementation of RtlFindSetRuns/RtlFindClearRuns.
950  */
951 static ULONG WINAPI NTDLL_FindRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
952                                    ULONG ulCount, BOOLEAN bLongest,
953                                    ULONG (*fn)(PCRTL_BITMAP,ULONG,PULONG))
954 {
955   BOOL bNeedSort = ulCount > 1 ? TRUE : FALSE;
956   ULONG ulPos = 0, ulRuns = 0;
957
958   TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
959
960   if (!ulCount)
961     return ~0U;
962
963   while (ulPos < lpBits->SizeOfBitMap)
964   {
965     /* Find next set/clear run */
966     ULONG ulSize, ulNextPos = fn(lpBits, ulPos, &ulSize);
967
968     if (ulNextPos == ~0U)
969       break;
970
971     if (bLongest && ulRuns == ulCount)
972     {
973       /* Sort runs with shortest at end, if they are out of order */
974       if (bNeedSort)
975         qsort(lpSeries, ulRuns, sizeof(RTL_BITMAP_RUN), NTDLL_RunSortFn);
976
977       /* Replace last run if this one is bigger */
978       if (ulSize > lpSeries[ulRuns - 1].NumberOfBits)
979       {
980         lpSeries[ulRuns - 1].StartingIndex = ulNextPos;
981         lpSeries[ulRuns - 1].NumberOfBits = ulSize;
982
983         /* We need to re-sort the array, _if_ we didn't leave it sorted */
984         if (ulRuns > 1 && ulSize > lpSeries[ulRuns - 2].NumberOfBits)
985           bNeedSort = TRUE;
986       }
987     }
988     else
989     {
990       /* Append to found runs */
991       lpSeries[ulRuns].StartingIndex = ulNextPos;
992       lpSeries[ulRuns].NumberOfBits = ulSize;
993       ulRuns++;
994
995       if (!bLongest && ulRuns == ulCount)
996         break;
997     }
998     ulPos = ulNextPos + ulSize;
999   }
1000   return ulRuns;
1001 }
1002
1003 /*************************************************************************
1004  * RtlFindSetRuns       [NTDLL.@]
1005  *
1006  * Find a series of set runs in a bitmap.
1007  *
1008  * PARAMS
1009  *  lpBits   [I] Bitmap pointer
1010  *  lpSeries [O] Array for each run found
1011  *  ulCount  [I] Number of runs to find
1012  *  bLongest [I] Whether to find the very longest runs or not
1013  *
1014  * RETURNS
1015  *  The number of set runs found.
1016  */
1017 ULONG WINAPI RtlFindSetRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
1018                             ULONG ulCount, BOOLEAN bLongest)
1019 {
1020   TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
1021
1022   return NTDLL_FindRuns(lpBits, lpSeries, ulCount, bLongest, NTDLL_FindSetRun);
1023 }
1024
1025 /*************************************************************************
1026  * RtlFindClearRuns     [NTDLL.@]
1027  *
1028  * Find a series of clear runs in a bitmap.
1029  *
1030  * PARAMS
1031  *  lpBits   [I] Bitmap pointer
1032  *  ulSeries [O] Array for each run found
1033  *  ulCount  [I] Number of runs to find
1034  *  bLongest [I] Whether to find the very longest runs or not
1035  *
1036  * RETURNS
1037  *  The number of clear runs found.
1038  */
1039 ULONG WINAPI RtlFindClearRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
1040                               ULONG ulCount, BOOLEAN bLongest)
1041 {
1042   TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
1043
1044   return NTDLL_FindRuns(lpBits, lpSeries, ulCount, bLongest, NTDLL_FindClearRun);
1045 }
1046
1047 /*************************************************************************
1048  * RtlFindLongestRunSet [NTDLL.@]
1049  *
1050  * Find the longest set run in a bitmap.
1051  *
1052  * PARAMS
1053  *  lpBits   [I] Bitmap pointer
1054  *  pulStart [O] Destination for start of run
1055  *
1056  * RETURNS
1057  *  The length of the run found, or 0 if no run is found.
1058  */
1059 ULONG WINAPI RtlFindLongestRunSet(PCRTL_BITMAP lpBits, PULONG pulStart)
1060 {
1061   RTL_BITMAP_RUN br;
1062
1063   TRACE("(%p,%p)\n", lpBits, pulStart);
1064
1065   if (RtlFindSetRuns(lpBits, &br, 1, TRUE) == 1)
1066   {
1067     if (pulStart)
1068       *pulStart = br.StartingIndex;
1069     return br.NumberOfBits;
1070   }
1071   return 0;
1072 }
1073
1074 /*************************************************************************
1075  * RtlFindLongestRunClear       [NTDLL.@]
1076  *
1077  * Find the longest clear run in a bitmap.
1078  *
1079  * PARAMS
1080  *  lpBits   [I] Bitmap pointer
1081  *  pulStart [O] Destination for start of run
1082  *
1083  * RETURNS
1084  *  The length of the run found, or 0 if no run is found.
1085  */
1086 ULONG WINAPI RtlFindLongestRunClear(PCRTL_BITMAP lpBits, PULONG pulStart)
1087 {
1088   RTL_BITMAP_RUN br;
1089
1090   TRACE("(%p,%p)\n", lpBits, pulStart);
1091
1092   if (RtlFindClearRuns(lpBits, &br, 1, TRUE) == 1)
1093   {
1094     if (pulStart)
1095       *pulStart = br.StartingIndex;
1096     return br.NumberOfBits;
1097   }
1098   return 0;
1099 }