reactos/lib/kernel32/misc/stubs.c

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