reactos/lib/kernel32/misc/stubs.c

   1 /* $Id: stubs.c,v 1.70 2004/03/18 18:29:19 weiden Exp $
   2  *
   3  * KERNEL32.DLL stubs (unimplemented functions)
   4  * Remove from this file, if you implement them.
   5  */
   6 #include <k32.h>
   7
   8 //#define _OLE2NLS_IN_BUILD_
   9
  10 /*
  11  * @unimplemented
  12  */
  13 BOOL
  14 STDCALL
  15 BaseAttachCompleteThunk (VOID)
  16 {
  17     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  18     return FALSE;
  19 }
  20
  21
  22 /*
  23  * @unimplemented
  24  */
  25 BOOL
  26 STDCALL
  27 CmdBatNotification (
  28     DWORD   Unknown
  29     )
  30 {
  31     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  32     return FALSE;
  33 }
  34
  35
  36 /*
  37  * @unimplemented
  38  */
  39 int
  40 STDCALL
  41 CompareStringA (
  42     LCID    Locale,
  43     DWORD   dwCmpFlags,
  44     LPCSTR  lpString1,
  45     int cchCount1,
  46     LPCSTR  lpString2,
  47     int cchCount2
  48     )
  49 {
  50     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  51     return 0;
  52 }
  53
  54
  55 /*
  56  * @unimplemented
  57  */
  58 int
  59 STDCALL
  60 CompareStringW (
  61     LCID    Locale,
  62     DWORD   dwCmpFlags,
  63     LPCWSTR lpString1,
  64     int cchCount1,
  65     LPCWSTR lpString2,
  66     int cchCount2
  67     )
  68 {
  69     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  70     return 0;
  71 }
  72
  73
  74 /*
  75  * @unimplemented
  76  */
  77 DWORD
  78 STDCALL
  79 CreateVirtualBuffer (
  80     DWORD   Unknown0,
  81     DWORD   Unknown1,
  82     DWORD   Unknown2
  83     )
  84 {
  85     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  86     return 0;
  87 }
  88
  89
  90 /*
  91  * @unimplemented
  92  */
  93 DWORD
  94 STDCALL
  95 ExitVDM (
  96     DWORD   Unknown0,
  97     DWORD   Unknown1
  98     )
  99 {
 100     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 101     return 0;
 102 }
 103
 104
 105 /*
 106  * @unimplemented
 107  */
 108 BOOL
 109 STDCALL
 110 ExtendVirtualBuffer (
 111     DWORD   Unknown0,
 112     DWORD   Unknown1
 113     )
 114 {
 115     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 116     return FALSE;
 117 }
 118
 119
 120 /*
 121  * @unimplemented
 122  */
 123 int
 124 STDCALL
 125 FoldStringW (
 126     DWORD   dwMapFlags,
 127     LPCWSTR lpSrcStr,
 128     int cchSrc,
 129     LPWSTR  lpDestStr,
 130     int cchDest
 131     )
 132 {
 133     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 134     return 0;
 135 }
 136
 137
 138 /*
 139  * @unimplemented
 140  */
 141 int
 142 STDCALL
 143 FoldStringA (
 144     DWORD   dwMapFlags,
 145     LPCSTR  lpSrcStr,
 146     int cchSrc,
 147     LPSTR   lpDestStr,
 148     int cchDest
 149     )
 150 {
 151     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 152     return 0;
 153 }
 154
 155
 156 /*
 157  * @unimplemented
 158  */
 159 BOOL
 160 STDCALL
 161 FreeVirtualBuffer (
 162     HANDLE  hVirtualBuffer
 163     )
 164 {
 165     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 166     return FALSE;
 167 }
 168
 169 /*
 170  * @unimplemented
 171  */
 172 BOOL
 173 STDCALL
 174 GetBinaryTypeW (
 175     LPCWSTR lpApplicationName,
 176     LPDWORD lpBinaryType
 177     )
 178 {
 179     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 180     return FALSE;
 181 }
 182
 183
 184 /*
 185  * @unimplemented
 186  */
 187 BOOL
 188 STDCALL
 189 GetBinaryTypeA (
 190     LPCSTR  lpApplicationName,
 191     LPDWORD lpBinaryType
 192     )
 193 {
 194     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 195     return FALSE;
 196 }
 197
 198 #ifndef _OLE2NLS_IN_BUILD_
 199
 200
 201
 202
 203
 204 /*
 205  * @unimplemented
 206  */
 207 DWORD
 208 STDCALL
 209 GetNextVDMCommand (
 210     DWORD   Unknown0
 211     )
 212 {
 213     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 214     return 0;
 215 }
 216
 217
 218 /*
 219  * @unimplemented
 220  */
 221 BOOL
 222 STDCALL
 223 GetStringTypeExW (
 224     LCID    Locale,
 225     DWORD   dwInfoType,
 226     LPCWSTR lpSrcStr,
 227     int cchSrc,
 228     LPWORD  lpCharType
 229     )
 230 {
 231     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 232     return FALSE;
 233 }
 234
 235
 236 /*
 237  * @unimplemented
 238  */
 239 BOOL
 240 STDCALL
 241 GetStringTypeExA (
 242     LCID    Locale,
 243     DWORD   dwInfoType,
 244     LPCSTR  lpSrcStr,
 245     int cchSrc,
 246     LPWORD  lpCharType
 247     )
 248 {
 249     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 250     return FALSE;
 251 }
 252
 253
 254 /*
 255  * @unimplemented
 256  */
 257 BOOL
 258 STDCALL
 259 GetStringTypeW (
 260     DWORD   dwInfoType,
 261     LPCWSTR lpSrcStr,
 262     int cchSrc,
 263     LPWORD  lpCharType
 264     )
 265 {
 266     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 267     return FALSE;
 268 }
 269
 270
 271 /*
 272  * @unimplemented
 273  */
 274 BOOL
 275 STDCALL
 276 GetStringTypeA (
 277     LCID    Locale,
 278     DWORD   dwInfoType,
 279     LPCSTR  lpSrcStr,
 280     int cchSrc,
 281     LPWORD  lpCharType
 282     )
 283 {
 284     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 285     return FALSE;
 286 }
 287
 288
 289 #endif
 290
 291 /*
 292  * @unimplemented
 293  */
 294 BOOL
 295 STDCALL
 296 GetSystemPowerStatus (
 297     DWORD   Unknown0
 298     )
 299 {
 300     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 301     return 0;
 302 }
 303
 304
 305 /*
 306  * @unimplemented
 307  */
 308 DWORD
 309 STDCALL
 310 GetVDMCurrentDirectories (
 311     DWORD   Unknown0,
 312     DWORD   Unknown1
 313     )
 314 {
 315     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 316     return 0;
 317 }
 318
 319 #ifndef _OLE2NLS_IN_BUILD_
 320
 321 /*
 322  * @unimplemented
 323  */
 324 BOOL
 325 STDCALL
 326 IsDBCSLeadByte (
 327     BYTE    TestChar
 328     )
 329 {
 330     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 331     return FALSE;
 332 }
 333
 334
 335 /*
 336  * @unimplemented
 337  */
 338 BOOL
 339 STDCALL
 340 IsDBCSLeadByteEx (
 341     UINT    CodePage,
 342     BYTE    TestChar
 343     )
 344 {
 345     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 346     return FALSE;
 347 }
 348
 349 #endif
 350
 351 /*
 352  * @unimplemented
 353  */
 354 DWORD
 355 STDCALL
 356 LoadModule (
 357     LPCSTR  lpModuleName,
 358     LPVOID  lpParameterBlock
 359     )
 360 {
 361     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 362     return 0;
 363 }
 364
 365
 366 /*
 367  * @unimplemented
 368  */
 369 BOOL
 370 STDCALL
 371 RegisterConsoleVDM (
 372     DWORD   Unknown0,
 373     DWORD   Unknown1,
 374     DWORD   Unknown2,
 375     DWORD   Unknown3,
 376     DWORD   Unknown4,
 377     DWORD   Unknown5,
 378     DWORD   Unknown6,
 379     DWORD   Unknown7,
 380     DWORD   Unknown8,
 381     DWORD   Unknown9,
 382     DWORD   Unknown10
 383     )
 384 {
 385     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 386     return FALSE;
 387 }
 388
 389
 390 /*
 391  * @unimplemented
 392  */
 393 BOOL
 394 STDCALL
 395 RegisterWowBaseHandlers (
 396     DWORD   Unknown0
 397     )
 398 {
 399     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 400     return FALSE;
 401 }
 402
 403
 404 /*
 405  * @unimplemented
 406  */
 407 BOOL
 408 STDCALL
 409 RegisterWowExec (
 410     DWORD   Unknown0
 411     )
 412 {
 413     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 414     return FALSE;
 415 }
 416
 417
 418 /*
 419  * @unimplemented
 420  */
 421 BOOL STDCALL
 422 SetSystemPowerState (
 423     BOOL fSuspend,
 424     BOOL fForce
 425     )
 426 {
 427     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 428     return FALSE;
 429 }
 430
 431
 432 /*
 433  * @unimplemented
 434  */
 435 BOOL
 436 STDCALL
 437 SetVDMCurrentDirectories (
 438     DWORD   Unknown0,
 439     DWORD   Unknown1
 440     )
 441 {
 442     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 443     return FALSE;
 444 }
 445
 446
 447 /*
 448  * @unimplemented
 449  */
 450 DWORD
 451 STDCALL
 452 TrimVirtualBuffer (
 453     DWORD   Unknown0
 454     )
 455 {
 456     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 457     return 0;
 458 }
 459
 460
 461 /*
 462  * @unimplemented
 463  */
 464 DWORD
 465 STDCALL
 466 VDMConsoleOperation (
 467     DWORD   Unknown0,
 468     DWORD   Unknown1
 469     )
 470 {
 471     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 472     return 0;
 473 }
 474
 475
 476 /*
 477  * @unimplemented
 478  */
 479 DWORD
 480 STDCALL
 481 VDMOperationStarted (
 482     DWORD   Unknown0
 483     )
 484 {
 485     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 486     return 0;
 487 }
 488
 489
 490 #ifndef _OLE2NLS_IN_BUILD_
 491
 492 /*
 493  * @unimplemented
 494  */
 495 DWORD
 496 STDCALL
 497 VerLanguageNameA (
 498     DWORD   wLang,
 499     LPSTR   szLang,
 500     DWORD   nSize
 501     )
 502 {
 503     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 504     return 0;
 505 }
 506
 507
 508 /*
 509  * @unimplemented
 510  */
 511 DWORD
 512 STDCALL
 513 VerLanguageNameW (
 514     DWORD   wLang,
 515     LPWSTR  szLang,
 516     DWORD   nSize
 517     )
 518 {
 519     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 520     return 0;
 521 }
 522
 523 #endif
 524
 525 /*
 526  * @unimplemented
 527  */
 528 DWORD
 529 STDCALL
 530 VirtualBufferExceptionHandler (
 531     DWORD   Unknown0,
 532     DWORD   Unknown1,
 533     DWORD   Unknown2
 534     )
 535 {
 536     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 537     return 0;
 538 }
 539
 540 /*
 541  * @unimplemented
 542  */
 543 BOOL
 544 STDCALL
 545 ActivateActCtx(
 546     HANDLE hActCtx,
 547     ULONG_PTR *lpCookie
 548     )
 549 {
 550     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 551     return 0;
 552 }
 553
 554 /*
 555  * @unimplemented
 556  */
 557 VOID
 558 STDCALL
 559 AddRefActCtx(
 560     HANDLE hActCtx
 561     )
 562 {
 563     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 564 }
 565
 566 /*
 567  * @unimplemented
 568  */
 569 BOOL
 570 STDCALL
 571 AllocateUserPhysicalPages(
 572     HANDLE hProcess,
 573     PULONG_PTR NumberOfPages,
 574     PULONG_PTR PageArray
 575     )
 576 {
 577     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 578     return 0;
 579 }
 580
 581 /*
 582  * @unimplemented
 583  */
 584 BOOL
 585 STDCALL
 586 AssignProcessToJobObject(
 587     HANDLE hJob,
 588     HANDLE hProcess
 589     )
 590 {
 591     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 592     return 0;
 593 }
 594
 595 /*
 596  * @unimplemented
 597  */
 598 BOOL
 599 STDCALL
 600 BindIoCompletionCallback (
 601     HANDLE FileHandle,
 602     LPOVERLAPPED_COMPLETION_ROUTINE Function,
 603     ULONG Flags
 604     )
 605 {
 606     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 607     return 0;
 608 }
 609
 610 /*
 611  * @unimplemented
 612  */
 613 BOOL
 614 STDCALL
 615 CancelDeviceWakeupRequest(
 616     HANDLE hDevice
 617     )
 618 {
 619     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 620     return 0;
 621 }
 622
 623 /*
 624  * @unimplemented
 625  */
 626 BOOL
 627 STDCALL
 628 CancelTimerQueueTimer(
 629     HANDLE TimerQueue,
 630     HANDLE Timer
 631     )
 632 {
 633     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 634     return 0;
 635 }
 636 /*
 637  * @unimplemented
 638  */
 639
 640 BOOL
 641 STDCALL
 642 ChangeTimerQueueTimer(
 643     HANDLE TimerQueue,
 644     HANDLE Timer,
 645     ULONG DueTime,
 646     ULONG Period
 647     )
 648 {
 649     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 650     return 0;
 651 }
 652
 653 /*
 654  * @unimplemented
 655  */
 656 HANDLE
 657 STDCALL
 658 CreateActCtxA(
 659     PCACTCTXA pActCtx
 660     )
 661 {
 662     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 663     return 0;
 664 }
 665
 666 /*
 667  * @unimplemented
 668  */
 669 HANDLE
 670 STDCALL
 671 CreateActCtxW(
 672     PCACTCTXW pActCtx
 673     )
 674 {
 675     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 676     return 0;
 677 }
 678
 679 /*
 680  * @unimplemented
 681  */
 682 BOOL
 683 STDCALL
 684 CreateJobSet (
 685     ULONG NumJob,
 686     PJOB_SET_ARRAY UserJobSet,
 687     ULONG Flags)
 688 {
 689     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 690     return 0;
 691 }
 692
 693 /*
 694  * @unimplemented
 695  */
 696 HANDLE
 697 STDCALL
 698 CreateMemoryResourceNotification(
 699     MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType
 700     )
 701 {
 702     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 703     return 0;
 704 }
 705
 706 /*
 707  * @unimplemented
 708  */
 709 HANDLE
 710 STDCALL
 711 CreateTimerQueue(
 712     VOID
 713     )
 714 {
 715     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 716     return 0;
 717 }
 718
 719 /*
 720  * @unimplemented
 721  */
 722 BOOL
 723 STDCALL
 724 CreateTimerQueueTimer(
 725     PHANDLE phNewTimer,
 726     HANDLE TimerQueue,
 727     WAITORTIMERCALLBACK Callback,
 728     PVOID Parameter,
 729     DWORD DueTime,
 730     DWORD Period,
 731     ULONG Flags
 732     )
 733 {
 734     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 735     return 0;
 736 }
 737
 738 /*
 739  * @unimplemented
 740  */
 741 BOOL
 742 STDCALL
 743 DeactivateActCtx(
 744     DWORD dwFlags,
 745     ULONG_PTR ulCookie
 746     )
 747 {
 748     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 749     return 0;
 750 }
 751
 752 /*
 753  * @unimplemented
 754  */
 755 BOOL
 756 STDCALL
 757 DeleteTimerQueue(
 758     HANDLE TimerQueue
 759     )
 760 {
 761     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 762     return 0;
 763 }
 764
 765 /*
 766  * @unimplemented
 767  */
 768 BOOL
 769 STDCALL
 770 DeleteTimerQueueEx(
 771     HANDLE TimerQueue,
 772     HANDLE CompletionEvent
 773     )
 774 {
 775     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 776     return 0;
 777 }
 778
 779 /*
 780  * @unimplemented
 781  */
 782 BOOL
 783 STDCALL
 784 DeleteTimerQueueTimer(
 785     HANDLE TimerQueue,
 786     HANDLE Timer,
 787     HANDLE CompletionEvent
 788     )
 789 {
 790     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 791     return 0;
 792 }
 793
 794 /*
 795  * @unimplemented
 796  */
 797 BOOL
 798 STDCALL
 799 FindActCtxSectionGuid(
 800     DWORD dwFlags,
 801     const GUID *lpExtensionGuid,
 802     ULONG ulSectionId,
 803     const GUID *lpGuidToFind,
 804     PACTCTX_SECTION_KEYED_DATA ReturnedData
 805     )
 806 {
 807     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 808     return 0;
 809 }
 810
 811 /*
 812  * @unimplemented
 813  */
 814 BOOL
 815 STDCALL
 816 FindVolumeClose(
 817     HANDLE hFindVolume
 818     )
 819 {
 820     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 821     return 0;
 822 }
 823
 824 /*
 825  * @unimplemented
 826  */
 827 BOOL
 828 STDCALL
 829 FindVolumeMountPointClose(
 830     HANDLE hFindVolumeMountPoint
 831     )
 832 {
 833     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 834     return 0;
 835 }
 836
 837 /*
 838  * @unimplemented
 839  */
 840 BOOL
 841 STDCALL
 842 FreeUserPhysicalPages(
 843     HANDLE hProcess,
 844     PULONG_PTR NumberOfPages,
 845     PULONG_PTR PageArray
 846     )
 847 {
 848     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 849     return 0;
 850 }
 851
 852 /*
 853  * @unimplemented
 854  */
 855 BOOL
 856 STDCALL
 857 GetCurrentActCtx(
 858     HANDLE *lphActCtx)
 859 {
 860     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 861     return 0;
 862 }
 863
 864 /*
 865  * @unimplemented
 866  */
 867 BOOL
 868 STDCALL
 869 GetDevicePowerState(
 870     HANDLE hDevice,
 871     BOOL *pfOn
 872     )
 873 {
 874     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 875     return 0;
 876 }
 877
 878 /*
 879  * @unimplemented
 880  */
 881 VOID
 882 STDCALL
 883 GetNativeSystemInfo(
 884     LPSYSTEM_INFO lpSystemInfo
 885     )
 886 {
 887     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 888 }
 889
 890 /*
 891  * @unimplemented
 892  */
 893 BOOL
 894 STDCALL
 895 GetNumaHighestNodeNumber(
 896     PULONG HighestNodeNumber
 897     )
 898 {
 899     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 900     return 0;
 901 }
 902
 903 /*
 904  * @unimplemented
 905  */
 906 BOOL
 907 STDCALL
 908 GetNumaNodeProcessorMask(
 909     UCHAR Node,
 910     PULONGLONG ProcessorMask
 911     )
 912 {
 913     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 914     return 0;
 915 }
 916
 917 /*
 918  * @unimplemented
 919  */
 920 BOOL
 921 STDCALL
 922 GetNumaProcessorNode(
 923     UCHAR Processor,
 924     PUCHAR NodeNumber
 925     )
 926 {
 927     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 928     return 0;
 929 }
 930
 931 /*
 932  * @unimplemented
 933  */
 934 BOOL
 935 STDCALL
 936 GetProcessHandleCount(
 937     HANDLE hProcess,
 938     PDWORD pdwHandleCount
 939     )
 940 {
 941     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 942     return 0;
 943 }
 944
 945 /*
 946  * @unimplemented
 947  */
 948 BOOL
 949 STDCALL
 950 GetProcessPriorityBoost(
 951     HANDLE hProcess,
 952     PBOOL pDisablePriorityBoost
 953     )
 954 {
 955     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 956     return 0;
 957 }
 958
 959 /*
 960  * @unimplemented
 961  */
 962 BOOL
 963 STDCALL
 964 GetSystemRegistryQuota(
 965     PDWORD pdwQuotaAllowed,
 966     PDWORD pdwQuotaUsed
 967     )
 968 {
 969     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 970     return 0;
 971 }
 972
 973 /*
 974  * @unimplemented
 975  */
 976 BOOL
 977 STDCALL
 978 GetSystemTimes(
 979     LPFILETIME lpIdleTime,
 980     LPFILETIME lpKernelTime,
 981     LPFILETIME lpUserTime
 982     )
 983 {
 984     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 985     return 0;
 986 }
 987
 988 /*
 989  * @unimplemented
 990  */
 991 BOOL
 992 STDCALL
 993 GetThreadIOPendingFlag(
 994     HANDLE hThread,
 995     PBOOL lpIOIsPending
 996     )
 997 {
 998     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 999     return 0;
1000 }
1001
1002 /*
1003  * @unimplemented
1004  */
1005 UINT
1006 STDCALL
1007 GetWriteWatch(
1008     DWORD  dwFlags,
1009     PVOID  lpBaseAddress,
1010     SIZE_T dwRegionSize,
1011     PVOID *lpAddresses,
1012     PULONG_PTR lpdwCount,
1013     PULONG lpdwGranularity
1014     )
1015 {
1016     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1017     return 0;
1018 }
1019
1020 /*
1021  * @unimplemented
1022  */
1023 BOOL
1024 STDCALL
1025 GlobalMemoryStatusEx(
1026     LPMEMORYSTATUSEX lpBuffer
1027     )
1028 {
1029     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1030     return 0;
1031 }
1032
1033 /*
1034  * @unimplemented
1035  */
1036 BOOL
1037 STDCALL
1038 HeapQueryInformation (
1039     HANDLE HeapHandle,
1040     HEAP_INFORMATION_CLASS HeapInformationClass,
1041     PVOID HeapInformation OPTIONAL,
1042     SIZE_T HeapInformationLength OPTIONAL,
1043     PSIZE_T ReturnLength OPTIONAL
1044     )
1045 {
1046     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1047     return 0;
1048 }
1049
1050 /*
1051  * @unimplemented
1052  */
1053 BOOL
1054 STDCALL
1055 HeapSetInformation (
1056     HANDLE HeapHandle,
1057     HEAP_INFORMATION_CLASS HeapInformationClass,
1058     PVOID HeapInformation OPTIONAL,
1059     SIZE_T HeapInformationLength OPTIONAL
1060     )
1061 {
1062     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1063     return 0;
1064 }
1065
1066 /*
1067  * @unimplemented
1068  */
1069 BOOL
1070 STDCALL
1071 IsProcessInJob (
1072     HANDLE ProcessHandle,
1073     HANDLE JobHandle,
1074     PBOOL Result
1075     )
1076 {
1077     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1078     return 0;
1079 }
1080
1081 /*
1082  * @unimplemented
1083  */
1084 BOOL
1085 STDCALL
1086 IsSystemResumeAutomatic(
1087     VOID
1088     )
1089 {
1090     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1091     return 0;
1092 }
1093
1094 /*
1095  * @unimplemented
1096  */
1097 BOOL
1098 STDCALL
1099 IsWow64Process(
1100     HANDLE hProcess,
1101     PBOOL Wow64Process
1102     )
1103 {
1104     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1105     return 0;
1106 }
1107
1108 /*
1109  * @unimplemented
1110  */
1111 BOOL
1112 STDCALL
1113 MapUserPhysicalPages(
1114     PVOID VirtualAddress,
1115     ULONG_PTR NumberOfPages,
1116     PULONG_PTR PageArray OPTIONAL
1117     )
1118 {
1119     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1120     return 0;
1121 }
1122
1123 /*
1124  * @unimplemented
1125  */
1126 BOOL
1127 STDCALL
1128 MapUserPhysicalPagesScatter(
1129     PVOID *VirtualAddresses,
1130     ULONG_PTR NumberOfPages,
1131     PULONG_PTR PageArray OPTIONAL
1132     )
1133 {
1134     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1135     return 0;
1136 }
1137
1138 /*
1139  * @unimplemented
1140  */
1141 HANDLE
1142 STDCALL
1143 OpenThread(
1144     DWORD dwDesiredAccess,
1145     BOOL bInheritHandle,
1146     DWORD dwThreadId
1147     )
1148 {
1149     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1150     return 0;
1151 }
1152
1153 /*
1154  * @unimplemented
1155  */
1156 BOOL
1157 STDCALL
1158 QueryActCtxW(
1159     DWORD dwFlags,
1160     HANDLE hActCtx,
1161     PVOID pvSubInstance,
1162     ULONG ulInfoClass,
1163     PVOID pvBuffer,
1164     SIZE_T cbBuffer OPTIONAL,
1165     SIZE_T *pcbWrittenOrRequired OPTIONAL
1166     )
1167 {
1168     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1169     return 0;
1170 }
1171
1172 /*
1173  * @unimplemented
1174  */
1175 BOOL
1176 STDCALL
1177 QueryInformationJobObject(
1178     HANDLE hJob,
1179     JOBOBJECTINFOCLASS JobObjectInformationClass,
1180     LPVOID lpJobObjectInformation,
1181     DWORD cbJobObjectInformationLength,
1182     LPDWORD lpReturnLength
1183     )
1184 {
1185     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1186     return 0;
1187 }
1188
1189 /*
1190  * @unimplemented
1191  */
1192 BOOL
1193 STDCALL
1194 QueryMemoryResourceNotification(
1195      HANDLE ResourceNotificationHandle,
1196     PBOOL  ResourceState
1197     )
1198 {
1199     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1200     return 0;
1201 }
1202
1203 /*
1204  * @unimplemented
1205  */
1206 DWORD
1207 STDCALL
1208 QueueUserAPC(
1209     PAPCFUNC pfnAPC,
1210     HANDLE hThread,
1211     ULONG_PTR dwData
1212     )
1213 {
1214     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1215     return 0;
1216 }
1217
1218 /*
1219  * @unimplemented
1220  */
1221 BOOL
1222 STDCALL
1223 QueueUserWorkItem(
1224     LPTHREAD_START_ROUTINE Function,
1225     PVOID Context,
1226     ULONG Flags
1227     )
1228 {
1229     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1230     return 0;
1231 }
1232
1233 /*
1234  * @unimplemented
1235  */
1236 BOOL
1237 STDCALL
1238 ReadDirectoryChangesW(
1239     HANDLE hDirectory,
1240     LPVOID lpBuffer,
1241     DWORD nBufferLength,
1242     BOOL bWatchSubtree,
1243     DWORD dwNotifyFilter,
1244     LPDWORD lpBytesReturned,
1245     LPOVERLAPPED lpOverlapped,
1246     LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
1247     )
1248 {
1249     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1250     return 0;
1251 }
1252
1253 /*
1254  * @unimplemented
1255  */
1256 BOOL
1257 STDCALL
1258 ReadFileScatter(
1259     HANDLE hFile,
1260     FILE_SEGMENT_ELEMENT aSegmentArray[],
1261     DWORD nNumberOfBytesToRead,
1262     LPDWORD lpReserved,
1263     LPOVERLAPPED lpOverlapped
1264     )
1265 {
1266     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1267     return 0;
1268 }
1269
1270 /*
1271  * @unimplemented
1272  */
1273 BOOL
1274 STDCALL
1275 RegisterWaitForSingleObject(
1276     PHANDLE phNewWaitObject,
1277     HANDLE hObject,
1278     WAITORTIMERCALLBACK Callback,
1279     PVOID Context,
1280     ULONG dwMilliseconds,
1281     ULONG dwFlags
1282     )
1283 {
1284     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1285     return 0;
1286 }
1287
1288 /*
1289  * @unimplemented
1290  */
1291 HANDLE
1292 STDCALL
1293 RegisterWaitForSingleObjectEx(
1294     HANDLE hObject,
1295     WAITORTIMERCALLBACK Callback,
1296     PVOID Context,
1297     ULONG dwMilliseconds,
1298     ULONG dwFlags
1299     )
1300 {
1301     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1302     return 0;
1303 }
1304
1305 /*
1306  * @unimplemented
1307  */
1308 VOID
1309 STDCALL
1310 ReleaseActCtx(
1311     HANDLE hActCtx
1312     )
1313 {
1314     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1315 }
1316
1317 /*
1318  * @unimplemented
1319  */
1320 ULONG
1321 STDCALL
1322 RemoveVectoredExceptionHandler(
1323     PVOID VectoredHandlerHandle
1324     )
1325 {
1326     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1327     return 0;
1328 }
1329
1330 /*
1331  * @unimplemented
1332  */
1333 BOOL
1334 STDCALL
1335 RequestDeviceWakeup(
1336     HANDLE hDevice
1337     )
1338 {
1339     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1340     return 0;
1341 }
1342
1343 /*
1344  * @unimplemented
1345  */
1346 BOOL
1347 STDCALL
1348 RequestWakeupLatency(
1349     LATENCY_TIME latency
1350     )
1351 {
1352     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1353     return 0;
1354 }
1355
1356 /*
1357  * @unimplemented
1358  */
1359 UINT
1360 STDCALL
1361 ResetWriteWatch(
1362     LPVOID lpBaseAddress,
1363     SIZE_T dwRegionSize
1364     )
1365 {
1366     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1367     return 0;
1368 }
1369
1370 /*
1371  * @unimplemented
1372  */
1373 VOID
1374 STDCALL
1375 RestoreLastError(
1376     DWORD dwErrCode
1377     )
1378 {
1379     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1380 }
1381
1382 /*
1383  * @unimplemented
1384  */
1385 DWORD
1386 STDCALL
1387 SetCriticalSectionSpinCount(
1388     LPCRITICAL_SECTION lpCriticalSection,
1389     DWORD dwSpinCount
1390     )
1391 {
1392     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1393     return 0;
1394 }
1395
1396 /*
1397  * @unimplemented
1398  */
1399 BOOL
1400 STDCALL
1401 SetInformationJobObject(
1402     HANDLE hJob,
1403     JOBOBJECTINFOCLASS JobObjectInformationClass,
1404     LPVOID lpJobObjectInformation,
1405     DWORD cbJobObjectInformationLength
1406     )
1407 {
1408     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1409     return 0;
1410 }
1411
1412 /*
1413  * @unimplemented
1414  */
1415 BOOL
1416 STDCALL
1417 SetMessageWaitingIndicator(
1418     HANDLE hMsgIndicator,
1419     ULONG ulMsgCount
1420     )
1421 {
1422     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1423     return 0;
1424 }
1425
1426 /*
1427  * @unimplemented
1428  */
1429 BOOL
1430 STDCALL
1431 SetProcessPriorityBoost(
1432     HANDLE hProcess,
1433     BOOL bDisablePriorityBoost
1434     )
1435 {
1436     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1437     return 0;
1438 }
1439
1440 /*
1441  * @unimplemented
1442  */
1443 EXECUTION_STATE
1444 STDCALL
1445 SetThreadExecutionState(
1446     EXECUTION_STATE esFlags
1447     )
1448 {
1449     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1450     return 0;
1451 }
1452
1453 /*
1454  * @unimplemented
1455  */
1456 HANDLE
1457 STDCALL
1458 SetTimerQueueTimer(
1459     HANDLE TimerQueue,
1460     WAITORTIMERCALLBACK Callback,
1461     PVOID Parameter,
1462     DWORD DueTime,
1463     DWORD Period,
1464     BOOL PreferIo
1465     )
1466 {
1467     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1468     return 0;
1469 }
1470
1471 /*
1472  * @unimplemented
1473  */
1474 BOOL
1475 STDCALL
1476 TerminateJobObject(
1477     HANDLE hJob,
1478     UINT uExitCode
1479     )
1480 {
1481     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1482     return 0;
1483 }
1484
1485 /*
1486  * @unimplemented
1487  */
1488 BOOL
1489 STDCALL
1490 TzSpecificLocalTimeToSystemTime(
1491     LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
1492     LPSYSTEMTIME lpLocalTime,
1493     LPSYSTEMTIME lpUniversalTime
1494     )
1495 {
1496     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1497     return 0;
1498 }
1499
1500 /*
1501  * @unimplemented
1502  */
1503 BOOL
1504 STDCALL
1505 UnregisterWait(
1506     HANDLE WaitHandle
1507     )
1508 {
1509     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1510     return 0;
1511 }
1512
1513 /*
1514  * @unimplemented
1515  */
1516 BOOL
1517 STDCALL
1518 UnregisterWaitEx(
1519     HANDLE WaitHandle,
1520     HANDLE CompletionEvent
1521     )
1522 {
1523     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1524     return 0;
1525 }
1526
1527 /*
1528  * @unimplemented
1529  */
1530 BOOL
1531 STDCALL
1532 WriteFileGather(
1533     HANDLE hFile,
1534     FILE_SEGMENT_ELEMENT aSegmentArray[],
1535     DWORD nNumberOfBytesToWrite,
1536     LPDWORD lpReserved,
1537     LPOVERLAPPED lpOverlapped
1538     )
1539 {
1540     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1541     return 0;
1542 }
1543
1544 /*
1545  * @unimplemented
1546  */
1547 DWORD
1548 STDCALL
1549 WTSGetActiveConsoleSessionId(VOID)
1550 {
1551     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1552     return 0;
1553 }
1554
1555 /*
1556  * @unimplemented
1557  */
1558 BOOL
1559 STDCALL
1560 ZombifyActCtx(
1561     HANDLE hActCtx
1562     )
1563 {
1564     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1565     return 0;
1566 }
1567
1568 /*
1569  * @unimplemented
1570  */
1571 BOOL
1572 STDCALL
1573 CheckNameLegalDOS8Dot3W(
1574     LPCWSTR lpName,
1575     LPSTR lpOemName OPTIONAL,
1576     DWORD OemNameSize OPTIONAL,
1577     PBOOL pbNameContainsSpaces OPTIONAL,
1578     PBOOL pbNameLegal
1579     )
1580 {
1581     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1582     return 0;
1583 }
1584
1585 /*
1586  * @unimplemented
1587  */
1588 HANDLE
1589 STDCALL
1590 CreateJobObjectW(
1591     LPSECURITY_ATTRIBUTES lpJobAttributes,
1592     LPCWSTR lpName
1593     )
1594 {
1595     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1596     return 0;
1597 }
1598
1599 /*
1600  * @unimplemented
1601  */
1602 BOOL
1603 STDCALL
1604 DeleteVolumeMountPointW(
1605     LPCWSTR lpszVolumeMountPoint
1606     )
1607 {
1608     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1609     return 0;
1610 }
1611
1612 /*
1613  * @unimplemented
1614  */
1615 BOOL
1616 STDCALL
1617 DnsHostnameToComputerNameW (
1618     LPCWSTR Hostname,
1619     LPWSTR ComputerName,
1620     LPDWORD nSize
1621     )
1622 {
1623     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1624     return 0;
1625 }
1626
1627 /*
1628  * @unimplemented
1629  */
1630 BOOL
1631 STDCALL
1632 FindActCtxSectionStringW(
1633     DWORD dwFlags,
1634     const GUID *lpExtensionGuid,
1635     ULONG ulSectionId,
1636     LPCWSTR lpStringToFind,
1637     PACTCTX_SECTION_KEYED_DATA ReturnedData
1638     )
1639 {
1640     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1641     return 0;
1642 }
1643
1644 /*
1645  * @unimplemented
1646  */
1647 HANDLE
1648 STDCALL
1649 FindFirstVolumeW(
1650     LPWSTR lpszVolumeName,
1651     DWORD cchBufferLength
1652     )
1653 {
1654     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1655     return 0;
1656 }
1657
1658 /*
1659  * @unimplemented
1660  */
1661 HANDLE
1662 STDCALL
1663 FindFirstVolumeMountPointW(
1664     LPCWSTR lpszRootPathName,
1665     LPWSTR lpszVolumeMountPoint,
1666     DWORD cchBufferLength
1667     )
1668 {
1669     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1670     return 0;
1671 }
1672
1673 /*
1674  * @unimplemented
1675  */
1676 BOOL
1677 STDCALL
1678 FindNextVolumeW(
1679     HANDLE hFindVolume,
1680     LPWSTR lpszVolumeName,
1681     DWORD cchBufferLength
1682     )
1683 {
1684     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1685     return 0;
1686 }
1687
1688 /*
1689  * @unimplemented
1690  */
1691 BOOL
1692 STDCALL
1693 FindNextVolumeMountPointW(
1694     HANDLE hFindVolumeMountPoint,
1695     LPWSTR lpszVolumeMountPoint,
1696     DWORD cchBufferLength
1697     )
1698 {
1699     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1700     return 0;
1701 }
1702
1703 /*
1704  * @unimplemented
1705  */
1706 DWORD
1707 STDCALL
1708 GetDllDirectoryW(
1709     DWORD nBufferLength,
1710     LPWSTR lpBuffer
1711     )
1712 {
1713     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1714     return 0;
1715 }
1716
1717 /*
1718  * @unimplemented
1719  */
1720 DWORD
1721 STDCALL
1722 GetFirmwareEnvironmentVariableW(
1723     LPCWSTR lpName,
1724     LPCWSTR lpGuid,
1725     PVOID   pBuffer,
1726     DWORD    nSize
1727     )
1728 {
1729     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1730     return 0;
1731 }
1732
1733 /*
1734  * @unimplemented
1735  */
1736 DWORD
1737 STDCALL
1738 GetLongPathNameW(
1739     LPCWSTR lpszShortPath,
1740     LPWSTR  lpszLongPath,
1741     DWORD    cchBuffer
1742     )
1743 {
1744     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1745     return 0;
1746 }
1747
1748 /*
1749  * @unimplemented
1750  */
1751 BOOL
1752 STDCALL
1753 GetModuleHandleExW(
1754     DWORD        dwFlags,
1755     LPCWSTR     lpModuleName,
1756     HMODULE*    phModule
1757     )
1758 {
1759     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1760     return 0;
1761 }
1762
1763 /*
1764  * @unimplemented
1765  */
1766 UINT
1767 STDCALL
1768 GetSystemWow64DirectoryW(
1769     LPWSTR lpBuffer,
1770     UINT uSize
1771     )
1772 {
1773     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1774     return 0;
1775 }
1776
1777 /*
1778  * @unimplemented
1779  */
1780 BOOL
1781 STDCALL
1782 GetVolumeNameForVolumeMountPointW(
1783     LPCWSTR lpszVolumeMountPoint,
1784     LPWSTR lpszVolumeName,
1785     DWORD cchBufferLength
1786     )
1787 {
1788     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1789     return 0;
1790 }
1791
1792 /*
1793  * @unimplemented
1794  */
1795 BOOL
1796 STDCALL
1797 GetVolumePathNameW(
1798     LPCWSTR lpszFileName,
1799     LPWSTR lpszVolumePathName,
1800     DWORD cchBufferLength
1801     )
1802 {
1803     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1804     return 0;
1805 }
1806
1807 /*
1808  * @unimplemented
1809  */
1810 BOOL
1811 STDCALL
1812 GetVolumePathNamesForVolumeNameW(
1813     LPCWSTR lpszVolumeName,
1814     LPWSTR lpszVolumePathNames,
1815     DWORD cchBufferLength,
1816     PDWORD lpcchReturnLength
1817     )
1818 {
1819     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1820     return 0;
1821 }
1822
1823 /*
1824  * @unimplemented
1825  */
1826 HANDLE
1827 STDCALL
1828 OpenJobObjectW(
1829     DWORD dwDesiredAccess,
1830     BOOL bInheritHandle,
1831     LPCWSTR lpName
1832     )
1833 {
1834     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1835     return 0;
1836 }
1837
1838 /*
1839  * @unimplemented
1840  */
1841 BOOL
1842 STDCALL
1843 ReplaceFileW(
1844     LPCWSTR lpReplacedFileName,
1845     LPCWSTR lpReplacementFileName,
1846     LPCWSTR lpBackupFileName,
1847     DWORD   dwReplaceFlags,
1848     LPVOID  lpExclude,
1849     LPVOID  lpReserved
1850     )
1851 {
1852     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1853     return 0;
1854 }
1855
1856 /*
1857  * @unimplemented
1858  */
1859 BOOL
1860 STDCALL
1861 SetComputerNameExW (
1862     COMPUTER_NAME_FORMAT NameType,
1863     LPCWSTR lpBuffer
1864     )
1865 {
1866     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1867     return 0;
1868 }
1869
1870 /*
1871  * @unimplemented
1872  */
1873 BOOL
1874 STDCALL
1875 SetDllDirectoryW(
1876     LPCWSTR lpPathName
1877     )
1878 {
1879     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1880     return 0;
1881 }
1882
1883 /*
1884  * @unimplemented
1885  */
1886 BOOL
1887 STDCALL
1888 SetFirmwareEnvironmentVariableW(
1889     LPCWSTR lpName,
1890     LPCWSTR lpGuid,
1891     PVOID    pValue,
1892     DWORD    nSize
1893     )
1894 {
1895     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1896     return 0;
1897 }
1898
1899 /*
1900  * @unimplemented
1901  */
1902 BOOL
1903 STDCALL
1904 SetVolumeMountPointW(
1905     LPCWSTR lpszVolumeMountPoint,
1906     LPCWSTR lpszVolumeName
1907     )
1908 {
1909     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1910     return 0;
1911 }
1912
1913 /*
1914  * @unimplemented
1915  */
1916 BOOL
1917 STDCALL
1918 VerifyVersionInfoW(
1919     LPOSVERSIONINFOEXW lpVersionInformation,
1920     DWORD dwTypeMask,
1921     DWORDLONG dwlConditionMask
1922     )
1923 {
1924     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1925     return 0;
1926 }
1927
1928 /*
1929  * @unimplemented
1930  */
1931 BOOL
1932 STDCALL
1933 CheckNameLegalDOS8Dot3A(
1934     LPCSTR lpName,
1935     LPSTR lpOemName OPTIONAL,
1936     DWORD OemNameSize OPTIONAL,
1937     PBOOL pbNameContainsSpaces OPTIONAL,
1938     PBOOL pbNameLegal
1939     )
1940 {
1941     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1942     return 0;
1943 }
1944
1945 /*
1946  * @unimplemented
1947  */
1948 HANDLE
1949 STDCALL
1950 CreateJobObjectA(
1951     LPSECURITY_ATTRIBUTES lpJobAttributes,
1952     LPCSTR lpName
1953     )
1954 {
1955     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1956     return 0;
1957 }
1958
1959 /*
1960  * @unimplemented
1961  */
1962 BOOL
1963 STDCALL
1964 DeleteVolumeMountPointA(
1965     LPCSTR lpszVolumeMountPoint
1966     )
1967 {
1968     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1969     return 0;
1970 }
1971
1972 /*
1973  * @unimplemented
1974  */
1975 BOOL
1976 STDCALL
1977 DnsHostnameToComputerNameA (
1978     LPCSTR Hostname,
1979     LPSTR ComputerName,
1980     LPDWORD nSize
1981     )
1982 {
1983     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1984     return 0;
1985 }
1986
1987 /*
1988  * @unimplemented
1989  */
1990 BOOL
1991 STDCALL
1992 FindActCtxSectionStringA(
1993     DWORD dwFlags,
1994     const GUID *lpExtensionGuid,
1995     ULONG ulSectionId,
1996     LPCSTR lpStringToFind,
1997     PACTCTX_SECTION_KEYED_DATA ReturnedData
1998     )
1999 {
2000     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2001     return 0;
2002 }
2003
2004 /*
2005  * @unimplemented
2006  */
2007 HANDLE
2008 STDCALL
2009 FindFirstVolumeA(
2010     LPSTR lpszVolumeName,
2011     DWORD cchBufferLength
2012     )
2013 {
2014     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2015     return 0;
2016 }
2017
2018 /*
2019  * @unimplemented
2020  */
2021 HANDLE
2022 STDCALL
2023 FindFirstVolumeMountPointA(
2024     LPCSTR lpszRootPathName,
2025     LPSTR lpszVolumeMountPoint,
2026     DWORD cchBufferLength
2027     )
2028 {
2029     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2030     return 0;
2031 }
2032
2033 /*
2034  * @unimplemented
2035  */
2036 BOOL
2037 STDCALL
2038 FindNextVolumeA(
2039     HANDLE hFindVolume,
2040     LPSTR lpszVolumeName,
2041     DWORD cchBufferLength
2042     )
2043 {
2044     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2045     return 0;
2046 }
2047
2048 /*
2049  * @unimplemented
2050  */
2051 BOOL
2052 STDCALL
2053 FindNextVolumeMountPointA(
2054     HANDLE hFindVolumeMountPoint,
2055     LPSTR lpszVolumeMountPoint,
2056     DWORD cchBufferLength
2057     )
2058 {
2059     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2060     return 0;
2061 }
2062
2063 /*
2064  * @unimplemented
2065  */
2066 DWORD
2067 STDCALL
2068 GetDllDirectoryA(
2069     DWORD nBufferLength,
2070     LPSTR lpBuffer
2071     )
2072 {
2073     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2074     return 0;
2075 }
2076
2077 /*
2078  * @unimplemented
2079  */
2080 DWORD
2081 STDCALL
2082 GetFirmwareEnvironmentVariableA(
2083     LPCSTR lpName,
2084     LPCSTR lpGuid,
2085     PVOID   pBuffer,
2086     DWORD    nSize
2087     )
2088 {
2089     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2090     return 0;
2091 }
2092
2093 /*
2094  * @unimplemented
2095  */
2096 DWORD
2097 STDCALL
2098 GetLongPathNameA(
2099     LPCSTR lpszShortPath,
2100     LPSTR  lpszLongPath,
2101     DWORD    cchBuffer
2102     )
2103 {
2104     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2105     return 0;
2106 }
2107
2108 /*
2109  * @unimplemented
2110  */
2111 BOOL
2112 STDCALL
2113 GetModuleHandleExA(
2114     DWORD        dwFlags,
2115     LPCSTR     lpModuleName,
2116     HMODULE*    phModule
2117     )
2118 {
2119     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2120     return 0;
2121 }
2122
2123 /*
2124  * @unimplemented
2125  */
2126 UINT
2127 STDCALL
2128 GetSystemWow64DirectoryA(
2129     LPSTR lpBuffer,
2130     UINT uSize
2131     )
2132 {
2133     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2134     return 0;
2135 }
2136
2137 /*
2138  * @unimplemented
2139  */
2140 BOOL
2141 STDCALL
2142 GetVolumeNameForVolumeMountPointA(
2143     LPCSTR lpszVolumeMountPoint,
2144     LPSTR lpszVolumeName,
2145     DWORD cchBufferLength
2146     )
2147 {
2148     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2149     return 0;
2150 }
2151
2152 /*
2153  * @unimplemented
2154  */
2155 BOOL
2156 STDCALL
2157 GetVolumePathNameA(
2158     LPCSTR lpszFileName,
2159     LPSTR lpszVolumePathName,
2160     DWORD cchBufferLength
2161     )
2162 {
2163     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2164     return 0;
2165 }
2166
2167 /*
2168  * @unimplemented
2169  */
2170 BOOL
2171 STDCALL
2172 GetVolumePathNamesForVolumeNameA(
2173     LPCSTR lpszVolumeName,
2174     LPSTR lpszVolumePathNames,
2175     DWORD cchBufferLength,
2176     PDWORD lpcchReturnLength
2177     )
2178 {
2179     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2180     return 0;
2181 }
2182
2183 /*
2184  * @unimplemented
2185  */
2186 HANDLE
2187 STDCALL
2188 OpenJobObjectA(
2189     DWORD dwDesiredAccess,
2190     BOOL bInheritHandle,
2191     LPCSTR lpName
2192     )
2193 {
2194     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2195     return 0;
2196 }
2197
2198 /*
2199  * @unimplemented
2200  */
2201 BOOL
2202 STDCALL
2203 ReplaceFileA(
2204     LPCSTR  lpReplacedFileName,
2205     LPCSTR  lpReplacementFileName,
2206     LPCSTR  lpBackupFileName,
2207     DWORD   dwReplaceFlags,
2208     LPVOID  lpExclude,
2209     LPVOID  lpReserved
2210     )
2211 {
2212     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2213     return 0;
2214 }
2215
2216 /*
2217  * @unimplemented
2218  */
2219 BOOL
2220 STDCALL
2221 SetComputerNameExA (
2222     COMPUTER_NAME_FORMAT NameType,
2223     LPCSTR lpBuffer
2224     )
2225 {
2226     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2227     return 0;
2228 }
2229
2230 /*
2231  * @unimplemented
2232  */
2233 BOOL
2234 STDCALL
2235 SetDllDirectoryA(
2236     LPCSTR lpPathName
2237     )
2238 {
2239     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2240     return 0;
2241 }
2242
2243 /*
2244  * @unimplemented
2245  */
2246 BOOL
2247 STDCALL
2248 SetFirmwareEnvironmentVariableA(
2249     LPCSTR lpName,
2250     LPCSTR lpGuid,
2251     PVOID    pValue,
2252     DWORD    nSize
2253     )
2254 {
2255     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2256     return 0;
2257 }
2258
2259 /*
2260  * @unimplemented
2261  */
2262 BOOL
2263 STDCALL
2264 SetVolumeMountPointA(
2265     LPCSTR lpszVolumeMountPoint,
2266     LPCSTR lpszVolumeName
2267     )
2268 {
2269     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2270     return 0;
2271 }
2272
2273 /*
2274  * @unimplemented
2275  */
2276 BOOL
2277 STDCALL
2278 VerifyVersionInfoA(
2279     LPOSVERSIONINFOEXA lpVersionInformation,
2280     DWORD dwTypeMask,
2281     DWORDLONG dwlConditionMask
2282     )
2283 {
2284     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2285     return 0;
2286 }
2287
2288 /*
2289  * @unimplemented
2290  */
2291 BOOL
2292 STDCALL
2293 EnumSystemLanguageGroupsW(
2294     LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc,
2295     DWORD                   dwFlags,
2296     LONG_PTR                lParam)
2297 {
2298     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2299     return 0;
2300 }
2301
2302 /*
2303  * @unimplemented
2304  */
2305 ULONGLONG
2306 STDCALL
2307 VerSetConditionMask(
2308         ULONGLONG   ConditionMask,
2309         DWORD   TypeMask,
2310         BYTE    Condition
2311         )
2312 {
2313     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2314     return 0;
2315 }
2316
2317 /*
2318  * @unimplemented
2319  */
2320 BOOL STDCALL GetConsoleKeyboardLayoutNameA(LPSTR name)
2321 {
2322     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2323     return 0;
2324 }
2325
2326 /*
2327  * @unimplemented
2328  */
2329 BOOL STDCALL GetConsoleKeyboardLayoutNameW(LPWSTR name)
2330 {
2331     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2332     return 0;
2333 }
2334
2335 /*
2336  * @unimplemented
2337  */
2338 DWORD STDCALL GetHandleContext(HANDLE hnd)
2339 {
2340     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2341     return 0;
2342 }
2343
2344 /*
2345  * @unimplemented
2346  */
2347 HANDLE STDCALL CreateSocketHandle(VOID)
2348 {
2349     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2350     return 0;
2351 }
2352
2353 /*
2354  * @unimplemented
2355  */
2356 BOOL STDCALL SetHandleContext(HANDLE hnd,DWORD context)
2357 {
2358     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2359     return 0;
2360 }
2361
2362 /*
2363  * @unimplemented
2364  */
2365 BOOL STDCALL SetConsoleInputExeNameA(LPCSTR name)
2366 {
2367     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2368     return 0;
2369 }
2370
2371 /*
2372  * @unimplemented
2373  */
2374 BOOL STDCALL SetConsoleInputExeNameW(LPCWSTR name)
2375 {
2376     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2377     return 0;
2378 }
2379
2380 /*
2381  * @unimplemented
2382  */
2383 BOOL STDCALL UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
2384                         LPSTR lpszInitName, LPSTR lpszProcName,
2385                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
2386                         LPVOID lpBuff )
2387 {
2388     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2389     return 0;
2390 }
2391
2392 /*
2393  * @unimplemented
2394  */
2395 VOID STDCALL UTUnRegister( HMODULE hModule )
2396 {
2397     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2398 }
2399
2400 /*
2401  * @unimplemented
2402  */
2403 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PDelayLoadInfo pdli)
2404 {
2405     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2406     return 0;
2407 }
2408
2409 /*
2410  * @unimplemented
2411  */
2412 NTSTATUS STDCALL CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
2413 {
2414     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2415     return 0;
2416 }
2417
2418 /*
2419  * @unimplemented
2420  */
2421 BOOL STDCALL GetConsoleInputExeNameA(ULONG length,LPCSTR name)
2422 {
2423     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2424     return 0;
2425 }
2426
2427 /*
2428  * @unimplemented
2429  */
2430 BOOL STDCALL GetConsoleInputExeNameW(ULONG length,LPCWSTR name)
2431 {
2432     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2433     return 0;
2434 }
2435
2436 /*
2437  * @unimplemented
2438  */
2439 BOOL STDCALL IsValidUILanguage(LANGID langid)
2440 {
2441     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2442     return 0;
2443 }
2444
2445 /*
2446  * @unimplemented
2447  */
2448 VOID STDCALL NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
2449 {
2450     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2451 }
2452
2453 /*
2454  * @unimplemented
2455  */
2456 UINT STDCALL SetCPGlobal(UINT CodePage)
2457 {
2458     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2459     return 0;
2460 }
2461
2462 /*
2463  * @unimplemented
2464  */
2465 BOOL
2466 STDCALL
2467 SetClientTimeZoneInformation(
2468                        CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation
2469                        )
2470 {
2471     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2472     return 0;
2473 }