lib/kernel32/misc/stubs.c

   1 /* $Id$
   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 LCID
  78 STDCALL
  79 ConvertDefaultLocale (
  80     LCID    Locale
  81     )
  82 {
  83     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  84     return 0;
  85 }
  86
  87
  88 /*
  89  * @unimplemented
  90  */
  91 DWORD
  92 STDCALL
  93 CreateVirtualBuffer (
  94     DWORD   Unknown0,
  95     DWORD   Unknown1,
  96     DWORD   Unknown2
  97     )
  98 {
  99     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 100     return 0;
 101 }
 102
 103
 104 /*
 105  * @unimplemented
 106  */
 107 WINBOOL
 108 STDCALL
 109 EnumCalendarInfoW (
 110     CALINFO_ENUMPROCW lpCalInfoEnumProc,
 111     LCID              Locale,
 112     CALID             Calendar,
 113     CALTYPE           CalType
 114     )
 115 {
 116     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 117     return FALSE;
 118 }
 119
 120
 121 /*
 122  * @unimplemented
 123  */
 124 WINBOOL
 125 STDCALL
 126 EnumCalendarInfoA (
 127     CALINFO_ENUMPROCA lpCalInfoEnumProc,
 128     LCID              Locale,
 129     CALID             Calendar,
 130     CALTYPE           CalType
 131     )
 132 {
 133     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 134     return FALSE;
 135 }
 136
 137
 138 /*
 139  * @unimplemented
 140  */
 141 WINBOOL
 142 STDCALL
 143 EnumDateFormatsW (
 144     DATEFMT_ENUMPROCW  lpDateFmtEnumProc,
 145     LCID               Locale,
 146     DWORD              dwFlags
 147     )
 148 {
 149     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 150     return FALSE;
 151 }
 152
 153
 154 /*
 155  * @unimplemented
 156  */
 157 WINBOOL
 158 STDCALL
 159 EnumDateFormatsA (
 160     DATEFMT_ENUMPROCA  lpDateFmtEnumProc,
 161     LCID               Locale,
 162     DWORD              dwFlags
 163     )
 164 {
 165     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 166     return FALSE;
 167 }
 168
 169
 170 /*
 171  * @unimplemented
 172  */
 173 WINBOOL
 174 STDCALL
 175 EnumSystemCodePagesW (
 176     CODEPAGE_ENUMPROCW  lpCodePageEnumProc,
 177     DWORD               dwFlags
 178     )
 179 {
 180     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 181     return FALSE;
 182 }
 183
 184
 185 /*
 186  * @unimplemented
 187  */
 188 WINBOOL
 189 STDCALL
 190 EnumSystemCodePagesA (
 191     CODEPAGE_ENUMPROCA lpCodePageEnumProc,
 192     DWORD              dwFlags
 193     )
 194 {
 195     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 196     return FALSE;
 197 }
 198
 199 #ifndef _OLE2NLS_IN_BUILD_
 200
 201 /*
 202  * @unimplemented
 203  */
 204 WINBOOL
 205 STDCALL
 206 EnumSystemLocalesW (
 207     LOCALE_ENUMPROCW lpLocaleEnumProc,
 208     DWORD            dwFlags
 209     )
 210 {
 211     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 212     return FALSE;
 213 }
 214
 215
 216 /*
 217  * @unimplemented
 218  */
 219 WINBOOL
 220 STDCALL
 221 EnumSystemLocalesA (
 222     LOCALE_ENUMPROCA lpLocaleEnumProc,
 223     DWORD            dwFlags
 224     )
 225 {
 226     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 227     return FALSE;
 228 }
 229
 230 #endif
 231
 232 /*
 233  * @unimplemented
 234  */
 235 WINBOOL
 236 STDCALL
 237 EnumTimeFormatsW (
 238     TIMEFMT_ENUMPROCW    lpTimeFmtEnumProc,
 239     LCID            Locale,
 240     DWORD           dwFlags
 241     )
 242 {
 243     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 244     return FALSE;
 245 }
 246
 247
 248 /*
 249  * @unimplemented
 250  */
 251 WINBOOL
 252 STDCALL
 253 EnumTimeFormatsA (
 254     TIMEFMT_ENUMPROCA  lpTimeFmtEnumProc,
 255     LCID               Locale,
 256     DWORD              dwFlags
 257     )
 258 {
 259     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 260     return FALSE;
 261 }
 262
 263
 264 /*
 265  * @unimplemented
 266  */
 267 DWORD
 268 STDCALL
 269 ExitVDM (
 270     DWORD   Unknown0,
 271     DWORD   Unknown1
 272     )
 273 {
 274     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 275     return 0;
 276 }
 277
 278
 279 /*
 280  * @unimplemented
 281  */
 282 BOOL
 283 STDCALL
 284 ExtendVirtualBuffer (
 285     DWORD   Unknown0,
 286     DWORD   Unknown1
 287     )
 288 {
 289     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 290     return FALSE;
 291 }
 292
 293
 294 /*
 295  * @unimplemented
 296  */
 297 int
 298 STDCALL
 299 FoldStringW (
 300     DWORD   dwMapFlags,
 301     LPCWSTR lpSrcStr,
 302     int cchSrc,
 303     LPWSTR  lpDestStr,
 304     int cchDest
 305     )
 306 {
 307     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 308     return 0;
 309 }
 310
 311
 312 /*
 313  * @unimplemented
 314  */
 315 int
 316 STDCALL
 317 FoldStringA (
 318     DWORD   dwMapFlags,
 319     LPCSTR  lpSrcStr,
 320     int cchSrc,
 321     LPSTR   lpDestStr,
 322     int cchDest
 323     )
 324 {
 325     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 326     return 0;
 327 }
 328
 329
 330 /*
 331  * @unimplemented
 332  */
 333 BOOL
 334 STDCALL
 335 FreeVirtualBuffer (
 336     HANDLE  hVirtualBuffer
 337     )
 338 {
 339     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 340     return FALSE;
 341 }
 342
 343 #ifndef _OLE2NLS_IN_BUILD_
 344
 345 /*
 346  * @unimplemented
 347  */
 348 UINT
 349 STDCALL
 350 GetACP (VOID)
 351 {
 352     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 353     return 1252;
 354 }
 355
 356 #endif
 357
 358 /*
 359  * @unimplemented
 360  */
 361 WINBOOL
 362 STDCALL
 363 GetBinaryTypeW (
 364     LPCWSTR lpApplicationName,
 365     LPDWORD lpBinaryType
 366     )
 367 {
 368     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 369     return FALSE;
 370 }
 371
 372
 373 /*
 374  * @unimplemented
 375  */
 376 WINBOOL
 377 STDCALL
 378 GetBinaryTypeA (
 379     LPCSTR  lpApplicationName,
 380     LPDWORD lpBinaryType
 381     )
 382 {
 383     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 384     return FALSE;
 385 }
 386
 387 #ifndef _OLE2NLS_IN_BUILD_
 388
 389 /*
 390  * @unimplemented
 391  */
 392 WINBOOL
 393 STDCALL
 394 GetCPInfo (
 395     UINT        CodePage,
 396     LPCPINFO    CodePageInfo
 397     )
 398 {
 399     unsigned i;
 400
 401     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 402
 403     CodePageInfo->MaxCharSize = 1;
 404     CodePageInfo->DefaultChar[0] = '?';
 405     for (i = 1; i < MAX_DEFAULTCHAR; i++)
 406         {
 407         CodePageInfo->DefaultChar[i] = '\0';
 408         }
 409     for (i = 0; i < MAX_LEADBYTES; i++)
 410         {
 411         CodePageInfo->LeadByte[i] = '\0';
 412         }
 413
 414     return TRUE;
 415 }
 416
 417 #endif
 418
 419 /*
 420  * @unimplemented
 421  */
 422 int
 423 STDCALL
 424 GetCurrencyFormatW (
 425     LCID            Locale,
 426     DWORD           dwFlags,
 427     LPCWSTR         lpValue,
 428     CONST CURRENCYFMTW   * lpFormat,
 429     LPWSTR          lpCurrencyStr,
 430     int         cchCurrency
 431     )
 432 {
 433     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 434     return 0;
 435 }
 436
 437
 438 /*
 439  * @unimplemented
 440  */
 441 int
 442 STDCALL
 443 GetCurrencyFormatA (
 444     LCID            Locale,
 445     DWORD           dwFlags,
 446     LPCSTR          lpValue,
 447     CONST CURRENCYFMTA   * lpFormat,
 448     LPSTR           lpCurrencyStr,
 449     int         cchCurrency
 450     )
 451 {
 452     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 453     return 0;
 454 }
 455
 456 #ifndef _OLE2NLS_IN_BUILD_
 457
 458 /*
 459  * @unimplemented
 460  */
 461 int
 462 STDCALL
 463 GetDateFormatW (
 464     LCID            Locale,
 465     DWORD           dwFlags,
 466     CONST SYSTEMTIME    * lpDate,
 467     LPCWSTR         lpFormat,
 468     LPWSTR          lpDateStr,
 469     int         cchDate
 470     )
 471 {
 472     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 473     return 0;
 474 }
 475
 476
 477 /*
 478  * @unimplemented
 479  */
 480 int
 481 STDCALL
 482 GetDateFormatA (
 483     LCID            Locale,
 484     DWORD           dwFlags,
 485     CONST SYSTEMTIME    * lpDate,
 486     LPCSTR          lpFormat,
 487     LPSTR           lpDateStr,
 488     int         cchDate
 489     )
 490 {
 491     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 492     return 0;
 493 }
 494
 495
 496 /*
 497  * @unimplemented
 498  */
 499 int
 500 STDCALL
 501 GetLocaleInfoW (
 502     LCID    Locale,
 503     LCTYPE  LCType,
 504     LPWSTR  lpLCData,
 505     int cchData
 506     )
 507 {
 508     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 509     return 0;
 510 }
 511
 512
 513 /*
 514  * @unimplemented
 515  */
 516 int
 517 STDCALL
 518 GetLocaleInfoA (
 519     LCID    Locale,
 520     LCTYPE  LCType,
 521     LPSTR   lpLCData,
 522     int cchData
 523     )
 524 {
 525     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 526     return 0;
 527 }
 528
 529
 530 /*
 531  * @unimplemented
 532  */
 533 DWORD
 534 STDCALL
 535 GetNextVDMCommand (
 536     DWORD   Unknown0
 537     )
 538 {
 539     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 540     return 0;
 541 }
 542
 543
 544 /*
 545  * @unimplemented
 546  */
 547 int
 548 STDCALL
 549 GetNumberFormatW (
 550     LCID        Locale,
 551     DWORD       dwFlags,
 552     LPCWSTR     lpValue,
 553     CONST NUMBERFMTW * lpFormat,
 554     LPWSTR      lpNumberStr,
 555     int     cchNumber
 556     )
 557 {
 558     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 559     return 0;
 560 }
 561
 562
 563 /*
 564  * @unimplemented
 565  */
 566 int
 567 STDCALL
 568 GetNumberFormatA (
 569     LCID        Locale,
 570     DWORD       dwFlags,
 571     LPCSTR      lpValue,
 572     CONST NUMBERFMTA * lpFormat,
 573     LPSTR       lpNumberStr,
 574     int     cchNumber
 575     )
 576 {
 577     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 578     return 0;
 579 }
 580
 581
 582 /*
 583  * @unimplemented
 584  */
 585 UINT
 586 STDCALL
 587 GetOEMCP (VOID)
 588 {
 589     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 590     return 437; /* FIXME: call csrss.exe */
 591 }
 592
 593
 594 /*
 595  * @unimplemented
 596  */
 597 WINBOOL
 598 STDCALL
 599 GetStringTypeExW (
 600     LCID    Locale,
 601     DWORD   dwInfoType,
 602     LPCWSTR lpSrcStr,
 603     int cchSrc,
 604     LPWORD  lpCharType
 605     )
 606 {
 607     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 608     return FALSE;
 609 }
 610
 611
 612 /*
 613  * @unimplemented
 614  */
 615 WINBOOL
 616 STDCALL
 617 GetStringTypeExA (
 618     LCID    Locale,
 619     DWORD   dwInfoType,
 620     LPCSTR  lpSrcStr,
 621     int cchSrc,
 622     LPWORD  lpCharType
 623     )
 624 {
 625     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 626     return FALSE;
 627 }
 628
 629
 630 /*
 631  * @unimplemented
 632  */
 633 WINBOOL
 634 STDCALL
 635 GetStringTypeW (
 636     DWORD   dwInfoType,
 637     LPCWSTR lpSrcStr,
 638     int cchSrc,
 639     LPWORD  lpCharType
 640     )
 641 {
 642     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 643     return FALSE;
 644 }
 645
 646
 647 /*
 648  * @unimplemented
 649  */
 650 WINBOOL
 651 STDCALL
 652 GetStringTypeA (
 653     LCID    Locale,
 654     DWORD   dwInfoType,
 655     LPCSTR  lpSrcStr,
 656     int cchSrc,
 657     LPWORD  lpCharType
 658     )
 659 {
 660     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 661     return FALSE;
 662 }
 663
 664
 665 /*
 666  * @unimplemented
 667  */
 668 LCID
 669 STDCALL
 670 GetSystemDefaultLCID (VOID)
 671 {
 672     /* FIXME: ??? */
 673     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 674     return MAKELCID(
 675         LANG_ENGLISH,
 676         SORT_DEFAULT
 677         );
 678 }
 679
 680
 681 /*
 682  * @unimplemented
 683  */
 684 LANGID
 685 STDCALL
 686 GetSystemDefaultLangID (VOID)
 687 {
 688      /* FIXME: ??? */
 689     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 690     return MAKELANGID(
 691         LANG_ENGLISH,
 692         SUBLANG_ENGLISH_US
 693         );
 694 }
 695
 696 #endif
 697
 698 /*
 699  * @unimplemented
 700  */
 701 WINBOOL
 702 STDCALL
 703 GetSystemPowerStatus (
 704     DWORD   Unknown0
 705     )
 706 {
 707     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 708     return 0;
 709 }
 710
 711 #ifndef _OLE2NLS_IN_BUILD_
 712
 713 /*
 714  * @unimplemented
 715  */
 716 LCID
 717 STDCALL
 718 GetThreadLocale (VOID)
 719 {
 720     /* FIXME: ??? */
 721     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 722     return MAKELCID(
 723         LANG_ENGLISH,
 724         SORT_DEFAULT
 725         );
 726 }
 727
 728 #endif
 729
 730 /*
 731  * @unimplemented
 732  */
 733 int
 734 STDCALL
 735 GetTimeFormatW (
 736     LCID            Locale,
 737     DWORD           dwFlags,
 738     CONST SYSTEMTIME    * lpTime,
 739     LPCWSTR         lpFormat,
 740     LPWSTR          lpTimeStr,
 741     int         cchTime
 742     )
 743 {
 744     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 745     return 0;
 746 }
 747
 748
 749 /*
 750  * @unimplemented
 751  */
 752 int
 753 STDCALL
 754 GetTimeFormatA (
 755     LCID            Locale,
 756     DWORD           dwFlags,
 757     CONST SYSTEMTIME    * lpTime,
 758     LPCSTR          lpFormat,
 759     LPSTR           lpTimeStr,
 760     int         cchTime
 761     )
 762 {
 763     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 764     return 0;
 765 }
 766
 767 #ifndef _OLE2NLS_IN_BUILD_
 768
 769 /*
 770  * @unimplemented
 771  */
 772 LCID
 773 STDCALL
 774 GetUserDefaultLCID (VOID)
 775 {
 776     /* FIXME: ??? */
 777     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 778     return MAKELCID(
 779         LANG_ENGLISH,
 780         SORT_DEFAULT
 781         );
 782 }
 783
 784
 785 /*
 786  * @unimplemented
 787  */
 788 LANGID
 789 STDCALL
 790 GetUserDefaultLangID (VOID)
 791 {
 792      /* FIXME: ??? */
 793     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 794     return MAKELANGID(
 795         LANG_ENGLISH,
 796         SUBLANG_ENGLISH_US
 797         );
 798 }
 799
 800 #endif
 801
 802 /*
 803  * @unimplemented
 804  */
 805 DWORD
 806 STDCALL
 807 GetVDMCurrentDirectories (
 808     DWORD   Unknown0,
 809     DWORD   Unknown1
 810     )
 811 {
 812     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 813     return 0;
 814 }
 815
 816 #ifndef _OLE2NLS_IN_BUILD_
 817
 818 /*
 819  * @unimplemented
 820  */
 821 WINBOOL
 822 STDCALL
 823 IsDBCSLeadByte (
 824     BYTE    TestChar
 825     )
 826 {
 827     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 828     return FALSE;
 829 }
 830
 831
 832 /*
 833  * @unimplemented
 834  */
 835 WINBOOL
 836 STDCALL
 837 IsDBCSLeadByteEx (
 838     UINT    CodePage,
 839     BYTE    TestChar
 840     )
 841 {
 842     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 843     return FALSE;
 844 }
 845
 846
 847 /*
 848  * @unimplemented
 849  */
 850 WINBOOL
 851 STDCALL
 852 IsValidCodePage (
 853     UINT    CodePage
 854     )
 855 {
 856     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 857     return FALSE;
 858 }
 859
 860
 861 /*
 862  * @unimplemented
 863  */
 864 WINBOOL
 865 STDCALL
 866 IsValidLocale (
 867     LCID    Locale,
 868     DWORD   dwFlags
 869     )
 870 {
 871     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 872     return FALSE;
 873 }
 874
 875
 876 /*
 877  * @unimplemented
 878  */
 879 int
 880 STDCALL
 881 LCMapStringA (
 882     LCID    Locale,
 883     DWORD   dwMapFlags,
 884     LPCSTR  lpSrcStr,
 885     int cchSrc,
 886     LPSTR   lpDestStr,
 887     int cchDest
 888     )
 889 {
 890     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 891     return 0;
 892 }
 893
 894
 895 /*
 896  * @unimplemented
 897  */
 898 int
 899 STDCALL
 900 LCMapStringW (
 901     LCID    Locale,
 902     DWORD   dwMapFlags,
 903     LPCWSTR lpSrcStr,
 904     int cchSrc,
 905     LPWSTR  lpDestStr,
 906     int cchDest
 907     )
 908 {
 909     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 910     return 0;
 911 }
 912
 913 #endif
 914
 915 /*
 916  * @unimplemented
 917  */
 918 DWORD
 919 STDCALL
 920 LoadModule (
 921     LPCSTR  lpModuleName,
 922     LPVOID  lpParameterBlock
 923     )
 924 {
 925     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 926     return 0;
 927 }
 928
 929
 930 /*
 931  * @unimplemented
 932  */
 933 WINBOOL
 934 STDCALL
 935 RegisterConsoleVDM (
 936     DWORD   Unknown0,
 937     DWORD   Unknown1,
 938     DWORD   Unknown2,
 939     DWORD   Unknown3,
 940     DWORD   Unknown4,
 941     DWORD   Unknown5,
 942     DWORD   Unknown6,
 943     DWORD   Unknown7,
 944     DWORD   Unknown8,
 945     DWORD   Unknown9,
 946     DWORD   Unknown10
 947     )
 948 {
 949     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 950     return FALSE;
 951 }
 952
 953
 954 /*
 955  * @unimplemented
 956  */
 957 WINBOOL
 958 STDCALL
 959 RegisterWowBaseHandlers (
 960     DWORD   Unknown0
 961     )
 962 {
 963     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 964     return FALSE;
 965 }
 966
 967
 968 /*
 969  * @unimplemented
 970  */
 971 WINBOOL
 972 STDCALL
 973 RegisterWowExec (
 974     DWORD   Unknown0
 975     )
 976 {
 977     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 978     return FALSE;
 979 }
 980
 981
 982 #ifndef _OLE2NLS_IN_BUILD_
 983
 984 /*
 985  * @unimplemented
 986  */
 987 WINBOOL
 988 STDCALL
 989 SetLocaleInfoA (
 990     LCID    Locale,
 991     LCTYPE  LCType,
 992     LPCSTR  lpLCData
 993     )
 994 {
 995     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 996     return FALSE;
 997 }
 998
 999
1000 /*
1001  * @unimplemented
1002  */
1003 WINBOOL
1004 STDCALL
1005 SetLocaleInfoW (
1006     LCID    Locale,
1007     LCTYPE  LCType,
1008     LPCWSTR lpLCData
1009     )
1010 {
1011     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1012     return FALSE;
1013 }
1014
1015
1016 /*
1017  * @unimplemented
1018  */
1019 WINBOOL
1020 STDCALL
1021 SetThreadLocale (
1022     LCID    Locale
1023     )
1024 {
1025     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1026     return FALSE;
1027 }
1028
1029 #endif
1030
1031
1032 /*
1033  * @unimplemented
1034  */
1035 WINBOOL STDCALL
1036 SetSystemPowerState (
1037     WINBOOL fSuspend,
1038     WINBOOL fForce
1039     )
1040 {
1041     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1042     return FALSE;
1043 }
1044
1045
1046 /*
1047  * @unimplemented
1048  */
1049 WINBOOL
1050 STDCALL
1051 SetVDMCurrentDirectories (
1052     DWORD   Unknown0,
1053     DWORD   Unknown1
1054     )
1055 {
1056     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1057     return FALSE;
1058 }
1059
1060
1061 /*
1062  * @unimplemented
1063  */
1064 DWORD
1065 STDCALL
1066 TrimVirtualBuffer (
1067     DWORD   Unknown0
1068     )
1069 {
1070     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1071     return 0;
1072 }
1073
1074
1075 /*
1076  * @unimplemented
1077  */
1078 DWORD
1079 STDCALL
1080 VDMConsoleOperation (
1081     DWORD   Unknown0,
1082     DWORD   Unknown1
1083     )
1084 {
1085     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1086     return 0;
1087 }
1088
1089
1090 /*
1091  * @unimplemented
1092  */
1093 DWORD
1094 STDCALL
1095 VDMOperationStarted (
1096     DWORD   Unknown0
1097     )
1098 {
1099     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1100     return 0;
1101 }
1102
1103
1104 #ifndef _OLE2NLS_IN_BUILD_
1105
1106 /*
1107  * @unimplemented
1108  */
1109 DWORD
1110 STDCALL
1111 VerLanguageNameA (
1112     DWORD   wLang,
1113     LPSTR   szLang,
1114     DWORD   nSize
1115     )
1116 {
1117     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1118     return 0;
1119 }
1120
1121
1122 /*
1123  * @unimplemented
1124  */
1125 DWORD
1126 STDCALL
1127 VerLanguageNameW (
1128     DWORD   wLang,
1129     LPWSTR  szLang,
1130     DWORD   nSize
1131     )
1132 {
1133     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1134     return 0;
1135 }
1136
1137 #endif
1138
1139 /*
1140  * @unimplemented
1141  */
1142 DWORD
1143 STDCALL
1144 VirtualBufferExceptionHandler (
1145     DWORD   Unknown0,
1146     DWORD   Unknown1,
1147     DWORD   Unknown2
1148     )
1149 {
1150     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1151     return 0;
1152 }
1153
1154 /*
1155  * @unimplemented
1156  */
1157 WINBOOL
1158 STDCALL
1159 ActivateActCtx(
1160     HANDLE hActCtx,
1161     ULONG_PTR *lpCookie
1162     )
1163 {
1164     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1165     return 0;
1166 }
1167
1168 /*
1169  * @unimplemented
1170  */
1171 VOID
1172 STDCALL
1173 AddRefActCtx(
1174     HANDLE hActCtx
1175     )
1176 {
1177     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1178 }
1179
1180 /*
1181  * @unimplemented
1182  */
1183 WINBOOL
1184 STDCALL
1185 AllocateUserPhysicalPages(
1186     HANDLE hProcess,
1187     PULONG_PTR NumberOfPages,
1188     PULONG_PTR PageArray
1189     )
1190 {
1191     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1192     return 0;
1193 }
1194
1195 /*
1196  * @unimplemented
1197  */
1198 WINBOOL
1199 STDCALL
1200 AssignProcessToJobObject(
1201     HANDLE hJob,
1202     HANDLE hProcess
1203     )
1204 {
1205     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1206     return 0;
1207 }
1208
1209 /*
1210  * @unimplemented
1211  */
1212 WINBOOL
1213 STDCALL
1214 BindIoCompletionCallback (
1215     HANDLE FileHandle,
1216     LPOVERLAPPED_COMPLETION_ROUTINE Function,
1217     ULONG Flags
1218     )
1219 {
1220     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1221     return 0;
1222 }
1223
1224 /*
1225  * @unimplemented
1226  */
1227 WINBOOL
1228 STDCALL
1229 CancelDeviceWakeupRequest(
1230     HANDLE hDevice
1231     )
1232 {
1233     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1234     return 0;
1235 }
1236
1237 /*
1238  * @unimplemented
1239  */
1240 WINBOOL
1241 STDCALL
1242 CancelTimerQueueTimer(
1243     HANDLE TimerQueue,
1244     HANDLE Timer
1245     )
1246 {
1247     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1248     return 0;
1249 }
1250 /*
1251  * @unimplemented
1252  */
1253
1254 WINBOOL
1255 STDCALL
1256 ChangeTimerQueueTimer(
1257     HANDLE TimerQueue,
1258     HANDLE Timer,
1259     ULONG DueTime,
1260     ULONG Period
1261     )
1262 {
1263     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1264     return 0;
1265 }
1266
1267 /*
1268  * @unimplemented
1269  */
1270 HANDLE
1271 STDCALL
1272 CreateActCtxA(
1273     PCACTCTXA pActCtx
1274     )
1275 {
1276     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1277     return 0;
1278 }
1279
1280 /*
1281  * @unimplemented
1282  */
1283 HANDLE
1284 STDCALL
1285 CreateActCtxW(
1286     PCACTCTXW pActCtx
1287     )
1288 {
1289     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1290     return 0;
1291 }
1292
1293 /*
1294  * @unimplemented
1295  */
1296 WINBOOL
1297 STDCALL
1298 CreateJobSet (
1299     ULONG NumJob,
1300     PJOB_SET_ARRAY UserJobSet,
1301     ULONG Flags)
1302 {
1303     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1304     return 0;
1305 }
1306
1307 /*
1308  * @unimplemented
1309  */
1310 HANDLE
1311 STDCALL
1312 CreateMemoryResourceNotification(
1313     MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType
1314     )
1315 {
1316     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1317     return 0;
1318 }
1319
1320 /*
1321  * @unimplemented
1322  */
1323 HANDLE
1324 STDCALL
1325 CreateTimerQueue(
1326     VOID
1327     )
1328 {
1329     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1330     return 0;
1331 }
1332
1333 /*
1334  * @unimplemented
1335  */
1336 WINBOOL
1337 STDCALL
1338 CreateTimerQueueTimer(
1339     PHANDLE phNewTimer,
1340     HANDLE TimerQueue,
1341     WAITORTIMERCALLBACK Callback,
1342     PVOID Parameter,
1343     DWORD DueTime,
1344     DWORD Period,
1345     ULONG Flags
1346     )
1347 {
1348     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1349     return 0;
1350 }
1351
1352 /*
1353  * @unimplemented
1354  */
1355 WINBOOL
1356 STDCALL
1357 DeactivateActCtx(
1358     DWORD dwFlags,
1359     ULONG_PTR ulCookie
1360     )
1361 {
1362     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1363     return 0;
1364 }
1365
1366 /*
1367  * @unimplemented
1368  */
1369 WINBOOL
1370 STDCALL
1371 DeleteTimerQueue(
1372     HANDLE TimerQueue
1373     )
1374 {
1375     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1376     return 0;
1377 }
1378
1379 /*
1380  * @unimplemented
1381  */
1382 WINBOOL
1383 STDCALL
1384 DeleteTimerQueueEx(
1385     HANDLE TimerQueue,
1386     HANDLE CompletionEvent
1387     )
1388 {
1389     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1390     return 0;
1391 }
1392
1393 /*
1394  * @unimplemented
1395  */
1396 WINBOOL
1397 STDCALL
1398 DeleteTimerQueueTimer(
1399     HANDLE TimerQueue,
1400     HANDLE Timer,
1401     HANDLE CompletionEvent
1402     )
1403 {
1404     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1405     return 0;
1406 }
1407
1408 /*
1409  * @unimplemented
1410  */
1411 WINBOOL
1412 STDCALL
1413 FindActCtxSectionGuid(
1414     DWORD dwFlags,
1415     const GUID *lpExtensionGuid,
1416     ULONG ulSectionId,
1417     const GUID *lpGuidToFind,
1418     PACTCTX_SECTION_KEYED_DATA ReturnedData
1419     )
1420 {
1421     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1422     return 0;
1423 }
1424
1425 /*
1426  * @unimplemented
1427  */
1428 WINBOOL
1429 STDCALL
1430 FindVolumeClose(
1431     HANDLE hFindVolume
1432     )
1433 {
1434     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1435     return 0;
1436 }
1437
1438 /*
1439  * @unimplemented
1440  */
1441 WINBOOL
1442 STDCALL
1443 FindVolumeMountPointClose(
1444     HANDLE hFindVolumeMountPoint
1445     )
1446 {
1447     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1448     return 0;
1449 }
1450
1451 /*
1452  * @unimplemented
1453  */
1454 WINBOOL
1455 STDCALL
1456 FreeUserPhysicalPages(
1457     HANDLE hProcess,
1458     PULONG_PTR NumberOfPages,
1459     PULONG_PTR PageArray
1460     )
1461 {
1462     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1463     return 0;
1464 }
1465
1466 /*
1467  * @unimplemented
1468  */
1469 WINBOOL
1470 STDCALL
1471 GetCurrentActCtx(
1472     HANDLE *lphActCtx)
1473 {
1474     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1475     return 0;
1476 }
1477
1478 /*
1479  * @unimplemented
1480  */
1481 WINBOOL
1482 STDCALL
1483 GetDevicePowerState(
1484     HANDLE hDevice,
1485     WINBOOL *pfOn
1486     )
1487 {
1488     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1489     return 0;
1490 }
1491
1492 /*
1493  * @unimplemented
1494  */
1495 WINBOOL
1496 STDCALL
1497 GetFileSizeEx(
1498     HANDLE hFile,
1499     PLARGE_INTEGER lpFileSize
1500     )
1501 {
1502     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1503     return 0;
1504 }
1505
1506 /*
1507  * @unimplemented
1508  */
1509 VOID
1510 STDCALL
1511 GetNativeSystemInfo(
1512     LPSYSTEM_INFO lpSystemInfo
1513     )
1514 {
1515     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1516 }
1517
1518 /*
1519  * @unimplemented
1520  */
1521 WINBOOL
1522 STDCALL
1523 GetNumaHighestNodeNumber(
1524     PULONG HighestNodeNumber
1525     )
1526 {
1527     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1528     return 0;
1529 }
1530
1531 /*
1532  * @unimplemented
1533  */
1534 WINBOOL
1535 STDCALL
1536 GetNumaNodeProcessorMask(
1537     UCHAR Node,
1538     PULONGLONG ProcessorMask
1539     )
1540 {
1541     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1542     return 0;
1543 }
1544
1545 /*
1546  * @unimplemented
1547  */
1548 WINBOOL
1549 STDCALL
1550 GetNumaProcessorNode(
1551     UCHAR Processor,
1552     PUCHAR NodeNumber
1553     )
1554 {
1555     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1556     return 0;
1557 }
1558
1559 /*
1560  * @unimplemented
1561  */
1562 WINBOOL
1563 STDCALL
1564 GetProcessHandleCount(
1565     HANDLE hProcess,
1566     PDWORD pdwHandleCount
1567     )
1568 {
1569     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1570     return 0;
1571 }
1572
1573 /*
1574  * @unimplemented
1575  */
1576 DWORD
1577 STDCALL
1578 GetProcessId(
1579     HANDLE Process
1580     )
1581 {
1582     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1583     return 0;
1584 }
1585
1586 /*
1587  * @unimplemented
1588  */
1589 WINBOOL
1590 STDCALL
1591 GetProcessIoCounters(
1592     HANDLE hProcess,
1593     PIO_COUNTERS lpIoCounters
1594     )
1595 {
1596     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1597     return 0;
1598 }
1599
1600 /*
1601  * @unimplemented
1602  */
1603 WINBOOL
1604 STDCALL
1605 GetProcessPriorityBoost(
1606     HANDLE hProcess,
1607     PWINBOOL pDisablePriorityBoost
1608     )
1609 {
1610     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1611     return 0;
1612 }
1613
1614 /*
1615  * @unimplemented
1616  */
1617 WINBOOL
1618 STDCALL
1619 GetSystemRegistryQuota(
1620     PDWORD pdwQuotaAllowed,
1621     PDWORD pdwQuotaUsed
1622     )
1623 {
1624     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1625     return 0;
1626 }
1627
1628 /*
1629  * @unimplemented
1630  */
1631 WINBOOL
1632 STDCALL
1633 GetSystemTimes(
1634     LPFILETIME lpIdleTime,
1635     LPFILETIME lpKernelTime,
1636     LPFILETIME lpUserTime
1637     )
1638 {
1639     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1640     return 0;
1641 }
1642
1643 /*
1644  * @unimplemented
1645  */
1646 WINBOOL
1647 STDCALL
1648 GetThreadIOPendingFlag(
1649     HANDLE hThread,
1650     PWINBOOL lpIOIsPending
1651     )
1652 {
1653     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1654     return 0;
1655 }
1656
1657 /*
1658  * @unimplemented
1659  */
1660 UINT
1661 STDCALL
1662 GetWriteWatch(
1663     DWORD  dwFlags,
1664     PVOID  lpBaseAddress,
1665     SIZE_T dwRegionSize,
1666     PVOID *lpAddresses,
1667     PULONG_PTR lpdwCount,
1668     PULONG lpdwGranularity
1669     )
1670 {
1671     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1672     return 0;
1673 }
1674
1675 /*
1676  * @unimplemented
1677  */
1678 WINBOOL
1679 STDCALL
1680 GlobalMemoryStatusEx(
1681     LPMEMORYSTATUSEX lpBuffer
1682     )
1683 {
1684     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1685     return 0;
1686 }
1687
1688 /*
1689  * @unimplemented
1690  */
1691 WINBOOL
1692 STDCALL
1693 HeapQueryInformation (
1694     HANDLE HeapHandle,
1695     HEAP_INFORMATION_CLASS HeapInformationClass,
1696     PVOID HeapInformation OPTIONAL,
1697     SIZE_T HeapInformationLength OPTIONAL,
1698     PSIZE_T ReturnLength OPTIONAL
1699     )
1700 {
1701     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1702     return 0;
1703 }
1704
1705 /*
1706  * @unimplemented
1707  */
1708 WINBOOL
1709 STDCALL
1710 HeapSetInformation (
1711     HANDLE HeapHandle,
1712     HEAP_INFORMATION_CLASS HeapInformationClass,
1713     PVOID HeapInformation OPTIONAL,
1714     SIZE_T HeapInformationLength OPTIONAL
1715     )
1716 {
1717     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1718     return 0;
1719 }
1720
1721 /*
1722  * @unimplemented
1723  */
1724 WINBOOL
1725 STDCALL
1726 InitializeCriticalSectionAndSpinCount(
1727     LPCRITICAL_SECTION lpCriticalSection,
1728     DWORD dwSpinCount
1729     )
1730 {
1731     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1732     return 0;
1733 }
1734
1735 /*
1736  * @unimplemented
1737  */
1738 WINBOOL
1739 STDCALL
1740 IsProcessInJob (
1741     HANDLE ProcessHandle,
1742     HANDLE JobHandle,
1743     PWINBOOL Result
1744     )
1745 {
1746     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1747     return 0;
1748 }
1749
1750 /*
1751  * @unimplemented
1752  */
1753 WINBOOL
1754 STDCALL
1755 IsSystemResumeAutomatic(
1756     VOID
1757     )
1758 {
1759     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1760     return 0;
1761 }
1762
1763 /*
1764  * @unimplemented
1765  */
1766 WINBOOL
1767 STDCALL
1768 IsWow64Process(
1769     HANDLE hProcess,
1770     PWINBOOL Wow64Process
1771     )
1772 {
1773     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1774     return 0;
1775 }
1776
1777 /*
1778  * @unimplemented
1779  */
1780 WINBOOL
1781 STDCALL
1782 MapUserPhysicalPages(
1783     PVOID VirtualAddress,
1784     ULONG_PTR NumberOfPages,
1785     PULONG_PTR PageArray OPTIONAL
1786     )
1787 {
1788     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1789     return 0;
1790 }
1791
1792 /*
1793  * @unimplemented
1794  */
1795 WINBOOL
1796 STDCALL
1797 MapUserPhysicalPagesScatter(
1798     PVOID *VirtualAddresses,
1799     ULONG_PTR NumberOfPages,
1800     PULONG_PTR PageArray OPTIONAL
1801     )
1802 {
1803     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1804     return 0;
1805 }
1806
1807 /*
1808  * @unimplemented
1809  */
1810 HANDLE
1811 STDCALL
1812 OpenThread(
1813     DWORD dwDesiredAccess,
1814     WINBOOL bInheritHandle,
1815     DWORD dwThreadId
1816     )
1817 {
1818     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1819     return 0;
1820 }
1821
1822 /*
1823  * @unimplemented
1824  */
1825 WINBOOL
1826 STDCALL
1827 QueryActCtxW(
1828     DWORD dwFlags,
1829     HANDLE hActCtx,
1830     PVOID pvSubInstance,
1831     ULONG ulInfoClass,
1832     PVOID pvBuffer,
1833     SIZE_T cbBuffer OPTIONAL,
1834     SIZE_T *pcbWrittenOrRequired OPTIONAL
1835     )
1836 {
1837     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1838     return 0;
1839 }
1840
1841 /*
1842  * @unimplemented
1843  */
1844 WINBOOL
1845 STDCALL
1846 QueryInformationJobObject(
1847     HANDLE hJob,
1848     JOBOBJECTINFOCLASS JobObjectInformationClass,
1849     LPVOID lpJobObjectInformation,
1850     DWORD cbJobObjectInformationLength,
1851     LPDWORD lpReturnLength
1852     )
1853 {
1854     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1855     return 0;
1856 }
1857
1858 /*
1859  * @unimplemented
1860  */
1861 WINBOOL
1862 STDCALL
1863 QueryMemoryResourceNotification(
1864      HANDLE ResourceNotificationHandle,
1865     PWINBOOL  ResourceState
1866     )
1867 {
1868     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1869     return 0;
1870 }
1871
1872 /*
1873  * @unimplemented
1874  */
1875 DWORD
1876 STDCALL
1877 QueueUserAPC(
1878     PAPCFUNC pfnAPC,
1879     HANDLE hThread,
1880     ULONG_PTR dwData
1881     )
1882 {
1883     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1884     return 0;
1885 }
1886
1887 /*
1888  * @unimplemented
1889  */
1890 WINBOOL
1891 STDCALL
1892 QueueUserWorkItem(
1893     LPTHREAD_START_ROUTINE Function,
1894     PVOID Context,
1895     ULONG Flags
1896     )
1897 {
1898     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1899     return 0;
1900 }
1901
1902 /*
1903  * @unimplemented
1904  */
1905 WINBOOL
1906 STDCALL
1907 ReadDirectoryChangesW(
1908     HANDLE hDirectory,
1909     LPVOID lpBuffer,
1910     DWORD nBufferLength,
1911     WINBOOL bWatchSubtree,
1912     DWORD dwNotifyFilter,
1913     LPDWORD lpBytesReturned,
1914     LPOVERLAPPED lpOverlapped,
1915     LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
1916     )
1917 {
1918     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1919     return 0;
1920 }
1921
1922 /*
1923  * @unimplemented
1924  */
1925 WINBOOL
1926 STDCALL
1927 ReadFileScatter(
1928     HANDLE hFile,
1929     FILE_SEGMENT_ELEMENT aSegmentArray[],
1930     DWORD nNumberOfBytesToRead,
1931     LPDWORD lpReserved,
1932     LPOVERLAPPED lpOverlapped
1933     )
1934 {
1935     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1936     return 0;
1937 }
1938
1939 /*
1940  * @unimplemented
1941  */
1942 WINBOOL
1943 STDCALL
1944 RegisterWaitForSingleObject(
1945     PHANDLE phNewWaitObject,
1946     HANDLE hObject,
1947     WAITORTIMERCALLBACK Callback,
1948     PVOID Context,
1949     ULONG dwMilliseconds,
1950     ULONG dwFlags
1951     )
1952 {
1953     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1954     return 0;
1955 }
1956
1957 /*
1958  * @unimplemented
1959  */
1960 HANDLE
1961 STDCALL
1962 RegisterWaitForSingleObjectEx(
1963     HANDLE hObject,
1964     WAITORTIMERCALLBACK Callback,
1965     PVOID Context,
1966     ULONG dwMilliseconds,
1967     ULONG dwFlags
1968     )
1969 {
1970     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1971     return 0;
1972 }
1973
1974 /*
1975  * @unimplemented
1976  */
1977 VOID
1978 STDCALL
1979 ReleaseActCtx(
1980     HANDLE hActCtx
1981     )
1982 {
1983     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1984 }
1985
1986 /*
1987  * @unimplemented
1988  */
1989 ULONG
1990 STDCALL
1991 RemoveVectoredExceptionHandler(
1992     PVOID VectoredHandlerHandle
1993     )
1994 {
1995     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1996     return 0;
1997 }
1998
1999 /*
2000  * @unimplemented
2001  */
2002 WINBOOL
2003 STDCALL
2004 RequestDeviceWakeup(
2005     HANDLE hDevice
2006     )
2007 {
2008     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2009     return 0;
2010 }
2011
2012 /*
2013  * @unimplemented
2014  */
2015 WINBOOL
2016 STDCALL
2017 RequestWakeupLatency(
2018     LATENCY_TIME latency
2019     )
2020 {
2021     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2022     return 0;
2023 }
2024
2025 /*
2026  * @unimplemented
2027  */
2028 UINT
2029 STDCALL
2030 ResetWriteWatch(
2031     LPVOID lpBaseAddress,
2032     SIZE_T dwRegionSize
2033     )
2034 {
2035     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2036     return 0;
2037 }
2038
2039 /*
2040  * @unimplemented
2041  */
2042 VOID
2043 STDCALL
2044 RestoreLastError(
2045     DWORD dwErrCode
2046     )
2047 {
2048     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2049 }
2050
2051 /*
2052  * @unimplemented
2053  */
2054 DWORD
2055 STDCALL
2056 SetCriticalSectionSpinCount(
2057     LPCRITICAL_SECTION lpCriticalSection,
2058     DWORD dwSpinCount
2059     )
2060 {
2061     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2062     return 0;
2063 }
2064
2065 /*
2066  * @unimplemented
2067  */
2068 WINBOOL
2069 STDCALL
2070 SetFilePointerEx(
2071     HANDLE hFile,
2072     LARGE_INTEGER liDistanceToMove,
2073     PLARGE_INTEGER lpNewFilePointer,
2074     DWORD dwMoveMethod
2075     )
2076 {
2077     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2078     return 0;
2079 }
2080
2081 /*
2082  * @unimplemented
2083  */
2084 WINBOOL
2085 STDCALL
2086 SetFileValidData(
2087     HANDLE hFile,
2088     LONGLONG ValidDataLength
2089     )
2090 {
2091     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2092     return 0;
2093 }
2094
2095 /*
2096  * @unimplemented
2097  */
2098 WINBOOL
2099 STDCALL
2100 SetInformationJobObject(
2101     HANDLE hJob,
2102     JOBOBJECTINFOCLASS JobObjectInformationClass,
2103     LPVOID lpJobObjectInformation,
2104     DWORD cbJobObjectInformationLength
2105     )
2106 {
2107     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2108     return 0;
2109 }
2110
2111 /*
2112  * @unimplemented
2113  */
2114 WINBOOL
2115 STDCALL
2116 SetMessageWaitingIndicator(
2117     HANDLE hMsgIndicator,
2118     ULONG ulMsgCount
2119     )
2120 {
2121     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2122     return 0;
2123 }
2124
2125 /*
2126  * @unimplemented
2127  */
2128 WINBOOL
2129 STDCALL
2130 SetProcessPriorityBoost(
2131     HANDLE hProcess,
2132     WINBOOL bDisablePriorityBoost
2133     )
2134 {
2135     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2136     return 0;
2137 }
2138
2139 /*
2140  * @unimplemented
2141  */
2142 EXECUTION_STATE
2143 STDCALL
2144 SetThreadExecutionState(
2145     EXECUTION_STATE esFlags
2146     )
2147 {
2148     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2149     return 0;
2150 }
2151
2152 /*
2153  * @unimplemented
2154  */
2155 HANDLE
2156 STDCALL
2157 SetTimerQueueTimer(
2158     HANDLE TimerQueue,
2159     WAITORTIMERCALLBACK Callback,
2160     PVOID Parameter,
2161     DWORD DueTime,
2162     DWORD Period,
2163     WINBOOL PreferIo
2164     )
2165 {
2166     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2167     return 0;
2168 }
2169
2170 /*
2171  * @unimplemented
2172  */
2173 WINBOOL
2174 STDCALL
2175 TerminateJobObject(
2176     HANDLE hJob,
2177     UINT uExitCode
2178     )
2179 {
2180     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2181     return 0;
2182 }
2183
2184 /*
2185  * @unimplemented
2186  */
2187 WINBOOL
2188 STDCALL
2189 TzSpecificLocalTimeToSystemTime(
2190     LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
2191     LPSYSTEMTIME lpLocalTime,
2192     LPSYSTEMTIME lpUniversalTime
2193     )
2194 {
2195     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2196     return 0;
2197 }
2198
2199 /*
2200  * @unimplemented
2201  */
2202 WINBOOL
2203 STDCALL
2204 UnregisterWait(
2205     HANDLE WaitHandle
2206     )
2207 {
2208     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2209     return 0;
2210 }
2211
2212 /*
2213  * @unimplemented
2214  */
2215 WINBOOL
2216 STDCALL
2217 UnregisterWaitEx(
2218     HANDLE WaitHandle,
2219     HANDLE CompletionEvent
2220     )
2221 {
2222     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2223     return 0;
2224 }
2225
2226 /*
2227  * @unimplemented
2228  */
2229 WINBOOL
2230 STDCALL
2231 WriteFileGather(
2232     HANDLE hFile,
2233     FILE_SEGMENT_ELEMENT aSegmentArray[],
2234     DWORD nNumberOfBytesToWrite,
2235     LPDWORD lpReserved,
2236     LPOVERLAPPED lpOverlapped
2237     )
2238 {
2239     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2240     return 0;
2241 }
2242
2243 /*
2244  * @unimplemented
2245  */
2246 DWORD
2247 STDCALL
2248 WTSGetActiveConsoleSessionId(VOID)
2249 {
2250     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2251     return 0;
2252 }
2253
2254 /*
2255  * @unimplemented
2256  */
2257 WINBOOL
2258 STDCALL
2259 ZombifyActCtx(
2260     HANDLE hActCtx
2261     )
2262 {
2263     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2264     return 0;
2265 }
2266
2267 /*
2268  * @unimplemented
2269  */
2270 WINBOOL
2271 STDCALL
2272 CheckNameLegalDOS8Dot3W(
2273     LPCWSTR lpName,
2274     LPSTR lpOemName OPTIONAL,
2275     DWORD OemNameSize OPTIONAL,
2276     PWINBOOL pbNameContainsSpaces OPTIONAL,
2277     PWINBOOL pbNameLegal
2278     )
2279 {
2280     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2281     return 0;
2282 }
2283
2284 /*
2285  * @unimplemented
2286  */
2287 WINBOOL
2288 STDCALL
2289 CreateHardLinkW(
2290     LPCWSTR lpFileName,
2291     LPCWSTR lpExistingFileName,
2292     LPSECURITY_ATTRIBUTES lpSecurityAttributes
2293     )
2294 {
2295     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2296     return 0;
2297 }
2298
2299 /*
2300  * @unimplemented
2301  */
2302 HANDLE
2303 STDCALL
2304 CreateJobObjectW(
2305     LPSECURITY_ATTRIBUTES lpJobAttributes,
2306     LPCWSTR lpName
2307     )
2308 {
2309     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2310     return 0;
2311 }
2312
2313 /*
2314  * @unimplemented
2315  */
2316 WINBOOL
2317 STDCALL
2318 DeleteVolumeMountPointW(
2319     LPCWSTR lpszVolumeMountPoint
2320     )
2321 {
2322     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2323     return 0;
2324 }
2325
2326 /*
2327  * @unimplemented
2328  */
2329 WINBOOL
2330 STDCALL
2331 DnsHostnameToComputerNameW (
2332     LPCWSTR Hostname,
2333     LPWSTR ComputerName,
2334     LPDWORD nSize
2335     )
2336 {
2337     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2338     return 0;
2339 }
2340
2341 /*
2342  * @unimplemented
2343  */
2344 WINBOOL
2345 STDCALL
2346 FindActCtxSectionStringW(
2347     DWORD dwFlags,
2348     const GUID *lpExtensionGuid,
2349     ULONG ulSectionId,
2350     LPCWSTR lpStringToFind,
2351     PACTCTX_SECTION_KEYED_DATA ReturnedData
2352     )
2353 {
2354     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2355     return 0;
2356 }
2357
2358 /*
2359  * @unimplemented
2360  */
2361 HANDLE
2362 STDCALL
2363 FindFirstVolumeW(
2364     LPWSTR lpszVolumeName,
2365     DWORD cchBufferLength
2366     )
2367 {
2368     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2369     return 0;
2370 }
2371
2372 /*
2373  * @unimplemented
2374  */
2375 HANDLE
2376 STDCALL
2377 FindFirstVolumeMountPointW(
2378     LPCWSTR lpszRootPathName,
2379     LPWSTR lpszVolumeMountPoint,
2380     DWORD cchBufferLength
2381     )
2382 {
2383     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2384     return 0;
2385 }
2386
2387 /*
2388  * @unimplemented
2389  */
2390 WINBOOL
2391 STDCALL
2392 FindNextVolumeW(
2393     HANDLE hFindVolume,
2394     LPWSTR lpszVolumeName,
2395     DWORD cchBufferLength
2396     )
2397 {
2398     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2399     return 0;
2400 }
2401
2402 /*
2403  * @unimplemented
2404  */
2405 WINBOOL
2406 STDCALL
2407 FindNextVolumeMountPointW(
2408     HANDLE hFindVolumeMountPoint,
2409     LPWSTR lpszVolumeMountPoint,
2410     DWORD cchBufferLength
2411     )
2412 {
2413     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2414     return 0;
2415 }
2416
2417 /*
2418  * @unimplemented
2419  */
2420 WINBOOL
2421 STDCALL
2422 GetComputerNameExW (
2423     COMPUTER_NAME_FORMAT NameType,
2424     LPWSTR lpBuffer,
2425     LPDWORD nSize
2426     )
2427 {
2428     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2429     return 0;
2430 }
2431
2432 /*
2433  * @unimplemented
2434  */
2435 DWORD
2436 STDCALL
2437 GetDllDirectoryW(
2438     DWORD nBufferLength,
2439     LPWSTR lpBuffer
2440     )
2441 {
2442     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2443     return 0;
2444 }
2445
2446 /*
2447  * @unimplemented
2448  */
2449 DWORD
2450 STDCALL
2451 GetFirmwareEnvironmentVariableW(
2452     LPCWSTR lpName,
2453     LPCWSTR lpGuid,
2454     PVOID   pBuffer,
2455     DWORD    nSize
2456     )
2457 {
2458     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2459     return 0;
2460 }
2461
2462 /*
2463  * @unimplemented
2464  */
2465 DWORD
2466 STDCALL
2467 GetLongPathNameW(
2468     LPCWSTR lpszShortPath,
2469     LPWSTR  lpszLongPath,
2470     DWORD    cchBuffer
2471     )
2472 {
2473     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2474     return 0;
2475 }
2476
2477 /*
2478  * @unimplemented
2479  */
2480 WINBOOL
2481 STDCALL
2482 GetModuleHandleExW(
2483     DWORD        dwFlags,
2484     LPCWSTR     lpModuleName,
2485     HMODULE*    phModule
2486     )
2487 {
2488     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2489     return 0;
2490 }
2491
2492 /*
2493  * @unimplemented
2494  */
2495 UINT
2496 STDCALL
2497 GetSystemWow64DirectoryW(
2498     LPWSTR lpBuffer,
2499     UINT uSize
2500     )
2501 {
2502     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2503     return 0;
2504 }
2505
2506 /*
2507  * @unimplemented
2508  */
2509 WINBOOL
2510 STDCALL
2511 GetVolumeNameForVolumeMountPointW(
2512     LPCWSTR lpszVolumeMountPoint,
2513     LPWSTR lpszVolumeName,
2514     DWORD cchBufferLength
2515     )
2516 {
2517     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2518     return 0;
2519 }
2520
2521 /*
2522  * @unimplemented
2523  */
2524 WINBOOL
2525 STDCALL
2526 GetVolumePathNameW(
2527     LPCWSTR lpszFileName,
2528     LPWSTR lpszVolumePathName,
2529     DWORD cchBufferLength
2530     )
2531 {
2532     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2533     return 0;
2534 }
2535
2536 /*
2537  * @unimplemented
2538  */
2539 WINBOOL
2540 STDCALL
2541 GetVolumePathNamesForVolumeNameW(
2542     LPCWSTR lpszVolumeName,
2543     LPWSTR lpszVolumePathNames,
2544     DWORD cchBufferLength,
2545     PDWORD lpcchReturnLength
2546     )
2547 {
2548     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2549     return 0;
2550 }
2551
2552 /*
2553  * @unimplemented
2554  */
2555 HANDLE
2556 STDCALL
2557 OpenJobObjectW(
2558     DWORD dwDesiredAccess,
2559     WINBOOL bInheritHandle,
2560     LPCWSTR lpName
2561     )
2562 {
2563     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2564     return 0;
2565 }
2566
2567 /*
2568  * @unimplemented
2569  */
2570 WINBOOL
2571 STDCALL
2572 ReplaceFileW(
2573     LPCWSTR lpReplacedFileName,
2574     LPCWSTR lpReplacementFileName,
2575     LPCWSTR lpBackupFileName,
2576     DWORD   dwReplaceFlags,
2577     LPVOID  lpExclude,
2578     LPVOID  lpReserved
2579     )
2580 {
2581     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2582     return 0;
2583 }
2584
2585 /*
2586  * @unimplemented
2587  */
2588 WINBOOL
2589 STDCALL
2590 SetComputerNameExW (
2591     COMPUTER_NAME_FORMAT NameType,
2592     LPCWSTR lpBuffer
2593     )
2594 {
2595     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2596     return 0;
2597 }
2598
2599 /*
2600  * @unimplemented
2601  */
2602 WINBOOL
2603 STDCALL
2604 SetDllDirectoryW(
2605     LPCWSTR lpPathName
2606     )
2607 {
2608     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2609     return 0;
2610 }
2611
2612 /*
2613  * @unimplemented
2614  */
2615 WINBOOL
2616 STDCALL
2617 SetFileShortNameW(
2618     HANDLE hFile,
2619     LPCWSTR lpShortName
2620     )
2621 {
2622     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2623     return 0;
2624 }
2625
2626 /*
2627  * @unimplemented
2628  */
2629 WINBOOL
2630 STDCALL
2631 SetFirmwareEnvironmentVariableW(
2632     LPCWSTR lpName,
2633     LPCWSTR lpGuid,
2634     PVOID    pValue,
2635     DWORD    nSize
2636     )
2637 {
2638     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2639     return 0;
2640 }
2641
2642 /*
2643  * @unimplemented
2644  */
2645 WINBOOL
2646 STDCALL
2647 SetVolumeMountPointW(
2648     LPCWSTR lpszVolumeMountPoint,
2649     LPCWSTR lpszVolumeName
2650     )
2651 {
2652     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2653     return 0;
2654 }
2655
2656 /*
2657  * @unimplemented
2658  */
2659 WINBOOL
2660 STDCALL
2661 VerifyVersionInfoW(
2662     LPOSVERSIONINFOEXW lpVersionInformation,
2663     DWORD dwTypeMask,
2664     DWORDLONG dwlConditionMask
2665     )
2666 {
2667     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2668     return 0;
2669 }
2670
2671 /*
2672  * @unimplemented
2673  */
2674 WINBOOL
2675 STDCALL
2676 CheckNameLegalDOS8Dot3A(
2677     LPCSTR lpName,
2678     LPSTR lpOemName OPTIONAL,
2679     DWORD OemNameSize OPTIONAL,
2680     PWINBOOL pbNameContainsSpaces OPTIONAL,
2681     PWINBOOL pbNameLegal
2682     )
2683 {
2684     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2685     return 0;
2686 }
2687
2688 /*
2689  * @unimplemented
2690  */
2691 WINBOOL
2692 STDCALL
2693 CreateHardLinkA(
2694     LPCSTR lpFileName,
2695     LPCSTR lpExistingFileName,
2696     LPSECURITY_ATTRIBUTES lpSecurityAttributes
2697     )
2698 {
2699     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2700     return 0;
2701 }
2702
2703 /*
2704  * @unimplemented
2705  */
2706 HANDLE
2707 STDCALL
2708 CreateJobObjectA(
2709     LPSECURITY_ATTRIBUTES lpJobAttributes,
2710     LPCSTR lpName
2711     )
2712 {
2713     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2714     return 0;
2715 }
2716
2717 /*
2718  * @unimplemented
2719  */
2720 WINBOOL
2721 STDCALL
2722 DeleteVolumeMountPointA(
2723     LPCSTR lpszVolumeMountPoint
2724     )
2725 {
2726     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2727     return 0;
2728 }
2729
2730 /*
2731  * @unimplemented
2732  */
2733 WINBOOL
2734 STDCALL
2735 DnsHostnameToComputerNameA (
2736     LPCSTR Hostname,
2737     LPSTR ComputerName,
2738     LPDWORD nSize
2739     )
2740 {
2741     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2742     return 0;
2743 }
2744
2745 /*
2746  * @unimplemented
2747  */
2748 WINBOOL
2749 STDCALL
2750 FindActCtxSectionStringA(
2751     DWORD dwFlags,
2752     const GUID *lpExtensionGuid,
2753     ULONG ulSectionId,
2754     LPCSTR lpStringToFind,
2755     PACTCTX_SECTION_KEYED_DATA ReturnedData
2756     )
2757 {
2758     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2759     return 0;
2760 }
2761
2762 /*
2763  * @unimplemented
2764  */
2765 HANDLE
2766 STDCALL
2767 FindFirstVolumeA(
2768     LPSTR lpszVolumeName,
2769     DWORD cchBufferLength
2770     )
2771 {
2772     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2773     return 0;
2774 }
2775
2776 /*
2777  * @unimplemented
2778  */
2779 HANDLE
2780 STDCALL
2781 FindFirstVolumeMountPointA(
2782     LPCSTR lpszRootPathName,
2783     LPSTR lpszVolumeMountPoint,
2784     DWORD cchBufferLength
2785     )
2786 {
2787     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2788     return 0;
2789 }
2790
2791 /*
2792  * @unimplemented
2793  */
2794 WINBOOL
2795 STDCALL
2796 FindNextVolumeA(
2797     HANDLE hFindVolume,
2798     LPSTR lpszVolumeName,
2799     DWORD cchBufferLength
2800     )
2801 {
2802     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2803     return 0;
2804 }
2805
2806 /*
2807  * @unimplemented
2808  */
2809 WINBOOL
2810 STDCALL
2811 FindNextVolumeMountPointA(
2812     HANDLE hFindVolumeMountPoint,
2813     LPSTR lpszVolumeMountPoint,
2814     DWORD cchBufferLength
2815     )
2816 {
2817     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2818     return 0;
2819 }
2820
2821 /*
2822  * @unimplemented
2823  */
2824 WINBOOL
2825 STDCALL
2826 GetComputerNameExA (
2827     COMPUTER_NAME_FORMAT NameType,
2828     LPSTR lpBuffer,
2829     LPDWORD nSize
2830     )
2831 {
2832     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2833     return 0;
2834 }
2835
2836 /*
2837  * @unimplemented
2838  */
2839 DWORD
2840 STDCALL
2841 GetDllDirectoryA(
2842     DWORD nBufferLength,
2843     LPSTR lpBuffer
2844     )
2845 {
2846     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2847     return 0;
2848 }
2849
2850 /*
2851  * @unimplemented
2852  */
2853 DWORD
2854 STDCALL
2855 GetFirmwareEnvironmentVariableA(
2856     LPCSTR lpName,
2857     LPCSTR lpGuid,
2858     PVOID   pBuffer,
2859     DWORD    nSize
2860     )
2861 {
2862     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2863     return 0;
2864 }
2865
2866 /*
2867  * @unimplemented
2868  */
2869 DWORD
2870 STDCALL
2871 GetLongPathNameA(
2872     LPCSTR lpszShortPath,
2873     LPSTR  lpszLongPath,
2874     DWORD    cchBuffer
2875     )
2876 {
2877     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2878     return 0;
2879 }
2880
2881 /*
2882  * @unimplemented
2883  */
2884 WINBOOL
2885 STDCALL
2886 GetModuleHandleExA(
2887     DWORD        dwFlags,
2888     LPCSTR     lpModuleName,
2889     HMODULE*    phModule
2890     )
2891 {
2892     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2893     return 0;
2894 }
2895
2896 /*
2897  * @unimplemented
2898  */
2899 UINT
2900 STDCALL
2901 GetSystemWow64DirectoryA(
2902     LPSTR lpBuffer,
2903     UINT uSize
2904     )
2905 {
2906     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2907     return 0;
2908 }
2909
2910 /*
2911  * @unimplemented
2912  */
2913 WINBOOL
2914 STDCALL
2915 GetVolumeNameForVolumeMountPointA(
2916     LPCSTR lpszVolumeMountPoint,
2917     LPSTR lpszVolumeName,
2918     DWORD cchBufferLength
2919     )
2920 {
2921     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2922     return 0;
2923 }
2924
2925 /*
2926  * @unimplemented
2927  */
2928 WINBOOL
2929 STDCALL
2930 GetVolumePathNameA(
2931     LPCSTR lpszFileName,
2932     LPSTR lpszVolumePathName,
2933     DWORD cchBufferLength
2934     )
2935 {
2936     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2937     return 0;
2938 }
2939
2940 /*
2941  * @unimplemented
2942  */
2943 WINBOOL
2944 STDCALL
2945 GetVolumePathNamesForVolumeNameA(
2946     LPCSTR lpszVolumeName,
2947     LPSTR lpszVolumePathNames,
2948     DWORD cchBufferLength,
2949     PDWORD lpcchReturnLength
2950     )
2951 {
2952     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2953     return 0;
2954 }
2955
2956 /*
2957  * @unimplemented
2958  */
2959 HANDLE
2960 STDCALL
2961 OpenJobObjectA(
2962     DWORD dwDesiredAccess,
2963     WINBOOL bInheritHandle,
2964     LPCSTR lpName
2965     )
2966 {
2967     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2968     return 0;
2969 }
2970
2971 /*
2972  * @unimplemented
2973  */
2974 WINBOOL
2975 STDCALL
2976 ReplaceFileA(
2977     LPCSTR  lpReplacedFileName,
2978     LPCSTR  lpReplacementFileName,
2979     LPCSTR  lpBackupFileName,
2980     DWORD   dwReplaceFlags,
2981     LPVOID  lpExclude,
2982     LPVOID  lpReserved
2983     )
2984 {
2985     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2986     return 0;
2987 }
2988
2989 /*
2990  * @unimplemented
2991  */
2992 WINBOOL
2993 STDCALL
2994 SetComputerNameExA (
2995     COMPUTER_NAME_FORMAT NameType,
2996     LPCSTR lpBuffer
2997     )
2998 {
2999     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3000     return 0;
3001 }
3002
3003 /*
3004  * @unimplemented
3005  */
3006 WINBOOL
3007 STDCALL
3008 SetDllDirectoryA(
3009     LPCSTR lpPathName
3010     )
3011 {
3012     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3013     return 0;
3014 }
3015
3016 /*
3017  * @unimplemented
3018  */
3019 WINBOOL
3020 STDCALL
3021 SetFileShortNameA(
3022     HANDLE hFile,
3023     LPCSTR lpShortName
3024     )
3025 {
3026     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3027     return 0;
3028 }
3029
3030 /*
3031  * @unimplemented
3032  */
3033 WINBOOL
3034 STDCALL
3035 SetFirmwareEnvironmentVariableA(
3036     LPCSTR lpName,
3037     LPCSTR lpGuid,
3038     PVOID    pValue,
3039     DWORD    nSize
3040     )
3041 {
3042     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3043     return 0;
3044 }
3045
3046 /*
3047  * @unimplemented
3048  */
3049 WINBOOL
3050 STDCALL
3051 SetVolumeMountPointA(
3052     LPCSTR lpszVolumeMountPoint,
3053     LPCSTR lpszVolumeName
3054     )
3055 {
3056     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3057     return 0;
3058 }
3059
3060 /*
3061  * @unimplemented
3062  */
3063 WINBOOL
3064 STDCALL
3065 VerifyVersionInfoA(
3066     LPOSVERSIONINFOEXA lpVersionInformation,
3067     DWORD dwTypeMask,
3068     DWORDLONG dwlConditionMask
3069     )
3070 {
3071     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3072     return 0;
3073 }
3074
3075 /*
3076  * @unimplemented
3077  */
3078 LANGID
3079 STDCALL
3080 GetUserDefaultUILanguage(VOID)
3081 {
3082     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3083     return 0;
3084 }
3085
3086 /*
3087  * @unimplemented
3088  */
3089 LANGID
3090 STDCALL
3091 GetSystemDefaultUILanguage(VOID)
3092 {
3093     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3094     return 0;
3095 }
3096
3097 /*
3098  * @unimplemented
3099  */
3100 WINBOOL
3101 STDCALL
3102 SetUserGeoID(
3103     GEOID       GeoId)
3104 {
3105     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3106     return 0;
3107 }
3108
3109 /*
3110  * @unimplemented
3111  */
3112 GEOID
3113 STDCALL
3114 GetUserGeoID(
3115     GEOCLASS    GeoClass)
3116 {
3117     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3118     return 0;
3119 }
3120
3121 /*
3122  * @unimplemented
3123  */
3124 WINBOOL
3125 STDCALL
3126 EnumSystemGeoID(
3127     GEOCLASS        GeoClass,
3128     GEOID           ParentGeoId,
3129     GEO_ENUMPROC    lpGeoEnumProc)
3130 {
3131     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3132     return 0;
3133 }
3134
3135 /*
3136  * @unimplemented
3137  */
3138 WINBOOL
3139 STDCALL
3140 IsValidLanguageGroup(
3141     LGRPID  LanguageGroup,
3142     DWORD   dwFlags)
3143 {
3144     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3145     return 0;
3146 }
3147
3148 /*
3149  * @unimplemented
3150  */
3151 WINBOOL
3152 STDCALL
3153 SetCalendarInfoA(
3154     LCID     Locale,
3155     CALID    Calendar,
3156     CALTYPE  CalType,
3157     LPCSTR  lpCalData)
3158 {
3159     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3160     return 0;
3161 }
3162
3163 /*
3164  * @unimplemented
3165  */
3166 WINBOOL
3167 STDCALL
3168 EnumUILanguagesA(
3169     UILANGUAGE_ENUMPROCA lpUILanguageEnumProc,
3170     DWORD                dwFlags,
3171     LONG_PTR             lParam)
3172 {
3173     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3174     return 0;
3175 }
3176
3177 /*
3178  * @unimplemented
3179  */
3180 WINBOOL
3181 STDCALL
3182 EnumLanguageGroupLocalesA(
3183     LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc,
3184     LGRPID                    LanguageGroup,
3185     DWORD                     dwFlags,
3186     LONG_PTR                  lParam)
3187 {
3188     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3189     return 0;
3190 }
3191
3192 /*
3193  * @unimplemented
3194  */
3195 WINBOOL
3196 STDCALL
3197 EnumSystemLanguageGroupsA(
3198     LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc,
3199     DWORD                   dwFlags,
3200     LONG_PTR                lParam)
3201 {
3202     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3203     return 0;
3204 }
3205
3206 /*
3207  * @unimplemented
3208  */
3209 int
3210 STDCALL
3211 GetGeoInfoA(
3212     GEOID       Location,
3213     GEOTYPE     GeoType,
3214     LPSTR     lpGeoData,
3215     int         cchData,
3216     LANGID      LangId)
3217 {
3218     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3219     return 0;
3220 }
3221
3222 /*
3223  * @unimplemented
3224  */
3225 WINBOOL
3226 STDCALL
3227 EnumDateFormatsExA(
3228     DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx,
3229     LCID                Locale,
3230     DWORD               dwFlags)
3231 {
3232     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3233     return 0;
3234 }
3235
3236 /*
3237  * @unimplemented
3238  */
3239 WINBOOL
3240 STDCALL
3241 EnumCalendarInfoExA(
3242     CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx,
3243     LCID                Locale,
3244     CALID               Calendar,
3245     CALTYPE             CalType)
3246 {
3247     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3248     return 0;
3249 }
3250
3251 /*
3252  * @unimplemented
3253  */
3254 int
3255 STDCALL
3256 GetCalendarInfoA(
3257     LCID     Locale,
3258     CALID    Calendar,
3259     CALTYPE  CalType,
3260     LPSTR   lpCalData,
3261     int      cchData,
3262     LPDWORD  lpValue)
3263 {
3264     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3265     return 0;
3266 }
3267
3268 /*
3269  * @unimplemented
3270  */
3271 WINBOOL
3272 STDCALL
3273 GetCPInfoExA(
3274     UINT          CodePage,
3275     DWORD         dwFlags,
3276     LPCPINFOEXA  lpCPInfoEx)
3277 {
3278     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3279     return 0;
3280 }
3281
3282 /*
3283  * @unimplemented
3284  */
3285 WINBOOL
3286 STDCALL
3287 SetCalendarInfoW(
3288     LCID     Locale,
3289     CALID    Calendar,
3290     CALTYPE  CalType,
3291     LPCWSTR  lpCalData)
3292 {
3293     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3294     return 0;
3295 }
3296
3297 /*
3298  * @unimplemented
3299  */
3300 WINBOOL
3301 STDCALL
3302 EnumUILanguagesW(
3303     UILANGUAGE_ENUMPROCW lpUILanguageEnumProc,
3304     DWORD                dwFlags,
3305     LONG_PTR             lParam)
3306 {
3307     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3308     return 0;
3309 }
3310
3311 /*
3312  * @unimplemented
3313  */
3314 WINBOOL
3315 STDCALL
3316 EnumLanguageGroupLocalesW(
3317     LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc,
3318     LGRPID                    LanguageGroup,
3319     DWORD                     dwFlags,
3320     LONG_PTR                  lParam)
3321 {
3322     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3323     return 0;
3324 }
3325
3326 /*
3327  * @unimplemented
3328  */
3329 WINBOOL
3330 STDCALL
3331 EnumSystemLanguageGroupsW(
3332     LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc,
3333     DWORD                   dwFlags,
3334     LONG_PTR                lParam)
3335 {
3336     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3337     return 0;
3338 }
3339
3340 /*
3341  * @unimplemented
3342  */
3343 int
3344 STDCALL
3345 GetGeoInfoW(
3346     GEOID       Location,
3347     GEOTYPE     GeoType,
3348     LPWSTR     lpGeoData,
3349     int         cchData,
3350     LANGID      LangId)
3351 {
3352     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3353     return 0;
3354 }
3355
3356 /*
3357  * @unimplemented
3358  */
3359 WINBOOL
3360 STDCALL
3361 EnumDateFormatsExW(
3362     DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx,
3363     LCID                Locale,
3364     DWORD               dwFlags)
3365 {
3366     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3367     return 0;
3368 }
3369
3370 /*
3371  * @unimplemented
3372  */
3373 WINBOOL
3374 STDCALL
3375 EnumCalendarInfoExW(
3376     CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx,
3377     LCID                Locale,
3378     CALID               Calendar,
3379     CALTYPE             CalType)
3380 {
3381     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3382     return 0;
3383 }
3384
3385 /*
3386  * @unimplemented
3387  */
3388 int
3389 STDCALL
3390 GetCalendarInfoW(
3391     LCID     Locale,
3392     CALID    Calendar,
3393     CALTYPE  CalType,
3394     LPWSTR   lpCalData,
3395     int      cchData,
3396     LPDWORD  lpValue)
3397 {
3398     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3399     return 0;
3400 }
3401
3402 /*
3403  * @unimplemented
3404  */
3405 WINBOOL
3406 STDCALL
3407 GetCPInfoExW(
3408     UINT          CodePage,
3409     DWORD         dwFlags,
3410     LPCPINFOEXW  lpCPInfoEx)
3411 {
3412     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3413     return 0;
3414 }
3415
3416 /*
3417  * @unimplemented
3418  */
3419 ULONGLONG
3420 STDCALL
3421 VerSetConditionMask(
3422         ULONGLONG   ConditionMask,
3423         DWORD   TypeMask,
3424         BYTE    Condition
3425         )
3426 {
3427     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3428     return 0;
3429 }
3430
3431 /*
3432  * @unimplemented
3433  */
3434 WINBOOL STDCALL GetConsoleKeyboardLayoutNameA(LPSTR name)
3435 {
3436     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3437     return 0;
3438 }
3439
3440 /*
3441  * @unimplemented
3442  */
3443 WINBOOL STDCALL GetConsoleKeyboardLayoutNameW(LPWSTR name)
3444 {
3445     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3446     return 0;
3447 }
3448
3449 /*
3450  * @unimplemented
3451  */
3452 BOOL STDCALL SetConsoleIcon(HICON hicon)
3453 {
3454     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3455     return 0;
3456 }
3457
3458 /*
3459  * @unimplemented
3460  */
3461 DWORD STDCALL GetHandleContext(HANDLE hnd)
3462 {
3463     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3464     return 0;
3465 }
3466
3467 /*
3468  * @unimplemented
3469  */
3470 HANDLE STDCALL CreateSocketHandle(VOID)
3471 {
3472     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3473     return 0;
3474 }
3475
3476 /*
3477  * @unimplemented
3478  */
3479 BOOL STDCALL SetHandleContext(HANDLE hnd,DWORD context)
3480 {
3481     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3482     return 0;
3483 }
3484
3485 /*
3486  * @unimplemented
3487  */
3488 BOOL STDCALL SetConsoleInputExeNameA(LPCSTR name)
3489 {
3490     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3491     return 0;
3492 }
3493
3494 /*
3495  * @unimplemented
3496  */
3497 BOOL STDCALL SetConsoleInputExeNameW(LPCWSTR name)
3498 {
3499     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3500     return 0;
3501 }
3502
3503 /*
3504  * @unimplemented
3505  */
3506 BOOL STDCALL UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
3507                         LPSTR lpszInitName, LPSTR lpszProcName,
3508                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
3509                         LPVOID lpBuff )
3510 {
3511     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3512     return 0;
3513 }
3514
3515 /*
3516  * @unimplemented
3517  */
3518 VOID STDCALL UTUnRegister( HMODULE hModule )
3519 {
3520     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3521 }
3522
3523 /*
3524  * @unimplemented
3525  */
3526 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PDelayLoadInfo pdli)
3527 {
3528     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3529     return 0;
3530 }
3531
3532 /*
3533  * @unimplemented
3534  */
3535 NTSTATUS STDCALL CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
3536 {
3537     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3538     return 0;
3539 }
3540
3541 /*
3542  * @unimplemented
3543  */
3544 BOOL STDCALL GetConsoleInputExeNameA(ULONG length,LPCSTR name)
3545 {
3546     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3547     return 0;
3548 }
3549
3550 /*
3551  * @unimplemented
3552  */
3553 BOOL STDCALL GetConsoleInputExeNameW(ULONG length,LPCWSTR name)
3554 {
3555     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3556     return 0;
3557 }
3558
3559 /*
3560  * @unimplemented
3561  */
3562 BOOL STDCALL IsValidUILanguage(LANGID langid)
3563 {
3564     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3565     return 0;
3566 }
3567
3568 /*
3569  * @unimplemented
3570  */
3571 VOID STDCALL NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
3572 {
3573     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3574 }
3575
3576 /*
3577  * @unimplemented
3578  */
3579 UINT STDCALL SetCPGlobal(UINT CodePage)
3580 {
3581     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3582     return 0;
3583 }
3584
3585 /*
3586  * @unimplemented
3587  */
3588 BOOL
3589 STDCALL
3590 SetClientTimeZoneInformation(
3591                        CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation
3592                        )
3593 {
3594     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3595     return 0;
3596 }