reactos/lib/kernel32/misc/stubs.c

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