reactos/lib/kernel32/misc/stubs.c

   1 /* $Id: stubs.c,v 1.62 2004/02/15 07:03:56 arty 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 BOOL
 882 STDCALL
 883 GetFileSizeEx(
 884     HANDLE hFile,
 885     PLARGE_INTEGER lpFileSize
 886     )
 887 {
 888     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 889     return 0;
 890 }
 891
 892 /*
 893  * @unimplemented
 894  */
 895 VOID
 896 STDCALL
 897 GetNativeSystemInfo(
 898     LPSYSTEM_INFO lpSystemInfo
 899     )
 900 {
 901     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 902 }
 903
 904 /*
 905  * @unimplemented
 906  */
 907 BOOL
 908 STDCALL
 909 GetNumaHighestNodeNumber(
 910     PULONG HighestNodeNumber
 911     )
 912 {
 913     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 914     return 0;
 915 }
 916
 917 /*
 918  * @unimplemented
 919  */
 920 BOOL
 921 STDCALL
 922 GetNumaNodeProcessorMask(
 923     UCHAR Node,
 924     PULONGLONG ProcessorMask
 925     )
 926 {
 927     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 928     return 0;
 929 }
 930
 931 /*
 932  * @unimplemented
 933  */
 934 BOOL
 935 STDCALL
 936 GetNumaProcessorNode(
 937     UCHAR Processor,
 938     PUCHAR NodeNumber
 939     )
 940 {
 941     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 942     return 0;
 943 }
 944
 945 /*
 946  * @unimplemented
 947  */
 948 BOOL
 949 STDCALL
 950 GetProcessHandleCount(
 951     HANDLE hProcess,
 952     PDWORD pdwHandleCount
 953     )
 954 {
 955     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 956     return 0;
 957 }
 958
 959 /*
 960  * @unimplemented
 961  */
 962 DWORD
 963 STDCALL
 964 GetProcessId(
 965     HANDLE Process
 966     )
 967 {
 968     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 969     return 0;
 970 }
 971
 972 /*
 973  * @unimplemented
 974  */
 975 BOOL
 976 STDCALL
 977 GetProcessIoCounters(
 978     HANDLE hProcess,
 979     PIO_COUNTERS lpIoCounters
 980     )
 981 {
 982     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 983     return 0;
 984 }
 985
 986 /*
 987  * @unimplemented
 988  */
 989 BOOL
 990 STDCALL
 991 GetProcessPriorityBoost(
 992     HANDLE hProcess,
 993     PBOOL pDisablePriorityBoost
 994     )
 995 {
 996     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 997     return 0;
 998 }
 999
1000 /*
1001  * @unimplemented
1002  */
1003 BOOL
1004 STDCALL
1005 GetSystemRegistryQuota(
1006     PDWORD pdwQuotaAllowed,
1007     PDWORD pdwQuotaUsed
1008     )
1009 {
1010     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1011     return 0;
1012 }
1013
1014 /*
1015  * @unimplemented
1016  */
1017 BOOL
1018 STDCALL
1019 GetSystemTimes(
1020     LPFILETIME lpIdleTime,
1021     LPFILETIME lpKernelTime,
1022     LPFILETIME lpUserTime
1023     )
1024 {
1025     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1026     return 0;
1027 }
1028
1029 /*
1030  * @unimplemented
1031  */
1032 BOOL
1033 STDCALL
1034 GetThreadIOPendingFlag(
1035     HANDLE hThread,
1036     PBOOL lpIOIsPending
1037     )
1038 {
1039     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1040     return 0;
1041 }
1042
1043 /*
1044  * @unimplemented
1045  */
1046 UINT
1047 STDCALL
1048 GetWriteWatch(
1049     DWORD  dwFlags,
1050     PVOID  lpBaseAddress,
1051     SIZE_T dwRegionSize,
1052     PVOID *lpAddresses,
1053     PULONG_PTR lpdwCount,
1054     PULONG lpdwGranularity
1055     )
1056 {
1057     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1058     return 0;
1059 }
1060
1061 /*
1062  * @unimplemented
1063  */
1064 BOOL
1065 STDCALL
1066 GlobalMemoryStatusEx(
1067     LPMEMORYSTATUSEX lpBuffer
1068     )
1069 {
1070     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1071     return 0;
1072 }
1073
1074 /*
1075  * @unimplemented
1076  */
1077 BOOL
1078 STDCALL
1079 HeapQueryInformation (
1080     HANDLE HeapHandle,
1081     HEAP_INFORMATION_CLASS HeapInformationClass,
1082     PVOID HeapInformation OPTIONAL,
1083     SIZE_T HeapInformationLength OPTIONAL,
1084     PSIZE_T ReturnLength OPTIONAL
1085     )
1086 {
1087     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1088     return 0;
1089 }
1090
1091 /*
1092  * @unimplemented
1093  */
1094 BOOL
1095 STDCALL
1096 HeapSetInformation (
1097     HANDLE HeapHandle,
1098     HEAP_INFORMATION_CLASS HeapInformationClass,
1099     PVOID HeapInformation OPTIONAL,
1100     SIZE_T HeapInformationLength OPTIONAL
1101     )
1102 {
1103     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1104     return 0;
1105 }
1106
1107 /*
1108  * @unimplemented
1109  */
1110 BOOL
1111 STDCALL
1112 IsProcessInJob (
1113     HANDLE ProcessHandle,
1114     HANDLE JobHandle,
1115     PBOOL Result
1116     )
1117 {
1118     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1119     return 0;
1120 }
1121
1122 /*
1123  * @unimplemented
1124  */
1125 BOOL
1126 STDCALL
1127 IsSystemResumeAutomatic(
1128     VOID
1129     )
1130 {
1131     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1132     return 0;
1133 }
1134
1135 /*
1136  * @unimplemented
1137  */
1138 BOOL
1139 STDCALL
1140 IsWow64Process(
1141     HANDLE hProcess,
1142     PBOOL Wow64Process
1143     )
1144 {
1145     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1146     return 0;
1147 }
1148
1149 /*
1150  * @unimplemented
1151  */
1152 BOOL
1153 STDCALL
1154 MapUserPhysicalPages(
1155     PVOID VirtualAddress,
1156     ULONG_PTR NumberOfPages,
1157     PULONG_PTR PageArray OPTIONAL
1158     )
1159 {
1160     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1161     return 0;
1162 }
1163
1164 /*
1165  * @unimplemented
1166  */
1167 BOOL
1168 STDCALL
1169 MapUserPhysicalPagesScatter(
1170     PVOID *VirtualAddresses,
1171     ULONG_PTR NumberOfPages,
1172     PULONG_PTR PageArray OPTIONAL
1173     )
1174 {
1175     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1176     return 0;
1177 }
1178
1179 /*
1180  * @unimplemented
1181  */
1182 HANDLE
1183 STDCALL
1184 OpenThread(
1185     DWORD dwDesiredAccess,
1186     BOOL bInheritHandle,
1187     DWORD dwThreadId
1188     )
1189 {
1190     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1191     return 0;
1192 }
1193
1194 /*
1195  * @unimplemented
1196  */
1197 BOOL
1198 STDCALL
1199 QueryActCtxW(
1200     DWORD dwFlags,
1201     HANDLE hActCtx,
1202     PVOID pvSubInstance,
1203     ULONG ulInfoClass,
1204     PVOID pvBuffer,
1205     SIZE_T cbBuffer OPTIONAL,
1206     SIZE_T *pcbWrittenOrRequired OPTIONAL
1207     )
1208 {
1209     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1210     return 0;
1211 }
1212
1213 /*
1214  * @unimplemented
1215  */
1216 BOOL
1217 STDCALL
1218 QueryInformationJobObject(
1219     HANDLE hJob,
1220     JOBOBJECTINFOCLASS JobObjectInformationClass,
1221     LPVOID lpJobObjectInformation,
1222     DWORD cbJobObjectInformationLength,
1223     LPDWORD lpReturnLength
1224     )
1225 {
1226     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1227     return 0;
1228 }
1229
1230 /*
1231  * @unimplemented
1232  */
1233 BOOL
1234 STDCALL
1235 QueryMemoryResourceNotification(
1236      HANDLE ResourceNotificationHandle,
1237     PBOOL  ResourceState
1238     )
1239 {
1240     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1241     return 0;
1242 }
1243
1244 /*
1245  * @unimplemented
1246  */
1247 DWORD
1248 STDCALL
1249 QueueUserAPC(
1250     PAPCFUNC pfnAPC,
1251     HANDLE hThread,
1252     ULONG_PTR dwData
1253     )
1254 {
1255     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1256     return 0;
1257 }
1258
1259 /*
1260  * @unimplemented
1261  */
1262 BOOL
1263 STDCALL
1264 QueueUserWorkItem(
1265     LPTHREAD_START_ROUTINE Function,
1266     PVOID Context,
1267     ULONG Flags
1268     )
1269 {
1270     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1271     return 0;
1272 }
1273
1274 /*
1275  * @unimplemented
1276  */
1277 BOOL
1278 STDCALL
1279 ReadDirectoryChangesW(
1280     HANDLE hDirectory,
1281     LPVOID lpBuffer,
1282     DWORD nBufferLength,
1283     BOOL bWatchSubtree,
1284     DWORD dwNotifyFilter,
1285     LPDWORD lpBytesReturned,
1286     LPOVERLAPPED lpOverlapped,
1287     LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
1288     )
1289 {
1290     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1291     return 0;
1292 }
1293
1294 /*
1295  * @unimplemented
1296  */
1297 BOOL
1298 STDCALL
1299 ReadFileScatter(
1300     HANDLE hFile,
1301     FILE_SEGMENT_ELEMENT aSegmentArray[],
1302     DWORD nNumberOfBytesToRead,
1303     LPDWORD lpReserved,
1304     LPOVERLAPPED lpOverlapped
1305     )
1306 {
1307     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1308     return 0;
1309 }
1310
1311 /*
1312  * @unimplemented
1313  */
1314 BOOL
1315 STDCALL
1316 RegisterWaitForSingleObject(
1317     PHANDLE phNewWaitObject,
1318     HANDLE hObject,
1319     WAITORTIMERCALLBACK Callback,
1320     PVOID Context,
1321     ULONG dwMilliseconds,
1322     ULONG dwFlags
1323     )
1324 {
1325     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1326     return 0;
1327 }
1328
1329 /*
1330  * @unimplemented
1331  */
1332 HANDLE
1333 STDCALL
1334 RegisterWaitForSingleObjectEx(
1335     HANDLE hObject,
1336     WAITORTIMERCALLBACK Callback,
1337     PVOID Context,
1338     ULONG dwMilliseconds,
1339     ULONG dwFlags
1340     )
1341 {
1342     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1343     return 0;
1344 }
1345
1346 /*
1347  * @unimplemented
1348  */
1349 VOID
1350 STDCALL
1351 ReleaseActCtx(
1352     HANDLE hActCtx
1353     )
1354 {
1355     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1356 }
1357
1358 /*
1359  * @unimplemented
1360  */
1361 ULONG
1362 STDCALL
1363 RemoveVectoredExceptionHandler(
1364     PVOID VectoredHandlerHandle
1365     )
1366 {
1367     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1368     return 0;
1369 }
1370
1371 /*
1372  * @unimplemented
1373  */
1374 BOOL
1375 STDCALL
1376 RequestDeviceWakeup(
1377     HANDLE hDevice
1378     )
1379 {
1380     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1381     return 0;
1382 }
1383
1384 /*
1385  * @unimplemented
1386  */
1387 BOOL
1388 STDCALL
1389 RequestWakeupLatency(
1390     LATENCY_TIME latency
1391     )
1392 {
1393     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1394     return 0;
1395 }
1396
1397 /*
1398  * @unimplemented
1399  */
1400 UINT
1401 STDCALL
1402 ResetWriteWatch(
1403     LPVOID lpBaseAddress,
1404     SIZE_T dwRegionSize
1405     )
1406 {
1407     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1408     return 0;
1409 }
1410
1411 /*
1412  * @unimplemented
1413  */
1414 VOID
1415 STDCALL
1416 RestoreLastError(
1417     DWORD dwErrCode
1418     )
1419 {
1420     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1421 }
1422
1423 /*
1424  * @unimplemented
1425  */
1426 DWORD
1427 STDCALL
1428 SetCriticalSectionSpinCount(
1429     LPCRITICAL_SECTION lpCriticalSection,
1430     DWORD dwSpinCount
1431     )
1432 {
1433     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1434     return 0;
1435 }
1436
1437 /*
1438  * @unimplemented
1439  */
1440 BOOL
1441 STDCALL
1442 SetFilePointerEx(
1443     HANDLE hFile,
1444     LARGE_INTEGER liDistanceToMove,
1445     PLARGE_INTEGER lpNewFilePointer,
1446     DWORD dwMoveMethod
1447     )
1448 {
1449     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1450     return 0;
1451 }
1452
1453 /*
1454  * @unimplemented
1455  */
1456 BOOL
1457 STDCALL
1458 SetFileValidData(
1459     HANDLE hFile,
1460     LONGLONG ValidDataLength
1461     )
1462 {
1463     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1464     return 0;
1465 }
1466
1467 /*
1468  * @unimplemented
1469  */
1470 BOOL
1471 STDCALL
1472 SetInformationJobObject(
1473     HANDLE hJob,
1474     JOBOBJECTINFOCLASS JobObjectInformationClass,
1475     LPVOID lpJobObjectInformation,
1476     DWORD cbJobObjectInformationLength
1477     )
1478 {
1479     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1480     return 0;
1481 }
1482
1483 /*
1484  * @unimplemented
1485  */
1486 BOOL
1487 STDCALL
1488 SetMessageWaitingIndicator(
1489     HANDLE hMsgIndicator,
1490     ULONG ulMsgCount
1491     )
1492 {
1493     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1494     return 0;
1495 }
1496
1497 /*
1498  * @unimplemented
1499  */
1500 BOOL
1501 STDCALL
1502 SetProcessPriorityBoost(
1503     HANDLE hProcess,
1504     BOOL bDisablePriorityBoost
1505     )
1506 {
1507     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1508     return 0;
1509 }
1510
1511 /*
1512  * @unimplemented
1513  */
1514 EXECUTION_STATE
1515 STDCALL
1516 SetThreadExecutionState(
1517     EXECUTION_STATE esFlags
1518     )
1519 {
1520     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1521     return 0;
1522 }
1523
1524 /*
1525  * @unimplemented
1526  */
1527 HANDLE
1528 STDCALL
1529 SetTimerQueueTimer(
1530     HANDLE TimerQueue,
1531     WAITORTIMERCALLBACK Callback,
1532     PVOID Parameter,
1533     DWORD DueTime,
1534     DWORD Period,
1535     BOOL PreferIo
1536     )
1537 {
1538     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1539     return 0;
1540 }
1541
1542 /*
1543  * @unimplemented
1544  */
1545 BOOL
1546 STDCALL
1547 TerminateJobObject(
1548     HANDLE hJob,
1549     UINT uExitCode
1550     )
1551 {
1552     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1553     return 0;
1554 }
1555
1556 /*
1557  * @unimplemented
1558  */
1559 BOOL
1560 STDCALL
1561 TzSpecificLocalTimeToSystemTime(
1562     LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
1563     LPSYSTEMTIME lpLocalTime,
1564     LPSYSTEMTIME lpUniversalTime
1565     )
1566 {
1567     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1568     return 0;
1569 }
1570
1571 /*
1572  * @unimplemented
1573  */
1574 BOOL
1575 STDCALL
1576 UnregisterWait(
1577     HANDLE WaitHandle
1578     )
1579 {
1580     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1581     return 0;
1582 }
1583
1584 /*
1585  * @unimplemented
1586  */
1587 BOOL
1588 STDCALL
1589 UnregisterWaitEx(
1590     HANDLE WaitHandle,
1591     HANDLE CompletionEvent
1592     )
1593 {
1594     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1595     return 0;
1596 }
1597
1598 /*
1599  * @unimplemented
1600  */
1601 BOOL
1602 STDCALL
1603 WriteFileGather(
1604     HANDLE hFile,
1605     FILE_SEGMENT_ELEMENT aSegmentArray[],
1606     DWORD nNumberOfBytesToWrite,
1607     LPDWORD lpReserved,
1608     LPOVERLAPPED lpOverlapped
1609     )
1610 {
1611     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1612     return 0;
1613 }
1614
1615 /*
1616  * @unimplemented
1617  */
1618 DWORD
1619 STDCALL
1620 WTSGetActiveConsoleSessionId(VOID)
1621 {
1622     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1623     return 0;
1624 }
1625
1626 /*
1627  * @unimplemented
1628  */
1629 BOOL
1630 STDCALL
1631 ZombifyActCtx(
1632     HANDLE hActCtx
1633     )
1634 {
1635     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1636     return 0;
1637 }
1638
1639 /*
1640  * @unimplemented
1641  */
1642 BOOL
1643 STDCALL
1644 CheckNameLegalDOS8Dot3W(
1645     LPCWSTR lpName,
1646     LPSTR lpOemName OPTIONAL,
1647     DWORD OemNameSize OPTIONAL,
1648     PBOOL pbNameContainsSpaces OPTIONAL,
1649     PBOOL pbNameLegal
1650     )
1651 {
1652     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1653     return 0;
1654 }
1655
1656 /*
1657  * @unimplemented
1658  */
1659 BOOL
1660 STDCALL
1661 CreateHardLinkW(
1662     LPCWSTR lpFileName,
1663     LPCWSTR lpExistingFileName,
1664     LPSECURITY_ATTRIBUTES lpSecurityAttributes
1665     )
1666 {
1667     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1668     return 0;
1669 }
1670
1671 /*
1672  * @unimplemented
1673  */
1674 HANDLE
1675 STDCALL
1676 CreateJobObjectW(
1677     LPSECURITY_ATTRIBUTES lpJobAttributes,
1678     LPCWSTR lpName
1679     )
1680 {
1681     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1682     return 0;
1683 }
1684
1685 /*
1686  * @unimplemented
1687  */
1688 BOOL
1689 STDCALL
1690 DeleteVolumeMountPointW(
1691     LPCWSTR lpszVolumeMountPoint
1692     )
1693 {
1694     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1695     return 0;
1696 }
1697
1698 /*
1699  * @unimplemented
1700  */
1701 BOOL
1702 STDCALL
1703 DnsHostnameToComputerNameW (
1704     LPCWSTR Hostname,
1705     LPWSTR ComputerName,
1706     LPDWORD nSize
1707     )
1708 {
1709     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1710     return 0;
1711 }
1712
1713 /*
1714  * @unimplemented
1715  */
1716 BOOL
1717 STDCALL
1718 FindActCtxSectionStringW(
1719     DWORD dwFlags,
1720     const GUID *lpExtensionGuid,
1721     ULONG ulSectionId,
1722     LPCWSTR lpStringToFind,
1723     PACTCTX_SECTION_KEYED_DATA ReturnedData
1724     )
1725 {
1726     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1727     return 0;
1728 }
1729
1730 /*
1731  * @unimplemented
1732  */
1733 HANDLE
1734 STDCALL
1735 FindFirstVolumeW(
1736     LPWSTR lpszVolumeName,
1737     DWORD cchBufferLength
1738     )
1739 {
1740     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1741     return 0;
1742 }
1743
1744 /*
1745  * @unimplemented
1746  */
1747 HANDLE
1748 STDCALL
1749 FindFirstVolumeMountPointW(
1750     LPCWSTR lpszRootPathName,
1751     LPWSTR lpszVolumeMountPoint,
1752     DWORD cchBufferLength
1753     )
1754 {
1755     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1756     return 0;
1757 }
1758
1759 /*
1760  * @unimplemented
1761  */
1762 BOOL
1763 STDCALL
1764 FindNextVolumeW(
1765     HANDLE hFindVolume,
1766     LPWSTR lpszVolumeName,
1767     DWORD cchBufferLength
1768     )
1769 {
1770     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1771     return 0;
1772 }
1773
1774 /*
1775  * @unimplemented
1776  */
1777 BOOL
1778 STDCALL
1779 FindNextVolumeMountPointW(
1780     HANDLE hFindVolumeMountPoint,
1781     LPWSTR lpszVolumeMountPoint,
1782     DWORD cchBufferLength
1783     )
1784 {
1785     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1786     return 0;
1787 }
1788
1789 /*
1790  * @unimplemented
1791  */
1792 DWORD
1793 STDCALL
1794 GetDllDirectoryW(
1795     DWORD nBufferLength,
1796     LPWSTR lpBuffer
1797     )
1798 {
1799     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1800     return 0;
1801 }
1802
1803 /*
1804  * @unimplemented
1805  */
1806 DWORD
1807 STDCALL
1808 GetFirmwareEnvironmentVariableW(
1809     LPCWSTR lpName,
1810     LPCWSTR lpGuid,
1811     PVOID   pBuffer,
1812     DWORD    nSize
1813     )
1814 {
1815     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1816     return 0;
1817 }
1818
1819 /*
1820  * @unimplemented
1821  */
1822 DWORD
1823 STDCALL
1824 GetLongPathNameW(
1825     LPCWSTR lpszShortPath,
1826     LPWSTR  lpszLongPath,
1827     DWORD    cchBuffer
1828     )
1829 {
1830     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1831     return 0;
1832 }
1833
1834 /*
1835  * @unimplemented
1836  */
1837 BOOL
1838 STDCALL
1839 GetModuleHandleExW(
1840     DWORD        dwFlags,
1841     LPCWSTR     lpModuleName,
1842     HMODULE*    phModule
1843     )
1844 {
1845     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1846     return 0;
1847 }
1848
1849 /*
1850  * @unimplemented
1851  */
1852 UINT
1853 STDCALL
1854 GetSystemWow64DirectoryW(
1855     LPWSTR lpBuffer,
1856     UINT uSize
1857     )
1858 {
1859     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1860     return 0;
1861 }
1862
1863 /*
1864  * @unimplemented
1865  */
1866 BOOL
1867 STDCALL
1868 GetVolumeNameForVolumeMountPointW(
1869     LPCWSTR lpszVolumeMountPoint,
1870     LPWSTR lpszVolumeName,
1871     DWORD cchBufferLength
1872     )
1873 {
1874     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1875     return 0;
1876 }
1877
1878 /*
1879  * @unimplemented
1880  */
1881 BOOL
1882 STDCALL
1883 GetVolumePathNameW(
1884     LPCWSTR lpszFileName,
1885     LPWSTR lpszVolumePathName,
1886     DWORD cchBufferLength
1887     )
1888 {
1889     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1890     return 0;
1891 }
1892
1893 /*
1894  * @unimplemented
1895  */
1896 BOOL
1897 STDCALL
1898 GetVolumePathNamesForVolumeNameW(
1899     LPCWSTR lpszVolumeName,
1900     LPWSTR lpszVolumePathNames,
1901     DWORD cchBufferLength,
1902     PDWORD lpcchReturnLength
1903     )
1904 {
1905     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1906     return 0;
1907 }
1908
1909 /*
1910  * @unimplemented
1911  */
1912 HANDLE
1913 STDCALL
1914 OpenJobObjectW(
1915     DWORD dwDesiredAccess,
1916     BOOL bInheritHandle,
1917     LPCWSTR lpName
1918     )
1919 {
1920     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1921     return 0;
1922 }
1923
1924 /*
1925  * @unimplemented
1926  */
1927 BOOL
1928 STDCALL
1929 ReplaceFileW(
1930     LPCWSTR lpReplacedFileName,
1931     LPCWSTR lpReplacementFileName,
1932     LPCWSTR lpBackupFileName,
1933     DWORD   dwReplaceFlags,
1934     LPVOID  lpExclude,
1935     LPVOID  lpReserved
1936     )
1937 {
1938     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1939     return 0;
1940 }
1941
1942 /*
1943  * @unimplemented
1944  */
1945 BOOL
1946 STDCALL
1947 SetComputerNameExW (
1948     COMPUTER_NAME_FORMAT NameType,
1949     LPCWSTR lpBuffer
1950     )
1951 {
1952     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1953     return 0;
1954 }
1955
1956 /*
1957  * @unimplemented
1958  */
1959 BOOL
1960 STDCALL
1961 SetDllDirectoryW(
1962     LPCWSTR lpPathName
1963     )
1964 {
1965     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1966     return 0;
1967 }
1968
1969 /*
1970  * @unimplemented
1971  */
1972 BOOL
1973 STDCALL
1974 SetFileShortNameW(
1975     HANDLE hFile,
1976     LPCWSTR lpShortName
1977     )
1978 {
1979     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1980     return 0;
1981 }
1982
1983 /*
1984  * @unimplemented
1985  */
1986 BOOL
1987 STDCALL
1988 SetFirmwareEnvironmentVariableW(
1989     LPCWSTR lpName,
1990     LPCWSTR lpGuid,
1991     PVOID    pValue,
1992     DWORD    nSize
1993     )
1994 {
1995     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1996     return 0;
1997 }
1998
1999 /*
2000  * @unimplemented
2001  */
2002 BOOL
2003 STDCALL
2004 SetVolumeMountPointW(
2005     LPCWSTR lpszVolumeMountPoint,
2006     LPCWSTR lpszVolumeName
2007     )
2008 {
2009     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2010     return 0;
2011 }
2012
2013 /*
2014  * @unimplemented
2015  */
2016 BOOL
2017 STDCALL
2018 VerifyVersionInfoW(
2019     LPOSVERSIONINFOEXW lpVersionInformation,
2020     DWORD dwTypeMask,
2021     DWORDLONG dwlConditionMask
2022     )
2023 {
2024     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2025     return 0;
2026 }
2027
2028 /*
2029  * @unimplemented
2030  */
2031 BOOL
2032 STDCALL
2033 CheckNameLegalDOS8Dot3A(
2034     LPCSTR lpName,
2035     LPSTR lpOemName OPTIONAL,
2036     DWORD OemNameSize OPTIONAL,
2037     PBOOL pbNameContainsSpaces OPTIONAL,
2038     PBOOL pbNameLegal
2039     )
2040 {
2041     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2042     return 0;
2043 }
2044
2045 /*
2046  * @unimplemented
2047  */
2048 BOOL
2049 STDCALL
2050 CreateHardLinkA(
2051     LPCSTR lpFileName,
2052     LPCSTR lpExistingFileName,
2053     LPSECURITY_ATTRIBUTES lpSecurityAttributes
2054     )
2055 {
2056     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2057     return 0;
2058 }
2059
2060 /*
2061  * @unimplemented
2062  */
2063 HANDLE
2064 STDCALL
2065 CreateJobObjectA(
2066     LPSECURITY_ATTRIBUTES lpJobAttributes,
2067     LPCSTR lpName
2068     )
2069 {
2070     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2071     return 0;
2072 }
2073
2074 /*
2075  * @unimplemented
2076  */
2077 BOOL
2078 STDCALL
2079 DeleteVolumeMountPointA(
2080     LPCSTR lpszVolumeMountPoint
2081     )
2082 {
2083     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2084     return 0;
2085 }
2086
2087 /*
2088  * @unimplemented
2089  */
2090 BOOL
2091 STDCALL
2092 DnsHostnameToComputerNameA (
2093     LPCSTR Hostname,
2094     LPSTR ComputerName,
2095     LPDWORD nSize
2096     )
2097 {
2098     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2099     return 0;
2100 }
2101
2102 /*
2103  * @unimplemented
2104  */
2105 BOOL
2106 STDCALL
2107 FindActCtxSectionStringA(
2108     DWORD dwFlags,
2109     const GUID *lpExtensionGuid,
2110     ULONG ulSectionId,
2111     LPCSTR lpStringToFind,
2112     PACTCTX_SECTION_KEYED_DATA ReturnedData
2113     )
2114 {
2115     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2116     return 0;
2117 }
2118
2119 /*
2120  * @unimplemented
2121  */
2122 HANDLE
2123 STDCALL
2124 FindFirstVolumeA(
2125     LPSTR lpszVolumeName,
2126     DWORD cchBufferLength
2127     )
2128 {
2129     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2130     return 0;
2131 }
2132
2133 /*
2134  * @unimplemented
2135  */
2136 HANDLE
2137 STDCALL
2138 FindFirstVolumeMountPointA(
2139     LPCSTR lpszRootPathName,
2140     LPSTR lpszVolumeMountPoint,
2141     DWORD cchBufferLength
2142     )
2143 {
2144     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2145     return 0;
2146 }
2147
2148 /*
2149  * @unimplemented
2150  */
2151 BOOL
2152 STDCALL
2153 FindNextVolumeA(
2154     HANDLE hFindVolume,
2155     LPSTR lpszVolumeName,
2156     DWORD cchBufferLength
2157     )
2158 {
2159     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2160     return 0;
2161 }
2162
2163 /*
2164  * @unimplemented
2165  */
2166 BOOL
2167 STDCALL
2168 FindNextVolumeMountPointA(
2169     HANDLE hFindVolumeMountPoint,
2170     LPSTR lpszVolumeMountPoint,
2171     DWORD cchBufferLength
2172     )
2173 {
2174     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2175     return 0;
2176 }
2177
2178 /*
2179  * @unimplemented
2180  */
2181 DWORD
2182 STDCALL
2183 GetDllDirectoryA(
2184     DWORD nBufferLength,
2185     LPSTR lpBuffer
2186     )
2187 {
2188     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2189     return 0;
2190 }
2191
2192 /*
2193  * @unimplemented
2194  */
2195 DWORD
2196 STDCALL
2197 GetFirmwareEnvironmentVariableA(
2198     LPCSTR lpName,
2199     LPCSTR lpGuid,
2200     PVOID   pBuffer,
2201     DWORD    nSize
2202     )
2203 {
2204     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2205     return 0;
2206 }
2207
2208 /*
2209  * @unimplemented
2210  */
2211 DWORD
2212 STDCALL
2213 GetLongPathNameA(
2214     LPCSTR lpszShortPath,
2215     LPSTR  lpszLongPath,
2216     DWORD    cchBuffer
2217     )
2218 {
2219     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2220     return 0;
2221 }
2222
2223 /*
2224  * @unimplemented
2225  */
2226 BOOL
2227 STDCALL
2228 GetModuleHandleExA(
2229     DWORD        dwFlags,
2230     LPCSTR     lpModuleName,
2231     HMODULE*    phModule
2232     )
2233 {
2234     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2235     return 0;
2236 }
2237
2238 /*
2239  * @unimplemented
2240  */
2241 UINT
2242 STDCALL
2243 GetSystemWow64DirectoryA(
2244     LPSTR lpBuffer,
2245     UINT uSize
2246     )
2247 {
2248     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2249     return 0;
2250 }
2251
2252 /*
2253  * @unimplemented
2254  */
2255 BOOL
2256 STDCALL
2257 GetVolumeNameForVolumeMountPointA(
2258     LPCSTR lpszVolumeMountPoint,
2259     LPSTR lpszVolumeName,
2260     DWORD cchBufferLength
2261     )
2262 {
2263     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2264     return 0;
2265 }
2266
2267 /*
2268  * @unimplemented
2269  */
2270 BOOL
2271 STDCALL
2272 GetVolumePathNameA(
2273     LPCSTR lpszFileName,
2274     LPSTR lpszVolumePathName,
2275     DWORD cchBufferLength
2276     )
2277 {
2278     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2279     return 0;
2280 }
2281
2282 /*
2283  * @unimplemented
2284  */
2285 BOOL
2286 STDCALL
2287 GetVolumePathNamesForVolumeNameA(
2288     LPCSTR lpszVolumeName,
2289     LPSTR lpszVolumePathNames,
2290     DWORD cchBufferLength,
2291     PDWORD lpcchReturnLength
2292     )
2293 {
2294     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2295     return 0;
2296 }
2297
2298 /*
2299  * @unimplemented
2300  */
2301 HANDLE
2302 STDCALL
2303 OpenJobObjectA(
2304     DWORD dwDesiredAccess,
2305     BOOL bInheritHandle,
2306     LPCSTR lpName
2307     )
2308 {
2309     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2310     return 0;
2311 }
2312
2313 /*
2314  * @unimplemented
2315  */
2316 BOOL
2317 STDCALL
2318 ReplaceFileA(
2319     LPCSTR  lpReplacedFileName,
2320     LPCSTR  lpReplacementFileName,
2321     LPCSTR  lpBackupFileName,
2322     DWORD   dwReplaceFlags,
2323     LPVOID  lpExclude,
2324     LPVOID  lpReserved
2325     )
2326 {
2327     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2328     return 0;
2329 }
2330
2331 /*
2332  * @unimplemented
2333  */
2334 BOOL
2335 STDCALL
2336 SetComputerNameExA (
2337     COMPUTER_NAME_FORMAT NameType,
2338     LPCSTR lpBuffer
2339     )
2340 {
2341     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2342     return 0;
2343 }
2344
2345 /*
2346  * @unimplemented
2347  */
2348 BOOL
2349 STDCALL
2350 SetDllDirectoryA(
2351     LPCSTR lpPathName
2352     )
2353 {
2354     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2355     return 0;
2356 }
2357
2358 /*
2359  * @unimplemented
2360  */
2361 BOOL
2362 STDCALL
2363 SetFileShortNameA(
2364     HANDLE hFile,
2365     LPCSTR lpShortName
2366     )
2367 {
2368     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2369     return 0;
2370 }
2371
2372 /*
2373  * @unimplemented
2374  */
2375 BOOL
2376 STDCALL
2377 SetFirmwareEnvironmentVariableA(
2378     LPCSTR lpName,
2379     LPCSTR lpGuid,
2380     PVOID    pValue,
2381     DWORD    nSize
2382     )
2383 {
2384     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2385     return 0;
2386 }
2387
2388 /*
2389  * @unimplemented
2390  */
2391 BOOL
2392 STDCALL
2393 SetVolumeMountPointA(
2394     LPCSTR lpszVolumeMountPoint,
2395     LPCSTR lpszVolumeName
2396     )
2397 {
2398     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2399     return 0;
2400 }
2401
2402 /*
2403  * @unimplemented
2404  */
2405 BOOL
2406 STDCALL
2407 VerifyVersionInfoA(
2408     LPOSVERSIONINFOEXA lpVersionInformation,
2409     DWORD dwTypeMask,
2410     DWORDLONG dwlConditionMask
2411     )
2412 {
2413     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2414     return 0;
2415 }
2416
2417 /*
2418  * @unimplemented
2419  */
2420 BOOL
2421 STDCALL
2422 EnumSystemLanguageGroupsW(
2423     LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc,
2424     DWORD                   dwFlags,
2425     LONG_PTR                lParam)
2426 {
2427     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2428     return 0;
2429 }
2430
2431 /*
2432  * @unimplemented
2433  */
2434 ULONGLONG
2435 STDCALL
2436 VerSetConditionMask(
2437         ULONGLONG   ConditionMask,
2438         DWORD   TypeMask,
2439         BYTE    Condition
2440         )
2441 {
2442     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2443     return 0;
2444 }
2445
2446 /*
2447  * @unimplemented
2448  */
2449 BOOL STDCALL GetConsoleKeyboardLayoutNameA(LPSTR name)
2450 {
2451     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2452     return 0;
2453 }
2454
2455 /*
2456  * @unimplemented
2457  */
2458 BOOL STDCALL GetConsoleKeyboardLayoutNameW(LPWSTR name)
2459 {
2460     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2461     return 0;
2462 }
2463
2464 /*
2465  * @unimplemented
2466  */
2467 BOOL STDCALL SetConsoleIcon(HICON hicon)
2468 {
2469     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2470     return 0;
2471 }
2472
2473 /*
2474  * @unimplemented
2475  */
2476 DWORD STDCALL GetHandleContext(HANDLE hnd)
2477 {
2478     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2479     return 0;
2480 }
2481
2482 /*
2483  * @unimplemented
2484  */
2485 HANDLE STDCALL CreateSocketHandle(VOID)
2486 {
2487     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2488     return 0;
2489 }
2490
2491 /*
2492  * @unimplemented
2493  */
2494 BOOL STDCALL SetHandleContext(HANDLE hnd,DWORD context)
2495 {
2496     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2497     return 0;
2498 }
2499
2500 /*
2501  * @unimplemented
2502  */
2503 BOOL STDCALL SetConsoleInputExeNameA(LPCSTR name)
2504 {
2505     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2506     return 0;
2507 }
2508
2509 /*
2510  * @unimplemented
2511  */
2512 BOOL STDCALL SetConsoleInputExeNameW(LPCWSTR name)
2513 {
2514     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2515     return 0;
2516 }
2517
2518 /*
2519  * @unimplemented
2520  */
2521 BOOL STDCALL UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
2522                         LPSTR lpszInitName, LPSTR lpszProcName,
2523                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
2524                         LPVOID lpBuff )
2525 {
2526     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2527     return 0;
2528 }
2529
2530 /*
2531  * @unimplemented
2532  */
2533 VOID STDCALL UTUnRegister( HMODULE hModule )
2534 {
2535     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2536 }
2537
2538 /*
2539  * @unimplemented
2540  */
2541 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PDelayLoadInfo pdli)
2542 {
2543     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2544     return 0;
2545 }
2546
2547 /*
2548  * @unimplemented
2549  */
2550 NTSTATUS STDCALL CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
2551 {
2552     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2553     return 0;
2554 }
2555
2556 /*
2557  * @unimplemented
2558  */
2559 BOOL STDCALL GetConsoleInputExeNameA(ULONG length,LPCSTR name)
2560 {
2561     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2562     return 0;
2563 }
2564
2565 /*
2566  * @unimplemented
2567  */
2568 BOOL STDCALL GetConsoleInputExeNameW(ULONG length,LPCWSTR name)
2569 {
2570     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2571     return 0;
2572 }
2573
2574 /*
2575  * @unimplemented
2576  */
2577 BOOL STDCALL IsValidUILanguage(LANGID langid)
2578 {
2579     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2580     return 0;
2581 }
2582
2583 /*
2584  * @unimplemented
2585  */
2586 VOID STDCALL NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
2587 {
2588     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2589 }
2590
2591 /*
2592  * @unimplemented
2593  */
2594 UINT STDCALL SetCPGlobal(UINT CodePage)
2595 {
2596     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2597     return 0;
2598 }
2599
2600 /*
2601  * @unimplemented
2602  */
2603 BOOL
2604 STDCALL
2605 SetClientTimeZoneInformation(
2606                        CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation
2607                        )
2608 {
2609     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2610     return 0;
2611 }