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   if (ulCount & 0x7)
 174     *lpOut |= NTDLL_maskBits[ulCount & 0x7];
 175 }
 176
 177 /*************************************************************************
 178  * RtlClearBits [NTDLL.@]
 179  *
 180  * Clear bits in a bitmap.
 181  *
 182  * PARAMS
 183  *  lpBits  [I] Bitmap pointer
 184  *  ulStart [I] First bit to set
 185  *  ulCount [I] Number of consecutive bits to clear
 186  *
 187  * RETURNS
 188  *  Nothing.
 189  */
 190 VOID WINAPI RtlClearBits(PRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
 191 {
 192   LPBYTE lpOut;
 193
 194   TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
 195
 196   if (!lpBits || !ulCount ||
 197       ulStart >= lpBits->SizeOfBitMap ||
 198       ulCount > lpBits->SizeOfBitMap - ulStart)
 199     return;
 200
 201   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
 202    * at a time. But beware of the pointer arithmetics...
 203    */
 204   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
 205
 206   /* Clear bits in first byte, if ulStart isn't a byte boundary */
 207   if (ulStart & 7)
 208   {
 209     if (ulCount > 7)
 210     {
 211       /* Clear from start bit to the end of the byte */
 212       *lpOut++ &= ~(0xff << (ulStart & 7));
 213       ulCount -= (8 - (ulStart & 7));
 214     }
 215     else
 216     {
 217       /* Clear from the start bit, possibly into the next byte also */
 218       USHORT initialWord = ~(NTDLL_maskBits[ulCount] << (ulStart & 7));
 219
 220       *lpOut++ &= (initialWord & 0xff);
 221       *lpOut &= (initialWord >> 8);
 222       return;
 223     }
 224   }
 225
 226   /* Clear bits (in blocks of 8) on whole byte boundaries */
 227   if (ulCount >> 3)
 228   {
 229     memset(lpOut, 0, ulCount >> 3);
 230     lpOut = lpOut + (ulCount >> 3);
 231   }
 232
 233   /* Clear remaining bits, if any */
 234   if (ulCount & 0x7)
 235     *lpOut &= ~NTDLL_maskBits[ulCount & 0x7];
 236 }
 237
 238 /*************************************************************************
 239  * RtlAreBitsSet        [NTDLL.@]
 240  *
 241  * Determine if part of a bitmap is set.
 242  *
 243  * PARAMS
 244  *  lpBits  [I] Bitmap pointer
 245  *  ulStart [I] First bit to check from
 246  *  ulCount [I] Number of consecutive bits to check
 247  *
 248  * RETURNS
 249  *  TRUE,  If ulCount bits from ulStart are set.
 250  *  FALSE, Otherwise.
 251  */
 252 BOOLEAN WINAPI RtlAreBitsSet(PCRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
 253 {
 254   LPBYTE lpOut;
 255   ULONG ulRemainder;
 256
 257   TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
 258
 259   if (!lpBits || !ulCount ||
 260       ulStart >= lpBits->SizeOfBitMap ||
 261       ulCount > lpBits->SizeOfBitMap - ulStart)
 262     return FALSE;
 263
 264   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
 265    * at a time. But beware of the pointer arithmetics...
 266    */
 267   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
 268
 269   /* Check bits in first byte, if ulStart isn't a byte boundary */
 270   if (ulStart & 7)
 271   {
 272     if (ulCount > 7)
 273     {
 274       /* Check from start bit to the end of the byte */
 275       if ((*lpOut &
 276           ((0xff << (ulStart & 7))) & 0xff) != ((0xff << (ulStart & 7) & 0xff)))
 277         return FALSE;
 278       lpOut++;
 279       ulCount -= (8 - (ulStart & 7));
 280     }
 281     else
 282     {
 283       /* Check from the start bit, possibly into the next byte also */
 284       USHORT initialWord = NTDLL_maskBits[ulCount] << (ulStart & 7);
 285
 286       if ((*lpOut & (initialWord & 0xff)) != (initialWord & 0xff))
 287         return FALSE;
 288       if ((initialWord & 0xff00) &&
 289           ((lpOut[1] & (initialWord >> 8)) != (initialWord >> 8)))
 290         return FALSE;
 291       return TRUE;
 292     }
 293   }
 294
 295   /* Check bits in blocks of 8 bytes */
 296   ulRemainder = ulCount & 7;
 297   ulCount >>= 3;
 298   while (ulCount--)
 299   {
 300     if (*lpOut++ != 0xff)
 301       return FALSE;
 302   }
 303
 304   /* Check remaining bits, if any */
 305   if (ulRemainder &&
 306       (*lpOut & NTDLL_maskBits[ulRemainder]) != NTDLL_maskBits[ulRemainder])
 307     return FALSE;
 308   return TRUE;
 309 }
 310
 311 /*************************************************************************
 312  * RtlAreBitsClear      [NTDLL.@]
 313  *
 314  * Determine if part of a bitmap is clear.
 315  *
 316  * PARAMS
 317  *  lpBits  [I] Bitmap pointer
 318  *  ulStart [I] First bit to check from
 319  *  ulCount [I] Number of consecutive bits to check
 320  *
 321  * RETURNS
 322  *  TRUE,  If ulCount bits from ulStart are clear.
 323  *  FALSE, Otherwise.
 324  */
 325 BOOLEAN WINAPI RtlAreBitsClear(PCRTL_BITMAP lpBits, ULONG ulStart, ULONG ulCount)
 326 {
 327   LPBYTE lpOut;
 328   ULONG ulRemainder;
 329
 330   TRACE("(%p,%d,%d)\n", lpBits, ulStart, ulCount);
 331
 332   if (!lpBits || !ulCount ||
 333       ulStart >= lpBits->SizeOfBitMap ||
 334       ulCount > lpBits->SizeOfBitMap - ulStart)
 335     return FALSE;
 336
 337   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
 338    * at a time. But beware of the pointer arithmetics...
 339    */
 340   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
 341
 342   /* Check bits in first byte, if ulStart isn't a byte boundary */
 343   if (ulStart & 7)
 344   {
 345     if (ulCount > 7)
 346     {
 347       /* Check from start bit to the end of the byte */
 348       if (*lpOut & ((0xff << (ulStart & 7)) & 0xff))
 349         return FALSE;
 350       lpOut++;
 351       ulCount -= (8 - (ulStart & 7));
 352     }
 353     else
 354     {
 355       /* Check from the start bit, possibly into the next byte also */
 356       USHORT initialWord = NTDLL_maskBits[ulCount] << (ulStart & 7);
 357
 358       if (*lpOut & (initialWord & 0xff))
 359         return FALSE;
 360       if ((initialWord & 0xff00) && (lpOut[1] & (initialWord >> 8)))
 361         return FALSE;
 362       return TRUE;
 363     }
 364   }
 365
 366   /* Check bits in blocks of 8 bytes */
 367   ulRemainder = ulCount & 7;
 368   ulCount >>= 3;
 369   while (ulCount--)
 370   {
 371     if (*lpOut++)
 372       return FALSE;
 373   }
 374
 375   /* Check remaining bits, if any */
 376   if (ulRemainder && *lpOut & NTDLL_maskBits[ulRemainder])
 377     return FALSE;
 378   return TRUE;
 379 }
 380
 381 /*************************************************************************
 382  * RtlFindSetBits       [NTDLL.@]
 383  *
 384  * Find a block of set bits in a bitmap.
 385  *
 386  * PARAMS
 387  *  lpBits  [I] Bitmap pointer
 388  *  ulCount [I] Number of consecutive set bits to find
 389  *  ulHint  [I] Suggested starting position for set bits
 390  *
 391  * RETURNS
 392  *  The bit at which the match was found, or -1 if no match was found.
 393  */
 394 ULONG WINAPI RtlFindSetBits(PCRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
 395 {
 396   ULONG ulPos, ulEnd;
 397
 398   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
 399
 400   if (!lpBits || !ulCount || ulCount > lpBits->SizeOfBitMap)
 401     return ~0U;
 402
 403   ulEnd = lpBits->SizeOfBitMap;
 404
 405   if (ulHint + ulCount > lpBits->SizeOfBitMap)
 406     ulHint = 0;
 407
 408   ulPos = ulHint;
 409
 410   while (ulPos < ulEnd)
 411   {
 412     /* FIXME: This could be made a _lot_ more efficient */
 413     if (RtlAreBitsSet(lpBits, ulPos, ulCount))
 414       return ulPos;
 415
 416     /* Start from the beginning if we hit the end and had a hint */
 417     if (ulPos == ulEnd - 1 && ulHint)
 418     {
 419       ulEnd = ulHint;
 420       ulPos = ulHint = 0;
 421     }
 422     else
 423       ulPos++;
 424   }
 425   return ~0U;
 426 }
 427
 428 /*************************************************************************
 429  * RtlFindClearBits     [NTDLL.@]
 430  *
 431  * Find a block of clear bits in a bitmap.
 432  *
 433  * PARAMS
 434  *  lpBits  [I] Bitmap pointer
 435  *  ulCount [I] Number of consecutive clear bits to find
 436  *  ulHint  [I] Suggested starting position for clear bits
 437  *
 438  * RETURNS
 439  *  The bit at which the match was found, or -1 if no match was found.
 440  */
 441 ULONG WINAPI RtlFindClearBits(PCRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
 442 {
 443   ULONG ulPos, ulEnd;
 444
 445   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
 446
 447   if (!lpBits || !ulCount || ulCount > lpBits->SizeOfBitMap)
 448     return ~0U;
 449
 450   ulEnd = lpBits->SizeOfBitMap;
 451
 452   if (ulHint + ulCount > lpBits->SizeOfBitMap)
 453     ulHint = 0;
 454
 455   ulPos = ulHint;
 456
 457   while (ulPos < ulEnd)
 458   {
 459     /* FIXME: This could be made a _lot_ more efficient */
 460     if (RtlAreBitsClear(lpBits, ulPos, ulCount))
 461       return ulPos;
 462
 463     /* Start from the beginning if we hit the end and started from ulHint */
 464     if (ulPos == ulEnd - 1 && ulHint)
 465     {
 466       ulEnd = ulHint;
 467       ulPos = ulHint = 0;
 468     }
 469     else
 470       ulPos++;
 471   }
 472   return ~0U;
 473 }
 474
 475 /*************************************************************************
 476  * RtlFindSetBitsAndClear       [NTDLL.@]
 477  *
 478  * Find a block of set bits in a bitmap, and clear them if found.
 479  *
 480  * PARAMS
 481  *  lpBits  [I] Bitmap pointer
 482  *  ulCount [I] Number of consecutive set bits to find
 483  *  ulHint  [I] Suggested starting position for set bits
 484  *
 485  * RETURNS
 486  *  The bit at which the match was found, or -1 if no match was found.
 487  */
 488 ULONG WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
 489 {
 490   ULONG ulPos;
 491
 492   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
 493
 494   ulPos = RtlFindSetBits(lpBits, ulCount, ulHint);
 495   if (ulPos != ~0U)
 496     RtlClearBits(lpBits, ulPos, ulCount);
 497   return ulPos;
 498 }
 499
 500 /*************************************************************************
 501  * RtlFindClearBitsAndSet       [NTDLL.@]
 502  *
 503  * Find a block of clear bits in a bitmap, and set them if found.
 504  *
 505  * PARAMS
 506  *  lpBits  [I] Bitmap pointer
 507  *  ulCount [I] Number of consecutive clear bits to find
 508  *  ulHint  [I] Suggested starting position for clear bits
 509  *
 510  * RETURNS
 511  *  The bit at which the match was found, or -1 if no match was found.
 512  */
 513 ULONG WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP lpBits, ULONG ulCount, ULONG ulHint)
 514 {
 515   ULONG ulPos;
 516
 517   TRACE("(%p,%d,%d)\n", lpBits, ulCount, ulHint);
 518
 519   ulPos = RtlFindClearBits(lpBits, ulCount, ulHint);
 520   if (ulPos != ~0U)
 521     RtlSetBits(lpBits, ulPos, ulCount);
 522   return ulPos;
 523 }
 524
 525 /*************************************************************************
 526  * RtlNumberOfSetBits   [NTDLL.@]
 527  *
 528  * Find the number of set bits in a bitmap.
 529  *
 530  * PARAMS
 531  *  lpBits [I] Bitmap pointer
 532  *
 533  * RETURNS
 534  *  The number of set bits.
 535  */
 536 ULONG WINAPI RtlNumberOfSetBits(PCRTL_BITMAP lpBits)
 537 {
 538   ULONG ulSet = 0;
 539
 540   TRACE("(%p)\n", lpBits);
 541
 542   if (lpBits)
 543   {
 544     LPBYTE lpOut = (BYTE *)lpBits->Buffer;
 545     ULONG ulCount, ulRemainder;
 546     BYTE bMasked;
 547
 548     ulCount = lpBits->SizeOfBitMap >> 3;
 549     ulRemainder = lpBits->SizeOfBitMap & 0x7;
 550
 551     while (ulCount--)
 552     {
 553       ulSet += NTDLL_nibbleBitCount[*lpOut >> 4];
 554       ulSet += NTDLL_nibbleBitCount[*lpOut & 0xf];
 555       lpOut++;
 556     }
 557
 558     if (ulRemainder)
 559     {
 560       bMasked = *lpOut & NTDLL_maskBits[ulRemainder];
 561       ulSet += NTDLL_nibbleBitCount[bMasked >> 4];
 562       ulSet += NTDLL_nibbleBitCount[bMasked & 0xf];
 563     }
 564   }
 565   return ulSet;
 566 }
 567
 568 /*************************************************************************
 569  * RtlNumberOfClearBits [NTDLL.@]
 570  *
 571  * Find the number of clear bits in a bitmap.
 572  *
 573  * PARAMS
 574  *  lpBits [I] Bitmap pointer
 575  *
 576  * RETURNS
 577  *  The number of clear bits.
 578  */
 579 ULONG WINAPI RtlNumberOfClearBits(PCRTL_BITMAP lpBits)
 580 {
 581   TRACE("(%p)\n", lpBits);
 582
 583   if (lpBits)
 584     return lpBits->SizeOfBitMap - RtlNumberOfSetBits(lpBits);
 585   return 0;
 586 }
 587
 588 /*************************************************************************
 589  * RtlFindMostSignificantBit    [NTDLL.@]
 590  *
 591  * Find the most significant bit in a 64 bit integer.
 592  *
 593  * RETURNS
 594  *  The position of the most significant bit.
 595  */
 596 CCHAR WINAPI RtlFindMostSignificantBit(ULONGLONG ulLong)
 597 {
 598     signed char ret = 32;
 599     DWORD dw;
 600
 601     if (!(dw = (ulLong >> 32)))
 602     {
 603         ret = 0;
 604         dw = (DWORD)ulLong;
 605     }
 606     if (dw & 0xffff0000)
 607     {
 608         dw >>= 16;
 609         ret += 16;
 610     }
 611     if (dw & 0xff00)
 612     {
 613         dw >>= 8;
 614         ret += 8;
 615     }
 616     if (dw & 0xf0)
 617     {
 618         dw >>= 4;
 619         ret += 4;
 620     }
 621     return ret + NTDLL_mostSignificant[dw];
 622 }
 623
 624 /*************************************************************************
 625  * RtlFindLeastSignificantBit   [NTDLL.@]
 626  *
 627  * Find the least significant bit in a 64 bit integer.
 628  *
 629  * RETURNS
 630  *  The position of the least significant bit.
 631  */
 632 CCHAR WINAPI RtlFindLeastSignificantBit(ULONGLONG ulLong)
 633 {
 634     signed char ret = 0;
 635     DWORD dw;
 636
 637     if (!(dw = (DWORD)ulLong))
 638     {
 639         ret = 32;
 640         if (!(dw = ulLong >> 32)) return -1;
 641     }
 642     if (!(dw & 0xffff))
 643     {
 644         dw >>= 16;
 645         ret += 16;
 646     }
 647     if (!(dw & 0xff))
 648     {
 649         dw >>= 8;
 650         ret += 8;
 651     }
 652     if (!(dw & 0x0f))
 653     {
 654         dw >>= 4;
 655         ret += 4;
 656     }
 657     return ret + NTDLL_leastSignificant[dw & 0x0f];
 658 }
 659
 660 /*************************************************************************
 661  * NTDLL_RunSortFn
 662  *
 663  * Internal helper: qsort comparison function for RTL_BITMAP_RUN arrays
 664  */
 665 static int NTDLL_RunSortFn(const void *lhs, const void *rhs)
 666 {
 667   if (((const RTL_BITMAP_RUN*)lhs)->NumberOfBits > ((const RTL_BITMAP_RUN*)rhs)->NumberOfBits)
 668     return -1;
 669   return 1;
 670 }
 671
 672 /*************************************************************************
 673  * NTDLL_FindSetRun
 674  *
 675  * Internal helper: Find the next run of set bits in a bitmap.
 676  */
 677 static ULONG NTDLL_FindSetRun(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpSize)
 678 {
 679   LPBYTE lpOut;
 680   ULONG ulFoundAt = 0, ulCount = 0;
 681
 682   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
 683    * at a time. But beware of the pointer arithmetics...
 684    */
 685   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
 686
 687   while (1)
 688   {
 689     /* Check bits in first byte */
 690     const BYTE bMask = (0xff << (ulStart & 7)) & 0xff;
 691     const BYTE bFirst = *lpOut & bMask;
 692
 693     if (bFirst)
 694     {
 695       /* Have a set bit in first byte */
 696       if (bFirst != bMask)
 697       {
 698         /* Not every bit is set */
 699         ULONG ulOffset;
 700
 701         if (bFirst & 0x0f)
 702           ulOffset = NTDLL_leastSignificant[bFirst & 0x0f];
 703         else
 704           ulOffset = 4 + NTDLL_leastSignificant[bFirst >> 4];
 705         ulStart += ulOffset;
 706         ulFoundAt = ulStart;
 707         for (;ulOffset < 8; ulOffset++)
 708         {
 709           if (!(bFirst & (1 << ulOffset)))
 710           {
 711             *lpSize = ulCount;
 712             return ulFoundAt; /* Set from start, but not until the end */
 713           }
 714           ulCount++;
 715           ulStart++;
 716         }
 717         /* Set to the end - go on to count further bits */
 718         lpOut++;
 719         break;
 720       }
 721       /* every bit from start until the end of the byte is set */
 722       ulFoundAt = ulStart;
 723       ulCount = 8 - (ulStart & 7);
 724       ulStart = (ulStart & ~7u) + 8;
 725       lpOut++;
 726       break;
 727     }
 728     ulStart = (ulStart & ~7u) + 8;
 729     lpOut++;
 730     if (ulStart >= lpBits->SizeOfBitMap)
 731       return ~0U;
 732   }
 733
 734   /* Count blocks of 8 set bits */
 735   while (*lpOut == 0xff)
 736   {
 737     ulCount += 8;
 738     ulStart += 8;
 739     if (ulStart >= lpBits->SizeOfBitMap)
 740     {
 741       *lpSize = ulCount - (ulStart - lpBits->SizeOfBitMap);
 742       return ulFoundAt;
 743     }
 744     lpOut++;
 745   }
 746
 747   /* Count remaining contiguous bits, if any */
 748   if (*lpOut & 1)
 749   {
 750     ULONG ulOffset = 0;
 751
 752     for (;ulOffset < 7u; ulOffset++)
 753     {
 754       if (!(*lpOut & (1 << ulOffset)))
 755         break;
 756       ulCount++;
 757     }
 758   }
 759   *lpSize = ulCount;
 760   return ulFoundAt;
 761 }
 762
 763 /*************************************************************************
 764  * NTDLL_FindClearRun
 765  *
 766  * Internal helper: Find the next run of set bits in a bitmap.
 767  */
 768 static ULONG NTDLL_FindClearRun(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpSize)
 769 {
 770   LPBYTE lpOut;
 771   ULONG ulFoundAt = 0, ulCount = 0;
 772
 773   /* FIXME: It might be more efficient/cleaner to manipulate four bytes
 774    * at a time. But beware of the pointer arithmetics...
 775    */
 776   lpOut = ((BYTE*)lpBits->Buffer) + (ulStart >> 3u);
 777
 778   while (1)
 779   {
 780     /* Check bits in first byte */
 781     const BYTE bMask = (0xff << (ulStart & 7)) & 0xff;
 782     const BYTE bFirst = (~*lpOut) & bMask;
 783
 784     if (bFirst)
 785     {
 786       /* Have a clear bit in first byte */
 787       if (bFirst != bMask)
 788       {
 789         /* Not every bit is clear */
 790         ULONG ulOffset;
 791
 792         if (bFirst & 0x0f)
 793           ulOffset = NTDLL_leastSignificant[bFirst & 0x0f];
 794         else
 795           ulOffset = 4 + NTDLL_leastSignificant[bFirst >> 4];
 796         ulStart += ulOffset;
 797         ulFoundAt = ulStart;
 798         for (;ulOffset < 8; ulOffset++)
 799         {
 800           if (!(bFirst & (1 << ulOffset)))
 801           {
 802             *lpSize = ulCount;
 803             return ulFoundAt; /* Clear from start, but not until the end */
 804           }
 805           ulCount++;
 806           ulStart++;
 807         }
 808         /* Clear to the end - go on to count further bits */
 809         lpOut++;
 810         break;
 811       }
 812       /* Every bit from start until the end of the byte is clear */
 813       ulFoundAt = ulStart;
 814       ulCount = 8 - (ulStart & 7);
 815       ulStart = (ulStart & ~7u) + 8;
 816       lpOut++;
 817       break;
 818     }
 819     ulStart = (ulStart & ~7u) + 8;
 820     lpOut++;
 821     if (ulStart >= lpBits->SizeOfBitMap)
 822       return ~0U;
 823   }
 824
 825   /* Count blocks of 8 clear bits */
 826   while (!*lpOut)
 827   {
 828     ulCount += 8;
 829     ulStart += 8;
 830     if (ulStart >= lpBits->SizeOfBitMap)
 831     {
 832       *lpSize = ulCount - (ulStart - lpBits->SizeOfBitMap);
 833       return ulFoundAt;
 834     }
 835     lpOut++;
 836   }
 837
 838   /* Count remaining contiguous bits, if any */
 839   if (!(*lpOut & 1))
 840   {
 841     ULONG ulOffset = 0;
 842
 843     for (;ulOffset < 7u; ulOffset++)
 844     {
 845       if (*lpOut & (1 << ulOffset))
 846         break;
 847       ulCount++;
 848     }
 849   }
 850   *lpSize = ulCount;
 851   return ulFoundAt;
 852 }
 853
 854 /*************************************************************************
 855  * RtlFindNextForwardRunSet     [NTDLL.@]
 856  *
 857  * Find the next run of set bits in a bitmap.
 858  *
 859  * PARAMS
 860  *  lpBits  [I] Bitmap pointer
 861  *  ulStart [I] Bit position to start searching from
 862  *  lpPos   [O] Start of run
 863  *
 864  * RETURNS
 865  *  Success: The length of the next set run in the bitmap. lpPos is set to
 866  *           the start of the run.
 867  *  Failure: 0, if no run is found or any parameters are invalid.
 868  */
 869 ULONG WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
 870 {
 871   ULONG ulSize = 0;
 872
 873   TRACE("(%p,%d,%p)\n", lpBits, ulStart, lpPos);
 874
 875   if (lpBits && ulStart < lpBits->SizeOfBitMap && lpPos)
 876     *lpPos = NTDLL_FindSetRun(lpBits, ulStart, &ulSize);
 877
 878   return ulSize;
 879 }
 880
 881 /*************************************************************************
 882  * RtlFindNextForwardRunClear   [NTDLL.@]
 883  *
 884  * Find the next run of clear bits in a bitmap.
 885  *
 886  * PARAMS
 887  *  lpBits  [I] Bitmap pointer
 888  *  ulStart [I] Bit position to start searching from
 889  *  lpPos   [O] Start of run
 890  *
 891  * RETURNS
 892  *  Success: The length of the next clear run in the bitmap. lpPos is set to
 893  *           the start of the run.
 894  *  Failure: 0, if no run is found or any parameters are invalid.
 895  */
 896 ULONG WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
 897 {
 898   ULONG ulSize = 0;
 899
 900   TRACE("(%p,%d,%p)\n", lpBits, ulStart, lpPos);
 901
 902   if (lpBits && ulStart < lpBits->SizeOfBitMap && lpPos)
 903     *lpPos = NTDLL_FindClearRun(lpBits, ulStart, &ulSize);
 904
 905   return ulSize;
 906 }
 907
 908 /*************************************************************************
 909  * RtlFindLastBackwardRunSet    [NTDLL.@]
 910  *
 911  * Find a previous run of set bits in a bitmap.
 912  *
 913  * PARAMS
 914  *  lpBits  [I] Bitmap pointer
 915  *  ulStart [I] Bit position to start searching from
 916  *  lpPos   [O] Start of run
 917  *
 918  * RETURNS
 919  *  Success: The length of the previous set run in the bitmap. lpPos is set to
 920  *           the start of the run.
 921  *  Failure: 0, if no run is found or any parameters are invalid.
 922  */
 923 ULONG WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
 924 {
 925   FIXME("(%p,%d,%p)-stub!\n", lpBits, ulStart, lpPos);
 926   return 0;
 927 }
 928
 929 /*************************************************************************
 930  * RtlFindLastBackwardRunClear  [NTDLL.@]
 931  *
 932  * Find a previous run of clear bits in a bitmap.
 933  *
 934  * PARAMS
 935  *  lpBits  [I] Bitmap pointer
 936  *  ulStart [I] Bit position to start searching from
 937  *  lpPos   [O] Start of run
 938  *
 939  * RETURNS
 940  *  Success: The length of the previous clear run in the bitmap. lpPos is set
 941  *           to the start of the run.
 942  *  Failure: 0, if no run is found or any parameters are invalid.
 943  */
 944 ULONG WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP lpBits, ULONG ulStart, PULONG lpPos)
 945 {
 946   FIXME("(%p,%d,%p)-stub!\n", lpBits, ulStart, lpPos);
 947   return 0;
 948 }
 949
 950 /*************************************************************************
 951  * NTDLL_FindRuns
 952  *
 953  * Internal implementation of RtlFindSetRuns/RtlFindClearRuns.
 954  */
 955 static ULONG NTDLL_FindRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
 956                             ULONG ulCount, BOOLEAN bLongest,
 957                             ULONG (*fn)(PCRTL_BITMAP,ULONG,PULONG))
 958 {
 959   BOOL bNeedSort = ulCount > 1 ? TRUE : FALSE;
 960   ULONG ulPos = 0, ulRuns = 0;
 961
 962   TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
 963
 964   if (!ulCount)
 965     return ~0U;
 966
 967   while (ulPos < lpBits->SizeOfBitMap)
 968   {
 969     /* Find next set/clear run */
 970     ULONG ulSize, ulNextPos = fn(lpBits, ulPos, &ulSize);
 971
 972     if (ulNextPos == ~0U)
 973       break;
 974
 975     if (bLongest && ulRuns == ulCount)
 976     {
 977       /* Sort runs with shortest at end, if they are out of order */
 978       if (bNeedSort)
 979         qsort(lpSeries, ulRuns, sizeof(RTL_BITMAP_RUN), NTDLL_RunSortFn);
 980
 981       /* Replace last run if this one is bigger */
 982       if (ulSize > lpSeries[ulRuns - 1].NumberOfBits)
 983       {
 984         lpSeries[ulRuns - 1].StartingIndex = ulNextPos;
 985         lpSeries[ulRuns - 1].NumberOfBits = ulSize;
 986
 987         /* We need to re-sort the array, _if_ we didn't leave it sorted */
 988         if (ulRuns > 1 && ulSize > lpSeries[ulRuns - 2].NumberOfBits)
 989           bNeedSort = TRUE;
 990       }
 991     }
 992     else
 993     {
 994       /* Append to found runs */
 995       lpSeries[ulRuns].StartingIndex = ulNextPos;
 996       lpSeries[ulRuns].NumberOfBits = ulSize;
 997       ulRuns++;
 998
 999       if (!bLongest && ulRuns == ulCount)
1000         break;
1001     }
1002     ulPos = ulNextPos + ulSize;
1003   }
1004   return ulRuns;
1005 }
1006
1007 /*************************************************************************
1008  * RtlFindSetRuns       [NTDLL.@]
1009  *
1010  * Find a series of set runs in a bitmap.
1011  *
1012  * PARAMS
1013  *  lpBits   [I] Bitmap pointer
1014  *  lpSeries [O] Array for each run found
1015  *  ulCount  [I] Number of runs to find
1016  *  bLongest [I] Whether to find the very longest runs or not
1017  *
1018  * RETURNS
1019  *  The number of set runs found.
1020  */
1021 ULONG WINAPI RtlFindSetRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
1022                             ULONG ulCount, BOOLEAN bLongest)
1023 {
1024   TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
1025
1026   return NTDLL_FindRuns(lpBits, lpSeries, ulCount, bLongest, NTDLL_FindSetRun);
1027 }
1028
1029 /*************************************************************************
1030  * RtlFindClearRuns     [NTDLL.@]
1031  *
1032  * Find a series of clear runs in a bitmap.
1033  *
1034  * PARAMS
1035  *  lpBits   [I] Bitmap pointer
1036  *  ulSeries [O] Array for each run found
1037  *  ulCount  [I] Number of runs to find
1038  *  bLongest [I] Whether to find the very longest runs or not
1039  *
1040  * RETURNS
1041  *  The number of clear runs found.
1042  */
1043 ULONG WINAPI RtlFindClearRuns(PCRTL_BITMAP lpBits, PRTL_BITMAP_RUN lpSeries,
1044                               ULONG ulCount, BOOLEAN bLongest)
1045 {
1046   TRACE("(%p,%p,%d,%d)\n", lpBits, lpSeries, ulCount, bLongest);
1047
1048   return NTDLL_FindRuns(lpBits, lpSeries, ulCount, bLongest, NTDLL_FindClearRun);
1049 }
1050
1051 /*************************************************************************
1052  * RtlFindLongestRunSet [NTDLL.@]
1053  *
1054  * Find the longest set run in a bitmap.
1055  *
1056  * PARAMS
1057  *  lpBits   [I] Bitmap pointer
1058  *  pulStart [O] Destination for start of run
1059  *
1060  * RETURNS
1061  *  The length of the run found, or 0 if no run is found.
1062  */
1063 ULONG WINAPI RtlFindLongestRunSet(PCRTL_BITMAP lpBits, PULONG pulStart)
1064 {
1065   RTL_BITMAP_RUN br;
1066
1067   TRACE("(%p,%p)\n", lpBits, pulStart);
1068
1069   if (RtlFindSetRuns(lpBits, &br, 1, TRUE) == 1)
1070   {
1071     if (pulStart)
1072       *pulStart = br.StartingIndex;
1073     return br.NumberOfBits;
1074   }
1075   return 0;
1076 }
1077
1078 /*************************************************************************
1079  * RtlFindLongestRunClear       [NTDLL.@]
1080  *
1081  * Find the longest clear run in a bitmap.
1082  *
1083  * PARAMS
1084  *  lpBits   [I] Bitmap pointer
1085  *  pulStart [O] Destination for start of run
1086  *
1087  * RETURNS
1088  *  The length of the run found, or 0 if no run is found.
1089  */
1090 ULONG WINAPI RtlFindLongestRunClear(PCRTL_BITMAP lpBits, PULONG pulStart)
1091 {
1092   RTL_BITMAP_RUN br;
1093
1094   TRACE("(%p,%p)\n", lpBits, pulStart);
1095
1096   if (RtlFindClearRuns(lpBits, &br, 1, TRUE) == 1)
1097   {
1098     if (pulStart)
1099       *pulStart = br.StartingIndex;
1100     return br.NumberOfBits;
1101   }
1102   return 0;
1103 }