reactos/include/ddk/rtl.h

   1 /* $Id: rtl.h,v 1.55 2001/07/04 20:40:18 chorns Exp $
   2  *
   3  */
   4
   5 #ifndef __DDK_RTL_H
   6 #define __DDK_RTL_H
   7
   8 #if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__) || defined(__NTDLL__) || defined (__NTAPP__)
   9
  10 #include <stddef.h>
  11 #include <stdarg.h>
  12
  13 #endif /* __NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ || __NTDLL__ || __NTAPP__ */
  14
  15 #include <pe.h>
  16
  17 typedef struct _INITIAL_TEB
  18 {
  19         PVOID StackBase;
  20         PVOID StackLimit;
  21         PVOID StackCommit;
  22         PVOID StackCommitMax;
  23         PVOID StackReserve;
  24 } INITIAL_TEB, *PINITIAL_TEB;
  25
  26 typedef struct _CONTROLLER_OBJECT
  27 {
  28    CSHORT Type;
  29    CSHORT Size;
  30    PVOID ControllerExtension;
  31    KDEVICE_QUEUE DeviceWaitQueue;
  32    ULONG Spare1;
  33    LARGE_INTEGER Spare2;
  34 } CONTROLLER_OBJECT, *PCONTROLLER_OBJECT;
  35
  36 typedef struct _STRING
  37 {
  38    /*
  39     * Length in bytes of the string stored in buffer
  40     */
  41    USHORT Length;
  42
  43    /*
  44     * Maximum length of the string
  45     */
  46    USHORT MaximumLength;
  47
  48    /*
  49     * String
  50     */
  51    PCHAR Buffer;
  52 } STRING, *PSTRING;
  53
  54 typedef STRING ANSI_STRING;
  55 typedef PSTRING PANSI_STRING;
  56
  57 typedef STRING OEM_STRING;
  58 typedef PSTRING POEM_STRING;
  59
  60
  61 typedef struct _TIME_FIELDS
  62 {
  63    CSHORT Year;
  64    CSHORT Month;
  65    CSHORT Day;
  66    CSHORT Hour;
  67    CSHORT Minute;
  68    CSHORT Second;
  69    CSHORT Milliseconds;
  70    CSHORT Weekday;
  71 } TIME_FIELDS, *PTIME_FIELDS;
  72
  73 typedef struct _RTL_BITMAP
  74 {
  75    ULONG  SizeOfBitMap;
  76    PULONG Buffer;
  77 } RTL_BITMAP, *PRTL_BITMAP;
  78
  79 typedef struct {
  80         ULONG           Length;
  81         ULONG           Unknown[11];
  82 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
  83
  84 typedef struct _RTL_ATOM_TABLE
  85 {
  86         ULONG TableSize;
  87         ULONG NumberOfAtoms;
  88         PVOID Lock;             /* fast mutex (kernel mode)/ critical section (user mode) */
  89         PVOID HandleTable;
  90         LIST_ENTRY Slot[0];
  91 } RTL_ATOM_TABLE, *PRTL_ATOM_TABLE;
  92
  93 struct _LB_RANGE
  94 {
  95         ULONG dummy;
  96 };
  97
  98 typedef struct _RTL_NLS_DATA
  99 {
 100         USHORT                  CodePage;
 101         USHORT                  MaxCharacterSize;  // SBCS = 1, DBCS = 2
 102         WCHAR                   DefaultCharacter;
 103         WCHAR                   char1;
 104         WCHAR                   char2;
 105         WCHAR                   char3;
 106         USHORT                  DbcsFlag;
 107         struct _LB_RANGE        LeadByteRange[6];
 108         USHORT                  reserved;
 109         PWCHAR                  MultiByteToUnicode;
 110         PCHAR                   UnicodeToMultiByte;
 111         ULONG                   unknown;
 112         PCHAR                   DbcsTags;
 113 } RTL_NLS_DATA, *PRTL_NLS_DATA;
 114
 115
 116 typedef struct _RTL_GENERIC_TABLE
 117 {
 118    PVOID RootElement;
 119    ULONG Unknown2;
 120    ULONG Unknown3;
 121    ULONG Unknown4;
 122    ULONG Unknown5;
 123    ULONG ElementCount;
 124    PVOID CompareRoutine;
 125    PVOID AllocateRoutine;
 126    PVOID FreeRoutine;
 127    ULONG UserParameter;
 128 } RTL_GENERIC_TABLE, *PRTL_GENERIC_TABLE;
 129
 130
 131 typedef struct _RTL_MESSAGE_RESOURCE_ENTRY
 132 {
 133    USHORT Length;
 134    USHORT Flags;
 135    UCHAR Text[1];
 136 } RTL_MESSAGE_RESOURCE_ENTRY, *PRTL_MESSAGE_RESOURCE_ENTRY;
 137
 138 typedef struct _RTL_MESSAGE_RESOURCE_BLOCK
 139 {
 140    ULONG LowId;
 141    ULONG HighId;
 142    ULONG OffsetToEntries;
 143 } RTL_MESSAGE_RESOURCE_BLOCK, *PRTL_MESSAGE_RESOURCE_BLOCK;
 144
 145 typedef struct _RTL_MESSAGE_RESOURCE_DATA
 146 {
 147    ULONG NumberOfBlocks;
 148    RTL_MESSAGE_RESOURCE_BLOCK Blocks[1];
 149 } RTL_MESSAGE_RESOURCE_DATA, *PRTL_MESSAGE_RESOURCE_DATA;
 150
 151
 152 /*
 153  * PURPOSE: Flags for RtlQueryRegistryValues
 154  */
 155 #define RTL_QUERY_REGISTRY_SUBKEY       (0x00000001)
 156 #define RTL_QUERY_REGISTRY_TOPKEY       (0x00000002)
 157 #define RTL_QUERY_REGISTRY_REQUIRED     (0x00000004)
 158 #define RTL_QUERY_REGISTRY_NOVALUE      (0x00000008)
 159 #define RTL_QUERY_REGISTRY_NOEXPAND     (0x00000010)
 160 #define RTL_QUERY_REGISTRY_DIRECT       (0x00000020)
 161 #define RTL_QUERY_REGISTRY_DELETE       (0x00000040)
 162
 163
 164 typedef NTSTATUS (*PRTL_QUERY_REGISTRY_ROUTINE)(PWSTR ValueName,
 165                                                 ULONG ValueType,
 166                                                 PVOID ValueData,
 167                                                 ULONG ValueLength,
 168                                                 PVOID Context,
 169                                                 PVOID EntryContext);
 170
 171 typedef struct _RTL_QUERY_REGISTRY_TABLE
 172 {
 173    PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine;
 174    ULONG Flags;
 175    PWSTR Name;
 176    PVOID EntryContext;
 177    ULONG DefaultType;
 178    PVOID DefaultData;
 179    ULONG DefaultLength;
 180 } RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;
 181
 182 /*
 183  * PURPOSE: Used with RtlCheckRegistryKey, RtlCreateRegistryKey,
 184  * RtlDeleteRegistryKey
 185  */
 186 #define RTL_REGISTRY_ABSOLUTE   0
 187 #define RTL_REGISTRY_SERVICES   1
 188 #define RTL_REGISTRY_CONTROL    2
 189 #define RTL_REGISTRY_WINDOWS_NT 3
 190 #define RTL_REGISTRY_DEVICEMAP  4
 191 #define RTL_REGISTRY_USER       5
 192 #define RTL_REGISTRY_MAXIMUM    6
 193
 194 #define RTL_REGISTRY_HANDLE     0x40000000
 195 #define RTL_REGISTRY_OPTIONAL   0x80000000
 196
 197
 198 #define SHORT_SIZE      (sizeof(USHORT))
 199 #define SHORT_MASK      (SHORT_SIZE-1)
 200 #define LONG_SIZE       (sizeof(ULONG))
 201 #define LONG_MASK       (LONG_SIZE-1)
 202 #define LOWBYTE_MASK    0x00FF
 203
 204 #define FIRSTBYTE(Value)        ((Value) & LOWBYTE_MASK)
 205 #define SECONDBYTE(Value)       (((Value) >> 8) & LOWBYTE_MASK)
 206 #define THIRDBYTE(Value)        (((Value) >> 16) & LOWBYTE_MASK)
 207 #define FOURTHBYTE(Value)       (((Value) >> 24) & LOWBYTE_MASK)
 208
 209 /* FIXME: reverse byte-order on big-endian machines (e.g. MIPS) */
 210 #define SHORT_LEAST_SIGNIFICANT_BIT     0
 211 #define SHORT_MOST_SIGNIFICANT_BIT      1
 212
 213 #define LONG_LEAST_SIGNIFICANT_BIT      0
 214 #define LONG_3RD_MOST_SIGNIFICANT_BIT   1
 215 #define LONG_2RD_MOST_SIGNIFICANT_BIT   2
 216 #define LONG_MOST_SIGNIFICANT_BIT       3
 217
 218
 219
 220 #if defined(__NTOSKRNL__) || defined(__NTDLL__)
 221 #define NLS_MB_CODE_PAGE_TAG     NlsMbCodePageTag
 222 #define NLS_MB_OEM_CODE_PAGE_TAG NlsMbOemCodePageTag
 223 #else
 224 #define NLS_MB_CODE_PAGE_TAG     (*NlsMbCodePageTag)
 225 #define NLS_MB_OEM_CODE_PAGE_TAG (*NlsMbOemCodePageTag)
 226 #endif /* __NTOSKRNL__ || __NTDLL__ */
 227
 228 extern BOOLEAN NLS_MB_CODE_PAGE_TAG;
 229 extern BOOLEAN NLS_MB_OEM_CODE_PAGE_TAG;
 230
 231
 232 /*
 233  * VOID
 234  * InitializeObjectAttributes (
 235  *      POBJECT_ATTRIBUTES      InitializedAttributes,
 236  *      PUNICODE_STRING         ObjectName,
 237  *      ULONG                   Attributes,
 238  *      HANDLE                  RootDirectory,
 239  *      PSECURITY_DESCRIPTOR    SecurityDescriptor
 240  *      );
 241  *
 242  * FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a
 243  * subsequent call to ZwCreateXXX or ZwOpenXXX
 244  * ARGUMENTS:
 245  *        InitializedAttributes (OUT) = Caller supplied storage for the
 246  *                                      object attributes
 247  *        ObjectName = Full path name for object
 248  *        Attributes = Attributes for the object
 249  *        RootDirectory = Where the object should be placed or NULL
 250  *        SecurityDescriptor = Ignored
 251  */
 252 #define InitializeObjectAttributes(p,n,a,r,s) \
 253 { \
 254         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
 255         (p)->ObjectName = n; \
 256         (p)->Attributes = a; \
 257         (p)->RootDirectory = r; \
 258         (p)->SecurityDescriptor = s; \
 259         (p)->SecurityQualityOfService = NULL; \
 260 }
 261
 262
 263 /*
 264  * VOID
 265  * InitializeListHead (
 266  *              PLIST_ENTRY     ListHead
 267  *              );
 268  *
 269  * FUNCTION: Initializes a double linked list
 270  * ARGUMENTS:
 271  *         ListHead = Caller supplied storage for the head of the list
 272  */
 273 #define InitializeListHead(ListHead) \
 274 { \
 275         (ListHead)->Flink = (ListHead); \
 276         (ListHead)->Blink = (ListHead); \
 277 }
 278
 279
 280 /*
 281  * VOID
 282  * InsertHeadList (
 283  *              PLIST_ENTRY     ListHead,
 284  *              PLIST_ENTRY     Entry
 285  *              );
 286  *
 287  * FUNCTION: Inserts an entry in a double linked list
 288  * ARGUMENTS:
 289  *        ListHead = Head of the list
 290  *        Entry = Entry to insert
 291  */
 292 #define InsertHeadList(ListHead, ListEntry) \
 293 { \
 294         PLIST_ENTRY OldFlink; \
 295         OldFlink = (ListHead)->Flink; \
 296         (ListEntry)->Flink = OldFlink; \
 297         (ListEntry)->Blink = (ListHead); \
 298         OldFlink->Blink = (ListEntry); \
 299         (ListHead)->Flink = (ListEntry); \
 300         assert((ListEntry) != NULL); \
 301         assert((ListEntry)->Blink!=NULL); \
 302         assert((ListEntry)->Blink->Flink == (ListEntry)); \
 303         assert((ListEntry)->Flink != NULL); \
 304         assert((ListEntry)->Flink->Blink == (ListEntry)); \
 305 }
 306
 307
 308 /*
 309  * VOID
 310  * InsertTailList (
 311  *              PLIST_ENTRY     ListHead,
 312  *              PLIST_ENTRY     Entry
 313  *              );
 314  *
 315  * FUNCTION:
 316  *      Inserts an entry in a double linked list
 317  *
 318  * ARGUMENTS:
 319  *      ListHead = Head of the list
 320  *      Entry = Entry to insert
 321  */
 322 #define InsertTailList(ListHead, ListEntry) \
 323 { \
 324         PLIST_ENTRY OldBlink; \
 325         OldBlink = (ListHead)->Blink; \
 326         (ListEntry)->Flink = (ListHead); \
 327         (ListEntry)->Blink = OldBlink; \
 328         OldBlink->Flink = (ListEntry); \
 329         (ListHead)->Blink = (ListEntry); \
 330         assert((ListEntry) != NULL); \
 331         assert((ListEntry)->Blink != NULL); \
 332         assert((ListEntry)->Blink->Flink == (ListEntry)); \
 333         assert((ListEntry)->Flink != NULL); \
 334         assert((ListEntry)->Flink->Blink == (ListEntry)); \
 335 }
 336
 337 /*
 338  * BOOLEAN
 339  * IsListEmpty (
 340  *      PLIST_ENTRY     ListHead
 341  *      );
 342  *
 343  * FUNCTION:
 344  *      Checks if a double linked list is empty
 345  *
 346  * ARGUMENTS:
 347  *      ListHead = Head of the list
 348 */
 349 #define IsListEmpty(ListHead) \
 350         ((ListHead)->Flink == (ListHead))
 351
 352
 353 /*
 354  * PSINGLE_LIST_ENTRY
 355  * PopEntryList (
 356  *      PSINGLE_LIST_ENTRY      ListHead
 357  *      );
 358  *
 359  * FUNCTION:
 360  *      Removes an entry from the head of a single linked list
 361  *
 362  * ARGUMENTS:
 363  *      ListHead = Head of the list
 364  *
 365  * RETURNS:
 366  *      The removed entry
 367  */
 368 /*
 369 #define PopEntryList(ListHead) \
 370         (ListHead)->Next; \
 371         { \
 372                 PSINGLE_LIST_ENTRY FirstEntry; \
 373                 FirstEntry = (ListHead)->Next; \
 374                 if (FirstEntry != NULL) \
 375                 { \
 376                         (ListHead)->Next = FirstEntry->Next; \
 377                 } \
 378         }
 379 */
 380 static
 381 inline
 382 PSINGLE_LIST_ENTRY
 383  PopEntryList(
 384         PSINGLE_LIST_ENTRY      ListHead
 385         )
 386 {
 387         PSINGLE_LIST_ENTRY ListEntry;
 388
 389         ListEntry = ListHead->Next;
 390         if (ListEntry!=NULL)
 391         {
 392                 ListHead->Next = ListEntry->Next;
 393         }
 394         return ListEntry;
 395 }
 396
 397 /*
 398 VOID
 399 PushEntryList (
 400         PSINGLE_LIST_ENTRY      ListHead,
 401         PSINGLE_LIST_ENTRY      Entry
 402         );
 403 */
 404 /*
 405 #define PushEntryList(ListHead,Entry) \
 406         (Entry)->Next = (ListHead)->Next; \
 407         (ListHead)->Next = (Entry)
 408 */
 409 static
 410 inline
 411 VOID
 412 PushEntryList (
 413         PSINGLE_LIST_ENTRY      ListHead,
 414         PSINGLE_LIST_ENTRY      Entry
 415         )
 416 {
 417         Entry->Next = ListHead->Next;
 418         ListHead->Next = Entry;
 419 }
 420
 421
 422 /*
 423  * An ReactOS extension
 424  */
 425 static
 426 inline
 427 PSINGLE_LIST_ENTRY
 428  PopEntrySList(
 429         PSLIST_HEADER   ListHead
 430         )
 431 {
 432         PSINGLE_LIST_ENTRY ListEntry;
 433
 434         ListEntry = ListHead->s.Next.Next;
 435         if (ListEntry!=NULL)
 436         {
 437                 ListHead->s.Next.Next = ListEntry->Next;
 438     ListHead->s.Depth++;
 439     ListHead->s.Sequence++;
 440   }
 441         return ListEntry;
 442 }
 443
 444
 445 /*
 446  * An ReactOS extension
 447  */
 448 static
 449 inline
 450 VOID
 451 PushEntrySList (
 452         PSLIST_HEADER   ListHead,
 453         PSINGLE_LIST_ENTRY      Entry
 454         )
 455 {
 456         Entry->Next = ListHead->s.Next.Next;
 457         ListHead->s.Next.Next = Entry;
 458   ListHead->s.Depth++;
 459   ListHead->s.Sequence++;
 460 }
 461
 462
 463 /*
 464  *VOID
 465  *RemoveEntryList (
 466  *      PLIST_ENTRY     Entry
 467  *      );
 468  *
 469  * FUNCTION:
 470  *      Removes an entry from a double linked list
 471  *
 472  * ARGUMENTS:
 473  *      ListEntry = Entry to remove
 474  */
 475 #define RemoveEntryList(ListEntry) \
 476 { \
 477         PLIST_ENTRY OldFlink; \
 478         PLIST_ENTRY OldBlink; \
 479         assert((ListEntry) != NULL); \
 480         assert((ListEntry)->Blink!=NULL); \
 481         assert((ListEntry)->Blink->Flink == (ListEntry)); \
 482         assert((ListEntry)->Flink != NULL); \
 483         assert((ListEntry)->Flink->Blink == (ListEntry)); \
 484         OldFlink = (ListEntry)->Flink; \
 485         OldBlink = (ListEntry)->Blink; \
 486         OldFlink->Blink = OldBlink; \
 487         OldBlink->Flink = OldFlink; \
 488         (ListEntry)->Flink = NULL; \
 489         (ListEntry)->Blink = NULL; \
 490 }
 491
 492
 493 /*
 494  * PLIST_ENTRY
 495  * RemoveHeadList (
 496  *      PLIST_ENTRY     ListHead
 497  *      );
 498  *
 499  * FUNCTION:
 500  *      Removes the head entry from a double linked list
 501  *
 502  * ARGUMENTS:
 503  *      ListHead = Head of the list
 504  *
 505  * RETURNS:
 506  *      The removed entry
 507  */
 508 /*
 509 #define RemoveHeadList(ListHead) \
 510         (ListHead)->Flink; \
 511         {RemoveEntryList((ListHead)->Flink)}
 512 */
 513 /*
 514 PLIST_ENTRY
 515 RemoveHeadList (
 516         PLIST_ENTRY     ListHead
 517         );
 518 */
 519
 520 static
 521 inline
 522 PLIST_ENTRY
 523 RemoveHeadList (
 524         PLIST_ENTRY     ListHead
 525         )
 526 {
 527         PLIST_ENTRY Old;
 528         PLIST_ENTRY OldFlink;
 529         PLIST_ENTRY OldBlink;
 530
 531         Old = ListHead->Flink;
 532
 533         OldFlink = ListHead->Flink->Flink;
 534         OldBlink = ListHead->Flink->Blink;
 535         OldFlink->Blink = OldBlink;
 536         OldBlink->Flink = OldFlink;
 537         if (Old != ListHead)
 538      {
 539         Old->Flink = NULL;
 540         Old->Blink = NULL;
 541      }
 542
 543         return(Old);
 544 }
 545
 546
 547 /*
 548  * PLIST_ENTRY
 549  * RemoveTailList (
 550  *      PLIST_ENTRY     ListHead
 551  *      );
 552  *
 553  * FUNCTION:
 554  *      Removes the tail entry from a double linked list
 555  *
 556  * ARGUMENTS:
 557  *      ListHead = Head of the list
 558  *
 559  * RETURNS:
 560  *      The removed entry
 561  */
 562 /*
 563 #define RemoveTailList(ListHead) \
 564         (ListHead)->Blink; \
 565         {RemoveEntryList((ListHead)->Blink)}
 566 */
 567 /*
 568 PLIST_ENTRY
 569 RemoveTailList (
 570         PLIST_ENTRY     ListHead
 571         );
 572 */
 573
 574 static
 575 inline
 576 PLIST_ENTRY
 577 RemoveTailList (
 578         PLIST_ENTRY ListHead
 579         )
 580 {
 581         PLIST_ENTRY Old;
 582         PLIST_ENTRY OldFlink;
 583         PLIST_ENTRY OldBlink;
 584
 585         Old = ListHead->Blink;
 586
 587         OldFlink = ListHead->Blink->Flink;
 588         OldBlink = ListHead->Blink->Blink;
 589         OldFlink->Blink = OldBlink;
 590         OldBlink->Flink = OldFlink;
 591    if (Old != ListHead)
 592      {
 593         Old->Flink = NULL;
 594         Old->Blink = NULL;
 595      }
 596
 597         return(Old);
 598 }
 599
 600
 601 NTSTATUS
 602 STDCALL
 603 RtlAddAtomToAtomTable (
 604         IN      PRTL_ATOM_TABLE AtomTable,
 605         IN      PWSTR           AtomName,
 606         OUT     PRTL_ATOM       Atom
 607         );
 608
 609 PVOID STDCALL
 610 RtlAllocateHeap (
 611         HANDLE  Heap,
 612         ULONG   Flags,
 613         ULONG   Size
 614         );
 615
 616 WCHAR
 617 STDCALL
 618 RtlAnsiCharToUnicodeChar (
 619         CHAR    AnsiChar
 620         );
 621
 622 ULONG
 623 STDCALL
 624 RtlAnsiStringToUnicodeSize (
 625         PANSI_STRING    AnsiString
 626         );
 627
 628 NTSTATUS
 629 STDCALL
 630 RtlAnsiStringToUnicodeString (
 631         PUNICODE_STRING DestinationString,
 632         PANSI_STRING    SourceString,
 633         BOOLEAN         AllocateDestinationString
 634         );
 635
 636 NTSTATUS
 637 STDCALL
 638 RtlAppendAsciizToString(
 639         PSTRING Destination,
 640         PCSZ    Source
 641         );
 642
 643 NTSTATUS
 644 STDCALL
 645 RtlAppendStringToString (
 646         PSTRING Destination,
 647         PSTRING Source
 648         );
 649
 650 NTSTATUS
 651 STDCALL
 652 RtlAppendUnicodeStringToString (
 653         PUNICODE_STRING Destination,
 654         PUNICODE_STRING Source
 655         );
 656
 657 NTSTATUS
 658 STDCALL
 659 RtlAppendUnicodeToString (
 660         PUNICODE_STRING Destination,
 661         PWSTR           Source
 662         );
 663
 664 BOOLEAN
 665 STDCALL
 666 RtlAreBitsClear (
 667         PRTL_BITMAP     BitMapHeader,
 668         ULONG           StartingIndex,
 669         ULONG           Length
 670         );
 671
 672 BOOLEAN
 673 STDCALL
 674 RtlAreBitsSet (
 675         PRTL_BITMAP     BitMapHeader,
 676         ULONG           StartingIndex,
 677         ULONG           Length
 678         );
 679
 680 VOID
 681 STDCALL
 682 RtlAssert (
 683         PVOID FailedAssertion,
 684         PVOID FileName,
 685         ULONG LineNumber,
 686         PCHAR Message
 687         );
 688
 689 NTSTATUS
 690 STDCALL
 691 RtlCharToInteger (
 692         PCSZ    String,
 693         ULONG   Base,
 694         PULONG  Value
 695         );
 696
 697 NTSTATUS
 698 STDCALL
 699 RtlCheckRegistryKey (
 700         ULONG   RelativeTo,
 701         PWSTR   Path
 702         );
 703
 704 VOID
 705 STDCALL
 706 RtlClearAllBits (
 707         IN      PRTL_BITMAP     BitMapHeader
 708         );
 709
 710 VOID
 711 STDCALL
 712 RtlClearBits (
 713         IN      PRTL_BITMAP     BitMapHeader,
 714         IN      ULONG           StartingIndex,
 715         IN      ULONG           NumberToClear
 716         );
 717
 718 DWORD
 719 STDCALL
 720 RtlCompactHeap (
 721         HANDLE  hheap,
 722         DWORD   flags
 723         );
 724
 725 ULONG
 726 STDCALL
 727 RtlCompareMemory (
 728         PVOID   Source1,
 729         PVOID   Source2,
 730         ULONG   Length
 731         );
 732
 733 LONG
 734 STDCALL
 735 RtlCompareString (
 736         PSTRING String1,
 737         PSTRING String2,
 738         BOOLEAN CaseInsensitive
 739         );
 740
 741 LONG
 742 STDCALL
 743 RtlCompareUnicodeString (
 744         PUNICODE_STRING String1,
 745         PUNICODE_STRING String2,
 746         BOOLEAN         BaseInsensitive
 747         );
 748
 749 LARGE_INTEGER
 750 STDCALL
 751 RtlConvertLongToLargeInteger (
 752         IN      LONG    SignedInteger
 753         );
 754
 755 NTSTATUS
 756 STDCALL
 757 RtlConvertSidToUnicodeString (
 758         IN OUT  PUNICODE_STRING String,
 759         IN      PSID            Sid,
 760         IN      BOOLEAN         AllocateString
 761         );
 762
 763 LARGE_INTEGER
 764 STDCALL
 765 RtlConvertUlongToLargeInteger (
 766         IN      ULONG   UnsignedInteger
 767         );
 768
 769 #if 0
 770 VOID
 771 RtlCopyBytes (
 772         PVOID           Destination,
 773         CONST VOID      * Source,
 774         ULONG           Length
 775         );
 776
 777 VOID
 778 RtlCopyMemory (
 779         VOID            * Destination,
 780         CONST VOID      * Source,
 781         ULONG           Length
 782         );
 783 #endif
 784
 785 #define RtlCopyMemory(Destination,Source,Length) \
 786         memcpy((Destination),(Source),(Length))
 787
 788 #define RtlCopyBytes RtlCopyMemory
 789
 790 VOID
 791 STDCALL
 792 RtlCopyString (
 793         PSTRING DestinationString,
 794         PSTRING SourceString
 795         );
 796
 797 VOID
 798 STDCALL
 799 RtlCopyUnicodeString (
 800         PUNICODE_STRING DestinationString,
 801         PUNICODE_STRING SourceString
 802         );
 803
 804 NTSTATUS
 805 STDCALL
 806 RtlCreateAtomTable (
 807         IN      ULONG TableSize,
 808         IN OUT  PRTL_ATOM_TABLE *AtomTable
 809         );
 810
 811 HANDLE
 812 STDCALL
 813 RtlCreateHeap (
 814         ULONG                   Flags,
 815         PVOID                   BaseAddress,
 816         ULONG                   SizeToReserve,
 817         ULONG                   SizeToCommit,
 818         PVOID                   Unknown,
 819         PRTL_HEAP_DEFINITION    Definition
 820         );
 821
 822 NTSTATUS
 823 STDCALL
 824 RtlCreateRegistryKey (
 825         ULONG   RelativeTo,
 826         PWSTR   Path
 827         );
 828
 829 NTSTATUS
 830 STDCALL
 831 RtlCreateSecurityDescriptor (
 832         PSECURITY_DESCRIPTOR    SecurityDescriptor,
 833         ULONG                   Revision
 834         );
 835
 836 BOOLEAN
 837 STDCALL
 838 RtlCreateUnicodeString (
 839         OUT     PUNICODE_STRING Destination,
 840         IN      PWSTR           Source
 841         );
 842
 843 BOOLEAN
 844 STDCALL
 845 RtlCreateUnicodeStringFromAsciiz (
 846         OUT     PUNICODE_STRING Destination,
 847         IN      PCSZ            Source
 848         );
 849
 850 NTSTATUS
 851 STDCALL
 852 RtlCustomCPToUnicodeN (
 853         PRTL_NLS_DATA   NlsData,
 854         PWCHAR          UnicodeString,
 855         ULONG           UnicodeSize,
 856         PULONG          ResultSize,
 857         PCHAR           CustomString,
 858         ULONG           CustomSize
 859         );
 860
 861 NTSTATUS
 862 STDCALL
 863 RtlDeleteAtomFromAtomTable (
 864         IN      PRTL_ATOM_TABLE AtomTable,
 865         IN      RTL_ATOM        Atom
 866         );
 867
 868 NTSTATUS
 869 STDCALL
 870 RtlDeleteRegistryValue (
 871         ULONG   RelativeTo,
 872         PWSTR   Path,
 873         PWSTR   ValueName
 874         );
 875
 876 NTSTATUS
 877 STDCALL
 878 RtlDestroyAtomTable (
 879         IN      PRTL_ATOM_TABLE AtomTable
 880         );
 881
 882 BOOL
 883 STDCALL
 884 RtlDestroyHeap (
 885         HANDLE  hheap
 886         );
 887
 888 NTSTATUS
 889 STDCALL
 890 RtlDowncaseUnicodeString (
 891         IN OUT PUNICODE_STRING  DestinationString,
 892         IN PUNICODE_STRING      SourceString,
 893         IN BOOLEAN              AllocateDestinationString
 894         );
 895
 896 NTSTATUS
 897 STDCALL
 898 RtlEmptyAtomTable (
 899         IN      PRTL_ATOM_TABLE AtomTable,
 900         IN      BOOLEAN         DeletePinned
 901         );
 902
 903 LARGE_INTEGER
 904 STDCALL
 905 RtlEnlargedIntegerMultiply (
 906         LONG    Multiplicand,
 907         LONG    Multiplier
 908         );
 909
 910 ULONG
 911 STDCALL
 912 RtlEnlargedUnsignedDivide (
 913         ULARGE_INTEGER  Dividend,
 914         ULONG           Divisor,
 915         PULONG          Remainder
 916         );
 917
 918 LARGE_INTEGER
 919 STDCALL
 920 RtlEnlargedUnsignedMultiply (
 921         ULONG   Multiplicand,
 922         ULONG   Multiplier
 923         );
 924
 925 BOOLEAN
 926 STDCALL
 927 RtlEqualString (
 928         PSTRING String1,
 929         PSTRING String2,
 930         BOOLEAN CaseInSensitive
 931         );
 932
 933 BOOLEAN
 934 STDCALL
 935 RtlEqualUnicodeString (
 936         PUNICODE_STRING String1,
 937         PUNICODE_STRING String2,
 938         BOOLEAN         CaseInSensitive
 939         );
 940
 941 LARGE_INTEGER
 942 STDCALL
 943 RtlExtendedIntegerMultiply (
 944         LARGE_INTEGER   Multiplicand,
 945         LONG            Multiplier
 946         );
 947
 948 LARGE_INTEGER
 949 STDCALL
 950 RtlExtendedLargeIntegerDivide (
 951         LARGE_INTEGER   Dividend,
 952         ULONG           Divisor,
 953         PULONG          Remainder
 954         );
 955
 956 LARGE_INTEGER
 957 STDCALL
 958 RtlExtendedMagicDivide (
 959         LARGE_INTEGER   Dividend,
 960         LARGE_INTEGER   MagicDivisor,
 961         CCHAR           ShiftCount
 962         );
 963
 964 VOID
 965 STDCALL
 966 RtlFillMemory (
 967         PVOID   Destination,
 968         ULONG   Length,
 969         UCHAR   Fill
 970         );
 971
 972 VOID
 973 STDCALL
 974 RtlFillMemoryUlong (
 975         PVOID   Destination,
 976         ULONG   Length,
 977         ULONG   Fill
 978         );
 979
 980 ULONG
 981 STDCALL
 982 RtlFindClearBits (
 983         PRTL_BITMAP     BitMapHeader,
 984         ULONG           NumberToFind,
 985         ULONG           HintIndex
 986         );
 987
 988 ULONG
 989 STDCALL
 990 RtlFindClearBitsAndSet (
 991         PRTL_BITMAP     BitMapHeader,
 992         ULONG           NumberToFind,
 993         ULONG           HintIndex
 994         );
 995
 996 ULONG
 997 STDCALL
 998 RtlFindFirstRunClear (
 999         PRTL_BITMAP     BitMapHeader,
1000         PULONG          StartingIndex
1001         );
1002
1003 ULONG
1004 STDCALL
1005 RtlFindFirstRunSet (
1006         PRTL_BITMAP     BitMapHeader,
1007         PULONG          StartingIndex
1008         );
1009
1010 ULONG
1011 STDCALL
1012 RtlFindLongestRunClear (
1013         PRTL_BITMAP     BitMapHeader,
1014         PULONG          StartingIndex
1015         );
1016
1017 ULONG
1018 STDCALL
1019 RtlFindLongestRunSet (
1020         PRTL_BITMAP     BitMapHeader,
1021         PULONG          StartingIndex
1022         );
1023
1024 NTSTATUS
1025 STDCALL
1026 RtlFindMessage (
1027         IN      PVOID                           BaseAddress,
1028         IN      ULONG                           Type,
1029         IN      ULONG                           Language,
1030         IN      ULONG                           MessageId,
1031         OUT     PRTL_MESSAGE_RESOURCE_ENTRY     *MessageResourceEntry
1032         );
1033
1034 ULONG
1035 STDCALL
1036 RtlFindSetBits (
1037         PRTL_BITMAP     BitMapHeader,
1038         ULONG           NumberToFind,
1039         ULONG           HintIndex
1040         );
1041
1042 ULONG
1043 STDCALL
1044 RtlFindSetBitsAndClear (
1045         PRTL_BITMAP     BitMapHeader,
1046         ULONG           NumberToFind,
1047         ULONG           HintIndex
1048         );
1049
1050 NTSTATUS
1051 STDCALL
1052 RtlFormatCurrentUserKeyPath (
1053         IN OUT  PUNICODE_STRING KeyPath
1054         );
1055
1056 VOID
1057 STDCALL
1058 RtlFreeAnsiString (
1059         PANSI_STRING    AnsiString
1060         );
1061
1062 BOOLEAN
1063 STDCALL
1064 RtlFreeHeap (
1065         HANDLE  Heap,
1066         ULONG   Flags,
1067         PVOID   Address
1068         );
1069
1070 VOID
1071 STDCALL
1072 RtlFreeOemString (
1073         POEM_STRING     OemString
1074         );
1075
1076 VOID
1077 STDCALL
1078 RtlFreeUnicodeString (
1079         PUNICODE_STRING UnicodeString
1080         );
1081
1082 VOID
1083 RtlGetCallersAddress (
1084         PVOID   * CallersAddress
1085         );
1086
1087 VOID
1088 STDCALL
1089 RtlGetDefaultCodePage (
1090         PUSHORT AnsiCodePage,
1091         PUSHORT OemCodePage
1092         );
1093
1094 HANDLE
1095 STDCALL
1096 RtlGetProcessHeap (
1097         VOID
1098         );
1099
1100 PVOID
1101 STDCALL
1102 RtlImageDirectoryEntryToData (
1103         PVOID   BaseAddress,
1104         BOOLEAN bFlag,
1105         ULONG   Directory,
1106         PULONG  Size
1107         );
1108
1109 PIMAGE_NT_HEADERS
1110 STDCALL
1111 RtlImageNtHeader (
1112         PVOID   BaseAddress
1113         );
1114
1115 PIMAGE_SECTION_HEADER
1116 STDCALL
1117 RtlImageRvaToSection (
1118         PIMAGE_NT_HEADERS       NtHeader,
1119         PVOID                   BaseAddress,
1120         ULONG                   Rva
1121         );
1122
1123 ULONG
1124 STDCALL
1125 RtlImageRvaToVa (
1126         PIMAGE_NT_HEADERS       NtHeader,
1127         PVOID                   BaseAddress,
1128         ULONG                   Rva,
1129         PIMAGE_SECTION_HEADER   *SectionHeader
1130         );
1131
1132 VOID
1133 STDCALL
1134 RtlInitAnsiString (
1135         PANSI_STRING    DestinationString,
1136         PCSZ            SourceString
1137         );
1138
1139 VOID
1140 STDCALL
1141 RtlInitString (
1142         PSTRING DestinationString,
1143         PCSZ    SourceString
1144         );
1145
1146 VOID
1147 STDCALL
1148 RtlInitUnicodeString (
1149         PUNICODE_STRING DestinationString,
1150         PCWSTR          SourceString
1151         );
1152
1153 VOID
1154 STDCALL
1155 RtlInitializeBitMap (
1156         IN OUT  PRTL_BITMAP     BitMapHeader,
1157         IN      PULONG          BitMapBuffer,
1158         IN      ULONG           SizeOfBitMap
1159         );
1160
1161 NTSTATUS
1162 STDCALL
1163 RtlInitializeContext (
1164         IN      HANDLE                  ProcessHandle,
1165         IN      PCONTEXT                Context,
1166         IN      PVOID                   Parameter,
1167         IN      PTHREAD_START_ROUTINE   StartAddress,
1168         IN OUT  PINITIAL_TEB            InitialTeb
1169         );
1170
1171 VOID
1172 STDCALL
1173 RtlInitializeGenericTable (
1174         IN OUT  PRTL_GENERIC_TABLE      Table,
1175         IN      PVOID                   CompareRoutine,
1176         IN      PVOID                   AllocateRoutine,
1177         IN      PVOID                   FreeRoutine,
1178         IN      ULONG                   UserParameter
1179         );
1180
1181 PVOID
1182 STDCALL
1183 RtlInsertElementGenericTable (
1184         IN OUT  PRTL_GENERIC_TABLE      Table,
1185         IN      PVOID                   Element,
1186         IN      ULONG                   ElementSize,
1187         IN      ULONG                   Unknown4
1188         );
1189
1190 NTSTATUS
1191 STDCALL
1192 RtlIntegerToChar (
1193         IN      ULONG   Value,
1194         IN      ULONG   Base,
1195         IN      ULONG   Length,
1196         IN OUT  PCHAR   String
1197         );
1198
1199 NTSTATUS
1200 STDCALL
1201 RtlIntegerToUnicodeString (
1202         IN      ULONG           Value,
1203         IN      ULONG           Base,
1204         IN OUT  PUNICODE_STRING String
1205         );
1206
1207 BOOLEAN
1208 STDCALL
1209 RtlIsGenericTableEmpty (
1210         IN      PRTL_GENERIC_TABLE      Table
1211         );
1212
1213 BOOLEAN
1214 STDCALL
1215 RtlIsNameLegalDOS8Dot3 (
1216         IN      PUNICODE_STRING UnicodeName,
1217         IN OUT  PANSI_STRING    AnsiName,
1218         IN OUT  PBOOLEAN        SpacesFound
1219         );
1220
1221 LARGE_INTEGER
1222 STDCALL
1223 RtlLargeIntegerAdd (
1224         LARGE_INTEGER   Addend1,
1225         LARGE_INTEGER   Addend2
1226         );
1227
1228 /*
1229  * VOID
1230  * RtlLargeIntegerAnd (
1231  *      PLARGE_INTEGER  Result,
1232  *      LARGE_INTEGER   Source,
1233  *      LARGE_INTEGER   Mask
1234  *      );
1235  */
1236 #define RtlLargeIntegerAnd(Result, Source, Mask) \
1237 { \
1238         Result.HighPart = Source.HighPart & Mask.HighPart; \
1239         Result.LowPart = Source.LowPart & Mask.LowPart; \
1240 }
1241
1242 LARGE_INTEGER
1243 STDCALL
1244 RtlLargeIntegerArithmeticShift (
1245         LARGE_INTEGER   LargeInteger,
1246         CCHAR   ShiftCount
1247         );
1248
1249 LARGE_INTEGER
1250 STDCALL
1251 RtlLargeIntegerDivide (
1252         LARGE_INTEGER   Dividend,
1253         LARGE_INTEGER   Divisor,
1254         PLARGE_INTEGER  Remainder
1255         );
1256
1257 /*
1258  * BOOLEAN
1259  * RtlLargeIntegerEqualTo (
1260  *      LARGE_INTEGER   Operand1,
1261  *      LARGE_INTEGER   Operand2
1262  *      );
1263  */
1264 #define RtlLargeIntegerEqualTo(X,Y) \
1265         (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1266
1267 /*
1268  * BOOLEAN
1269  * RtlLargeIntegerEqualToZero (
1270  *      LARGE_INTEGER   Operand
1271  *      );
1272  */
1273 #define RtlLargeIntegerEqualToZero(X) \
1274         (!((X).LowPart | (X).HighPart))
1275
1276 /*
1277  * BOOLEAN
1278  * RtlLargeIntegerGreaterThan (
1279  *      LARGE_INTEGER   Operand1,
1280  *      LARGE_INTEGER   Operand2
1281  *      );
1282  */
1283 #define RtlLargeIntegerGreaterThan(X,Y) \
1284         ((((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
1285           ((X).HighPart > (Y).HighPart))
1286
1287 /*
1288  * BOOLEAN
1289  * RtlLargeIntegerGreaterThanOrEqualTo (
1290  *      LARGE_INTEGER   Operand1,
1291  *      LARGE_INTEGER   Operand2
1292  *      );
1293  */
1294 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) \
1295         ((((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
1296           ((X).HighPart > (Y).HighPart))
1297
1298 /*
1299  * BOOLEAN
1300  * RtlLargeIntegerGreaterThanOrEqualToZero (
1301  *      LARGE_INTEGER   Operand1
1302  *      );
1303  */
1304 #define RtlLargeIntegerGreaterOrEqualToZero(X) \
1305         ((X).HighPart >= 0)
1306
1307 /*
1308  * BOOLEAN
1309  * RtlLargeIntegerGreaterThanZero (
1310  *      LARGE_INTEGER   Operand1
1311  *      );
1312  */
1313 #define RtlLargeIntegerGreaterThanZero(X) \
1314         ((((X).HighPart == 0) && ((X).LowPart > 0)) || \
1315           ((X).HighPart > 0 ))
1316
1317 /*
1318  * BOOLEAN
1319  * RtlLargeIntegerLessThan (
1320  *      LARGE_INTEGER   Operand1,
1321  *      LARGE_INTEGER   Operand2
1322  *      );
1323  */
1324 #define RtlLargeIntegerLessThan(X,Y) \
1325         ((((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
1326           ((X).HighPart < (Y).HighPart))
1327
1328 /*
1329  * BOOLEAN
1330  * RtlLargeIntegerLessThanOrEqualTo (
1331  *      LARGE_INTEGER   Operand1,
1332  *      LARGE_INTEGER   Operand2
1333  *      );
1334  */
1335 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) \
1336         ((((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
1337           ((X).HighPart < (Y).HighPart))
1338
1339 /*
1340  * BOOLEAN
1341  * RtlLargeIntegerLessThanOrEqualToZero (
1342  *      LARGE_INTEGER   Operand
1343  *      );
1344  */
1345 #define RtlLargeIntegerLessOrEqualToZero(X) \
1346         (((X).HighPart < 0) || !((X).LowPart | (X).HighPart))
1347
1348 /*
1349  * BOOLEAN
1350  * RtlLargeIntegerLessThanZero (
1351  *      LARGE_INTEGER   Operand
1352  *      );
1353  */
1354 #define RtlLargeIntegerLessThanZero(X) \
1355         (((X).HighPart < 0))
1356
1357 LARGE_INTEGER
1358 STDCALL
1359 RtlLargeIntegerNegate (
1360         LARGE_INTEGER   Subtrahend
1361         );
1362
1363 /*
1364  * BOOLEAN
1365  * RtlLargeIntegerNotEqualTo (
1366  *      LARGE_INTEGER   Operand1,
1367  *      LARGE_INTEGER   Operand2
1368  *      );
1369  */
1370 #define RtlLargeIntegerNotEqualTo(X,Y) \
1371         ((((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1372
1373 /*
1374  * BOOLEAN
1375  * RtlLargeIntegerNotEqualToZero (
1376  *      LARGE_INTEGER   Operand
1377  *      );
1378  */
1379 #define RtlLargeIntegerNotEqualToZero(X) \
1380         (((X).LowPart | (X).HighPart))
1381
1382 LARGE_INTEGER
1383 STDCALL
1384 RtlLargeIntegerShiftLeft (
1385         LARGE_INTEGER   LargeInteger,
1386         CCHAR           ShiftCount
1387         );
1388
1389 LARGE_INTEGER
1390 STDCALL
1391 RtlLargeIntegerShiftRight (
1392         LARGE_INTEGER   LargeInteger,
1393         CCHAR           ShiftCount
1394         );
1395
1396 LARGE_INTEGER
1397 STDCALL
1398 RtlLargeIntegerSubtract (
1399         LARGE_INTEGER   Minuend,
1400         LARGE_INTEGER   Subtrahend
1401         );
1402
1403 ULONG
1404 STDCALL
1405 RtlLengthSecurityDescriptor (
1406         PSECURITY_DESCRIPTOR    SecurityDescriptor
1407         );
1408
1409 BOOL
1410 STDCALL
1411 RtlLockHeap (
1412         HANDLE  hheap
1413         );
1414
1415 NTSTATUS
1416 STDCALL
1417 RtlLookupAtomInAtomTable (
1418         IN      PRTL_ATOM_TABLE AtomTable,
1419         IN      PWSTR           AtomName,
1420         OUT     PRTL_ATOM       Atom
1421         );
1422
1423 VOID STDCALL
1424 RtlMoveMemory (PVOID Destination, CONST VOID* Source, ULONG Length);
1425
1426 NTSTATUS
1427 STDCALL
1428 RtlMultiByteToUnicodeN (
1429         PWCHAR UnicodeString,
1430         ULONG  UnicodeSize,
1431         PULONG ResultSize,
1432         PCHAR  MbString,
1433         ULONG  MbSize
1434         );
1435
1436 NTSTATUS
1437 STDCALL
1438 RtlMultiByteToUnicodeSize (
1439         PULONG UnicodeSize,
1440         PCHAR  MbString,
1441         ULONG  MbSize
1442         );
1443
1444 DWORD
1445 STDCALL
1446 RtlNtStatusToDosError (
1447         NTSTATUS        StatusCode
1448         );
1449
1450 DWORD
1451 STDCALL
1452 RtlNtStatusToDosErrorNoTeb (
1453         NTSTATUS        StatusCode
1454         );
1455
1456 int
1457 STDCALL
1458 RtlNtStatusToPsxErrno (
1459         NTSTATUS        StatusCode
1460         );
1461
1462 ULONG
1463 STDCALL
1464 RtlNumberGenericTableElements (
1465         IN      PRTL_GENERIC_TABLE      Table
1466         );
1467
1468 ULONG
1469 STDCALL
1470 RtlNumberOfClearBits (
1471         PRTL_BITMAP     BitMapHeader
1472         );
1473
1474 ULONG
1475 STDCALL
1476 RtlNumberOfSetBits (
1477         PRTL_BITMAP     BitMapHeader
1478         );
1479
1480 ULONG
1481 STDCALL
1482 RtlOemStringToUnicodeSize (
1483         POEM_STRING     AnsiString
1484         );
1485
1486 NTSTATUS
1487 STDCALL
1488 RtlOemStringToUnicodeString (
1489         PUNICODE_STRING DestinationString,
1490         POEM_STRING     SourceString,
1491         BOOLEAN         AllocateDestinationString
1492         );
1493
1494 NTSTATUS
1495 STDCALL
1496 RtlOemToUnicodeN (
1497         PWCHAR  UnicodeString,
1498         ULONG   UnicodeSize,
1499         PULONG  ResultSize,
1500         PCHAR   OemString,
1501         ULONG   OemSize
1502         );
1503
1504 NTSTATUS
1505 STDCALL
1506 RtlOpenCurrentUser (
1507         IN      ACCESS_MASK     DesiredAccess,
1508         OUT     PHANDLE         KeyHandle
1509         );
1510
1511 NTSTATUS STDCALL
1512 RtlPinAtomInAtomTable (
1513         IN      PRTL_ATOM_TABLE AtomTable,
1514         IN      RTL_ATOM        Atom
1515         );
1516
1517 BOOLEAN
1518 STDCALL
1519 RtlPrefixString (
1520         PANSI_STRING    String1,
1521         PANSI_STRING    String2,
1522         BOOLEAN         CaseInsensitive
1523         );
1524
1525 BOOLEAN
1526 STDCALL
1527 RtlPrefixUnicodeString (
1528         PUNICODE_STRING String1,
1529         PUNICODE_STRING String2,
1530         BOOLEAN         CaseInsensitive
1531         );
1532
1533 NTSTATUS
1534 STDCALL
1535 RtlQueryAtomInAtomTable (
1536         IN      PRTL_ATOM_TABLE AtomTable,
1537         IN      RTL_ATOM        Atom,
1538         IN OUT  PULONG          RefCount OPTIONAL,
1539         IN OUT  PULONG          PinCount OPTIONAL,
1540         IN OUT  PWSTR           AtomName OPTIONAL,
1541         IN OUT  PULONG          NameLength OPTIONAL
1542         );
1543
1544 NTSTATUS
1545 STDCALL
1546 RtlQueryRegistryValues (
1547         IN      ULONG                           RelativeTo,
1548         IN      PWSTR                           Path,
1549         IN      PRTL_QUERY_REGISTRY_TABLE       QueryTable,
1550         IN      PVOID                           Context,
1551         IN      PVOID                           Environment
1552         );
1553
1554 NTSTATUS
1555 STDCALL
1556 RtlQueryTimeZoneInformation (
1557         IN OUT  PTIME_ZONE_INFORMATION  TimeZoneInformation
1558         );
1559
1560 VOID
1561 STDCALL
1562 RtlRaiseException (
1563         IN      PEXCEPTION_RECORD       ExceptionRecord
1564         );
1565
1566 LPVOID
1567 STDCALL
1568 RtlReAllocateHeap (
1569         HANDLE  hheap,
1570         DWORD   flags,
1571         LPVOID  ptr,
1572         DWORD   size
1573         );
1574
1575 /*
1576  * VOID
1577  * RtlRetrieveUlong (
1578  *      PULONG  DestinationAddress,
1579  *      PULONG  SourceAddress
1580  *      );
1581  */
1582 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
1583         if ((ULONG)(SrcAddress) & LONG_MASK) \
1584         { \
1585                 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1586                 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1587                 ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
1588                 ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
1589         } \
1590         else \
1591         { \
1592                 *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
1593         }
1594
1595 /*
1596  * VOID
1597  * RtlRetrieveUshort (
1598  *      PUSHORT DestinationAddress,
1599  *      PUSHORT SourceAddress
1600  *      );
1601  */
1602 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
1603         if ((ULONG)(SrcAddress) & SHORT_MASK) \
1604         { \
1605                 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1606                 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1607         } \
1608         else \
1609         { \
1610                 *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
1611         }
1612
1613 VOID
1614 STDCALL
1615 RtlSecondsSince1970ToTime (
1616         ULONG SecondsSince1970,
1617         PLARGE_INTEGER Time
1618         );
1619
1620 VOID
1621 STDCALL
1622 RtlSecondsSince1980ToTime (
1623         ULONG SecondsSince1980,
1624         PLARGE_INTEGER Time
1625         );
1626
1627 VOID
1628 STDCALL
1629 RtlSetAllBits (
1630         IN      PRTL_BITMAP     BitMapHeader
1631         );
1632
1633 VOID
1634 STDCALL
1635 RtlSetBits (
1636         PRTL_BITMAP     BitMapHeader,
1637         ULONG           StartingIndex,
1638         ULONG           NumberToSet
1639         );
1640
1641 NTSTATUS
1642 STDCALL
1643 RtlSetDaclSecurityDescriptor (
1644         PSECURITY_DESCRIPTOR    SecurityDescriptor,
1645         BOOLEAN                 DaclPresent,
1646         PACL                    Dacl,
1647         BOOLEAN                 DaclDefaulted
1648         );
1649
1650 NTSTATUS
1651 STDCALL
1652 RtlSetTimeZoneInformation (
1653         IN OUT  PTIME_ZONE_INFORMATION  TimeZoneInformation
1654         );
1655
1656 DWORD
1657 STDCALL
1658 RtlSizeHeap (
1659         HANDLE  hheap,
1660         DWORD   flags,
1661         PVOID   pmem
1662         );
1663
1664 /*
1665  * VOID
1666  * RtlStoreUlong (
1667  *      PULONG  Address,
1668  *      ULONG   Value
1669  *      );
1670  */
1671 #define RtlStoreUlong(Address,Value) \
1672         if ((ULONG)(Address) & LONG_MASK) \
1673         { \
1674                 ((PUCHAR)(Address))[LONG_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1675                 ((PUCHAR)(Address))[LONG_3RD_MOST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1676                 ((PUCHAR)(Address))[LONG_2ND_MOST_SIGNIFICANT_BIT]=(UCHAR)(THIRDBYTE(Value)); \
1677                 ((PUCHAR)(Address))[LONG_MOST_SIGNIFICANT_BIT]=(UCHAR)(FOURTHBYTE(Value)); \
1678         } \
1679         else \
1680         { \
1681                 *((PULONG)(Address))=(ULONG)(Value); \
1682         }
1683
1684 /*
1685  * VOID
1686  * RtlStoreUshort (
1687  *      PUSHORT Address,
1688  *      USHORT  Value
1689  *      );
1690  */
1691 #define RtlStoreUshort(Address,Value) \
1692         if ((ULONG)(Address) & SHORT_MASK) \
1693         { \
1694                 ((PUCHAR)(Address))[SHORT_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1695                 ((PUCHAR)(Address))[SHORT_MOST_SIGNIFICANT_BIT]=(UCHAR)(SECONDBYTE(Value)); \
1696         } \
1697         else \
1698         { \
1699                 *((PUSHORT)(Address))=(USHORT)(Value); \
1700         }
1701
1702 BOOLEAN
1703 STDCALL
1704 RtlTimeFieldsToTime (
1705         PTIME_FIELDS    TimeFields,
1706         PLARGE_INTEGER  Time
1707         );
1708
1709 BOOLEAN
1710 STDCALL
1711 RtlTimeToSecondsSince1970 (
1712         PLARGE_INTEGER Time,
1713         PULONG SecondsSince1970
1714         );
1715
1716 BOOLEAN
1717 STDCALL
1718 RtlTimeToSecondsSince1980 (
1719         PLARGE_INTEGER Time,
1720         PULONG SecondsSince1980
1721         );
1722
1723 VOID
1724 STDCALL
1725 RtlTimeToTimeFields (
1726         PLARGE_INTEGER  Time,
1727         PTIME_FIELDS    TimeFields
1728         );
1729
1730 ULONG
1731 STDCALL
1732 RtlUnicodeStringToAnsiSize (
1733         IN      PUNICODE_STRING UnicodeString
1734         );
1735
1736 NTSTATUS
1737 STDCALL
1738 RtlUnicodeStringToAnsiString (
1739         IN OUT  PANSI_STRING    DestinationString,
1740         IN      PUNICODE_STRING SourceString,
1741         IN      BOOLEAN         AllocateDestinationString
1742         );
1743
1744 NTSTATUS
1745 STDCALL
1746 RtlUnicodeStringToInteger (
1747         IN      PUNICODE_STRING String,
1748         IN      ULONG           Base,
1749         OUT     PULONG          Value
1750         );
1751
1752 ULONG
1753 STDCALL
1754 RtlUnicodeStringToOemSize (
1755         IN      PUNICODE_STRING UnicodeString
1756         );
1757
1758 NTSTATUS
1759 STDCALL
1760 RtlUnicodeStringToCountedOemString (
1761         IN OUT  POEM_STRING     DestinationString,
1762         IN      PUNICODE_STRING SourceString,
1763         IN      BOOLEAN         AllocateDestinationString
1764         );
1765
1766 NTSTATUS
1767 STDCALL
1768 RtlUnicodeStringToOemString (
1769         IN OUT  POEM_STRING     DestinationString,
1770         IN      PUNICODE_STRING SourceString,
1771         IN      BOOLEAN         AllocateDestinationString
1772         );
1773
1774 NTSTATUS
1775 STDCALL
1776 RtlUnicodeToCustomCPN (
1777         PRTL_NLS_DATA   NlsData,
1778         PCHAR           MbString,
1779         ULONG           MbSize,
1780         PULONG          ResultSize,
1781         PWCHAR          UnicodeString,
1782         ULONG           UnicodeSize
1783         );
1784
1785 NTSTATUS
1786 STDCALL
1787 RtlUnicodeToMultiByteN (
1788         PCHAR   MbString,
1789         ULONG   MbSize,
1790         PULONG  ResultSize,
1791         PWCHAR  UnicodeString,
1792         ULONG   UnicodeSize
1793         );
1794
1795 NTSTATUS
1796 STDCALL
1797 RtlUnicodeToMultiByteSize (
1798         PULONG  MbSize,
1799         PWCHAR  UnicodeString,
1800         ULONG   UnicodeSize
1801         );
1802
1803 NTSTATUS
1804 STDCALL
1805 RtlUnicodeToOemN (
1806         PCHAR   OemString,
1807         ULONG   OemSize,
1808         PULONG  ResultSize,
1809         PWCHAR  UnicodeString,
1810         ULONG   UnicodeSize
1811         );
1812
1813 BOOL
1814 STDCALL
1815 RtlUnlockHeap (
1816         HANDLE  hheap
1817         );
1818
1819 VOID
1820 STDCALL
1821 RtlUnwind (
1822         ULONG   Unknown1,
1823         ULONG   Unknown2,
1824         ULONG   Unknown3,
1825         ULONG   Unknown4
1826         );
1827
1828 WCHAR
1829 STDCALL
1830 RtlUpcaseUnicodeChar (
1831         WCHAR Source
1832         );
1833
1834 NTSTATUS
1835 STDCALL
1836 RtlUpcaseUnicodeString (
1837         IN OUT  PUNICODE_STRING DestinationString,
1838         IN      PUNICODE_STRING SourceString,
1839         IN      BOOLEAN         AllocateDestinationString
1840         );
1841
1842 NTSTATUS
1843 STDCALL
1844 RtlUpcaseUnicodeStringToAnsiString (
1845         IN OUT  PANSI_STRING    DestinationString,
1846         IN      PUNICODE_STRING SourceString,
1847         IN      BOOLEAN         AllocateDestinationString
1848         );
1849
1850 NTSTATUS
1851 STDCALL
1852 RtlUpcaseUnicodeStringToCountedOemString (
1853         IN OUT  POEM_STRING     DestinationString,
1854         IN      PUNICODE_STRING SourceString,
1855         IN      BOOLEAN         AllocateDestinationString
1856         );
1857
1858 NTSTATUS
1859 STDCALL
1860 RtlUpcaseUnicodeStringToOemString (
1861         IN OUT  POEM_STRING     DestinationString,
1862         IN      PUNICODE_STRING SourceString,
1863         IN      BOOLEAN         AllocateDestinationString
1864         );
1865
1866 NTSTATUS
1867 STDCALL
1868 RtlUpcaseUnicodeToCustomCPN (
1869         PRTL_NLS_DATA   NlsData,
1870         PCHAR           MbString,
1871         ULONG           MbSize,
1872         PULONG          ResultSize,
1873         PWCHAR          UnicodeString,
1874         ULONG           UnicodeSize
1875         );
1876
1877 NTSTATUS
1878 STDCALL
1879 RtlUpcaseUnicodeToMultiByteN (
1880         PCHAR   MbString,
1881         ULONG   MbSize,
1882         PULONG  ResultSize,
1883         PWCHAR  UnicodeString,
1884         ULONG   UnicodeSize
1885         );
1886
1887 NTSTATUS
1888 STDCALL
1889 RtlUpcaseUnicodeToOemN (
1890         PCHAR   OemString,
1891         ULONG   OemSize,
1892         PULONG  ResultSize,
1893         PWCHAR  UnicodeString,
1894         ULONG   UnicodeSize
1895         );
1896
1897 CHAR
1898 STDCALL
1899 RtlUpperChar (
1900         CHAR    Source
1901         );
1902
1903 VOID
1904 STDCALL
1905 RtlUpperString (
1906         PSTRING DestinationString,
1907         PSTRING SourceString
1908         );
1909
1910 BOOL
1911 STDCALL
1912 RtlValidateHeap (
1913         HANDLE  hheap,
1914         DWORD   flags,
1915         PVOID   pmem
1916         );
1917
1918 BOOLEAN
1919 STDCALL
1920 RtlValidSecurityDescriptor (
1921         PSECURITY_DESCRIPTOR    SecurityDescriptor
1922         );
1923
1924 NTSTATUS
1925 STDCALL
1926 RtlWriteRegistryValue (
1927         ULONG   RelativeTo,
1928         PWSTR   Path,
1929         PWSTR   ValueName,
1930         ULONG   ValueType,
1931         PVOID   ValueData,
1932         ULONG   ValueLength
1933         );
1934
1935 VOID STDCALL
1936 RtlZeroMemory (PVOID Destination, ULONG Length);
1937
1938 ULONG
1939 STDCALL
1940 RtlxAnsiStringToUnicodeSize (
1941         IN      PANSI_STRING    AnsiString
1942         );
1943
1944 ULONG
1945 STDCALL
1946 RtlxOemStringToUnicodeSize (
1947         IN      POEM_STRING     OemString
1948         );
1949
1950 ULONG
1951 STDCALL
1952 RtlxUnicodeStringToAnsiSize (
1953         IN      PUNICODE_STRING UnicodeString
1954         );
1955
1956 ULONG
1957 STDCALL
1958 RtlxUnicodeStringToOemSize (
1959         IN      PUNICODE_STRING UnicodeString
1960         );
1961
1962
1963 /* Register io functions */
1964
1965 UCHAR
1966 STDCALL
1967 READ_REGISTER_UCHAR (
1968         PUCHAR  Register
1969         );
1970
1971 USHORT
1972 STDCALL
1973 READ_REGISTER_USHORT (
1974         PUSHORT Register
1975         );
1976
1977 ULONG
1978 STDCALL
1979 READ_REGISTER_ULONG (
1980         PULONG  Register
1981         );
1982
1983 VOID
1984 STDCALL
1985 READ_REGISTER_BUFFER_UCHAR (
1986         PUCHAR  Register,
1987         PUCHAR  Buffer,
1988         ULONG   Count
1989         );
1990
1991 VOID
1992 STDCALL
1993 READ_REGISTER_BUFFER_USHORT (
1994         PUSHORT Register,
1995         PUSHORT Buffer,
1996         ULONG   Count
1997         );
1998
1999 VOID
2000 STDCALL
2001 READ_REGISTER_BUFFER_ULONG (
2002         PULONG  Register,
2003         PULONG  Buffer,
2004         ULONG   Count
2005         );
2006
2007 VOID
2008 STDCALL
2009 WRITE_REGISTER_UCHAR (
2010         PUCHAR  Register,
2011         UCHAR   Value
2012         );
2013
2014 VOID
2015 STDCALL
2016 WRITE_REGISTER_USHORT (
2017         PUSHORT Register,
2018         USHORT  Value
2019         );
2020
2021 VOID
2022 STDCALL
2023 WRITE_REGISTER_ULONG (
2024         PULONG  Register,
2025         ULONG   Value
2026         );
2027
2028 VOID
2029 STDCALL
2030 WRITE_REGISTER_BUFFER_UCHAR (
2031         PUCHAR  Register,
2032         PUCHAR  Buffer,
2033         ULONG   Count
2034         );
2035
2036 VOID
2037 STDCALL
2038 WRITE_REGISTER_BUFFER_USHORT (
2039         PUSHORT Register,
2040         PUSHORT Buffer,
2041         ULONG   Count
2042         );
2043
2044 VOID
2045 STDCALL
2046 WRITE_REGISTER_BUFFER_ULONG (
2047         PULONG  Register,
2048         PULONG  Buffer,
2049         ULONG   Count
2050         );
2051
2052
2053 NTSTATUS STDCALL RtlCreateAcl(PACL Acl, ULONG AclSize, ULONG AclRevision);
2054 NTSTATUS STDCALL RtlQueryInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
2055 NTSTATUS STDCALL RtlSetInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
2056 BOOLEAN STDCALL RtlValidAcl (PACL Acl);
2057
2058 NTSTATUS STDCALL RtlAddAccessAllowedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
2059 NTSTATUS STDCALL RtlAddAccessDeniedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
2060 NTSTATUS STDCALL RtlAddAce(PACL Acl, ULONG Revision, ULONG StartingIndex, PACE AceList, ULONG AceListLength);
2061 NTSTATUS STDCALL RtlAddAuditAccessAce (PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid, BOOLEAN Success, BOOLEAN Failure);
2062 NTSTATUS STDCALL RtlDeleteAce(PACL Acl, ULONG AceIndex);
2063 BOOLEAN STDCALL RtlFirstFreeAce(PACL Acl, PACE* Ace);
2064 NTSTATUS STDCALL RtlGetAce(PACL Acl, ULONG AceIndex, PACE *Ace);
2065
2066 NTSTATUS STDCALL RtlAbsoluteToSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
2067 NTSTATUS STDCALL RtlMakeSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
2068 NTSTATUS STDCALL RtlCreateSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG Revision);
2069 BOOLEAN STDCALL RtlValidSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
2070 ULONG STDCALL RtlLengthSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
2071 NTSTATUS STDCALL RtlSetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN DaclPresent, PACL Dacl, BOOLEAN DaclDefaulted);
2072 NTSTATUS STDCALL RtlGetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN DaclPresent, PACL* Dacl, PBOOLEAN DaclDefauted);
2073 NTSTATUS STDCALL RtlSetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Owner, BOOLEAN OwnerDefaulted);
2074 NTSTATUS STDCALL RtlGetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Owner, PBOOLEAN OwnerDefaulted);
2075 NTSTATUS STDCALL RtlSetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Group, BOOLEAN GroupDefaulted);
2076 NTSTATUS STDCALL RtlGetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Group, PBOOLEAN GroupDefaulted);
2077 NTSTATUS STDCALL RtlGetControlSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL Control, PULONG Revision);
2078 NTSTATUS STDCALL RtlSetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN SaclPresent, PACL Sacl, BOOLEAN SaclDefaulted);
2079 NTSTATUS STDCALL RtlGetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN SaclPresent, PACL* Sacl, PBOOLEAN SaclDefauted);
2080 NTSTATUS STDCALL RtlSelfRelativeToAbsoluteSD (PSECURITY_DESCRIPTOR RelSD,
2081                                               PSECURITY_DESCRIPTOR AbsSD,
2082                                               PDWORD AbsSDSize,
2083                                               PACL Dacl,
2084                                               PDWORD DaclSize,
2085                                               PACL Sacl,
2086                                               PDWORD SaclSize,
2087                                               PSID Owner,
2088                                               PDWORD OwnerSize,
2089                                               PSID Group,
2090                                               PDWORD GroupSize);
2091
2092 NTSTATUS STDCALL RtlAllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
2093                                               UCHAR SubAuthorityCount,
2094                                               ULONG SubAuthority0,
2095                                               ULONG SubAuthority1,
2096                                               ULONG SubAuthority2,
2097                                               ULONG SubAuthority3,
2098                                               ULONG SubAuthority4,
2099                                               ULONG SubAuthority5,
2100                                               ULONG SubAuthority6,
2101                                               ULONG SubAuthority7,
2102                                               PSID *Sid);
2103 ULONG STDCALL RtlLengthRequiredSid (UCHAR SubAuthorityCount);
2104 PSID_IDENTIFIER_AUTHORITY STDCALL RtlIdentifierAuthoritySid (PSID Sid);
2105 NTSTATUS STDCALL RtlInitializeSid (PSID Sid, PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, UCHAR SubAuthorityCount);
2106 PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
2107 NTSTATUS STDCALL RtlCopySid (ULONG BufferLength, PSID Dest, PSID Src);
2108 BOOLEAN STDCALL RtlEqualPrefixSid (PSID Sid1, PSID Sid2);
2109 BOOLEAN STDCALL RtlEqualSid(PSID Sid1, PSID Sid2);
2110 PSID STDCALL RtlFreeSid (PSID Sid);
2111 ULONG STDCALL RtlLengthSid (PSID Sid);
2112 PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
2113 PUCHAR STDCALL RtlSubAuthorityCountSid (PSID Sid);
2114 BOOLEAN STDCALL RtlValidSid (PSID Sid);
2115 NTSTATUS STDCALL RtlConvertSidToUnicodeString (PUNICODE_STRING String, PSID Sid, BOOLEAN AllocateBuffer);
2116
2117 BOOLEAN STDCALL RtlAreAllAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
2118 BOOLEAN STDCALL RtlAreAnyAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
2119 VOID STDCALL RtlMapGenericMask (PACCESS_MASK AccessMask, PGENERIC_MAPPING GenericMapping);
2120
2121
2122 /*  functions exported from NTOSKRNL.EXE which are considered RTL  */
2123
2124 #if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__) || defined(__NTDLL__) || defined(__NTAPP__)
2125
2126 char *_itoa (int value, char *string, int radix);
2127 int _snprintf(char * buf, size_t cnt, const char *fmt, ...);
2128 int _snwprintf(wchar_t *buf, size_t cnt, const wchar_t *fmt, ...);
2129 int _stricmp(const char *s1, const char *s2);
2130 char * _strlwr(char *x);
2131 int _strnicmp(const char *s1, const char *s2, size_t n);
2132 char * _strnset(char* szToFill, int szFill, size_t sizeMaxFill);
2133 char * _strrev(char *s);
2134 char * _strset(char* szToFill, int szFill);
2135 char * _strupr(char *x);
2136 int _vsnprintf(char *buf, size_t cnt, const char *fmt, va_list args);
2137 int _wcsicmp (const wchar_t* cs, const wchar_t* ct);
2138 wchar_t * _wcslwr (wchar_t *x);
2139 int _wcsnicmp (const wchar_t * cs,const wchar_t * ct,size_t count);
2140 wchar_t* _wcsnset (wchar_t* wsToFill, wchar_t wcFill, size_t sizeMaxFill);
2141 wchar_t * _wcsrev(wchar_t *s);
2142 wchar_t *_wcsupr(wchar_t *x);
2143
2144 int atoi(const char *str);
2145 long atol(const char *str);
2146 int isdigit(int c);
2147 int islower(int c);
2148 int isprint(int c);
2149 int isspace(int c);
2150 int isupper(int c);
2151 int isxdigit(int c);
2152 size_t mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count);
2153 int mbtowc (wchar_t *wchar, const char *mbchar, size_t count);
2154 void * memchr(const void *s, int c, size_t n);
2155 void * memcpy(void *to, const void *from, size_t count);
2156 void * memmove(void *dest,const void *src, size_t count);
2157 void * memset(void *src, int val, size_t count);
2158
2159 #if 0
2160 qsort
2161 #endif
2162
2163 int rand(void);
2164 int sprintf(char * buf, const char *fmt, ...);
2165 void srand(unsigned seed);
2166 char * strcat(char *s, const char *append);
2167 char * strchr(const char *s, int c);
2168 int strcmp(const char *s1, const char *s2);
2169 char * strcpy(char *to, const char *from);
2170 size_t strlen(const char *str);
2171 char * strncat(char *dst, const char *src, size_t n);
2172 int strncmp(const char *s1, const char *s2, size_t n);
2173 char *strncpy(char *dst, const char *src, size_t n);
2174 char *strrchr(const char *s, int c);
2175 size_t strspn(const char *s1, const char *s2);
2176 char *strstr(const char *s, const char *find);
2177 int swprintf(wchar_t *buf, const wchar_t *fmt, ...);
2178 int tolower(int c);
2179 int toupper(int c);
2180 wchar_t towlower(wchar_t c);
2181 wchar_t towupper(wchar_t c);
2182 int vsprintf(char *buf, const char *fmt, va_list args);
2183 wchar_t * wcscat(wchar_t *dest, const wchar_t *src);
2184 wchar_t * wcschr(const wchar_t *str, wchar_t ch);
2185 int wcscmp(const wchar_t *cs, const wchar_t *ct);
2186 wchar_t* wcscpy(wchar_t* str1, const wchar_t* str2);
2187 size_t wcscspn(const wchar_t *str,const wchar_t *reject);
2188 size_t wcslen(const wchar_t *s);
2189 wchar_t * wcsncat(wchar_t *dest, const wchar_t *src, size_t count);
2190 int wcsncmp(const wchar_t *cs, const wchar_t *ct, size_t count);
2191 wchar_t * wcsncpy(wchar_t *dest, const wchar_t *src, size_t count);
2192 wchar_t * wcsrchr(const wchar_t *str, wchar_t ch);
2193 size_t wcsspn(const wchar_t *str,const wchar_t *accept);
2194 wchar_t *wcsstr(const wchar_t *s,const wchar_t *b);
2195 size_t wcstombs (char *mbstr, const wchar_t *wcstr, size_t count);
2196 int wctomb (char *mbchar, wchar_t wchar);
2197
2198 #endif /* __NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ || __NTDLL__ || __NTAPP__ */
2199
2200 #endif /* __DDK_RTL_H */