include/xdk/rtlfuncs.h

   1 /******************************************************************************
   2  *                         Runtime Library Functions                          *
   3  ******************************************************************************/
   4
   5 $if (_WDMDDK_)
   6
   7 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
   8
   9 #define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }
  10
  11 FORCEINLINE
  12 VOID
  13 InitializeListHead(
  14   OUT PLIST_ENTRY ListHead)
  15 {
  16   ListHead->Flink = ListHead->Blink = ListHead;
  17 }
  18
  19 BOOLEAN
  20 FORCEINLINE
  21 IsListEmpty(
  22   IN CONST LIST_ENTRY * ListHead)
  23 {
  24   return (BOOLEAN)(ListHead->Flink == ListHead);
  25 }
  26
  27 FORCEINLINE
  28 BOOLEAN
  29 RemoveEntryList(
  30   IN PLIST_ENTRY Entry)
  31 {
  32   PLIST_ENTRY OldFlink;
  33   PLIST_ENTRY OldBlink;
  34
  35   OldFlink = Entry->Flink;
  36   OldBlink = Entry->Blink;
  37   OldFlink->Blink = OldBlink;
  38   OldBlink->Flink = OldFlink;
  39   return (BOOLEAN)(OldFlink == OldBlink);
  40 }
  41
  42 FORCEINLINE
  43 PLIST_ENTRY
  44 RemoveHeadList(
  45   IN OUT PLIST_ENTRY ListHead)
  46 {
  47   PLIST_ENTRY Flink;
  48   PLIST_ENTRY Entry;
  49
  50   Entry = ListHead->Flink;
  51   Flink = Entry->Flink;
  52   ListHead->Flink = Flink;
  53   Flink->Blink = ListHead;
  54   return Entry;
  55 }
  56
  57 FORCEINLINE
  58 PLIST_ENTRY
  59 RemoveTailList(
  60   IN OUT PLIST_ENTRY ListHead)
  61 {
  62   PLIST_ENTRY Blink;
  63   PLIST_ENTRY Entry;
  64
  65   Entry = ListHead->Blink;
  66   Blink = Entry->Blink;
  67   ListHead->Blink = Blink;
  68   Blink->Flink = ListHead;
  69   return Entry;
  70 }
  71
  72 FORCEINLINE
  73 VOID
  74 InsertTailList(
  75   IN OUT PLIST_ENTRY ListHead,
  76   IN OUT PLIST_ENTRY Entry)
  77 {
  78   PLIST_ENTRY OldBlink;
  79   OldBlink = ListHead->Blink;
  80   Entry->Flink = ListHead;
  81   Entry->Blink = OldBlink;
  82   OldBlink->Flink = Entry;
  83   ListHead->Blink = Entry;
  84 }
  85
  86 FORCEINLINE
  87 VOID
  88 InsertHeadList(
  89   IN OUT PLIST_ENTRY ListHead,
  90   IN OUT PLIST_ENTRY Entry)
  91 {
  92   PLIST_ENTRY OldFlink;
  93   OldFlink = ListHead->Flink;
  94   Entry->Flink = OldFlink;
  95   Entry->Blink = ListHead;
  96   OldFlink->Blink = Entry;
  97   ListHead->Flink = Entry;
  98 }
  99
 100 FORCEINLINE
 101 VOID
 102 AppendTailList(
 103   IN OUT PLIST_ENTRY ListHead,
 104   IN OUT PLIST_ENTRY ListToAppend)
 105 {
 106   PLIST_ENTRY ListEnd = ListHead->Blink;
 107
 108   ListHead->Blink->Flink = ListToAppend;
 109   ListHead->Blink = ListToAppend->Blink;
 110   ListToAppend->Blink->Flink = ListHead;
 111   ListToAppend->Blink = ListEnd;
 112 }
 113
 114 FORCEINLINE
 115 PSINGLE_LIST_ENTRY
 116 PopEntryList(
 117   IN OUT PSINGLE_LIST_ENTRY ListHead)
 118 {
 119   PSINGLE_LIST_ENTRY FirstEntry;
 120   FirstEntry = ListHead->Next;
 121   if (FirstEntry != NULL) {
 122     ListHead->Next = FirstEntry->Next;
 123   }
 124   return FirstEntry;
 125 }
 126
 127 FORCEINLINE
 128 VOID
 129 PushEntryList(
 130   IN OUT PSINGLE_LIST_ENTRY ListHead,
 131   IN OUT PSINGLE_LIST_ENTRY Entry)
 132 {
 133   Entry->Next = ListHead->Next;
 134   ListHead->Next = Entry;
 135 }
 136
 137 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
 138
 139 NTSYSAPI
 140 VOID
 141 NTAPI
 142 RtlAssert(
 143   IN PVOID FailedAssertion,
 144   IN PVOID FileName,
 145   IN ULONG LineNumber,
 146   IN PSTR Message);
 147
 148 /* VOID
 149  * RtlCopyMemory(
 150  *     IN VOID UNALIGNED *Destination,
 151  *     IN CONST VOID UNALIGNED *Source,
 152  *     IN SIZE_T Length)
 153  */
 154 #define RtlCopyMemory(Destination, Source, Length) \
 155     memcpy(Destination, Source, Length)
 156
 157 #define RtlCopyBytes RtlCopyMemory
 158
 159 #if defined(_M_AMD64)
 160 NTSYSAPI
 161 VOID
 162 NTAPI
 163 RtlCopyMemoryNonTemporal(
 164   VOID UNALIGNED *Destination,
 165   CONST VOID UNALIGNED *Source,
 166   SIZE_T Length);
 167 #else
 168 #define RtlCopyMemoryNonTemporal RtlCopyMemory
 169 #endif
 170
 171 /* BOOLEAN
 172  * RtlEqualLuid(
 173  *     IN PLUID Luid1,
 174  *     IN PLUID Luid2)
 175  */
 176 #define RtlEqualLuid(Luid1, Luid2) \
 177     (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
 178
 179 /* ULONG
 180  * RtlEqualMemory(
 181  *     IN VOID UNALIGNED *Destination,
 182  *     IN CONST VOID UNALIGNED *Source,
 183  *     IN SIZE_T Length)
 184  */
 185 #define RtlEqualMemory(Destination, Source, Length) \
 186     (!memcmp(Destination, Source, Length))
 187
 188 /* VOID
 189  * RtlFillMemory(
 190  *     IN VOID UNALIGNED *Destination,
 191  *     IN SIZE_T Length,
 192  *     IN UCHAR Fill)
 193  */
 194 #define RtlFillMemory(Destination, Length, Fill) \
 195     memset(Destination, Fill, Length)
 196
 197 #define RtlFillBytes RtlFillMemory
 198
 199 NTSYSAPI
 200 VOID
 201 NTAPI
 202 RtlFreeUnicodeString(
 203   IN OUT PUNICODE_STRING UnicodeString);
 204
 205 NTSYSAPI
 206 NTSTATUS
 207 NTAPI
 208 RtlGUIDFromString(
 209   IN PUNICODE_STRING GuidString,
 210   OUT GUID *Guid);
 211
 212 NTSYSAPI
 213 VOID
 214 NTAPI
 215 RtlInitUnicodeString(
 216   IN OUT PUNICODE_STRING DestinationString,
 217   IN PCWSTR SourceString OPTIONAL);
 218
 219 /* VOID
 220  * RtlMoveMemory(
 221  *    IN VOID UNALIGNED *Destination,
 222  *    IN CONST VOID UNALIGNED *Source,
 223  *    IN SIZE_T Length)
 224  */
 225 #define RtlMoveMemory(Destination, Source, Length) \
 226     memmove(Destination, Source, Length)
 227
 228 NTSYSAPI
 229 NTSTATUS
 230 NTAPI
 231 RtlStringFromGUID(
 232   IN REFGUID Guid,
 233   OUT PUNICODE_STRING GuidString);
 234
 235 /* VOID
 236  * RtlZeroMemory(
 237  *     IN VOID UNALIGNED *Destination,
 238  *     IN SIZE_T Length)
 239  */
 240 #define RtlZeroMemory(Destination, Length) \
 241     memset(Destination, 0, Length)
 242
 243 #define RtlZeroBytes RtlZeroMemory
 244
 245 $endif
 246 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 247
 248 $if (_NTIFS_)
 249 NTSYSAPI
 250 PVOID
 251 NTAPI
 252 RtlAllocateHeap(
 253   IN HANDLE HeapHandle,
 254   IN ULONG Flags OPTIONAL,
 255   IN SIZE_T Size);
 256
 257 NTSYSAPI
 258 BOOLEAN
 259 NTAPI
 260 RtlFreeHeap(
 261   IN PVOID HeapHandle,
 262   IN ULONG Flags OPTIONAL,
 263   IN PVOID BaseAddress);
 264
 265 $endif
 266
 267 $if (_NTDDK_)
 268
 269 #ifndef RTL_USE_AVL_TABLES
 270
 271 NTSYSAPI
 272 VOID
 273 NTAPI
 274 RtlInitializeGenericTable(
 275   OUT PRTL_GENERIC_TABLE Table,
 276   IN PRTL_GENERIC_COMPARE_ROUTINE CompareRoutine,
 277   IN PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine,
 278   IN PRTL_GENERIC_FREE_ROUTINE FreeRoutine,
 279   IN PVOID TableContext OPTIONAL);
 280
 281 NTSYSAPI
 282 PVOID
 283 NTAPI
 284 RtlInsertElementGenericTable(
 285   IN PRTL_GENERIC_TABLE Table,
 286   IN PVOID Buffer,
 287   IN CLONG BufferSize,
 288   OUT PBOOLEAN NewElement OPTIONAL);
 289
 290 NTSYSAPI
 291 PVOID
 292 NTAPI
 293 RtlInsertElementGenericTableFull(
 294   IN PRTL_GENERIC_TABLE Table,
 295   IN PVOID Buffer,
 296   IN CLONG BufferSize,
 297   OUT PBOOLEAN NewElement OPTIONAL,
 298   IN PVOID NodeOrParent,
 299   IN TABLE_SEARCH_RESULT SearchResult);
 300
 301 NTSYSAPI
 302 BOOLEAN
 303 NTAPI
 304 RtlDeleteElementGenericTable(
 305   IN PRTL_GENERIC_TABLE Table,
 306   IN PVOID Buffer);
 307
 308 NTSYSAPI
 309 PVOID
 310 NTAPI
 311 RtlLookupElementGenericTable(
 312   IN PRTL_GENERIC_TABLE Table,
 313   IN PVOID Buffer);
 314
 315 NTSYSAPI
 316 PVOID
 317 NTAPI
 318 RtlLookupElementGenericTableFull(
 319   IN PRTL_GENERIC_TABLE Table,
 320   IN PVOID Buffer,
 321   OUT PVOID *NodeOrParent,
 322   OUT TABLE_SEARCH_RESULT *SearchResult);
 323
 324 NTSYSAPI
 325 PVOID
 326 NTAPI
 327 RtlEnumerateGenericTable(
 328   IN PRTL_GENERIC_TABLE Table,
 329   IN BOOLEAN Restart);
 330
 331 NTSYSAPI
 332 PVOID
 333 NTAPI
 334 RtlEnumerateGenericTableWithoutSplaying(
 335   IN PRTL_GENERIC_TABLE Table,
 336   IN OUT PVOID *RestartKey);
 337
 338 NTSYSAPI
 339 PVOID
 340 NTAPI
 341 RtlGetElementGenericTable(
 342   IN PRTL_GENERIC_TABLE Table,
 343   IN ULONG I);
 344
 345 NTSYSAPI
 346 ULONG
 347 NTAPI
 348 RtlNumberGenericTableElements(
 349   IN PRTL_GENERIC_TABLE Table);
 350
 351 NTSYSAPI
 352 BOOLEAN
 353 NTAPI
 354 RtlIsGenericTableEmpty(
 355   IN PRTL_GENERIC_TABLE Table);
 356
 357 #endif /* !RTL_USE_AVL_TABLES */
 358
 359 #define RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT     8
 360
 361 NTSYSAPI
 362 PRTL_SPLAY_LINKS
 363 NTAPI
 364 RtlSplay(
 365   IN OUT PRTL_SPLAY_LINKS Links);
 366
 367 NTSYSAPI
 368 PRTL_SPLAY_LINKS
 369 NTAPI
 370 RtlDelete(
 371   IN PRTL_SPLAY_LINKS Links);
 372
 373 NTSYSAPI
 374 VOID
 375 NTAPI
 376 RtlDeleteNoSplay(
 377   IN PRTL_SPLAY_LINKS Links,
 378   IN OUT PRTL_SPLAY_LINKS *Root);
 379
 380 NTSYSAPI
 381 PRTL_SPLAY_LINKS
 382 NTAPI
 383 RtlSubtreeSuccessor(
 384   IN PRTL_SPLAY_LINKS Links);
 385
 386 NTSYSAPI
 387 PRTL_SPLAY_LINKS
 388 NTAPI
 389 RtlSubtreePredecessor(
 390   IN PRTL_SPLAY_LINKS Links);
 391
 392 NTSYSAPI
 393 PRTL_SPLAY_LINKS
 394 NTAPI
 395 RtlRealSuccessor(
 396   IN PRTL_SPLAY_LINKS Links);
 397
 398 NTSYSAPI
 399 PRTL_SPLAY_LINKS
 400 NTAPI
 401 RtlRealPredecessor(
 402   IN PRTL_SPLAY_LINKS Links);
 403
 404 NTSYSAPI
 405 BOOLEAN
 406 NTAPI
 407 RtlPrefixUnicodeString(
 408   IN PCUNICODE_STRING  String1,
 409   IN PCUNICODE_STRING  String2,
 410   IN BOOLEAN  CaseInSensitive);
 411
 412 NTSYSAPI
 413 VOID
 414 NTAPI
 415 RtlUpperString(
 416   IN OUT PSTRING  DestinationString,
 417   IN const PSTRING  SourceString);
 418
 419 NTSYSAPI
 420 NTSTATUS
 421 NTAPI
 422 RtlUpcaseUnicodeString(
 423   IN OUT PUNICODE_STRING DestinationString,
 424   IN PCUNICODE_STRING  SourceString,
 425   IN BOOLEAN  AllocateDestinationString);
 426
 427 NTSYSAPI
 428 VOID
 429 NTAPI
 430 RtlMapGenericMask(
 431   IN OUT PACCESS_MASK AccessMask,
 432   IN PGENERIC_MAPPING GenericMapping);
 433
 434 NTSYSAPI
 435 NTSTATUS
 436 NTAPI
 437 RtlVolumeDeviceToDosName(
 438   IN PVOID VolumeDeviceObject,
 439   OUT PUNICODE_STRING DosName);
 440
 441 NTSYSAPI
 442 NTSTATUS
 443 NTAPI
 444 RtlGetVersion(
 445   IN OUT PRTL_OSVERSIONINFOW lpVersionInformation);
 446
 447 NTSYSAPI
 448 NTSTATUS
 449 NTAPI
 450 RtlVerifyVersionInfo(
 451   IN PRTL_OSVERSIONINFOEXW VersionInfo,
 452   IN ULONG TypeMask,
 453   IN ULONGLONG ConditionMask);
 454
 455 NTSYSAPI
 456 LONG
 457 NTAPI
 458 RtlCompareString(
 459   IN const PSTRING String1,
 460   IN const PSTRING String2,
 461   IN BOOLEAN CaseInSensitive);
 462
 463 NTSYSAPI
 464 VOID
 465 NTAPI
 466 RtlCopyString(
 467   OUT PSTRING DestinationString,
 468   IN const PSTRING SourceString OPTIONAL);
 469
 470 NTSYSAPI
 471 BOOLEAN
 472 NTAPI
 473 RtlEqualString(
 474   IN const PSTRING String1,
 475   IN const PSTRING String2,
 476   IN BOOLEAN CaseInSensitive);
 477
 478 NTSYSAPI
 479 NTSTATUS
 480 NTAPI
 481 RtlCharToInteger(
 482   IN PCSZ String,
 483   IN ULONG Base OPTIONAL,
 484   OUT PULONG Value);
 485
 486 NTSYSAPI
 487 CHAR
 488 NTAPI
 489 RtlUpperChar(
 490   IN CHAR Character);
 491
 492 NTSYSAPI
 493 ULONG
 494 NTAPI
 495 RtlWalkFrameChain(
 496   OUT PVOID *Callers,
 497   IN ULONG Count,
 498   IN ULONG Flags);
 499
 500 $endif
 501
 502 $if (_WDMDDK_)
 503 NTSYSAPI
 504 BOOLEAN
 505 NTAPI
 506 RtlAreBitsClear(
 507   IN PRTL_BITMAP BitMapHeader,
 508   IN ULONG StartingIndex,
 509   IN ULONG Length);
 510
 511 NTSYSAPI
 512 BOOLEAN
 513 NTAPI
 514 RtlAreBitsSet(
 515   IN PRTL_BITMAP BitMapHeader,
 516   IN ULONG StartingIndex,
 517   IN ULONG Length);
 518
 519 NTSYSAPI
 520 NTSTATUS
 521 NTAPI
 522 RtlAnsiStringToUnicodeString(
 523   IN OUT PUNICODE_STRING DestinationString,
 524   IN PANSI_STRING SourceString,
 525   IN BOOLEAN AllocateDestinationString);
 526
 527 NTSYSAPI
 528 ULONG
 529 NTAPI
 530 RtlxAnsiStringToUnicodeSize(
 531   IN PCANSI_STRING AnsiString);
 532
 533 #define RtlAnsiStringToUnicodeSize(String) (               \
 534   NLS_MB_CODE_PAGE_TAG ?                                   \
 535   RtlxAnsiStringToUnicodeSize(String) :                    \
 536   ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)   \
 537 )
 538
 539 NTSYSAPI
 540 NTSTATUS
 541 NTAPI
 542 RtlAppendUnicodeStringToString(
 543   IN OUT PUNICODE_STRING Destination,
 544   IN PCUNICODE_STRING Source);
 545
 546 NTSYSAPI
 547 NTSTATUS
 548 NTAPI
 549 RtlAppendUnicodeToString(
 550   IN OUT PUNICODE_STRING Destination,
 551   IN PCWSTR Source);
 552
 553 NTSYSAPI
 554 NTSTATUS
 555 NTAPI
 556 RtlCheckRegistryKey(
 557   IN ULONG RelativeTo,
 558   IN PWSTR Path);
 559
 560 NTSYSAPI
 561 VOID
 562 NTAPI
 563 RtlClearAllBits(
 564   IN PRTL_BITMAP BitMapHeader);
 565
 566 NTSYSAPI
 567 VOID
 568 NTAPI
 569 RtlClearBits(
 570   IN PRTL_BITMAP BitMapHeader,
 571   IN ULONG StartingIndex,
 572   IN ULONG NumberToClear);
 573
 574 NTSYSAPI
 575 SIZE_T
 576 NTAPI
 577 RtlCompareMemory(
 578   IN CONST VOID *Source1,
 579   IN CONST VOID *Source2,
 580   IN SIZE_T Length);
 581
 582 NTSYSAPI
 583 LONG
 584 NTAPI
 585 RtlCompareUnicodeString(
 586   IN PCUNICODE_STRING String1,
 587   IN PCUNICODE_STRING String2,
 588   IN BOOLEAN CaseInSensitive);
 589
 590 NTSYSAPI
 591 LONG
 592 NTAPI
 593 RtlCompareUnicodeStrings(
 594   IN PCWCH String1,
 595   IN SIZE_T String1Length,
 596   IN PCWCH String2,
 597   IN SIZE_T String2Length,
 598   IN BOOLEAN CaseInSensitive);
 599
 600 NTSYSAPI
 601 VOID
 602 NTAPI
 603 RtlCopyUnicodeString(
 604   IN OUT PUNICODE_STRING DestinationString,
 605   IN PCUNICODE_STRING SourceString OPTIONAL);
 606
 607 NTSYSAPI
 608 NTSTATUS
 609 NTAPI
 610 RtlCreateRegistryKey(
 611   IN ULONG RelativeTo,
 612   IN PWSTR Path);
 613
 614 NTSYSAPI
 615 NTSTATUS
 616 NTAPI
 617 RtlCreateSecurityDescriptor(
 618   IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 619   IN ULONG Revision);
 620
 621 NTSYSAPI
 622 NTSTATUS
 623 NTAPI
 624 RtlDeleteRegistryValue(
 625   IN ULONG RelativeTo,
 626   IN PCWSTR Path,
 627   IN PCWSTR ValueName);
 628
 629 NTSYSAPI
 630 BOOLEAN
 631 NTAPI
 632 RtlEqualUnicodeString(
 633   IN CONST UNICODE_STRING *String1,
 634   IN CONST UNICODE_STRING *String2,
 635   IN BOOLEAN CaseInSensitive);
 636
 637 #if !defined(_AMD64_) && !defined(_IA64_)
 638 NTSYSAPI
 639 LARGE_INTEGER
 640 NTAPI
 641 RtlExtendedIntegerMultiply(
 642   IN LARGE_INTEGER Multiplicand,
 643   IN LONG Multiplier);
 644
 645 NTSYSAPI
 646 LARGE_INTEGER
 647 NTAPI
 648 RtlExtendedLargeIntegerDivide(
 649   IN LARGE_INTEGER Dividend,
 650   IN ULONG Divisor,
 651   OUT PULONG Remainder OPTIONAL);
 652 #endif
 653
 654 #if defined(_X86_) || defined(_IA64_)
 655 NTSYSAPI
 656 LARGE_INTEGER
 657 NTAPI
 658 RtlExtendedMagicDivide(
 659     IN LARGE_INTEGER Dividend,
 660     IN LARGE_INTEGER MagicDivisor,
 661     IN CCHAR  ShiftCount);
 662 #endif
 663
 664 NTSYSAPI
 665 VOID
 666 NTAPI
 667 RtlFreeAnsiString(
 668   IN PANSI_STRING AnsiString);
 669
 670 NTSYSAPI
 671 ULONG
 672 NTAPI
 673 RtlFindClearBits(
 674   IN PRTL_BITMAP BitMapHeader,
 675   IN ULONG NumberToFind,
 676   IN ULONG HintIndex);
 677
 678 NTSYSAPI
 679 ULONG
 680 NTAPI
 681 RtlFindClearBitsAndSet(
 682   IN PRTL_BITMAP BitMapHeader,
 683   IN ULONG NumberToFind,
 684   IN ULONG HintIndex);
 685
 686 NTSYSAPI
 687 ULONG
 688 NTAPI
 689 RtlFindFirstRunClear(
 690   IN PRTL_BITMAP BitMapHeader,
 691   OUT PULONG StartingIndex);
 692
 693 NTSYSAPI
 694 ULONG
 695 NTAPI
 696 RtlFindClearRuns(
 697   IN PRTL_BITMAP BitMapHeader,
 698   OUT PRTL_BITMAP_RUN RunArray,
 699   IN ULONG SizeOfRunArray,
 700   IN BOOLEAN LocateLongestRuns);
 701
 702 NTSYSAPI
 703 ULONG
 704 NTAPI
 705 RtlFindLastBackwardRunClear(
 706   IN PRTL_BITMAP BitMapHeader,
 707   IN ULONG FromIndex,
 708   OUT PULONG StartingRunIndex);
 709
 710 NTSYSAPI
 711 CCHAR
 712 NTAPI
 713 RtlFindLeastSignificantBit(
 714   IN ULONGLONG Set);
 715
 716 NTSYSAPI
 717 ULONG
 718 NTAPI
 719 RtlFindLongestRunClear(
 720   IN PRTL_BITMAP BitMapHeader,
 721   OUT PULONG StartingIndex);
 722
 723 NTSYSAPI
 724 CCHAR
 725 NTAPI
 726 RtlFindMostSignificantBit(
 727   IN ULONGLONG Set);
 728
 729 NTSYSAPI
 730 ULONG
 731 NTAPI
 732 RtlFindNextForwardRunClear(
 733   IN PRTL_BITMAP BitMapHeader,
 734   IN ULONG FromIndex,
 735   OUT PULONG StartingRunIndex);
 736
 737 NTSYSAPI
 738 ULONG
 739 NTAPI
 740 RtlFindSetBits(
 741   IN PRTL_BITMAP BitMapHeader,
 742   IN ULONG NumberToFind,
 743   IN ULONG HintIndex);
 744
 745 NTSYSAPI
 746 ULONG
 747 NTAPI
 748 RtlFindSetBitsAndClear(
 749   IN PRTL_BITMAP BitMapHeader,
 750   IN ULONG NumberToFind,
 751   IN ULONG HintIndex);
 752
 753 NTSYSAPI
 754 VOID
 755 NTAPI
 756 RtlInitAnsiString(
 757   IN OUT PANSI_STRING DestinationString,
 758   IN PCSZ SourceString);
 759
 760 NTSYSAPI
 761 VOID
 762 NTAPI
 763 RtlInitializeBitMap(
 764   IN PRTL_BITMAP BitMapHeader,
 765   IN PULONG BitMapBuffer,
 766   IN ULONG SizeOfBitMap);
 767
 768 NTSYSAPI
 769 VOID
 770 NTAPI
 771 RtlInitString(
 772   IN OUT PSTRING DestinationString,
 773   IN PCSZ SourceString);
 774
 775 NTSYSAPI
 776 NTSTATUS
 777 NTAPI
 778 RtlIntegerToUnicodeString(
 779   IN ULONG Value,
 780   IN ULONG Base OPTIONAL,
 781   IN OUT PUNICODE_STRING String);
 782
 783 NTSYSAPI
 784 NTSTATUS
 785 NTAPI
 786 RtlInt64ToUnicodeString(
 787   IN ULONGLONG Value,
 788   IN ULONG Base OPTIONAL,
 789   IN OUT PUNICODE_STRING String);
 790
 791 #ifdef _WIN64
 792 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 793     RtlInt64ToUnicodeString(Value, Base, String)
 794 #else
 795 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 796     RtlIntegerToUnicodeString(Value, Base, String)
 797 #endif
 798
 799 /* BOOLEAN
 800  * RtlIsZeroLuid(
 801  *     IN PLUID L1);
 802  */
 803 #define RtlIsZeroLuid(_L1) \
 804     ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
 805
 806 NTSYSAPI
 807 ULONG
 808 NTAPI
 809 RtlLengthSecurityDescriptor(
 810   IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 811
 812 NTSYSAPI
 813 ULONG
 814 NTAPI
 815 RtlNumberOfClearBits(
 816   IN PRTL_BITMAP BitMapHeader);
 817
 818 NTSYSAPI
 819 ULONG
 820 NTAPI
 821 RtlNumberOfSetBits(
 822   IN PRTL_BITMAP BitMapHeader);
 823
 824 NTSYSAPI
 825 NTSTATUS
 826 NTAPI
 827 RtlQueryRegistryValues(
 828   IN ULONG RelativeTo,
 829   IN PCWSTR Path,
 830   IN OUT PRTL_QUERY_REGISTRY_TABLE QueryTable,
 831   IN PVOID Context OPTIONAL,
 832   IN PVOID Environment OPTIONAL);
 833
 834 #define SHORT_SIZE  (sizeof(USHORT))
 835 #define SHORT_MASK  (SHORT_SIZE - 1)
 836 #define LONG_SIZE (sizeof(LONG))
 837 #define LONGLONG_SIZE   (sizeof(LONGLONG))
 838 #define LONG_MASK (LONG_SIZE - 1)
 839 #define LONGLONG_MASK   (LONGLONG_SIZE - 1)
 840 #define LOWBYTE_MASK 0x00FF
 841
 842 #define FIRSTBYTE(VALUE)  ((VALUE) & LOWBYTE_MASK)
 843 #define SECONDBYTE(VALUE) (((VALUE) >> 8) & LOWBYTE_MASK)
 844 #define THIRDBYTE(VALUE)  (((VALUE) >> 16) & LOWBYTE_MASK)
 845 #define FOURTHBYTE(VALUE) (((VALUE) >> 24) & LOWBYTE_MASK)
 846
 847 NTSYSAPI
 848 VOID
 849 NTAPI
 850 RtlSetAllBits(
 851   IN PRTL_BITMAP BitMapHeader);
 852
 853 NTSYSAPI
 854 VOID
 855 NTAPI
 856 RtlSetBits(
 857   IN PRTL_BITMAP BitMapHeader,
 858   IN ULONG StartingIndex,
 859   IN ULONG NumberToSet);
 860
 861 NTSYSAPI
 862 NTSTATUS
 863 NTAPI
 864 RtlSetDaclSecurityDescriptor(
 865   IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 866   IN BOOLEAN DaclPresent,
 867   IN PACL Dacl OPTIONAL,
 868   IN BOOLEAN DaclDefaulted OPTIONAL);
 869
 870 #if defined(_AMD64_)
 871
 872 /* VOID
 873  * RtlStoreUlong(
 874  *     IN PULONG Address,
 875  *     IN ULONG Value);
 876  */
 877 #define RtlStoreUlong(Address,Value) \
 878     *(ULONG UNALIGNED *)(Address) = (Value)
 879
 880 /* VOID
 881  * RtlStoreUlonglong(
 882  *     IN OUT PULONGLONG Address,
 883  *     ULONGLONG Value);
 884  */
 885 #define RtlStoreUlonglong(Address,Value) \
 886     *(ULONGLONG UNALIGNED *)(Address) = (Value)
 887
 888 /* VOID
 889  * RtlStoreUshort(
 890  *     IN PUSHORT Address,
 891  *     IN USHORT Value);
 892  */
 893 #define RtlStoreUshort(Address,Value) \
 894     *(USHORT UNALIGNED *)(Address) = (Value)
 895
 896 /* VOID
 897  * RtlRetrieveUshort(
 898  *     PUSHORT DestinationAddress,
 899  *    PUSHORT SourceAddress);
 900  */
 901 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 902     *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
 903
 904 /* VOID
 905  * RtlRetrieveUlong(
 906  *    PULONG DestinationAddress,
 907  *    PULONG SourceAddress);
 908  */
 909 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 910     *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
 911
 912 #else
 913
 914 #define RtlStoreUlong(Address,Value)                      \
 915     if ((ULONG_PTR)(Address) & LONG_MASK) { \
 916         ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT]    = (UCHAR)(FIRSTBYTE(Value)); \
 917         ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
 918         ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
 919         ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT]     = (UCHAR)(FOURTHBYTE(Value)); \
 920     } \
 921     else { \
 922         *((PULONG)(Address)) = (ULONG) (Value); \
 923     }
 924
 925 #define RtlStoreUlonglong(Address,Value) \
 926     if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
 927         RtlStoreUlong((ULONG_PTR)(Address), \
 928                       (ULONGLONG)(Value) & 0xFFFFFFFF); \
 929         RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
 930                       (ULONGLONG)(Value) >> 32); \
 931     } else { \
 932         *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
 933     }
 934
 935 #define RtlStoreUshort(Address,Value) \
 936     if ((ULONG_PTR)(Address) & SHORT_MASK) { \
 937         ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
 938         ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
 939     } \
 940     else { \
 941         *((PUSHORT) (Address)) = (USHORT)Value; \
 942     }
 943
 944 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 945     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 946     { \
 947         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 948         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 949     } \
 950     else \
 951     { \
 952         *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
 953     }
 954
 955 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 956     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 957     { \
 958         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 959         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 960         ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
 961         ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
 962     } \
 963     else \
 964     { \
 965         *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
 966     }
 967
 968 #endif /* defined(_AMD64_) */
 969
 970 #ifdef _WIN64
 971 /* VOID
 972  * RtlStoreUlongPtr(
 973  *     IN OUT PULONG_PTR Address,
 974  *     IN ULONG_PTR Value);
 975  */
 976 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlonglong(Address,Value)
 977 #else
 978 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlong(Address,Value)
 979 #endif /* _WIN64 */
 980
 981
 982 NTSYSAPI
 983 BOOLEAN
 984 NTAPI
 985 RtlTimeFieldsToTime(
 986   IN PTIME_FIELDS TimeFields,
 987   IN PLARGE_INTEGER Time);
 988
 989 NTSYSAPI
 990 VOID
 991 NTAPI
 992 RtlTimeToTimeFields(
 993   IN PLARGE_INTEGER Time,
 994   IN PTIME_FIELDS TimeFields);
 995
 996 NTSYSAPI
 997 ULONG
 998 FASTCALL
 999 RtlUlongByteSwap(
1000   IN ULONG Source);
1001
1002 NTSYSAPI
1003 ULONGLONG
1004 FASTCALL
1005 RtlUlonglongByteSwap(
1006   IN ULONGLONG Source);
1007
1008 NTSYSAPI
1009 NTSTATUS
1010 NTAPI
1011 RtlUnicodeStringToAnsiString(
1012   IN OUT PANSI_STRING DestinationString,
1013   IN PCUNICODE_STRING SourceString,
1014   IN BOOLEAN AllocateDestinationString);
1015
1016 NTSYSAPI
1017 ULONG
1018 NTAPI
1019 RtlxUnicodeStringToAnsiSize(
1020   IN PCUNICODE_STRING UnicodeString);
1021
1022 #define RtlUnicodeStringToAnsiSize(String) (                  \
1023     NLS_MB_CODE_PAGE_TAG ?                                    \
1024     RtlxUnicodeStringToAnsiSize(String) :                     \
1025     ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
1026 )
1027
1028 NTSYSAPI
1029 NTSTATUS
1030 NTAPI
1031 RtlUnicodeStringToInteger(
1032   IN PCUNICODE_STRING String,
1033   IN ULONG Base OPTIONAL,
1034   OUT PULONG Value);
1035
1036 NTSYSAPI
1037 WCHAR
1038 NTAPI
1039 RtlUpcaseUnicodeChar(
1040   IN WCHAR SourceCharacter);
1041
1042 NTSYSAPI
1043 USHORT
1044 FASTCALL
1045 RtlUshortByteSwap(
1046   IN USHORT Source);
1047
1048 NTSYSAPI
1049 BOOLEAN
1050 NTAPI
1051 RtlValidRelativeSecurityDescriptor(
1052   IN PSECURITY_DESCRIPTOR SecurityDescriptorInput,
1053   IN ULONG SecurityDescriptorLength,
1054   IN SECURITY_INFORMATION RequiredInformation);
1055
1056 NTSYSAPI
1057 BOOLEAN
1058 NTAPI
1059 RtlValidSecurityDescriptor(
1060   IN PSECURITY_DESCRIPTOR SecurityDescriptor);
1061
1062 NTSYSAPI
1063 NTSTATUS
1064 NTAPI
1065 RtlWriteRegistryValue(
1066   IN ULONG RelativeTo,
1067   IN PCWSTR Path,
1068   IN PCWSTR ValueName,
1069   IN ULONG ValueType,
1070   IN PVOID ValueData,
1071   IN ULONG ValueLength);
1072
1073 $endif
1074
1075 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
1076
1077 $if (_WDMDDK_)
1078
1079 #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
1080 NTSYSAPI
1081 VOID
1082 FASTCALL
1083 RtlPrefetchMemoryNonTemporal(
1084   IN PVOID Source,
1085   IN SIZE_T Length);
1086 #endif
1087
1088 $endif
1089
1090 #if (NTDDI_VERSION >= NTDDI_WINXP)
1091
1092 $if (_NTDDK_)
1093
1094 NTSYSAPI
1095 VOID
1096 NTAPI
1097 RtlInitializeGenericTableAvl(
1098   OUT PRTL_AVL_TABLE Table,
1099   IN PRTL_AVL_COMPARE_ROUTINE CompareRoutine,
1100   IN PRTL_AVL_ALLOCATE_ROUTINE AllocateRoutine,
1101   IN PRTL_AVL_FREE_ROUTINE FreeRoutine,
1102   IN PVOID TableContext OPTIONAL);
1103
1104 NTSYSAPI
1105 PVOID
1106 NTAPI
1107 RtlInsertElementGenericTableAvl(
1108   IN PRTL_AVL_TABLE Table,
1109   IN PVOID Buffer,
1110   IN CLONG BufferSize,
1111   OUT PBOOLEAN NewElement OPTIONAL);
1112
1113 NTSYSAPI
1114 PVOID
1115 NTAPI
1116 RtlInsertElementGenericTableFullAvl(
1117   IN PRTL_AVL_TABLE Table,
1118   IN PVOID Buffer,
1119   IN CLONG BufferSize,
1120   OUT PBOOLEAN NewElement OPTIONAL,
1121   IN PVOID NodeOrParent,
1122   IN TABLE_SEARCH_RESULT SearchResult);
1123
1124 NTSYSAPI
1125 BOOLEAN
1126 NTAPI
1127 RtlDeleteElementGenericTableAvl(
1128   IN PRTL_AVL_TABLE Table,
1129   IN PVOID Buffer);
1130
1131 NTSYSAPI
1132 PVOID
1133 NTAPI
1134 RtlLookupElementGenericTableAvl(
1135   IN PRTL_AVL_TABLE Table,
1136   IN PVOID Buffer);
1137
1138 NTSYSAPI
1139 PVOID
1140 NTAPI
1141 RtlLookupElementGenericTableFullAvl(
1142   IN PRTL_AVL_TABLE Table,
1143   IN PVOID Buffer,
1144   OUT PVOID *NodeOrParent,
1145   OUT TABLE_SEARCH_RESULT *SearchResult);
1146
1147 NTSYSAPI
1148 PVOID
1149 NTAPI
1150 RtlEnumerateGenericTableAvl(
1151   IN PRTL_AVL_TABLE Table,
1152   IN BOOLEAN Restart);
1153
1154 NTSYSAPI
1155 PVOID
1156 NTAPI
1157 RtlEnumerateGenericTableWithoutSplayingAvl(
1158   IN PRTL_AVL_TABLE Table,
1159   IN OUT PVOID *RestartKey);
1160
1161 NTSYSAPI
1162 PVOID
1163 NTAPI
1164 RtlLookupFirstMatchingElementGenericTableAvl(
1165   IN PRTL_AVL_TABLE Table,
1166   IN PVOID Buffer,
1167   OUT PVOID *RestartKey);
1168
1169 NTSYSAPI
1170 PVOID
1171 NTAPI
1172 RtlEnumerateGenericTableLikeADirectory(
1173   IN PRTL_AVL_TABLE Table,
1174   IN PRTL_AVL_MATCH_FUNCTION MatchFunction OPTIONAL,
1175   IN PVOID MatchData OPTIONAL,
1176   IN ULONG NextFlag,
1177   IN OUT PVOID *RestartKey,
1178   IN OUT PULONG DeleteCount,
1179   IN PVOID Buffer);
1180
1181 NTSYSAPI
1182 PVOID
1183 NTAPI
1184 RtlGetElementGenericTableAvl(
1185   IN PRTL_AVL_TABLE Table,
1186   IN ULONG I);
1187
1188 NTSYSAPI
1189 ULONG
1190 NTAPI
1191 RtlNumberGenericTableElementsAvl(
1192   IN PRTL_AVL_TABLE Table);
1193
1194 NTSYSAPI
1195 BOOLEAN
1196 NTAPI
1197 RtlIsGenericTableEmptyAvl(
1198   IN PRTL_AVL_TABLE Table);
1199
1200 $endif
1201
1202 $if (_WDMDDK_)
1203
1204 NTSYSAPI
1205 VOID
1206 NTAPI
1207 RtlClearBit(
1208   PRTL_BITMAP BitMapHeader,
1209   ULONG BitNumber);
1210
1211 NTSYSAPI
1212 WCHAR
1213 NTAPI
1214 RtlDowncaseUnicodeChar(
1215   IN WCHAR SourceCharacter);
1216
1217 NTSYSAPI
1218 VOID
1219 NTAPI
1220 RtlSetBit(
1221   PRTL_BITMAP BitMapHeader,
1222   ULONG BitNumber);
1223
1224 NTSYSAPI
1225 BOOLEAN
1226 NTAPI
1227 RtlTestBit(
1228   IN PRTL_BITMAP BitMapHeader,
1229   IN ULONG BitNumber);
1230
1231 NTSYSAPI
1232 NTSTATUS
1233 NTAPI
1234 RtlHashUnicodeString(
1235   IN CONST UNICODE_STRING *String,
1236   IN BOOLEAN CaseInSensitive,
1237   IN ULONG HashAlgorithm,
1238   OUT PULONG HashValue);
1239
1240 $endif
1241
1242 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
1243
1244 #if (NTDDI_VERSION >= NTDDI_VISTA)
1245
1246 $if (_NTDDK_)
1247
1248 NTSYSAPI
1249 VOID
1250 NTAPI
1251 RtlRunOnceInitialize(
1252   OUT PRTL_RUN_ONCE RunOnce);
1253
1254 NTSYSAPI
1255 NTSTATUS
1256 NTAPI
1257 RtlRunOnceExecuteOnce(
1258   IN OUT PRTL_RUN_ONCE RunOnce,
1259   IN PRTL_RUN_ONCE_INIT_FN InitFn,
1260   IN OUT PVOID Parameter OPTIONAL,
1261   OUT PVOID *Context OPTIONAL);
1262
1263 NTSYSAPI
1264 NTSTATUS
1265 NTAPI
1266 RtlRunOnceBeginInitialize(
1267   IN OUT PRTL_RUN_ONCE RunOnce,
1268   IN ULONG Flags,
1269   OUT PVOID *Context OPTIONAL);
1270
1271 NTSYSAPI
1272 NTSTATUS
1273 NTAPI
1274 RtlRunOnceComplete(
1275   IN OUT PRTL_RUN_ONCE RunOnce,
1276   IN ULONG Flags,
1277   IN PVOID Context OPTIONAL);
1278
1279 NTSYSAPI
1280 BOOLEAN
1281 NTAPI
1282 RtlGetProductInfo(
1283   IN ULONG OSMajorVersion,
1284   IN ULONG OSMinorVersion,
1285   IN ULONG SpMajorVersion,
1286   IN ULONG SpMinorVersion,
1287   OUT PULONG ReturnedProductType);
1288
1289 $endif
1290
1291 $if (_WDMDDK_)
1292
1293 NTSYSAPI
1294 ULONG
1295 NTAPI
1296 RtlNumberOfSetBitsUlongPtr(
1297   IN ULONG_PTR Target);
1298
1299 NTSYSAPI
1300 ULONGLONG
1301 NTAPI
1302 RtlIoDecodeMemIoResource(
1303   IN struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
1304   OUT PULONGLONG Alignment OPTIONAL,
1305   OUT PULONGLONG MinimumAddress OPTIONAL,
1306   OUT PULONGLONG MaximumAddress OPTIONAL);
1307
1308 NTSYSAPI
1309 NTSTATUS
1310 NTAPI
1311 RtlIoEncodeMemIoResource(
1312   IN struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
1313   IN UCHAR Type,
1314   IN ULONGLONG Length,
1315   IN ULONGLONG Alignment,
1316   IN ULONGLONG MinimumAddress,
1317   IN ULONGLONG MaximumAddress);
1318
1319 NTSYSAPI
1320 ULONGLONG
1321 NTAPI
1322 RtlCmDecodeMemIoResource(
1323   IN struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
1324   OUT PULONGLONG Start OPTIONAL);
1325
1326 NTSYSAPI
1327 NTSTATUS
1328 NTAPI
1329 RtlFindClosestEncodableLength(
1330   IN ULONGLONG SourceLength,
1331   OUT PULONGLONG TargetLength);
1332
1333 NTSYSAPI
1334 NTSTATUS
1335 NTAPI
1336 RtlCmEncodeMemIoResource(
1337   IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
1338   IN UCHAR Type,
1339   IN ULONGLONG Length,
1340   IN ULONGLONG Start);
1341
1342 $endif
1343
1344 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
1345
1346 #if (NTDDI_VERSION >= NTDDI_WIN7)
1347
1348 $if (_NTDDK_)
1349
1350 NTSYSAPI
1351 BOOLEAN
1352 NTAPI
1353 RtlCreateHashTable(
1354   IN OUT PRTL_DYNAMIC_HASH_TABLE *HashTable OPTIONAL,
1355   IN ULONG Shift,
1356   IN ULONG Flags);
1357
1358 NTSYSAPI
1359 VOID
1360 NTAPI
1361 RtlDeleteHashTable(
1362   IN PRTL_DYNAMIC_HASH_TABLE HashTable);
1363
1364 NTSYSAPI
1365 BOOLEAN
1366 NTAPI
1367 RtlInsertEntryHashTable(
1368   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1369   IN PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
1370   IN ULONG_PTR Signature,
1371   IN OUT PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context OPTIONAL);
1372
1373 NTSYSAPI
1374 BOOLEAN
1375 NTAPI
1376 RtlRemoveEntryHashTable(
1377   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1378   IN PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
1379   IN OUT PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context OPTIONAL);
1380
1381 NTSYSAPI
1382 PRTL_DYNAMIC_HASH_TABLE_ENTRY
1383 NTAPI
1384 RtlLookupEntryHashTable(
1385   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1386   IN ULONG_PTR Signature,
1387   OUT PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context OPTIONAL);
1388
1389 NTSYSAPI
1390 PRTL_DYNAMIC_HASH_TABLE_ENTRY
1391 NTAPI
1392 RtlGetNextEntryHashTable(
1393   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1394   IN PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
1395
1396 NTSYSAPI
1397 BOOLEAN
1398 NTAPI
1399 RtlInitEnumerationHashTable(
1400   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1401   OUT PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
1402
1403 NTSYSAPI
1404 PRTL_DYNAMIC_HASH_TABLE_ENTRY
1405 NTAPI
1406 RtlEnumerateEntryHashTable(
1407   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1408   IN OUT PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
1409
1410 NTSYSAPI
1411 VOID
1412 NTAPI
1413 RtlEndEnumerationHashTable(
1414   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1415   IN OUT PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
1416
1417 NTSYSAPI
1418 BOOLEAN
1419 NTAPI
1420 RtlInitWeakEnumerationHashTable(
1421   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1422   OUT PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
1423
1424 NTSYSAPI
1425 PRTL_DYNAMIC_HASH_TABLE_ENTRY
1426 NTAPI
1427 RtlWeaklyEnumerateEntryHashTable(
1428   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1429   IN OUT PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
1430
1431 NTSYSAPI
1432 VOID
1433 NTAPI
1434 RtlEndWeakEnumerationHashTable(
1435   IN PRTL_DYNAMIC_HASH_TABLE HashTable,
1436   IN OUT PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
1437
1438 NTSYSAPI
1439 BOOLEAN
1440 NTAPI
1441 RtlExpandHashTable(
1442   IN PRTL_DYNAMIC_HASH_TABLE HashTable);
1443
1444 NTSYSAPI
1445 BOOLEAN
1446 NTAPI
1447 RtlContractHashTable(
1448   IN PRTL_DYNAMIC_HASH_TABLE HashTable);
1449
1450 $endif
1451
1452 $if (_WDMDDK_)
1453
1454 NTSYSAPI
1455 NTSTATUS
1456 NTAPI
1457 RtlUnicodeToUTF8N(
1458   OUT PCHAR UTF8StringDestination,
1459   IN ULONG UTF8StringMaxByteCount,
1460   OUT PULONG UTF8StringActualByteCount,
1461   IN PCWCH UnicodeStringSource,
1462   IN ULONG UnicodeStringByteCount);
1463
1464 NTSYSAPI
1465 NTSTATUS
1466 NTAPI
1467 RtlUTF8ToUnicodeN(
1468   OUT PWSTR UnicodeStringDestination,
1469   IN ULONG UnicodeStringMaxByteCount,
1470   OUT PULONG UnicodeStringActualByteCount,
1471   IN PCCH UTF8StringSource,
1472   IN ULONG UTF8StringByteCount);
1473
1474 NTSYSAPI
1475 ULONG64
1476 NTAPI
1477 RtlGetEnabledExtendedFeatures(
1478   IN ULONG64 FeatureMask);
1479
1480 $endif
1481
1482 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
1483
1484 $if (_WDMDDK_)
1485
1486 #if !defined(MIDL_PASS)
1487 /* inline funftions */
1488 //DECLSPEC_DEPRECATED_DDK_WINXP
1489 static __inline
1490 LARGE_INTEGER
1491 NTAPI_INLINE
1492 RtlConvertLongToLargeInteger(
1493   IN LONG SignedInteger)
1494 {
1495   LARGE_INTEGER ret;
1496   ret.QuadPart = SignedInteger;
1497   return ret;
1498 }
1499
1500 //DECLSPEC_DEPRECATED_DDK_WINXP
1501 static __inline
1502 LARGE_INTEGER
1503 NTAPI_INLINE
1504 RtlConvertUlongToLargeInteger(
1505   IN ULONG UnsignedInteger)
1506 {
1507   LARGE_INTEGER ret;
1508   ret.QuadPart = UnsignedInteger;
1509   return ret;
1510 }
1511
1512 //DECLSPEC_DEPRECATED_DDK_WINXP
1513 static __inline
1514 LARGE_INTEGER
1515 NTAPI_INLINE
1516 RtlLargeIntegerShiftLeft(
1517   IN LARGE_INTEGER LargeInteger,
1518   IN CCHAR ShiftCount)
1519 {
1520   LARGE_INTEGER Result;
1521
1522   Result.QuadPart = LargeInteger.QuadPart << ShiftCount;
1523   return Result;
1524 }
1525
1526 //DECLSPEC_DEPRECATED_DDK_WINXP
1527 static __inline
1528 LARGE_INTEGER
1529 NTAPI_INLINE
1530 RtlLargeIntegerShiftRight(
1531   IN LARGE_INTEGER LargeInteger,
1532   IN CCHAR ShiftCount)
1533 {
1534   LARGE_INTEGER Result;
1535
1536   Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount;
1537   return Result;
1538 }
1539
1540 //DECLSPEC_DEPRECATED_DDK
1541 static __inline
1542 ULONG
1543 NTAPI_INLINE
1544 RtlEnlargedUnsignedDivide(
1545   IN ULARGE_INTEGER Dividend,
1546   IN ULONG Divisor,
1547   IN OUT PULONG Remainder)
1548 {
1549   if (Remainder)
1550     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
1551   return (ULONG)(Dividend.QuadPart / Divisor);
1552 }
1553
1554 //DECLSPEC_DEPRECATED_DDK
1555 static __inline
1556 LARGE_INTEGER
1557 NTAPI_INLINE
1558 RtlLargeIntegerNegate(
1559   IN LARGE_INTEGER Subtrahend)
1560 {
1561   LARGE_INTEGER Difference;
1562
1563   Difference.QuadPart = -Subtrahend.QuadPart;
1564   return Difference;
1565 }
1566
1567 //DECLSPEC_DEPRECATED_DDK
1568 static __inline
1569 LARGE_INTEGER
1570 NTAPI_INLINE
1571 RtlLargeIntegerSubtract(
1572   IN LARGE_INTEGER Minuend,
1573   IN LARGE_INTEGER Subtrahend)
1574 {
1575   LARGE_INTEGER Difference;
1576
1577   Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
1578   return Difference;
1579 }
1580
1581 //DECLSPEC_DEPRECATED_DDK
1582 static __inline
1583 LARGE_INTEGER
1584 NTAPI_INLINE
1585 RtlEnlargedUnsignedMultiply(
1586   IN ULONG Multiplicand,
1587   IN ULONG Multiplier)
1588 {
1589   LARGE_INTEGER ret;
1590   ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
1591   return ret;
1592 }
1593
1594 //DECLSPEC_DEPRECATED_DDK
1595 static __inline
1596 LARGE_INTEGER
1597 NTAPI_INLINE
1598 RtlEnlargedIntegerMultiply(
1599   IN LONG Multiplicand,
1600   IN LONG Multiplier)
1601 {
1602   LARGE_INTEGER ret;
1603   ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
1604   return ret;
1605 }
1606
1607 FORCEINLINE
1608 VOID
1609 RtlInitEmptyAnsiString(
1610   OUT PANSI_STRING AnsiString,
1611   IN PCHAR Buffer,
1612   IN USHORT BufferSize)
1613 {
1614   AnsiString->Length = 0;
1615   AnsiString->MaximumLength = BufferSize;
1616   AnsiString->Buffer = Buffer;
1617 }
1618
1619 FORCEINLINE
1620 VOID
1621 RtlInitEmptyUnicodeString(
1622   OUT PUNICODE_STRING UnicodeString,
1623   IN PWSTR Buffer,
1624   IN USHORT BufferSize)
1625 {
1626   UnicodeString->Length = 0;
1627   UnicodeString->MaximumLength = BufferSize;
1628   UnicodeString->Buffer = Buffer;
1629 }
1630 $endif
1631
1632 #if defined(_AMD64_) || defined(_IA64_)
1633
1634 $if (_WDMDDK_)
1635
1636 static __inline
1637 LARGE_INTEGER
1638 NTAPI_INLINE
1639 RtlExtendedIntegerMultiply(
1640   IN LARGE_INTEGER Multiplicand,
1641   IN LONG Multiplier)
1642 {
1643   LARGE_INTEGER ret;
1644   ret.QuadPart = Multiplicand.QuadPart * Multiplier;
1645   return ret;
1646 }
1647
1648 static __inline
1649 LARGE_INTEGER
1650 NTAPI_INLINE
1651 RtlExtendedLargeIntegerDivide(
1652   IN LARGE_INTEGER Dividend,
1653   IN ULONG Divisor,
1654   OUT PULONG Remainder OPTIONAL)
1655 {
1656   LARGE_INTEGER ret;
1657   ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
1658   if (Remainder)
1659     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
1660   return ret;
1661 }
1662
1663 $endif
1664
1665 $if (_NTDDK_)
1666
1667 //DECLSPEC_DEPRECATED_DDK_WINXP
1668 FORCEINLINE
1669 LARGE_INTEGER
1670 NTAPI_INLINE
1671 RtlLargeIntegerDivide(
1672   IN LARGE_INTEGER Dividend,
1673   IN LARGE_INTEGER Divisor,
1674   OUT PLARGE_INTEGER Remainder OPTIONAL)
1675 {
1676   LARGE_INTEGER ret;
1677   ret.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
1678   if (Remainder)
1679     Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
1680   return ret;
1681 }
1682
1683 #else
1684
1685 #if (NTDDI_VERSION >= NTDDI_WIN2K)
1686 NTSYSAPI
1687 LARGE_INTEGER
1688 NTAPI
1689 RtlLargeIntegerDivide(
1690   IN LARGE_INTEGER Dividend,
1691   IN LARGE_INTEGER Divisor,
1692   OUT PLARGE_INTEGER Remainder OPTIONAL);
1693 #endif
1694
1695 $endif
1696
1697 #endif /* defined(_AMD64_) || defined(_IA64_) */
1698
1699 $if (_WDMDDK_)
1700
1701 #if defined(_AMD64_)
1702
1703 #define MultiplyHigh __mulh
1704 #define UnsignedMultiplyHigh __umulh
1705
1706 //DECLSPEC_DEPRECATED_DDK
1707 static __inline
1708 LARGE_INTEGER
1709 NTAPI_INLINE
1710 RtlExtendedMagicDivide(
1711   IN LARGE_INTEGER Dividend,
1712   IN LARGE_INTEGER MagicDivisor,
1713   IN CCHAR ShiftCount)
1714 {
1715   LARGE_INTEGER ret;
1716   ULONG64 ret64;
1717   BOOLEAN Pos;
1718   Pos = (Dividend.QuadPart >= 0);
1719   ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
1720                                MagicDivisor.QuadPart);
1721   ret64 >>= ShiftCount;
1722   ret.QuadPart = Pos ? ret64 : -ret64;
1723   return ret;
1724 }
1725 #endif
1726
1727 //DECLSPEC_DEPRECATED_DDK
1728 static __inline
1729 LARGE_INTEGER
1730 NTAPI_INLINE
1731 RtlLargeIntegerAdd(
1732   IN LARGE_INTEGER Addend1,
1733   IN LARGE_INTEGER Addend2)
1734 {
1735   LARGE_INTEGER ret;
1736   ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
1737   return ret;
1738 }
1739
1740 /* VOID
1741  * RtlLargeIntegerAnd(
1742  *     IN OUT LARGE_INTEGER Result,
1743  *     IN LARGE_INTEGER Source,
1744  *     IN LARGE_INTEGER Mask);
1745  */
1746 #define RtlLargeIntegerAnd(Result, Source, Mask) \
1747     Result.QuadPart = Source.QuadPart & Mask.QuadPart
1748
1749 //DECLSPEC_DEPRECATED_DDK
1750 static __inline
1751 LARGE_INTEGER
1752 NTAPI_INLINE
1753 RtlLargeIntegerArithmeticShift(
1754   IN LARGE_INTEGER LargeInteger,
1755   IN CCHAR ShiftCount)
1756 {
1757   LARGE_INTEGER ret;
1758   ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
1759   return ret;
1760 }
1761
1762 /* BOOLEAN
1763  * RtlLargeIntegerEqualTo(
1764  *     IN LARGE_INTEGER  Operand1,
1765  *     IN LARGE_INTEGER  Operand2);
1766  */
1767 #define RtlLargeIntegerEqualTo(X,Y) \
1768     (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1769
1770 FORCEINLINE
1771 PVOID
1772 RtlSecureZeroMemory(
1773   OUT PVOID Pointer,
1774   IN SIZE_T Size)
1775 {
1776   volatile char* vptr = (volatile char*)Pointer;
1777 #if defined(_M_AMD64)
1778   __stosb((PUCHAR)vptr, 0, Size);
1779 #else
1780   char * endptr = (char *)vptr + Size;
1781   while (vptr < endptr) {
1782     *vptr = 0; vptr++;
1783   }
1784 #endif
1785    return Pointer;
1786 }
1787
1788 #if defined(_M_AMD64)
1789 FORCEINLINE
1790 BOOLEAN
1791 RtlCheckBit(
1792   IN PRTL_BITMAP BitMapHeader,
1793   IN ULONG BitPosition)
1794 {
1795   return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
1796 }
1797 #else
1798 #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
1799 #endif /* defined(_M_AMD64) */
1800
1801 #define RtlLargeIntegerGreaterThan(X,Y) (                              \
1802     (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
1803     ((X).HighPart > (Y).HighPart)                                      \
1804 )
1805
1806 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) (                      \
1807     (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
1808     ((X).HighPart > (Y).HighPart)                                       \
1809 )
1810
1811 #define RtlLargeIntegerNotEqualTo(X,Y) (                          \
1812     (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
1813 )
1814
1815 #define RtlLargeIntegerLessThan(X,Y) (                                 \
1816     (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
1817     ((X).HighPart < (Y).HighPart)                                      \
1818 )
1819
1820 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) (                         \
1821     (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
1822     ((X).HighPart < (Y).HighPart)                                       \
1823 )
1824
1825 #define RtlLargeIntegerGreaterThanZero(X) (       \
1826     (((X).HighPart == 0) && ((X).LowPart > 0)) || \
1827     ((X).HighPart > 0 )                           \
1828 )
1829
1830 #define RtlLargeIntegerGreaterOrEqualToZero(X) ( (X).HighPart >= 0 )
1831
1832 #define RtlLargeIntegerEqualToZero(X) ( !((X).LowPart | (X).HighPart) )
1833
1834 #define RtlLargeIntegerNotEqualToZero(X) ( ((X).LowPart | (X).HighPart) )
1835
1836 #define RtlLargeIntegerLessThanZero(X) ( ((X).HighPart < 0) )
1837
1838 #define RtlLargeIntegerLessOrEqualToZero(X) ( ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) )
1839
1840 #endif /* !defined(MIDL_PASS) */
1841
1842 /* Byte Swap Functions */
1843 #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
1844     ((defined(_M_AMD64) || defined(_M_IA64)) \
1845         && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
1846
1847 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
1848 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
1849 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
1850
1851 #endif
1852
1853 #if DBG
1854
1855 #define ASSERT(exp) \
1856   (VOID)((!(exp)) ? \
1857     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
1858
1859 #define ASSERTMSG(msg, exp) \
1860   (VOID)((!(exp)) ? \
1861     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, msg ), FALSE : TRUE)
1862
1863 #define RTL_SOFT_ASSERT(exp) \
1864   (VOID)((!(exp)) ? \
1865     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
1866
1867 #define RTL_SOFT_ASSERTMSG(msg, exp) \
1868   (VOID)((!(exp)) ? \
1869     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n   Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
1870
1871 #define RTL_VERIFY(exp) ASSERT(exp)
1872 #define RTL_VERIFYMSG(msg, exp) ASSERTMSG(msg, exp)
1873
1874 #define RTL_SOFT_VERIFY(exp) RTL_SOFT_ASSERT(exp)
1875 #define RTL_SOFT_VERIFYMSG(msg, exp) RTL_SOFT_ASSERTMSG(msg, exp)
1876
1877 #if defined(_MSC_VER)
1878
1879 #define NT_ASSERT(exp) \
1880    ((!(exp)) ? \
1881       (__annotation(L"Debug", L"AssertFail", L#exp), \
1882        DbgRaiseAssertionFailure(), FALSE) : TRUE)
1883
1884 #define NT_ASSERTMSG(msg, exp) \
1885    ((!(exp)) ? \
1886       (__annotation(L"Debug", L"AssertFail", L##msg), \
1887       DbgRaiseAssertionFailure(), FALSE) : TRUE)
1888
1889 #define NT_ASSERTMSGW(msg, exp) \
1890     ((!(exp)) ? \
1891         (__annotation(L"Debug", L"AssertFail", msg), \
1892          DbgRaiseAssertionFailure(), FALSE) : TRUE)
1893
1894 #define NT_VERIFY     NT_ASSERT
1895 #define NT_VERIFYMSG  NT_ASSERTMSG
1896 #define NT_VERIFYMSGW NT_ASSERTMSGW
1897
1898 #else
1899
1900 /* GCC doesn't support __annotation (nor PDB) */
1901 #define NT_ASSERT(exp) \
1902    (VOID)((!(exp)) ? (DbgRaiseAssertionFailure(), FALSE) : TRUE)
1903
1904 #define NT_ASSERTMSG NT_ASSERT
1905 #define NT_ASSERTMSGW NT_ASSERT
1906
1907 #endif
1908
1909 #else /* !DBG */
1910
1911 #define ASSERT(exp) ((VOID) 0)
1912 #define ASSERTMSG(msg, exp) ((VOID) 0)
1913
1914 #define RTL_SOFT_ASSERT(exp) ((VOID) 0)
1915 #define RTL_SOFT_ASSERTMSG(msg, exp) ((VOID) 0)
1916
1917 #define RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)
1918 #define RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
1919
1920 #define RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)
1921 #define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
1922
1923 #define NT_ASSERT(exp)          ((VOID)0)
1924 #define NT_ASSERTMSG(msg, exp)  ((VOID)0)
1925 #define NT_ASSERTMSGW(msg, exp) ((VOID)0)
1926
1927 #define NT_VERIFY(_exp)           ((_exp) ? TRUE : FALSE)
1928 #define NT_VERIFYMSG(_msg, _exp ) ((_exp) ? TRUE : FALSE)
1929 #define NT_VERIFYMSGW(_msg, _exp) ((_exp) ? TRUE : FALSE)
1930
1931 #endif /* DBG */
1932
1933 #define InitializeListHead32(ListHead) (\
1934     (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))
1935
1936 #if !defined(_WINBASE_)
1937
1938 #if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_))
1939
1940 NTKERNELAPI
1941 VOID
1942 InitializeSListHead(
1943   OUT PSLIST_HEADER SListHead);
1944
1945 #else
1946
1947 VOID
1948 FORCEINLINE
1949 InitializeSListHead(
1950   OUT PSLIST_HEADER SListHead)
1951 {
1952 #if defined(_IA64_)
1953   ULONG64 FeatureBits;
1954 #endif
1955
1956 #if defined(_WIN64)
1957   if (((ULONG_PTR)SListHead & 0xf) != 0) {
1958     RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
1959   }
1960 #endif
1961   RtlZeroMemory(SListHead, sizeof(SLIST_HEADER));
1962 #if defined(_IA64_)
1963   FeatureBits = __getReg(CV_IA64_CPUID4);
1964   if ((FeatureBits & KF_16BYTE_INSTR) != 0) {
1965     SListHead->Header16.HeaderType = 1;
1966     SListHead->Header16.Init = 1;
1967   }
1968 #endif
1969 }
1970
1971 #endif
1972
1973 #if defined(_WIN64)
1974
1975 #define InterlockedPopEntrySList(Head) \
1976     ExpInterlockedPopEntrySList(Head)
1977
1978 #define InterlockedPushEntrySList(Head, Entry) \
1979     ExpInterlockedPushEntrySList(Head, Entry)
1980
1981 #define InterlockedFlushSList(Head) \
1982     ExpInterlockedFlushSList(Head)
1983
1984 #define QueryDepthSList(Head) \
1985     ExQueryDepthSList(Head)
1986
1987 #else /* !defined(_WIN64) */
1988
1989 NTKERNELAPI
1990 PSLIST_ENTRY
1991 FASTCALL
1992 InterlockedPopEntrySList(
1993   IN PSLIST_HEADER ListHead);
1994
1995 NTKERNELAPI
1996 PSLIST_ENTRY
1997 FASTCALL
1998 InterlockedPushEntrySList(
1999   IN PSLIST_HEADER ListHead,
2000   IN PSLIST_ENTRY ListEntry);
2001
2002 #define InterlockedFlushSList(ListHead) \
2003     ExInterlockedFlushSList(ListHead)
2004
2005 #define QueryDepthSList(Head) \
2006     ExQueryDepthSList(Head)
2007
2008 #endif /* !defined(_WIN64) */
2009
2010 #endif /* !defined(_WINBASE_) */
2011
2012 #define RTL_CONTEXT_EX_OFFSET(ContextEx, Chunk) ((ContextEx)->Chunk.Offset)
2013 #define RTL_CONTEXT_EX_LENGTH(ContextEx, Chunk) ((ContextEx)->Chunk.Length)
2014 #define RTL_CONTEXT_EX_CHUNK(Base, Layout, Chunk)       \
2015     ((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk)))
2016 #define RTL_CONTEXT_OFFSET(Context, Chunk)              \
2017     RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk)
2018 #define RTL_CONTEXT_LENGTH(Context, Chunk)              \
2019     RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk)
2020 #define RTL_CONTEXT_CHUNK(Context, Chunk)               \
2021     RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1),    \
2022                          (PCONTEXT_EX)(Context + 1),    \
2023                          Chunk)
2024
2025 BOOLEAN
2026 RTLVERLIB_DDI(RtlIsNtDdiVersionAvailable)(
2027   IN ULONG Version);
2028
2029 BOOLEAN
2030 RTLVERLIB_DDI(RtlIsServicePackVersionInstalled)(
2031   IN ULONG Version);
2032
2033 #ifndef RtlIsNtDdiVersionAvailable
2034 #define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable
2035 #endif
2036
2037 #ifndef RtlIsServicePackVersionInstalled
2038 #define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled
2039 #endif
2040
2041 #define RtlInterlockedSetBits(Flags, Flag) \
2042     InterlockedOr((PLONG)(Flags), Flag)
2043
2044 #define RtlInterlockedAndBits(Flags, Flag) \
2045     InterlockedAnd((PLONG)(Flags), Flag)
2046
2047 #define RtlInterlockedClearBits(Flags, Flag) \
2048     RtlInterlockedAndBits(Flags, ~(Flag))
2049
2050 #define RtlInterlockedXorBits(Flags, Flag) \
2051     InterlockedXor(Flags, Flag)
2052
2053 #define RtlInterlockedSetBitsDiscardReturn(Flags, Flag) \
2054     (VOID) RtlInterlockedSetBits(Flags, Flag)
2055
2056 #define RtlInterlockedAndBitsDiscardReturn(Flags, Flag) \
2057     (VOID) RtlInterlockedAndBits(Flags, Flag)
2058
2059 #define RtlInterlockedClearBitsDiscardReturn(Flags, Flag) \
2060     RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))
2061
2062 $endif
2063
2064 $if (_NTDDK_)
2065
2066 #ifdef RTL_USE_AVL_TABLES
2067
2068 #define RtlInitializeGenericTable               RtlInitializeGenericTableAvl
2069 #define RtlInsertElementGenericTable            RtlInsertElementGenericTableAvl
2070 #define RtlInsertElementGenericTableFull        RtlInsertElementGenericTableFullAvl
2071 #define RtlDeleteElementGenericTable            RtlDeleteElementGenericTableAvl
2072 #define RtlLookupElementGenericTable            RtlLookupElementGenericTableAvl
2073 #define RtlLookupElementGenericTableFull        RtlLookupElementGenericTableFullAvl
2074 #define RtlEnumerateGenericTable                RtlEnumerateGenericTableAvl
2075 #define RtlEnumerateGenericTableWithoutSplaying RtlEnumerateGenericTableWithoutSplayingAvl
2076 #define RtlGetElementGenericTable               RtlGetElementGenericTableAvl
2077 #define RtlNumberGenericTableElements           RtlNumberGenericTableElementsAvl
2078 #define RtlIsGenericTableEmpty                  RtlIsGenericTableEmptyAvl
2079
2080 #endif /* RTL_USE_AVL_TABLES */
2081
2082 #define RtlInitializeSplayLinks(Links) {    \
2083   PRTL_SPLAY_LINKS _SplayLinks;            \
2084   _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \
2085   _SplayLinks->Parent = _SplayLinks;   \
2086   _SplayLinks->LeftChild = NULL;       \
2087   _SplayLinks->RightChild = NULL;      \
2088 }
2089
2090 #define RtlIsLeftChild(Links) \
2091     (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
2092
2093 #define RtlIsRightChild(Links) \
2094     (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
2095
2096 #define RtlRightChild(Links) \
2097     ((PRTL_SPLAY_LINKS)(Links))->RightChild
2098
2099 #define RtlIsRoot(Links) \
2100     (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))
2101
2102 #define RtlLeftChild(Links) \
2103     ((PRTL_SPLAY_LINKS)(Links))->LeftChild
2104
2105 #define RtlParent(Links) \
2106     ((PRTL_SPLAY_LINKS)(Links))->Parent
2107
2108 #define RtlInsertAsLeftChild(ParentLinks,ChildLinks)    \
2109     {                                                   \
2110         PRTL_SPLAY_LINKS _SplayParent;                  \
2111         PRTL_SPLAY_LINKS _SplayChild;                   \
2112         _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
2113         _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
2114         _SplayParent->LeftChild = _SplayChild;          \
2115         _SplayChild->Parent = _SplayParent;             \
2116     }
2117
2118 #define RtlInsertAsRightChild(ParentLinks,ChildLinks)   \
2119     {                                                   \
2120         PRTL_SPLAY_LINKS _SplayParent;                  \
2121         PRTL_SPLAY_LINKS _SplayChild;                   \
2122         _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
2123         _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
2124         _SplayParent->RightChild = _SplayChild;         \
2125         _SplayChild->Parent = _SplayParent;             \
2126     }
2127
2128 #if !defined(MIDL_PASS)
2129
2130 FORCEINLINE
2131 LUID
2132 NTAPI_INLINE
2133 RtlConvertLongToLuid(
2134   IN LONG Val)
2135 {
2136   LUID Luid;
2137   LARGE_INTEGER Temp;
2138
2139   Temp.QuadPart = Val;
2140   Luid.LowPart = Temp.u.LowPart;
2141   Luid.HighPart = Temp.u.HighPart;
2142   return Luid;
2143 }
2144
2145 FORCEINLINE
2146 LUID
2147 NTAPI_INLINE
2148 RtlConvertUlongToLuid(
2149   IN ULONG Val)
2150 {
2151   LUID Luid;
2152
2153   Luid.LowPart = Val;
2154   Luid.HighPart = 0;
2155   return Luid;
2156 }
2157
2158 #endif /* !defined(MIDL_PASS) */
2159
2160 #if (defined(_M_AMD64) || defined(_M_IA64)) && !defined(_REALLY_GET_CALLERS_CALLER_)
2161 #define RtlGetCallersAddress(CallersAddress, CallersCaller) \
2162     *CallersAddress = (PVOID)_ReturnAddress(); \
2163     *CallersCaller = NULL;
2164 #else
2165 #if (NTDDI_VERSION >= NTDDI_WIN2K)
2166 NTSYSAPI
2167 VOID
2168 NTAPI
2169 RtlGetCallersAddress(
2170   OUT PVOID *CallersAddress,
2171   OUT PVOID *CallersCaller);
2172 #endif
2173 #endif
2174
2175 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
2176
2177 #if (NTDDI_VERSION >= NTDDI_WIN7)
2178
2179 FORCEINLINE
2180 VOID
2181 NTAPI
2182 RtlInitHashTableContext(
2183   IN OUT PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
2184 {
2185   Context->ChainHead = NULL;
2186   Context->PrevLinkage = NULL;
2187 }
2188
2189 FORCEINLINE
2190 VOID
2191 NTAPI
2192 RtlInitHashTableContextFromEnumerator(
2193   IN OUT PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context,
2194   IN PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)
2195 {
2196   Context->ChainHead = Enumerator->ChainHead;
2197   Context->PrevLinkage = Enumerator->HashEntry.Linkage.Blink;
2198 }
2199
2200 FORCEINLINE
2201 VOID
2202 NTAPI
2203 RtlReleaseHashTableContext(
2204   IN OUT PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
2205 {
2206   UNREFERENCED_PARAMETER(Context);
2207   return;
2208 }
2209
2210 FORCEINLINE
2211 ULONG
2212 NTAPI
2213 RtlTotalBucketsHashTable(
2214   IN PRTL_DYNAMIC_HASH_TABLE HashTable)
2215 {
2216   return HashTable->TableSize;
2217 }
2218
2219 FORCEINLINE
2220 ULONG
2221 NTAPI
2222 RtlNonEmptyBucketsHashTable(
2223   IN PRTL_DYNAMIC_HASH_TABLE HashTable)
2224 {
2225   return HashTable->NonEmptyBuckets;
2226 }
2227
2228 FORCEINLINE
2229 ULONG
2230 NTAPI
2231 RtlEmptyBucketsHashTable(
2232   IN PRTL_DYNAMIC_HASH_TABLE HashTable)
2233 {
2234   return HashTable->TableSize - HashTable->NonEmptyBuckets;
2235 }
2236
2237 FORCEINLINE
2238 ULONG
2239 NTAPI
2240 RtlTotalEntriesHashTable(
2241   IN PRTL_DYNAMIC_HASH_TABLE HashTable)
2242 {
2243   return HashTable->NumEntries;
2244 }
2245
2246 FORCEINLINE
2247 ULONG
2248 NTAPI
2249 RtlActiveEnumeratorsHashTable(
2250   IN PRTL_DYNAMIC_HASH_TABLE HashTable)
2251 {
2252   return HashTable->NumEnumerators;
2253 }
2254
2255 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
2256
2257 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
2258
2259 $endif