reactos/dll/win32/kernel32/misc/stubs.c

   1 /*
   2  * KERNEL32.DLL stubs (STUB functions)
   3  * Remove from this file, if you implement them.
   4  */
   5
   6 #include <k32.h>
   7
   8 #define NDEBUG
   9 #include <debug.h>
  10
  11 #define STUB \
  12   SetLastError(ERROR_CALL_NOT_IMPLEMENTED); \
  13   DPRINT1("%s() is UNIMPLEMENTED!\n", __FUNCTION__)
  14
  15 /*
  16  * @unimplemented
  17  */
  18 BOOL
  19 WINAPI
  20 BaseAttachCompleteThunk (VOID)
  21 {
  22     STUB;
  23     return FALSE;
  24 }
  25
  26 /*
  27  * @unimplemented
  28  */
  29 VOID WINAPI
  30 BaseDumpAppcompatCache(VOID)
  31 {
  32     STUB;
  33 }
  34
  35 /*
  36  * @unimplemented
  37  */
  38 VOID WINAPI
  39 BaseFlushAppcompatCache(VOID)
  40 {
  41     STUB;
  42 }
  43
  44 /*
  45  * @unimplemented
  46  */
  47 BOOL
  48 WINAPI
  49 BaseCheckAppcompatCache(ULONG Unknown1,
  50                         ULONG Unknown2,
  51                         ULONG Unknown3,
  52                         PULONG Unknown4)
  53 {
  54     STUB;
  55     if (Unknown4) *Unknown4 = 0;
  56     return TRUE;
  57 }
  58
  59 /*
  60  * @unimplemented
  61  */
  62 VOID WINAPI
  63 BaseUpdateAppcompatCache(ULONG Unknown1, ULONG Unknown2, ULONG Unknown3)
  64 {
  65     STUB;
  66 }
  67
  68 /*
  69  * @unimplemented
  70  */
  71 BOOL
  72 WINAPI
  73 CmdBatNotification (
  74     DWORD   Unknown
  75     )
  76 {
  77     STUB;
  78     return FALSE;
  79 }
  80
  81
  82 /*
  83  * @unimplemented
  84  */
  85 DWORD
  86 WINAPI
  87 CreateVirtualBuffer (
  88     DWORD   Unknown0,
  89     DWORD   Unknown1,
  90     DWORD   Unknown2
  91     )
  92 {
  93     STUB;
  94     return 0;
  95 }
  96
  97
  98 /*
  99  * @unimplemented
 100  */
 101 DWORD
 102 WINAPI
 103 ExitVDM (
 104     DWORD   Unknown0,
 105     DWORD   Unknown1
 106     )
 107 {
 108     STUB;
 109     return 0;
 110 }
 111
 112
 113 /*
 114  * @unimplemented
 115  */
 116 BOOL
 117 WINAPI
 118 ExtendVirtualBuffer (
 119     DWORD   Unknown0,
 120     DWORD   Unknown1
 121     )
 122 {
 123     STUB;
 124     return FALSE;
 125 }
 126
 127
 128 /*
 129  * @unimplemented
 130  */
 131 BOOL
 132 WINAPI
 133 FreeVirtualBuffer (
 134     HANDLE  hVirtualBuffer
 135     )
 136 {
 137     STUB;
 138     return FALSE;
 139 }
 140
 141
 142 /*
 143  * @unimplemented
 144  */
 145 DWORD
 146 WINAPI
 147 GetNextVDMCommand (
 148     DWORD   Unknown0
 149     )
 150 {
 151     STUB;
 152     return 0;
 153 }
 154
 155
 156 /*
 157  * @unimplemented
 158  */
 159 DWORD
 160 WINAPI
 161 GetVDMCurrentDirectories (
 162     DWORD   Unknown0,
 163     DWORD   Unknown1
 164     )
 165 {
 166     STUB;
 167     return 0;
 168 }
 169
 170
 171 /*
 172  * @unimplemented
 173  */
 174 BOOL
 175 WINAPI
 176 RegisterConsoleVDM (
 177     DWORD   Unknown0,
 178     DWORD   Unknown1,
 179     DWORD   Unknown2,
 180     DWORD   Unknown3,
 181     DWORD   Unknown4,
 182     DWORD   Unknown5,
 183     DWORD   Unknown6,
 184     DWORD   Unknown7,
 185     DWORD   Unknown8,
 186     DWORD   Unknown9,
 187     DWORD   Unknown10
 188     )
 189 {
 190     STUB;
 191     return FALSE;
 192 }
 193
 194
 195 /*
 196  * @unimplemented
 197  */
 198 BOOL
 199 WINAPI
 200 RegisterWowBaseHandlers (
 201     DWORD   Unknown0
 202     )
 203 {
 204     STUB;
 205     return FALSE;
 206 }
 207
 208
 209 /*
 210  * @unimplemented
 211  */
 212 BOOL
 213 WINAPI
 214 RegisterWowExec (
 215     DWORD   Unknown0
 216     )
 217 {
 218     STUB;
 219     return FALSE;
 220 }
 221
 222
 223 /*
 224  * @unimplemented
 225  */
 226 BOOL
 227 WINAPI
 228 SetVDMCurrentDirectories (
 229     DWORD   Unknown0,
 230     DWORD   Unknown1
 231     )
 232 {
 233     STUB;
 234     return FALSE;
 235 }
 236
 237
 238 /*
 239  * @unimplemented
 240  */
 241 DWORD
 242 WINAPI
 243 TrimVirtualBuffer (
 244     DWORD   Unknown0
 245     )
 246 {
 247     STUB;
 248     return 0;
 249 }
 250
 251
 252 /*
 253  * @unimplemented
 254  */
 255 DWORD
 256 WINAPI
 257 VDMConsoleOperation (
 258     DWORD   Unknown0,
 259     DWORD   Unknown1
 260     )
 261 {
 262     STUB;
 263     return 0;
 264 }
 265
 266
 267 /*
 268  * @unimplemented
 269  */
 270 DWORD
 271 WINAPI
 272 VDMOperationStarted (
 273     DWORD   Unknown0
 274     )
 275 {
 276     STUB;
 277     return 0;
 278 }
 279
 280 /*
 281  * @unimplemented
 282  */
 283 DWORD
 284 WINAPI
 285 VirtualBufferExceptionHandler (
 286     DWORD   Unknown0,
 287     DWORD   Unknown1,
 288     DWORD   Unknown2
 289     )
 290 {
 291     STUB;
 292     return 0;
 293 }
 294
 295 /*
 296  * @implemented
 297  */
 298 BOOL
 299 WINAPI
 300 BindIoCompletionCallback(HANDLE FileHandle,
 301                          LPOVERLAPPED_COMPLETION_ROUTINE Function,
 302                          ULONG Flags)
 303 {
 304     NTSTATUS Status = 0;
 305
 306     DPRINT("(%p, %p, %d)\n", FileHandle, Function, Flags);
 307
 308     Status = RtlSetIoCompletionCallback(FileHandle,
 309                                         (PIO_APC_ROUTINE)Function,
 310                                         Flags);
 311
 312     if (!NT_SUCCESS(Status))
 313     {
 314         SetLastError(RtlNtStatusToDosError(Status));
 315         return FALSE;
 316     }
 317
 318     return TRUE;
 319 }
 320
 321 /*
 322  * @unimplemented
 323  */
 324 BOOL
 325 WINAPI
 326 CreateJobSet (
 327     ULONG NumJob,
 328     PJOB_SET_ARRAY UserJobSet,
 329     ULONG Flags)
 330 {
 331     STUB;
 332     return 0;
 333 }
 334
 335 /*
 336  * @unimplemented
 337  */
 338 BOOL
 339 WINAPI
 340 FindVolumeMountPointClose(
 341     HANDLE hFindVolumeMountPoint
 342     )
 343 {
 344     STUB;
 345     return 0;
 346 }
 347
 348 /*
 349  * @unimplemented
 350  */
 351 BOOL
 352 WINAPI
 353 GetNumaHighestNodeNumber(
 354     PULONG HighestNodeNumber
 355     )
 356 {
 357     STUB;
 358     return 0;
 359 }
 360
 361 /*
 362  * @unimplemented
 363  */
 364 BOOL
 365 WINAPI
 366 GetNumaNodeProcessorMask(
 367     UCHAR Node,
 368     PULONGLONG ProcessorMask
 369     )
 370 {
 371     STUB;
 372     return 0;
 373 }
 374
 375 /*
 376  * @unimplemented
 377  */
 378 BOOL
 379 WINAPI
 380 GetNumaProcessorNode(
 381     UCHAR Processor,
 382     PUCHAR NodeNumber
 383     )
 384 {
 385     STUB;
 386     return 0;
 387 }
 388
 389 /*
 390  * @implemented
 391  */
 392 BOOL
 393 WINAPI
 394 ReadFileScatter(HANDLE hFile,
 395                 FILE_SEGMENT_ELEMENT aSegmentArray[],
 396                 DWORD nNumberOfBytesToRead,
 397                 LPDWORD lpReserved,
 398                 LPOVERLAPPED lpOverlapped)
 399 {
 400     PIO_STATUS_BLOCK pIOStatus;
 401     LARGE_INTEGER Offset;
 402     NTSTATUS Status;
 403
 404     DPRINT("(%p %p %u %p)\n", hFile, aSegmentArray, nNumberOfBytesToRead, lpOverlapped);
 405
 406     Offset.LowPart  = lpOverlapped->Offset;
 407     Offset.HighPart = lpOverlapped->OffsetHigh;
 408     pIOStatus = (PIO_STATUS_BLOCK) lpOverlapped;
 409     pIOStatus->Status = STATUS_PENDING;
 410     pIOStatus->Information = 0;
 411
 412     Status = NtReadFileScatter(hFile,
 413                                NULL,
 414                                NULL,
 415                                NULL,
 416                                pIOStatus,
 417                                aSegmentArray,
 418                                nNumberOfBytesToRead,
 419                                &Offset,
 420                                NULL);
 421
 422     if (!NT_SUCCESS(Status))
 423     {
 424         SetLastError(RtlNtStatusToDosError(Status));
 425         return FALSE;
 426     }
 427
 428     return TRUE;
 429 }
 430
 431 /*
 432  * @unimplemented
 433  */
 434 VOID
 435 WINAPI
 436 RestoreLastError(
 437     DWORD dwErrCode
 438     )
 439 {
 440     STUB;
 441 }
 442
 443 /*
 444  * @implemented
 445  */
 446 BOOL
 447 WINAPI
 448 WriteFileGather(HANDLE hFile,
 449                 FILE_SEGMENT_ELEMENT aSegmentArray[],
 450                 DWORD nNumberOfBytesToWrite,
 451                 LPDWORD lpReserved,
 452                 LPOVERLAPPED lpOverlapped)
 453 {
 454     PIO_STATUS_BLOCK IOStatus;
 455     LARGE_INTEGER Offset;
 456     NTSTATUS Status;
 457
 458     DPRINT("%p %p %u %p\n", hFile, aSegmentArray, nNumberOfBytesToWrite, lpOverlapped);
 459
 460     Offset.LowPart = lpOverlapped->Offset;
 461     Offset.HighPart = lpOverlapped->OffsetHigh;
 462     IOStatus = (PIO_STATUS_BLOCK) lpOverlapped;
 463     IOStatus->Status = STATUS_PENDING;
 464     IOStatus->Information = 0;
 465
 466     Status = NtWriteFileGather(hFile,
 467                                NULL,
 468                                NULL,
 469                                NULL,
 470                                IOStatus,
 471                                aSegmentArray,
 472                                nNumberOfBytesToWrite,
 473                                &Offset,
 474                                NULL);
 475
 476     if (!NT_SUCCESS(Status))
 477     {
 478         SetLastError(RtlNtStatusToDosError(Status));
 479         return FALSE;
 480     }
 481
 482     return TRUE;
 483 }
 484
 485 /*
 486  * @unimplemented
 487  */
 488 BOOL
 489 WINAPI
 490 DeleteVolumeMountPointW(
 491     LPCWSTR lpszVolumeMountPoint
 492     )
 493 {
 494     STUB;
 495     return 0;
 496 }
 497
 498 /*
 499  * @unimplemented
 500  */
 501 HANDLE
 502 WINAPI
 503 FindFirstVolumeMountPointW(
 504     LPCWSTR lpszRootPathName,
 505     LPWSTR lpszVolumeMountPoint,
 506     DWORD cchBufferLength
 507     )
 508 {
 509     STUB;
 510     return 0;
 511 }
 512
 513 /*
 514  * @implemented
 515  */
 516 BOOL
 517 WINAPI
 518 FindNextVolumeW(
 519         HANDLE handle,
 520         LPWSTR volume,
 521         DWORD len
 522     )
 523 {
 524     MOUNTMGR_MOUNT_POINTS *data = handle;
 525
 526     while (data->Size < data->NumberOfMountPoints)
 527     {
 528         static const WCHAR volumeW[] = {'\\','?','?','\\','V','o','l','u','m','e','{',};
 529         WCHAR *link = (WCHAR *)((char *)data + data->MountPoints[data->Size].SymbolicLinkNameOffset);
 530         DWORD size = data->MountPoints[data->Size].SymbolicLinkNameLength;
 531         data->Size++;
 532         /* skip non-volumes */
 533         if (size < sizeof(volumeW) || memcmp( link, volumeW, sizeof(volumeW) )) continue;
 534         if (size + sizeof(WCHAR) >= len * sizeof(WCHAR))
 535         {
 536             SetLastError( ERROR_FILENAME_EXCED_RANGE );
 537             return FALSE;
 538         }
 539         memcpy( volume, link, size );
 540         volume[1] = '\\';  /* map \??\ to \\?\ */
 541         volume[size / sizeof(WCHAR)] = '\\';  /* Windows appends a backslash */
 542         volume[size / sizeof(WCHAR) + 1] = 0;
 543         DPRINT( "returning entry %u %s\n", data->Size - 1, volume );
 544         return TRUE;
 545     }
 546     SetLastError( ERROR_NO_MORE_FILES );
 547     return FALSE;
 548 }
 549
 550 /*
 551  * @unimplemented
 552  */
 553 BOOL
 554 WINAPI
 555 FindNextVolumeMountPointW(
 556     HANDLE hFindVolumeMountPoint,
 557     LPWSTR lpszVolumeMountPoint,
 558     DWORD cchBufferLength
 559     )
 560 {
 561     STUB;
 562     return 0;
 563 }
 564
 565 /*
 566  * @unimplemented
 567  */
 568 DWORD
 569 WINAPI
 570 GetFirmwareEnvironmentVariableW(
 571     LPCWSTR lpName,
 572     LPCWSTR lpGuid,
 573     PVOID   pBuffer,
 574     DWORD    nSize
 575     )
 576 {
 577     STUB;
 578     return 0;
 579 }
 580
 581 /*
 582  * @unimplemented
 583  */
 584 BOOL
 585 WINAPI
 586 GetVolumePathNamesForVolumeNameW(
 587     LPCWSTR lpszVolumeName,
 588     LPWSTR lpszVolumePathNames,
 589     DWORD cchBufferLength,
 590     PDWORD lpcchReturnLength
 591     )
 592 {
 593     STUB;
 594     return 0;
 595 }
 596
 597 /*
 598  * @unimplemented
 599  */
 600 BOOL
 601 WINAPI
 602 SetFirmwareEnvironmentVariableW(
 603     LPCWSTR lpName,
 604     LPCWSTR lpGuid,
 605     PVOID    pValue,
 606     DWORD    nSize
 607     )
 608 {
 609     STUB;
 610     return 0;
 611 }
 612
 613 /*
 614  * @unimplemented
 615  */
 616 BOOL
 617 WINAPI
 618 SetVolumeMountPointW(
 619     LPCWSTR lpszVolumeMountPoint,
 620     LPCWSTR lpszVolumeName
 621     )
 622 {
 623     STUB;
 624     return 0;
 625 }
 626
 627 /*
 628  * @unimplemented
 629  */
 630 BOOL
 631 WINAPI
 632 DeleteVolumeMountPointA(
 633     LPCSTR lpszVolumeMountPoint
 634     )
 635 {
 636     STUB;
 637     return 0;
 638 }
 639
 640 /*
 641  * @unimplemented
 642  */
 643 HANDLE
 644 WINAPI
 645 FindFirstVolumeMountPointA(
 646     LPCSTR lpszRootPathName,
 647     LPSTR lpszVolumeMountPoint,
 648     DWORD cchBufferLength
 649     )
 650 {
 651     STUB;
 652     return 0;
 653 }
 654
 655 /*
 656  * @implemented
 657  */
 658 BOOL
 659 WINAPI
 660 FindNextVolumeA(HANDLE handle,
 661                 LPSTR volume,
 662                 DWORD len)
 663 {
 664     WCHAR *buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, len * sizeof(WCHAR));
 665     BOOL ret;
 666
 667     if (!buffer)
 668     {
 669         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 670         return FALSE;
 671     }
 672
 673     if ((ret = FindNextVolumeW( handle, buffer, len )))
 674     {
 675         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
 676     }
 677
 678     HeapFree( GetProcessHeap(), 0, buffer );
 679     return ret;
 680 }
 681
 682 /*
 683  * @unimplemented
 684  */
 685 BOOL
 686 WINAPI
 687 FindNextVolumeMountPointA(
 688     HANDLE hFindVolumeMountPoint,
 689     LPSTR lpszVolumeMountPoint,
 690     DWORD cchBufferLength
 691     )
 692 {
 693     STUB;
 694     return 0;
 695 }
 696
 697 /*
 698  * @unimplemented
 699  */
 700 DWORD
 701 WINAPI
 702 GetFirmwareEnvironmentVariableA(
 703     LPCSTR lpName,
 704     LPCSTR lpGuid,
 705     PVOID   pBuffer,
 706     DWORD    nSize
 707     )
 708 {
 709     STUB;
 710     return 0;
 711 }
 712
 713 /*
 714  * @unimplemented
 715  */
 716 BOOL
 717 WINAPI
 718 GetVolumePathNamesForVolumeNameA(
 719     LPCSTR lpszVolumeName,
 720     LPSTR lpszVolumePathNames,
 721     DWORD cchBufferLength,
 722     PDWORD lpcchReturnLength
 723     )
 724 {
 725     STUB;
 726     return 0;
 727 }
 728
 729 /*
 730  * @unimplemented
 731  */
 732 BOOL
 733 WINAPI
 734 SetFirmwareEnvironmentVariableA(
 735     LPCSTR lpName,
 736     LPCSTR lpGuid,
 737     PVOID    pValue,
 738     DWORD    nSize
 739     )
 740 {
 741     STUB;
 742     return 0;
 743 }
 744
 745 /*
 746  * @unimplemented
 747  */
 748 BOOL
 749 WINAPI
 750 SetVolumeMountPointA(
 751     LPCSTR lpszVolumeMountPoint,
 752     LPCSTR lpszVolumeName
 753     )
 754 {
 755     STUB;
 756     return 0;
 757 }
 758
 759 /*
 760  * @unimplemented
 761  */
 762 BOOL WINAPI GetConsoleKeyboardLayoutNameA(LPSTR name)
 763 {
 764     STUB;
 765     return 0;
 766 }
 767
 768 /*
 769  * @unimplemented
 770  */
 771 BOOL WINAPI GetConsoleKeyboardLayoutNameW(LPWSTR name)
 772 {
 773     STUB;
 774     return 0;
 775 }
 776
 777 /*
 778  * @unimplemented
 779  */
 780 DWORD WINAPI GetHandleContext(HANDLE hnd)
 781 {
 782     STUB;
 783     return 0;
 784 }
 785
 786 /*
 787  * @unimplemented
 788  */
 789 HANDLE WINAPI CreateSocketHandle(VOID)
 790 {
 791     STUB;
 792     return INVALID_HANDLE_VALUE;
 793 }
 794
 795 /*
 796  * @unimplemented
 797  */
 798 BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context)
 799 {
 800     STUB;
 801     return 0;
 802 }
 803
 804 /*
 805  * @unimplemented
 806  */
 807 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
 808                         LPSTR lpszInitName, LPSTR lpszProcName,
 809                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
 810                         LPVOID lpBuff )
 811 {
 812     STUB;
 813     return 0;
 814 }
 815
 816 /*
 817  * @unimplemented
 818  */
 819 VOID WINAPI UTUnRegister( HMODULE hModule )
 820 {
 821     STUB;
 822 }
 823
 824 /*
 825  * @unimplemented
 826  */
 827 FARPROC WINAPI DelayLoadFailureHook(LPCSTR pszDllName, LPCSTR pszProcName)
 828 {
 829     STUB;
 830     return NULL;
 831 }
 832
 833 /*
 834  * @unimplemented
 835  */
 836 NTSTATUS WINAPI CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
 837 {
 838     STUB;
 839     return 0;
 840 }
 841
 842 /*
 843  * @unimplemented
 844  */
 845 BOOL WINAPI IsValidUILanguage(LANGID langid)
 846 {
 847     STUB;
 848     return 0;
 849 }
 850
 851 /*
 852  * @unimplemented
 853  */
 854 VOID WINAPI NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
 855 {
 856     STUB;
 857 }
 858
 859 /*
 860  * @unimplemented
 861  */
 862 UINT WINAPI SetCPGlobal(UINT CodePage)
 863 {
 864     STUB;
 865     return 0;
 866 }
 867
 868 /*
 869  * @unimplemented
 870  */
 871 BOOL
 872 WINAPI
 873 SetClientTimeZoneInformation(
 874     CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation)
 875 {
 876     STUB;
 877     return 0;
 878 }
 879
 880 ULONG
 881 WINAPI
 882 NlsGetCacheUpdateCount(VOID)
 883 {
 884     STUB;
 885     return 0;
 886 }
 887
 888 BOOL
 889 WINAPI
 890 Wow64EnableWow64FsRedirection (BOOL Wow64EnableWow64FsRedirection)
 891 {
 892     STUB;
 893     return FALSE;
 894 }
 895
 896 BOOL
 897 WINAPI
 898 Wow64DisableWow64FsRedirection (VOID ** pv)
 899 {
 900     STUB;
 901     return FALSE;
 902 }
 903
 904 BOOL
 905 WINAPI
 906 Wow64RevertWow64FsRedirection (VOID * pv)
 907 {
 908     STUB;
 909     return FALSE;
 910 }
 911
 912 UINT
 913 WINAPI
 914 EnumSystemFirmwareTables(IN DWORD FirmwareTableProviderSignature,
 915                          OUT PVOID pFirmwareTableBuffer,
 916                          IN DWORD BufferSize)
 917 {
 918     STUB;
 919     return 0;
 920 }
 921
 922 BOOL
 923 WINAPI
 924 GetSystemFileCacheSize(OUT PSIZE_T lpMinimumFileCacheSize,
 925                        OUT PSIZE_T lpMaximumFileCacheSize,
 926                        OUT PDWORD lpFlags)
 927 {
 928     STUB;
 929     return FALSE;
 930 }
 931
 932 UINT
 933 WINAPI
 934 GetSystemFirmwareTable(IN DWORD FirmwareTableProviderSignature,
 935                        IN DWORD FirmwareTableID,
 936                        OUT PVOID pFirmwareTableBuffer,
 937                        IN DWORD BufferSize)
 938 {
 939     STUB;
 940     return 0;
 941 }
 942
 943 BOOL
 944 WINAPI
 945 SetSystemFileCacheSize(IN SIZE_T MinimumFileCacheSize,
 946                        IN SIZE_T MaximumFileCacheSize,
 947                        IN DWORD Flags)
 948 {
 949     STUB;
 950     return FALSE;
 951 }
 952
 953 BOOL
 954 WINAPI
 955 SetThreadStackGuarantee(IN OUT PULONG StackSizeInBytes)
 956 {
 957     STUB;
 958     return FALSE;
 959 }
 960
 961 HANDLE
 962 WINAPI
 963 ReOpenFile(IN HANDLE hOriginalFile,
 964            IN DWORD dwDesiredAccess,
 965            IN DWORD dwShareMode,
 966            IN DWORD dwFlags)
 967 {
 968     STUB;
 969     return INVALID_HANDLE_VALUE;
 970 }
 971
 972 BOOL
 973 WINAPI
 974 SetProcessWorkingSetSizeEx(IN HANDLE hProcess,
 975                            IN SIZE_T dwMinimumWorkingSetSize,
 976                            IN SIZE_T dwMaximumWorkingSetSize,
 977                            IN DWORD Flags)
 978 {
 979     STUB;
 980     return FALSE;
 981 }
 982
 983
 984 BOOL
 985 WINAPI
 986 GetProcessWorkingSetSizeEx(IN HANDLE hProcess,
 987                            OUT PSIZE_T lpMinimumWorkingSetSize,
 988                            OUT PSIZE_T lpMaximumWorkingSetSize,
 989                            OUT PDWORD Flags)
 990 {
 991     STUB;
 992     return FALSE;
 993 }
 994
 995 BOOL
 996 WINAPI
 997 GetLogicalProcessorInformation(OUT PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
 998                                IN OUT PDWORD ReturnLength)
 999 {
1000     STUB;
1001     return FALSE;
1002 }
1003
1004 BOOL
1005 WINAPI
1006 GetNumaAvailableMemoryNode(IN UCHAR Node,
1007                            OUT PULONGLONG AvailableBytes)
1008 {
1009     STUB;
1010     return FALSE;
1011 }
1012
1013 BOOL
1014 WINAPI
1015 GetNumaAvailableMemory(PVOID lpInfo,
1016                        ULONG Length,
1017                        PULONG ReturnLength)
1018 {
1019     STUB;
1020     return FALSE;
1021 }
1022
1023 BOOL
1024 WINAPI
1025 GetNumaProcessorMap(PVOID lpInfo,
1026                     ULONG Length,
1027                     PULONG ReturnLength)
1028 {
1029     STUB;
1030     return FALSE;
1031 }
1032
1033 BOOL
1034 WINAPI
1035 NlsResetProcessLocale(VOID)
1036 {
1037     STUB;
1038     return TRUE;
1039 }
1040
1041 DWORD
1042 WINAPI
1043 AddLocalAlternateComputerNameA(LPSTR lpName, PNTSTATUS Status)
1044 {
1045     STUB;
1046     return 0;
1047 }
1048
1049 DWORD
1050 WINAPI
1051 AddLocalAlternateComputerNameW(LPWSTR lpName, PNTSTATUS Status)
1052 {
1053     STUB;
1054     return 0;
1055 }
1056
1057 NTSTATUS
1058 WINAPI
1059 BaseCleanupAppcompatCache()
1060 {
1061     STUB;
1062     return STATUS_NOT_IMPLEMENTED;
1063 }
1064
1065 NTSTATUS
1066 WINAPI
1067 BaseCleanupAppcompatCacheSupport(PVOID pUnknown)
1068 {
1069     STUB;
1070     return STATUS_NOT_IMPLEMENTED;
1071 }
1072
1073 BOOL
1074 WINAPI
1075 BaseInitAppcompatCache(VOID)
1076 {
1077     STUB;
1078     return FALSE;
1079 }
1080
1081 BOOL
1082 WINAPI
1083 BaseInitAppcompatCacheSupport(VOID)
1084 {
1085     STUB;
1086     return FALSE;
1087 }
1088
1089 VOID
1090 WINAPI
1091 CreateProcessInternalWSecure(VOID)
1092 {
1093     STUB;
1094 }
1095
1096 DWORD
1097 WINAPI
1098 EnumerateLocalComputerNamesA(PVOID pUnknown, DWORD Size, LPSTR lpBuffer, LPDWORD lpnSize)
1099 {
1100     STUB;
1101     return ERROR_CALL_NOT_IMPLEMENTED;
1102 }
1103
1104 DWORD
1105 WINAPI
1106 EnumerateLocalComputerNamesW(PVOID pUnknown, DWORD Size, LPWSTR lpBuffer, LPDWORD lpnSize)
1107 {
1108     STUB;
1109     return ERROR_CALL_NOT_IMPLEMENTED;
1110 }
1111
1112 PVOID
1113 WINAPI
1114 GetComPlusPackageInstallStatus(VOID)
1115 {
1116     STUB;
1117     return NULL;
1118 }
1119
1120 BOOL
1121 WINAPI
1122 GetConsoleCharType(HANDLE hConsole, COORD Coord, PDWORD Type)
1123 {
1124     STUB;
1125     return FALSE;
1126 }
1127
1128 BOOL
1129 WINAPI
1130 GetConsoleCursorMode(HANDLE hConsole, PBOOL pUnknown1, PBOOL pUnknown2)
1131 {
1132     STUB;
1133     return FALSE;
1134 }
1135
1136 BOOL
1137 WINAPI
1138 GetConsoleNlsMode(HANDLE hConsole, LPDWORD lpMode)
1139 {
1140     STUB;
1141     return FALSE;
1142 }
1143
1144 VOID
1145 WINAPI
1146 GetDefaultSortkeySize(LPVOID lpUnknown)
1147 {
1148     STUB;
1149     lpUnknown = NULL;
1150 }
1151
1152 VOID
1153 WINAPI
1154 GetLinguistLangSize(LPVOID lpUnknown)
1155 {
1156     STUB;
1157     lpUnknown = NULL;
1158 }
1159
1160 BOOL
1161 WINAPI
1162 OpenDataFile(HANDLE hFile, DWORD dwUnused)
1163 {
1164     STUB;
1165     return FALSE;
1166 }
1167
1168 BOOL
1169 WINAPI
1170 OpenProfileUserMapping(VOID)
1171 {
1172     STUB;
1173     return FALSE;
1174 }
1175
1176 BOOL
1177 WINAPI
1178 PrivMoveFileIdentityW(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
1179 {
1180     STUB;
1181     return FALSE;
1182 }
1183
1184 BOOL
1185 WINAPI
1186 ReadConsoleInputExA(HANDLE hConsole, LPVOID lpBuffer, DWORD dwLen, LPDWORD Unknown1, DWORD Unknown2)
1187 {
1188     STUB;
1189     return FALSE;
1190 }
1191
1192 BOOL
1193 WINAPI
1194 ReadConsoleInputExW(HANDLE hConsole, LPVOID lpBuffer, DWORD dwLen, LPDWORD Unknown1, DWORD Unknown2)
1195 {
1196     STUB;
1197     return FALSE;
1198 }
1199
1200 BOOL
1201 WINAPI
1202 RegisterConsoleIME(HWND hWnd, LPDWORD ThreadId)
1203 {
1204     STUB;
1205     return FALSE;
1206 }
1207
1208 BOOL
1209 WINAPI
1210 RegisterConsoleOS2(BOOL bUnknown)
1211 {
1212     STUB;
1213     return FALSE;
1214 }
1215
1216 DWORD
1217 WINAPI
1218 RemoveLocalAlternateComputerNameA(LPSTR lpName, DWORD Unknown)
1219 {
1220     STUB;
1221     return ERROR_CALL_NOT_IMPLEMENTED;
1222 }
1223
1224 DWORD
1225 WINAPI
1226 RemoveLocalAlternateComputerNameW(LPWSTR lpName, DWORD Unknown)
1227 {
1228     STUB;
1229     return ERROR_CALL_NOT_IMPLEMENTED;
1230 }
1231
1232 BOOL
1233 WINAPI
1234 SetComPlusPackageInstallStatus(LPVOID lpInfo)
1235 {
1236     STUB;
1237     return FALSE;
1238 }
1239
1240 BOOL
1241 WINAPI
1242 SetConsoleCursorMode(HANDLE hConsole, BOOL Unknown1, BOOL Unknown2)
1243 {
1244     STUB;
1245     return FALSE;
1246 }
1247
1248 BOOL
1249 WINAPI
1250 SetConsoleLocalEUDC(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3, DWORD Unknown4)
1251 {
1252     STUB;
1253     return FALSE;
1254 }
1255
1256 BOOL
1257 WINAPI
1258 SetConsoleNlsMode(HANDLE hConsole, DWORD dwMode)
1259 {
1260     STUB;
1261     return FALSE;
1262 }
1263
1264 BOOL
1265 WINAPI
1266 SetConsoleOS2OemFormat(BOOL bUnknown)
1267 {
1268     STUB;
1269     return FALSE;
1270 }
1271
1272 BOOL
1273 WINAPI
1274 UnregisterConsoleIME(VOID)
1275 {
1276     STUB;
1277     return FALSE;
1278 }