reactos/lib/kernel32/misc/stubs.c

   1 /* $Id: stubs.c,v 1.15 2000/04/25 23:22:54 ea Exp $
   2  *
   3  * KERNEL32.DLL stubs (unimplemented functions)
   4  * Remove from this file, if you implement them.
   5  */
   6 #include <windows.h>
   7
   8 ATOM
   9 STDCALL
  10 AddAtomA (
  11         LPCSTR  lpString
  12         )
  13 {
  14         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  15         return 0;
  16 }
  17
  18
  19 ATOM
  20 STDCALL
  21 AddAtomW (
  22         LPCWSTR lpString
  23         )
  24 {
  25         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  26         return 0;
  27 }
  28
  29 BOOL
  30 STDCALL
  31 AddConsoleAliasA (
  32         DWORD a0,
  33         DWORD a1,
  34         DWORD a2
  35         )
  36 {
  37         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  38         return FALSE;
  39 }
  40
  41 BOOL
  42 STDCALL
  43 AddConsoleAliasW (
  44         DWORD a0,
  45         DWORD a1,
  46         DWORD a2
  47         )
  48 {
  49         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  50         return FALSE;
  51 }
  52
  53 WINBOOL
  54 STDCALL
  55 BackupRead (
  56         HANDLE  hFile,
  57         LPBYTE  lpBuffer,
  58         DWORD   nNumberOfBytesToRead,
  59         LPDWORD lpNumberOfBytesRead,
  60         WINBOOL bAbort,
  61         WINBOOL bProcessSecurity,
  62         LPVOID  * lpContext
  63         )
  64 {
  65         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  66         return FALSE;
  67 }
  68
  69
  70 WINBOOL
  71 STDCALL
  72 BackupSeek (
  73         HANDLE  hFile,
  74         DWORD   dwLowBytesToSeek,
  75         DWORD   dwHighBytesToSeek,
  76         LPDWORD lpdwLowByteSeeked,
  77         LPDWORD lpdwHighByteSeeked,
  78         LPVOID  * lpContext
  79         )
  80 {
  81         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  82         return FALSE;
  83 }
  84
  85
  86 WINBOOL
  87 STDCALL
  88 BackupWrite (
  89         HANDLE  hFile,
  90         LPBYTE  lpBuffer,
  91         DWORD   nNumberOfBytesToWrite,
  92         LPDWORD lpNumberOfBytesWritten,
  93         WINBOOL bAbort,
  94         WINBOOL bProcessSecurity,
  95         LPVOID  * lpContext
  96         )
  97 {
  98         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  99         return FALSE;
 100 }
 101
 102
 103 BOOL
 104 STDCALL
 105 BaseAttachCompleteThunk (VOID)
 106 {
 107         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 108         return FALSE;
 109 }
 110
 111
 112 HANDLE
 113 STDCALL
 114 BeginUpdateResourceW (
 115         LPCWSTR pFileName,
 116         WINBOOL bDeleteExistingResources
 117         )
 118 {
 119         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 120         return FALSE;
 121 }
 122
 123
 124 HANDLE
 125 STDCALL
 126 BeginUpdateResourceA (
 127         LPCSTR  pFileName,
 128         WINBOOL bDeleteExistingResources
 129         )
 130 {
 131         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 132         return FALSE;
 133 }
 134
 135
 136 WINBOOL
 137 STDCALL
 138 BuildCommDCBA (
 139         LPCSTR  lpDef,
 140         LPDCB   lpDCB
 141         )
 142 {
 143         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 144         return FALSE;
 145 }
 146
 147
 148 WINBOOL
 149 STDCALL
 150 BuildCommDCBW (
 151         LPCWSTR lpDef,
 152         LPDCB   lpDCB
 153         )
 154 {
 155         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 156         return FALSE;
 157 }
 158
 159
 160 WINBOOL
 161 STDCALL
 162 BuildCommDCBAndTimeoutsA (
 163         LPCSTR          lpDef,
 164         LPDCB           lpDCB,
 165         LPCOMMTIMEOUTS  lpCommTimeouts
 166         )
 167 {
 168         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 169         return FALSE;
 170 }
 171
 172
 173 WINBOOL
 174 STDCALL
 175 BuildCommDCBAndTimeoutsW (
 176         LPCWSTR         lpDef,
 177         LPDCB           lpDCB,
 178         LPCOMMTIMEOUTS  lpCommTimeouts
 179         )
 180 {
 181         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 182         return FALSE;
 183 }
 184
 185
 186 WINBOOL
 187 STDCALL
 188 CallNamedPipeA (
 189         LPCSTR  lpNamedPipeName,
 190         LPVOID  lpInBuffer,
 191         DWORD   nInBufferSize,
 192         LPVOID  lpOutBuffer,
 193         DWORD   nOutBufferSize,
 194         LPDWORD lpBytesRead,
 195         DWORD   nTimeOut
 196         )
 197 {
 198         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 199         return FALSE;
 200 }
 201
 202
 203 WINBOOL
 204 STDCALL
 205 CallNamedPipeW (
 206         LPCWSTR lpNamedPipeName,
 207         LPVOID  lpInBuffer,
 208         DWORD   nInBufferSize,
 209         LPVOID  lpOutBuffer,
 210         DWORD   nOutBufferSize,
 211         LPDWORD lpBytesRead,
 212         DWORD   nTimeOut
 213         )
 214 {
 215         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 216         return FALSE;
 217 }
 218
 219
 220 WINBOOL
 221 STDCALL
 222 ClearCommBreak (
 223         HANDLE  hFile
 224         )
 225 {
 226         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 227         return FALSE;
 228 }
 229
 230
 231 WINBOOL
 232 STDCALL
 233 ClearCommError (
 234         HANDLE          hFile,
 235         LPDWORD         lpErrors,
 236         LPCOMSTAT       lpStat
 237         )
 238 {
 239         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 240         return FALSE;
 241 }
 242
 243
 244 BOOL
 245 STDCALL
 246 CloseProfileUserMapping ( VOID)
 247 {
 248         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 249         return FALSE;
 250 }
 251
 252
 253 BOOL
 254 STDCALL
 255 CmdBatNotification (
 256         DWORD   Unknown
 257         )
 258 {
 259         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 260         return FALSE;
 261 }
 262
 263
 264 WINBOOL
 265 STDCALL
 266 CommConfigDialogA (
 267         LPCSTR          lpszName,
 268         HWND            hWnd,
 269         LPCOMMCONFIG    lpCC
 270         )
 271 {
 272         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 273         return FALSE;
 274 }
 275
 276
 277 WINBOOL
 278 STDCALL
 279 CommConfigDialogW (
 280         LPCWSTR         lpszName,
 281         HWND            hWnd,
 282         LPCOMMCONFIG    lpCC
 283         )
 284 {
 285         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 286         return FALSE;
 287 }
 288
 289
 290 int
 291 STDCALL
 292 CompareStringA (
 293         LCID    Locale,
 294         DWORD   dwCmpFlags,
 295         LPCSTR  lpString1,
 296         int     cchCount1,
 297         LPCSTR  lpString2,
 298         int     cchCount2
 299         )
 300 {
 301         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 302         return 0;
 303 }
 304
 305
 306 int
 307 STDCALL
 308 CompareStringW (
 309         LCID    Locale,
 310         DWORD   dwCmpFlags,
 311         LPCWSTR lpString1,
 312         int     cchCount1,
 313         LPCWSTR lpString2,
 314         int     cchCount2
 315         )
 316 {
 317         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 318         return 0;
 319 }
 320
 321
 322 WINBOOL
 323 STDCALL
 324 ConnectNamedPipe (
 325         HANDLE          hNamedPipe,
 326         LPOVERLAPPED    lpOverlapped
 327         )
 328 {
 329         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 330         return FALSE;
 331 }
 332
 333
 334 BOOL
 335 STDCALL
 336 ConsoleMenuControl (
 337         HANDLE  hConsole,
 338         DWORD   Unknown1,
 339         DWORD   Unknown2
 340         )
 341 {
 342         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 343         return FALSE;
 344 }
 345
 346
 347 LCID
 348 STDCALL
 349 ConvertDefaultLocale (
 350         LCID    Locale
 351         )
 352 {
 353         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 354         return 0;
 355 }
 356
 357
 358 HANDLE
 359 STDCALL
 360 CreateMailslotA (
 361         LPCSTR                  lpName,
 362         DWORD                   nMaxMessageSize,
 363         DWORD                   lReadTimeout,
 364         LPSECURITY_ATTRIBUTES   lpSecurityAttributes
 365         )
 366 {
 367         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 368         return INVALID_HANDLE_VALUE;
 369 }
 370
 371
 372 HANDLE
 373 STDCALL
 374 CreateMailslotW (
 375         LPCWSTR                 lpName,
 376         DWORD                   nMaxMessageSize,
 377         DWORD                   lReadTimeout,
 378         LPSECURITY_ATTRIBUTES   lpSecurityAttributes
 379         )
 380 {
 381         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 382         return INVALID_HANDLE_VALUE;
 383 }
 384
 385
 386 HANDLE
 387 STDCALL
 388 CreateNamedPipeW (
 389         LPCWSTR                 lpName,
 390         DWORD                   dwOpenMode,
 391         DWORD                   dwPipeMode,
 392         DWORD                   nMaxInstances,
 393         DWORD                   nOutBufferSize,
 394         DWORD                   nInBufferSize,
 395         DWORD                   nDefaultTimeOut,
 396         LPSECURITY_ATTRIBUTES   lpSecurityAttributes
 397         )
 398 {
 399         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 400         return INVALID_HANDLE_VALUE;
 401 }
 402
 403
 404 HANDLE
 405 STDCALL
 406 CreateNamedPipeA (
 407         LPCSTR                  lpName,
 408         DWORD                   dwOpenMode,
 409         DWORD                   dwPipeMode,
 410         DWORD                   nMaxInstances,
 411         DWORD                   nOutBufferSize,
 412         DWORD                   nInBufferSize,
 413         DWORD                   nDefaultTimeOut,
 414         LPSECURITY_ATTRIBUTES   lpSecurityAttributes
 415         )
 416 {
 417         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 418         return INVALID_HANDLE_VALUE;
 419 }
 420
 421
 422 DWORD
 423 STDCALL
 424 CreateTapePartition (
 425         HANDLE  hDevice,
 426         DWORD   dwPartitionMethod,
 427         DWORD   dwCount,
 428         DWORD   dwSize
 429         )
 430 {
 431         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 432         return 0;
 433 }
 434
 435
 436 DWORD
 437 STDCALL
 438 CreateVirtualBuffer (
 439         DWORD   Unknown0,
 440         DWORD   Unknown1,
 441         DWORD   Unknown2
 442         )
 443 {
 444         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 445         return 0;
 446 }
 447
 448
 449 ATOM
 450 STDCALL
 451 DeleteAtom (
 452         ATOM    nAtom
 453         )
 454 {
 455         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 456         return 0;
 457 }
 458
 459
 460 WINBOOL
 461 STDCALL
 462 DisableThreadLibraryCalls (
 463         HMODULE hLibModule
 464         )
 465 {
 466         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 467         return FALSE;
 468 }
 469
 470
 471 WINBOOL
 472 STDCALL
 473 DisconnectNamedPipe (
 474         HANDLE  hNamedPipe
 475         )
 476 {
 477         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 478         return FALSE;
 479 }
 480
 481
 482 BOOL
 483 STDCALL
 484 DuplicateConsoleHandle (
 485         HANDLE  hConsole,
 486         DWORD   Unknown1,
 487         DWORD   Unknown2,
 488         DWORD   Unknown3
 489         )
 490 {
 491         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 492         return FALSE;
 493 }
 494
 495
 496 WINBOOL
 497 STDCALL
 498 EndUpdateResourceW (
 499         HANDLE  hUpdate,
 500         WINBOOL fDiscard
 501         )
 502 {
 503         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 504         return FALSE;
 505 }
 506
 507
 508 WINBOOL
 509 STDCALL
 510 EndUpdateResourceA (
 511         HANDLE  hUpdate,
 512         WINBOOL fDiscard
 513         )
 514 {
 515         return EndUpdateResourceW(
 516                         hUpdate,
 517                         fDiscard
 518                         );
 519 }
 520
 521
 522 WINBOOL
 523 STDCALL
 524 EnumCalendarInfoW (
 525     CALINFO_ENUMPROC lpCalInfoEnumProc,
 526     LCID              Locale,
 527     CALID             Calendar,
 528     CALTYPE           CalType
 529     )
 530 {
 531         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 532         return FALSE;
 533 }
 534
 535
 536
 537 WINBOOL
 538 STDCALL
 539 EnumCalendarInfoA (
 540         CALINFO_ENUMPROC        lpCalInfoEnumProc,
 541         LCID                    Locale,
 542         CALID                   Calendar,
 543         CALTYPE                 CalType
 544         )
 545 {
 546         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 547         return FALSE;
 548 }
 549
 550
 551 WINBOOL
 552 STDCALL
 553 EnumDateFormatsW (
 554         DATEFMT_ENUMPROC        lpDateFmtEnumProc,
 555         LCID                    Locale,
 556         DWORD                   dwFlags
 557         )
 558 {
 559         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 560         return FALSE;
 561 }
 562
 563
 564 WINBOOL
 565 STDCALL
 566 EnumDateFormatsA (
 567         DATEFMT_ENUMPROC        lpDateFmtEnumProc,
 568         LCID                    Locale,
 569         DWORD                   dwFlags
 570         )
 571 {
 572         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 573         return FALSE;
 574 }
 575
 576
 577 WINBOOL
 578 STDCALL
 579 EnumResourceLanguagesW (
 580         HINSTANCE       hModule,
 581         LPCWSTR         lpType,
 582         LPCWSTR         lpName,
 583         ENUMRESLANGPROC lpEnumFunc,
 584         LONG            lParam
 585         )
 586 {
 587         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 588         return FALSE;
 589 }
 590
 591
 592 WINBOOL
 593 STDCALL
 594 EnumResourceLanguagesA (
 595         HINSTANCE       hModule,
 596         LPCSTR          lpType,
 597         LPCSTR          lpName,
 598         ENUMRESLANGPROC lpEnumFunc,
 599         LONG            lParam
 600         )
 601 {
 602         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 603         return FALSE;
 604 }
 605
 606
 607 WINBOOL
 608 STDCALL
 609 EnumResourceNamesW (
 610         HINSTANCE       hModule,
 611         LPCWSTR         lpType,
 612         ENUMRESNAMEPROC lpEnumFunc,
 613         LONG            lParam
 614         )
 615 {
 616         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 617         return FALSE;
 618 }
 619
 620
 621 WINBOOL
 622 STDCALL
 623 EnumResourceNamesA (
 624         HINSTANCE       hModule,
 625         LPCSTR          lpType,
 626         ENUMRESNAMEPROC lpEnumFunc,
 627         LONG            lParam
 628         )
 629 {
 630         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 631         return FALSE;
 632 }
 633
 634
 635 WINBOOL
 636 STDCALL
 637 EnumResourceTypesW (
 638         HINSTANCE       hModule,
 639         ENUMRESTYPEPROC lpEnumFunc,
 640         LONG            lParam
 641         )
 642 {
 643         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 644         return FALSE;
 645 }
 646
 647
 648
 649 WINBOOL
 650 STDCALL
 651 EnumResourceTypesA (
 652         HINSTANCE       hModule,
 653         ENUMRESTYPEPROC lpEnumFunc,
 654         LONG            lParam
 655         )
 656 {
 657         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 658         return FALSE;
 659 }
 660
 661
 662 WINBOOL
 663 STDCALL
 664 EnumSystemCodePagesW (
 665         CODEPAGE_ENUMPROC       lpCodePageEnumProc,
 666         DWORD                   dwFlags
 667         )
 668 {
 669         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 670         return FALSE;
 671 }
 672
 673
 674 WINBOOL
 675 STDCALL
 676 EnumSystemCodePagesA (
 677         CODEPAGE_ENUMPROC       lpCodePageEnumProc,
 678         DWORD                   dwFlags
 679         )
 680 {
 681         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 682         return FALSE;
 683 }
 684
 685
 686 WINBOOL
 687 STDCALL
 688 EnumSystemLocalesW (
 689         LOCALE_ENUMPROC lpLocaleEnumProc,
 690         DWORD           dwFlags
 691         )
 692 {
 693         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 694         return FALSE;
 695 }
 696
 697
 698 WINBOOL
 699 STDCALL
 700 EnumSystemLocalesA (
 701         LOCALE_ENUMPROC lpLocaleEnumProc,
 702         DWORD           dwFlags
 703         )
 704 {
 705         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 706         return FALSE;
 707 }
 708
 709
 710 WINBOOL
 711 STDCALL
 712 EnumTimeFormatsW (
 713         TIMEFMT_ENUMPROC        lpTimeFmtEnumProc,
 714         LCID                    Locale,
 715         DWORD                   dwFlags
 716         )
 717 {
 718         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 719         return FALSE;
 720 }
 721
 722
 723 WINBOOL
 724 STDCALL
 725 EnumTimeFormatsA (
 726         TIMEFMT_ENUMPROC        lpTimeFmtEnumProc,
 727         LCID                    Locale,
 728         DWORD                   dwFlags
 729         )
 730 {
 731         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 732         return FALSE;
 733 }
 734
 735
 736 DWORD
 737 STDCALL
 738 EraseTape (
 739         HANDLE  hDevice,
 740         DWORD   dwEraseType,
 741         WINBOOL bImmediate
 742         )
 743 {
 744         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 745         return 0;
 746 }
 747
 748
 749 WINBOOL
 750 STDCALL
 751 EscapeCommFunction (
 752         HANDLE  hFile,
 753         DWORD   dwFunc
 754         )
 755 {
 756         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 757         return FALSE;
 758 }
 759
 760
 761 DWORD
 762 STDCALL
 763 ExitVDM (
 764         DWORD   Unknown0,
 765         DWORD   Unknown1
 766         )
 767 {
 768         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 769         return 0;
 770 }
 771
 772
 773 DWORD
 774 STDCALL
 775 ExpungeConsoleCommandHistoryW (
 776         DWORD   Unknown0
 777         )
 778 {
 779         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 780         return 0;
 781 }
 782
 783
 784 DWORD
 785 STDCALL
 786 ExpungeConsoleCommandHistoryA (
 787         DWORD   Unknown0
 788         )
 789 {
 790         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 791         return 0;
 792 }
 793
 794
 795 BOOL
 796 STDCALL
 797 ExtendVirtualBuffer (
 798         DWORD   Unknown0,
 799         DWORD   Unknown1
 800         )
 801 {
 802         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 803         return FALSE;
 804 }
 805
 806
 807 VOID
 808 STDCALL
 809 FatalExit (
 810           int ExitCode
 811           )
 812 {
 813         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 814 }
 815
 816
 817 ATOM
 818 STDCALL
 819 FindAtomW (
 820         LPCWSTR lpString
 821         )
 822 {
 823         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 824         return 0;
 825 }
 826
 827
 828 ATOM
 829 STDCALL
 830 FindAtomA (
 831         LPCSTR lpString
 832         )
 833 {
 834         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 835         return 0;
 836 }
 837
 838
 839 WINBOOL
 840 STDCALL
 841 FindCloseChangeNotification (
 842         HANDLE  hChangeHandle
 843         )
 844 {
 845         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 846         return FALSE;
 847 }
 848
 849
 850 HANDLE
 851 STDCALL
 852 FindFirstChangeNotificationW (
 853         LPCWSTR lpPathName,
 854         WINBOOL bWatchSubtree,
 855         DWORD   dwNotifyFilter
 856         )
 857 {
 858         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 859         return INVALID_HANDLE_VALUE;
 860 }
 861
 862
 863 HANDLE
 864 STDCALL
 865 FindFirstChangeNotificationA (
 866         LPCSTR  lpPathName,
 867         WINBOOL bWatchSubtree,
 868         DWORD   dwNotifyFilter
 869         )
 870 {
 871         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 872         return INVALID_HANDLE_VALUE;
 873 }
 874
 875
 876 WINBOOL
 877 STDCALL
 878 FindNextChangeNotification (
 879         HANDLE  hChangeHandle
 880         )
 881 {
 882         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 883         return FALSE;
 884 }
 885
 886
 887
 888 int
 889 STDCALL
 890 FoldStringW (
 891         DWORD   dwMapFlags,
 892         LPCWSTR lpSrcStr,
 893         int     cchSrc,
 894         LPWSTR  lpDestStr,
 895         int     cchDest
 896         )
 897 {
 898         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 899         return 0;
 900 }
 901
 902
 903 int
 904 STDCALL
 905 FoldStringA (
 906         DWORD   dwMapFlags,
 907         LPCSTR  lpSrcStr,
 908         int     cchSrc,
 909         LPSTR   lpDestStr,
 910         int     cchDest
 911         )
 912 {
 913         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 914         return 0;
 915 }
 916
 917
 918 DWORD
 919 STDCALL
 920 FormatMessageW (
 921         DWORD   dwFlags,
 922         LPCVOID lpSource,
 923         DWORD   dwMessageId,
 924         DWORD   dwLanguageId,
 925         LPWSTR  lpBuffer,
 926         DWORD   nSize,
 927         va_list * Arguments
 928         )
 929 {
 930         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 931         return 0;
 932 }
 933
 934
 935 DWORD
 936 STDCALL
 937 FormatMessageA (
 938         DWORD   dwFlags,
 939         LPCVOID lpSource,
 940         DWORD   dwMessageId,
 941         DWORD   dwLanguageId,
 942         LPSTR   lpBuffer,
 943         DWORD   nSize,
 944         va_list * Arguments
 945         )
 946 {
 947         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 948         return 0;
 949 }
 950
 951
 952 BOOL
 953 STDCALL
 954 FreeVirtualBuffer (
 955         HANDLE  hVirtualBuffer
 956         )
 957 {
 958         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 959         return FALSE;
 960 }
 961
 962
 963 UINT
 964 STDCALL
 965 GetACP (VOID)
 966 {
 967         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 968         return 0;
 969 }
 970
 971
 972
 973 UINT
 974 STDCALL
 975 GetAtomNameW (
 976         ATOM    nAtom,
 977         LPWSTR  lpBuffer,
 978         int     nSize
 979         )
 980 {
 981         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 982         return 0;
 983 }
 984
 985
 986 UINT
 987 STDCALL
 988 GetAtomNameA (
 989         ATOM    nAtom,
 990         LPSTR   lpBuffer,
 991         int     nSize
 992         )
 993 {
 994         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 995         return 0;
 996 }
 997
 998
 999 WINBOOL
1000 STDCALL
1001 GetBinaryTypeW (
1002         LPCWSTR lpApplicationName,
1003         LPDWORD lpBinaryType
1004         )
1005 {
1006         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1007         return FALSE;
1008 }
1009
1010
1011 WINBOOL
1012 STDCALL
1013 GetBinaryTypeA (
1014         LPCSTR  lpApplicationName,
1015         LPDWORD lpBinaryType
1016         )
1017 {
1018         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1019         return FALSE;
1020 }
1021
1022
1023 WINBOOL
1024 STDCALL
1025 GetCPInfo (
1026         UINT            a0,
1027         LPCPINFO        a1
1028         )
1029 {
1030         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1031         return 0;
1032 }
1033
1034
1035 WINBOOL
1036 STDCALL
1037 GetCommConfig (
1038         HANDLE          hCommDev,
1039         LPCOMMCONFIG    lpCC,
1040         LPDWORD         lpdwSize
1041         )
1042 {
1043         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1044         return FALSE;
1045 }
1046
1047
1048 WINBOOL
1049 STDCALL
1050 GetCommMask (
1051         HANDLE  hFile,
1052         LPDWORD lpEvtMask
1053         )
1054 {
1055         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1056         return FALSE;
1057 }
1058
1059
1060
1061 WINBOOL
1062 STDCALL
1063 GetCommModemStatus (
1064         HANDLE  hFile,
1065         LPDWORD lpModemStat
1066         )
1067 {
1068         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1069         return FALSE;
1070 }
1071
1072
1073 WINBOOL
1074 STDCALL
1075 GetCommProperties (
1076         HANDLE          hFile,
1077         LPCOMMPROP      lpCommProp
1078         )
1079 {
1080         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1081         return FALSE;
1082 }
1083
1084
1085 WINBOOL
1086 STDCALL
1087 GetCommState (
1088         HANDLE hFile,
1089         LPDCB lpDCB
1090         )
1091 {
1092         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1093         return FALSE;
1094 }
1095
1096
1097 WINBOOL
1098 STDCALL
1099 GetCommTimeouts (
1100         HANDLE          hFile,
1101         LPCOMMTIMEOUTS  lpCommTimeouts
1102         )
1103 {
1104         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1105         return FALSE;
1106 }
1107
1108
1109 WINBOOL
1110 STDCALL
1111 GetComputerNameW (
1112         LPWSTR lpBuffer,
1113         LPDWORD nSize
1114         )
1115 {
1116         WCHAR   Name [MAX_COMPUTERNAME_LENGTH + 1];
1117         DWORD   Size = 0;
1118
1119         /*
1120          * FIXME: get the computer's name from
1121          * the registry.
1122          */
1123         lstrcpyW( Name, L"ROSHost" ); /* <-- FIXME -- */
1124         Size = lstrlenW(Name) + 1;
1125         if (Size > *nSize)
1126         {
1127                 *nSize = Size;
1128                 SetLastError(ERROR_BUFFER_OVERFLOW);
1129                 return FALSE;
1130         }
1131         lstrcpyW( lpBuffer, Name );
1132         return TRUE;
1133 }
1134
1135
1136 WINBOOL
1137 STDCALL
1138 GetComputerNameA (
1139         LPSTR   lpBuffer,
1140         LPDWORD nSize
1141         )
1142 {
1143         WCHAR   Name [MAX_COMPUTERNAME_LENGTH + 1];
1144         int i;
1145
1146         if (FALSE == GetComputerNameW(
1147                         Name,
1148                         nSize
1149                         ))
1150         {
1151                 return FALSE;
1152         }
1153 /* FIXME --> */
1154 /* Use UNICODE to ANSI */
1155         for ( i=0; Name[i]; ++i )
1156         {
1157                 lpBuffer[i] = (CHAR) Name[i];
1158         }
1159         lpBuffer[i] = '\0';
1160 /* FIXME <-- */
1161         return TRUE;
1162 }
1163
1164
1165 DWORD
1166 STDCALL
1167 GetConsoleAliasW (
1168         DWORD   Unknown0,
1169         DWORD   Unknown1,
1170         DWORD   Unknown2,
1171         DWORD   Unknown3
1172         )
1173 {
1174         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1175         return 0;
1176 }
1177
1178
1179 DWORD
1180 STDCALL
1181 GetConsoleAliasA (
1182         DWORD   Unknown0,
1183         DWORD   Unknown1,
1184         DWORD   Unknown2,
1185         DWORD   Unknown3
1186         )
1187 {
1188         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1189         return 0;
1190 }
1191
1192
1193
1194 DWORD
1195 STDCALL
1196 GetConsoleAliasExesW (
1197         DWORD   Unknown0,
1198         DWORD   Unknown1
1199         )
1200 {
1201         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1202         return 0;
1203 }
1204
1205
1206
1207 DWORD
1208 STDCALL
1209 GetConsoleAliasExesA (
1210         DWORD   Unknown0,
1211         DWORD   Unknown1
1212         )
1213 {
1214         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1215         return 0;
1216 }
1217
1218
1219
1220 DWORD
1221 STDCALL
1222 GetConsoleAliasExesLengthA (VOID)
1223 {
1224         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1225         return 0;
1226 }
1227
1228
1229
1230 DWORD
1231 STDCALL
1232 GetConsoleAliasExesLengthW (VOID)
1233 {
1234         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1235         return 0;
1236 }
1237
1238
1239
1240 DWORD
1241 STDCALL
1242 GetConsoleAliasesW (
1243         DWORD   Unknown0,
1244         DWORD   Unknown1,
1245         DWORD   Unknown2
1246         )
1247 {
1248         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1249         return 0;
1250 }
1251
1252
1253
1254 DWORD
1255 STDCALL
1256 GetConsoleAliasesA (
1257         DWORD   Unknown0,
1258         DWORD   Unknown1,
1259         DWORD   Unknown2
1260         )
1261 {
1262         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1263         return 0;
1264 }
1265
1266
1267
1268 DWORD
1269 STDCALL
1270 GetConsoleAliasesLengthW (
1271         DWORD Unknown0
1272         )
1273 {
1274         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1275         return 0;
1276 }
1277
1278
1279
1280 DWORD
1281 STDCALL
1282 GetConsoleAliasesLengthA (
1283         DWORD Unknown0
1284         )
1285 {
1286         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1287         return 0;
1288 }
1289
1290
1291 DWORD
1292 STDCALL
1293 GetConsoleCommandHistoryW (
1294         DWORD   Unknown0,
1295         DWORD   Unknown1,
1296         DWORD   Unknown2
1297         )
1298 {
1299         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1300         return 0;
1301 }
1302
1303
1304 DWORD
1305 STDCALL
1306 GetConsoleCommandHistoryA (
1307         DWORD   Unknown0,
1308         DWORD   Unknown1,
1309         DWORD   Unknown2
1310         )
1311 {
1312         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1313         return 0;
1314 }
1315
1316
1317 DWORD
1318 STDCALL
1319 GetConsoleCommandHistoryLengthW (
1320         DWORD   Unknown0
1321         )
1322 {
1323         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1324         return 0;
1325 }
1326
1327
1328 DWORD
1329 STDCALL
1330 GetConsoleCommandHistoryLengthA (
1331         DWORD   Unknown0
1332         )
1333 {
1334         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1335         return 0;
1336 }
1337
1338
1339 DWORD
1340 STDCALL
1341 GetConsoleDisplayMode (
1342         DWORD   Unknown0
1343         )
1344 {
1345         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1346         return 0;
1347 }
1348
1349
1350 DWORD
1351 STDCALL
1352 GetConsoleFontInfo (
1353         DWORD   Unknown0,
1354         DWORD   Unknown1,
1355         DWORD   Unknown2,
1356         DWORD   Unknown3
1357         )
1358 {
1359         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1360         return 0;
1361 }
1362
1363
1364 DWORD
1365 STDCALL
1366 GetConsoleFontSize (
1367         DWORD   Unknown0,
1368         DWORD   Unknown1
1369         )
1370 {
1371         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1372         return 0;
1373 }
1374
1375
1376 DWORD
1377 STDCALL
1378 GetConsoleHardwareState (
1379         DWORD   Unknown0,
1380         DWORD   Unknown1,
1381         DWORD   Unknown2
1382         )
1383 {
1384         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1385         return 0;
1386 }
1387
1388
1389 DWORD
1390 STDCALL
1391 GetConsoleInputWaitHandle (VOID)
1392 {
1393         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1394         return FALSE;
1395 }
1396
1397
1398 int
1399 STDCALL
1400 GetCurrencyFormatW (
1401         LCID                    Locale,
1402         DWORD                   dwFlags,
1403         LPCWSTR                 lpValue,
1404         CONST CURRENCYFMT       * lpFormat,
1405         LPWSTR                  lpCurrencyStr,
1406         int                     cchCurrency
1407         )
1408 {
1409         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1410         return 0;
1411 }
1412
1413
1414 int
1415 STDCALL
1416 GetCurrencyFormatA (
1417         LCID                    Locale,
1418         DWORD                   dwFlags,
1419         LPCSTR                  lpValue,
1420         CONST CURRENCYFMT       * lpFormat,
1421         LPSTR                   lpCurrencyStr,
1422         int                     cchCurrency
1423         )
1424 {
1425         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1426         return 0;
1427 }
1428
1429
1430 DWORD
1431 STDCALL
1432 GetCurrentConsoleFont (
1433         DWORD   Unknown0,
1434         DWORD   Unknown1,
1435         DWORD   Unknown2
1436         )
1437 {
1438         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1439         return 0;
1440 }
1441
1442
1443 int
1444 STDCALL
1445 GetDateFormatW (
1446         LCID                    Locale,
1447         DWORD                   dwFlags,
1448         CONST SYSTEMTIME        * lpDate,
1449         LPCWSTR                 lpFormat,
1450         LPWSTR                  lpDateStr,
1451         int                     cchDate
1452         )
1453 {
1454         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1455         return 0;
1456 }
1457
1458
1459 int
1460 STDCALL
1461 GetDateFormatA (
1462         LCID                    Locale,
1463         DWORD                   dwFlags,
1464         CONST SYSTEMTIME        * lpDate,
1465         LPCSTR                  lpFormat,
1466         LPSTR                   lpDateStr,
1467         int                     cchDate
1468         )
1469 {
1470         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1471         return 0;
1472 }
1473
1474
1475 WINBOOL
1476 STDCALL
1477 GetDefaultCommConfigW (
1478         LPCWSTR         lpszName,
1479         LPCOMMCONFIG    lpCC,
1480         LPDWORD         lpdwSize
1481         )
1482 {
1483         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1484         return FALSE;
1485 }
1486
1487
1488 WINBOOL
1489 STDCALL
1490 GetDefaultCommConfigA (
1491         LPCSTR          lpszName,
1492         LPCOMMCONFIG    lpCC,
1493         LPDWORD         lpdwSize
1494         )
1495 {
1496         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1497         return FALSE;
1498 }
1499
1500
1501 int
1502 STDCALL
1503 GetLocaleInfoW (
1504         LCID    Locale,
1505         LCTYPE  LCType,
1506         LPWSTR  lpLCData,
1507         int     cchData
1508         )
1509 {
1510         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1511         return 0;
1512 }
1513
1514
1515 int
1516 STDCALL
1517 GetLocaleInfoA (
1518         LCID    Locale,
1519         LCTYPE  LCType,
1520         LPSTR   lpLCData,
1521         int     cchData
1522         )
1523 {
1524         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1525         return 0;
1526 }
1527
1528
1529 WINBOOL
1530 STDCALL
1531 GetMailslotInfo (
1532         HANDLE  hMailslot,
1533         LPDWORD lpMaxMessageSize,
1534         LPDWORD lpNextSize,
1535         LPDWORD lpMessageCount,
1536         LPDWORD lpReadTimeout
1537         )
1538 {
1539         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1540         return FALSE;
1541 }
1542
1543
1544 DWORD
1545 STDCALL
1546 GetModuleFileNameW (
1547         HINSTANCE       hModule,
1548         LPWSTR          lpFilename,
1549         DWORD           nSize
1550         )
1551 {
1552         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1553         return 0;
1554 }
1555
1556
1557 DWORD
1558 STDCALL
1559 GetModuleFileNameA (
1560         HINSTANCE       hModule,
1561         LPSTR           lpFilename,
1562         DWORD           nSize
1563         )
1564 {
1565         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1566         return 0;
1567 }
1568
1569
1570 HMODULE
1571 STDCALL
1572 GetModuleHandleW (
1573         LPCWSTR lpModuleName
1574         )
1575 {
1576         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1577         return INVALID_HANDLE_VALUE;
1578 }
1579
1580
1581
1582
1583
1584 WINBOOL
1585 STDCALL
1586 GetNamedPipeHandleStateW (
1587         HANDLE  hNamedPipe,
1588         LPDWORD lpState,
1589         LPDWORD lpCurInstances,
1590         LPDWORD lpMaxCollectionCount,
1591         LPDWORD lpCollectDataTimeout,
1592         LPWSTR  lpUserName,
1593         DWORD   nMaxUserNameSize
1594         )
1595 {
1596         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1597         return FALSE;
1598 }
1599
1600
1601 WINBOOL
1602 STDCALL
1603 GetNamedPipeHandleStateA (
1604         HANDLE  hNamedPipe,
1605         LPDWORD lpState,
1606         LPDWORD lpCurInstances,
1607         LPDWORD lpMaxCollectionCount,
1608         LPDWORD lpCollectDataTimeout,
1609         LPSTR   lpUserName,
1610         DWORD   nMaxUserNameSize
1611         )
1612 {
1613         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1614         return FALSE;
1615 }
1616
1617
1618 WINBOOL
1619 STDCALL
1620 GetNamedPipeInfo (
1621         HANDLE  hNamedPipe,
1622         LPDWORD lpFlags,
1623         LPDWORD lpOutBufferSize,
1624         LPDWORD lpInBufferSize,
1625         LPDWORD lpMaxInstances
1626         )
1627 {
1628         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1629         return FALSE;
1630 }
1631
1632
1633 DWORD
1634 STDCALL
1635 GetNextVDMCommand (
1636         DWORD   Unknown0
1637         )
1638 {
1639         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1640         return 0;
1641 }
1642
1643
1644 int
1645 STDCALL
1646 GetNumberFormatW (
1647         LCID            Locale,
1648         DWORD           dwFlags,
1649         LPCWSTR         lpValue,
1650         CONST NUMBERFMT * lpFormat,
1651         LPWSTR          lpNumberStr,
1652         int             cchNumber
1653         )
1654 {
1655         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1656         return 0;
1657 }
1658
1659
1660 int
1661 STDCALL
1662 GetNumberFormatA (
1663         LCID            Locale,
1664         DWORD           dwFlags,
1665         LPCSTR          lpValue,
1666         CONST NUMBERFMT * lpFormat,
1667         LPSTR           lpNumberStr,
1668         int             cchNumber
1669         )
1670 {
1671         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1672         return 0;
1673 }
1674
1675
1676 int
1677 STDCALL
1678 GetNumberOfConsoleFonts (VOID)
1679 {
1680         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1681         return 1; /* FIXME: call csrss.exe */
1682 }
1683
1684
1685 UINT
1686 STDCALL
1687 GetOEMCP (VOID)
1688 {
1689         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1690         return 437; /* FIXME: call csrss.exe */
1691 }
1692
1693
1694 UINT
1695 STDCALL
1696 GetPrivateProfileIntW (
1697         LPCWSTR lpAppName,
1698         LPCWSTR lpKeyName,
1699         INT     nDefault,
1700         LPCWSTR lpFileName
1701         )
1702 {
1703         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1704         return 0;
1705 }
1706
1707
1708 UINT
1709 STDCALL
1710 GetPrivateProfileIntA (
1711         LPCSTR  lpAppName,
1712         LPCSTR  lpKeyName,
1713         INT     nDefault,
1714         LPCSTR  lpFileName
1715         )
1716 {
1717         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1718         return 0;
1719 }
1720
1721
1722 DWORD
1723 STDCALL
1724 GetPrivateProfileSectionW (
1725         LPCWSTR lpAppName,
1726         LPWSTR  lpReturnedString,
1727         DWORD   nSize,
1728         LPCWSTR lpFileName
1729         )
1730 {
1731         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1732         return 0;
1733 }
1734
1735
1736 DWORD
1737 STDCALL
1738 GetPrivateProfileSectionA (
1739         LPCSTR  lpAppName,
1740         LPSTR   lpReturnedString,
1741         DWORD   nSize,
1742         LPCSTR  lpFileName
1743         )
1744 {
1745         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1746         return 0;
1747 }
1748
1749
1750 DWORD
1751 STDCALL
1752 GetPrivateProfileSectionNamesW (
1753         DWORD   Unknown0,
1754         DWORD   Unknown1,
1755         DWORD   Unknown2
1756         )
1757 {
1758         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1759         return 0;
1760 }
1761
1762
1763 DWORD
1764 STDCALL
1765 GetPrivateProfileSectionNamesA (
1766         DWORD   Unknown0,
1767         DWORD   Unknown1,
1768         DWORD   Unknown2
1769         )
1770 {
1771         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1772         return 0;
1773 }
1774
1775
1776 DWORD
1777 STDCALL
1778 GetPrivateProfileStringW (
1779         LPCWSTR lpAppName,
1780         LPCWSTR lpKeyName,
1781         LPCWSTR lpDefault,
1782         LPWSTR  lpReturnedString,
1783         DWORD   nSize,
1784         LPCWSTR lpFileName
1785         )
1786 {
1787         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1788         return 0;
1789 }
1790
1791
1792 DWORD
1793 STDCALL
1794 GetPrivateProfileStringA (
1795         LPCSTR  lpAppName,
1796         LPCSTR  lpKeyName,
1797         LPCSTR  lpDefault,
1798         LPSTR   lpReturnedString,
1799         DWORD   nSize,
1800         LPCSTR  lpFileName
1801         )
1802 {
1803         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1804         return 0;
1805 }
1806
1807
1808 DWORD
1809 STDCALL
1810 GetPrivateProfileStructW (
1811         DWORD   Unknown0,
1812         DWORD   Unknown1,
1813         DWORD   Unknown2,
1814         DWORD   Unknown3,
1815         DWORD   Unknown4
1816         )
1817 {
1818         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1819         return 0;
1820 }
1821
1822
1823 DWORD
1824 STDCALL
1825 GetPrivateProfileStructA (
1826         DWORD   Unknown0,
1827         DWORD   Unknown1,
1828         DWORD   Unknown2,
1829         DWORD   Unknown3,
1830         DWORD   Unknown4
1831         )
1832 {
1833         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1834         return 0;
1835 }
1836
1837
1838 WINBOOL
1839 STDCALL
1840 GetProcessAffinityMask (
1841         HANDLE  hProcess,
1842         LPDWORD lpProcessAffinityMask,
1843         LPDWORD lpSystemAffinityMask
1844         )
1845 {
1846         if (    (NULL == lpProcessAffinityMask)
1847                 || (NULL == lpSystemAffinityMask)
1848                 )
1849         {
1850                 SetLastError(ERROR_BAD_ARGUMENTS);
1851                 return FALSE;
1852         }
1853         /* FIXME: check hProcess is actually a process */
1854         /* FIXME: query the kernel process object */
1855         *lpProcessAffinityMask = 0x00000001;
1856         *lpSystemAffinityMask  = 0x00000001;
1857         return TRUE;
1858 }
1859
1860
1861 WINBOOL
1862 STDCALL
1863 GetProcessShutdownParameters (
1864         LPDWORD lpdwLevel,
1865         LPDWORD lpdwFlags
1866         )
1867 {
1868         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1869         return FALSE;
1870 }
1871
1872
1873 DWORD
1874 STDCALL
1875 GetProcessVersion (
1876         DWORD   Unknown0
1877         )
1878 {
1879         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1880         return 0;
1881 }
1882
1883
1884 WINBOOL
1885 STDCALL
1886 GetProcessWorkingSetSize (
1887         HANDLE  hProcess,
1888         LPDWORD lpMinimumWorkingSetSize,
1889         LPDWORD lpMaximumWorkingSetSize
1890         )
1891 {
1892         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1893         return FALSE;
1894 }
1895
1896
1897 UINT
1898 STDCALL
1899 GetProfileIntW (
1900         LPCWSTR lpAppName,
1901         LPCWSTR lpKeyName,
1902         INT     nDefault
1903         )
1904 {
1905         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1906         return 0;
1907 }
1908
1909
1910 UINT
1911 STDCALL
1912 GetProfileIntA (
1913         LPCSTR  lpAppName,
1914         LPCSTR  lpKeyName,
1915         INT     nDefault
1916         )
1917 {
1918         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1919         return 0;
1920 }
1921
1922
1923 DWORD
1924 STDCALL
1925 GetProfileSectionW (
1926         LPCWSTR lpAppName,
1927         LPWSTR  lpReturnedString,
1928         DWORD   nSize
1929         )
1930 {
1931         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1932         return 0;
1933 }
1934
1935
1936 DWORD
1937 STDCALL
1938 GetProfileSectionA (
1939         LPCSTR  lpAppName,
1940         LPSTR   lpReturnedString,
1941         DWORD   nSize
1942         )
1943 {
1944         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1945         return 0;
1946 }
1947
1948
1949 DWORD
1950 STDCALL
1951 GetProfileStringW (
1952         LPCWSTR lpAppName,
1953         LPCWSTR lpKeyName,
1954         LPCWSTR lpDefault,
1955         LPWSTR  lpReturnedString,
1956         DWORD   nSize
1957         )
1958 {
1959         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1960         return 0;
1961 }
1962
1963
1964 DWORD
1965 STDCALL
1966 GetProfileStringA (
1967         LPCSTR  lpAppName,
1968         LPCSTR  lpKeyName,
1969         LPCSTR  lpDefault,
1970         LPSTR   lpReturnedString,
1971         DWORD   nSize
1972         )
1973 {
1974         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1975         return 0;
1976 }
1977
1978
1979 WINBOOL
1980 STDCALL
1981 GetStringTypeExW (
1982         LCID    Locale,
1983         DWORD   dwInfoType,
1984         LPCWSTR lpSrcStr,
1985         int     cchSrc,
1986         LPWORD  lpCharType
1987         )
1988 {
1989         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1990         return FALSE;
1991 }
1992
1993
1994 WINBOOL
1995 STDCALL
1996 GetStringTypeExA (
1997         LCID    Locale,
1998         DWORD   dwInfoType,
1999         LPCSTR  lpSrcStr,
2000         int     cchSrc,
2001         LPWORD  lpCharType
2002         )
2003 {
2004         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2005         return FALSE;
2006 }
2007
2008
2009 WINBOOL
2010 STDCALL
2011 GetStringTypeW (
2012         DWORD   dwInfoType,
2013         LPCWSTR lpSrcStr,
2014         int     cchSrc,
2015         LPWORD  lpCharType
2016         )
2017 {
2018         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2019         return FALSE;
2020 }
2021
2022
2023 WINBOOL
2024 STDCALL
2025 GetStringTypeA (
2026         LCID    Locale,
2027         DWORD   dwInfoType,
2028         LPCSTR  lpSrcStr,
2029         int     cchSrc,
2030         LPWORD  lpCharType
2031         )
2032 {
2033         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2034         return FALSE;
2035 }
2036
2037
2038 LCID
2039 STDCALL
2040 GetSystemDefaultLCID (VOID)
2041 {
2042         /* FIXME: ??? */
2043         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2044         return MAKELCID(
2045                 LANG_ENGLISH,
2046                 SORT_DEFAULT
2047                 );
2048 }
2049
2050
2051 LANGID
2052 STDCALL
2053 GetSystemDefaultLangID (VOID)
2054 {
2055          /* FIXME: ??? */
2056         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2057         return MAKELANGID(
2058                 LANG_ENGLISH,
2059                 SUBLANG_ENGLISH_US
2060                 );
2061 }
2062
2063
2064 DWORD
2065 STDCALL
2066 GetSystemPowerStatus (
2067         DWORD   Unknown0
2068         )
2069 {
2070         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2071         return 0;
2072 }
2073
2074
2075 DWORD
2076 STDCALL
2077 GetTapeParameters (
2078         HANDLE  hDevice,
2079         DWORD   dwOperation,
2080         LPDWORD lpdwSize,
2081         LPVOID  lpTapeInformation
2082         )
2083 {
2084         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2085         return 0;
2086 }
2087
2088
2089 DWORD
2090 STDCALL
2091 GetTapeStatus (
2092         HANDLE  hDevice
2093         )
2094 {
2095         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2096         return 0;
2097 }
2098
2099
2100 LCID
2101 STDCALL
2102 GetThreadLocale (VOID)
2103 {
2104         /* FIXME: ??? */
2105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2106         return MAKELCID(
2107                 LANG_ENGLISH,
2108                 SORT_DEFAULT
2109                 );
2110 }
2111
2112
2113 WINBOOL
2114 STDCALL
2115 GetThreadSelectorEntry (
2116         HANDLE          hThread,
2117         DWORD           dwSelector,
2118         LPLDT_ENTRY     lpSelectorEntry
2119         )
2120 {
2121         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2122         return FALSE;
2123 }
2124
2125
2126 int
2127 STDCALL
2128 GetTimeFormatW (
2129         LCID                    Locale,
2130         DWORD                   dwFlags,
2131         CONST SYSTEMTIME        * lpTime,
2132         LPCWSTR                 lpFormat,
2133         LPWSTR                  lpTimeStr,
2134         int                     cchTime
2135         )
2136 {
2137         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2138         return 0;
2139 }
2140
2141
2142 int
2143 STDCALL
2144 GetTimeFormatA (
2145         LCID                    Locale,
2146         DWORD                   dwFlags,
2147         CONST SYSTEMTIME        * lpTime,
2148         LPCSTR                  lpFormat,
2149         LPSTR                   lpTimeStr,
2150         int                     cchTime
2151         )
2152 {
2153         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2154         return 0;
2155 }
2156
2157
2158 LCID
2159 STDCALL
2160 GetUserDefaultLCID (VOID)
2161 {
2162         /* FIXME: ??? */
2163         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2164         return MAKELCID(
2165                 LANG_ENGLISH,
2166                 SORT_DEFAULT
2167                 );
2168 }
2169
2170
2171 LANGID
2172 STDCALL
2173 GetUserDefaultLangID (VOID)
2174 {
2175          /* FIXME: ??? */
2176         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2177         return MAKELANGID(
2178                 LANG_ENGLISH,
2179                 SUBLANG_ENGLISH_US
2180                 );
2181 }
2182
2183
2184 DWORD
2185 STDCALL
2186 GetVDMCurrentDirectories (
2187         DWORD   Unknown0,
2188         DWORD   Unknown1
2189         )
2190 {
2191         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2192         return 0;
2193 }
2194
2195
2196 ATOM
2197 STDCALL
2198 GlobalAddAtomW (
2199         LPCWSTR lpString
2200         )
2201 {
2202         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2203         return 0;
2204 }
2205
2206
2207 ATOM
2208 STDCALL
2209 GlobalAddAtomA (
2210         LPCSTR  lpString
2211         )
2212 {
2213         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2214         return 0;
2215 }
2216
2217
2218 HGLOBAL
2219 STDCALL
2220 GlobalAlloc (
2221         UINT    uFlags,
2222         DWORD   dwBytes
2223         )
2224 {
2225         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2226         return 0;
2227 }
2228
2229
2230 UINT
2231 STDCALL
2232 GlobalCompact (
2233         DWORD   dwMinFree
2234         )
2235 {
2236         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2237         return 0;
2238 }
2239
2240
2241 ATOM
2242 STDCALL
2243 GlobalDeleteAtom (
2244         ATOM    nAtom
2245         )
2246 {
2247         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2248         return 0;
2249 }
2250
2251
2252 ATOM
2253 STDCALL
2254 GlobalFindAtomW (
2255         LPCWSTR lpString
2256         )
2257 {
2258         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2259         return 0;
2260 }
2261
2262
2263 ATOM
2264 STDCALL
2265 GlobalFindAtomA (
2266         LPCSTR  lpString
2267         )
2268 {
2269         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2270         return 0;
2271 }
2272
2273
2274 VOID
2275 STDCALL
2276 GlobalFix (
2277         HGLOBAL hMem
2278         )
2279 {
2280         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2281 }
2282
2283
2284 UINT
2285 STDCALL
2286 GlobalFlags (
2287         HGLOBAL hMem
2288         )
2289 {
2290         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2291         return 0;
2292 }
2293
2294
2295 HGLOBAL
2296 STDCALL
2297 GlobalFree (
2298         HGLOBAL hMem
2299         )
2300 {
2301         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2302         return hMem;
2303 }
2304
2305
2306 UINT
2307 STDCALL
2308 GlobalGetAtomNameA (
2309         ATOM    nAtom,
2310         LPSTR   lpBuffer,
2311         int     nSize
2312         )
2313 {
2314         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2315         return 0;
2316 }
2317
2318
2319 UINT
2320 STDCALL
2321 GlobalGetAtomNameW (
2322         ATOM    nAtom,
2323         LPWSTR  lpBuffer,
2324         int     nSize
2325         )
2326 {
2327         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2328         return 0;
2329 }
2330
2331
2332 HGLOBAL
2333 STDCALL
2334 GlobalHandle (
2335         LPCVOID pMem
2336         )
2337 {
2338         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2339         return 0;
2340 }
2341
2342
2343 LPVOID
2344 STDCALL
2345 GlobalLock (
2346         HGLOBAL hMem
2347         )
2348 {
2349         /* In Win32 GlobalAlloc returns LPVOID? */
2350         return hMem;
2351 }
2352
2353
2354 VOID
2355 STDCALL
2356 GlobalMemoryStatus (
2357         LPMEMORYSTATUS  lpBuffer
2358         )
2359 {
2360         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2361 }
2362
2363
2364 HGLOBAL
2365 STDCALL
2366 GlobalReAlloc (
2367         HGLOBAL hMem,
2368         DWORD   dwBytes,
2369         UINT    uFlags
2370         )
2371 {
2372         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2373         return 0;
2374 }
2375
2376
2377 DWORD
2378 STDCALL
2379 GlobalSize (
2380         HGLOBAL hMem
2381         )
2382 {
2383         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2384         return 0;
2385 }
2386
2387
2388 WINBOOL
2389 STDCALL
2390 GlobalUnWire (
2391         HGLOBAL hMem
2392         )
2393 {
2394         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2395         return FALSE;
2396 }
2397
2398
2399 VOID
2400 STDCALL
2401 GlobalUnfix (
2402         HGLOBAL hMem
2403         )
2404 {
2405         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2406 }
2407
2408
2409 WINBOOL
2410 STDCALL
2411 GlobalUnlock (
2412         HGLOBAL hMem
2413         )
2414 {
2415         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2416         return FALSE;
2417 }
2418
2419
2420 LPVOID
2421 STDCALL
2422 GlobalWire (
2423         HGLOBAL hMem
2424         )
2425 {
2426         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2427         return NULL; /* ? */
2428 }
2429
2430
2431 DWORD
2432 STDCALL
2433 HeapCreateTagsW (
2434         DWORD   Unknown0,
2435         DWORD   Unknown1,
2436         DWORD   Unknown2,
2437         DWORD   Unknown3
2438         )
2439 {
2440         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2441         return 0;
2442 }
2443
2444
2445 DWORD
2446 STDCALL
2447 HeapExtend (
2448         DWORD   Unknown0,
2449         DWORD   Unknown1,
2450         DWORD   Unknown2,
2451         DWORD   Unknown3
2452         )
2453 {
2454         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2455         return 0;
2456 }
2457
2458
2459 DWORD
2460 STDCALL
2461 HeapQueryTagW (
2462         DWORD   Unknown0,
2463         DWORD   Unknown1,
2464         DWORD   Unknown2,
2465         DWORD   Unknown3,
2466         DWORD   Unknown4
2467         )
2468 {
2469         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2470         return 0;
2471 }
2472
2473
2474 DWORD
2475 STDCALL
2476 HeapSummary (
2477         DWORD   Unknown0,
2478         DWORD   Unknown1,
2479         DWORD   Unknown2
2480         )
2481 {
2482         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2483         return 0;
2484 }
2485
2486
2487 DWORD
2488 STDCALL
2489 HeapUsage (
2490         DWORD   Unknown0,
2491         DWORD   Unknown1,
2492         DWORD   Unknown2,
2493         DWORD   Unknown3,
2494         DWORD   Unknown4
2495         )
2496 {
2497         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2498         return 0;
2499 }
2500
2501
2502 WINBOOL
2503 STDCALL
2504 HeapWalk (
2505         HANDLE                  hHeap,
2506         LPPROCESS_HEAP_ENTRY    lpEntry
2507         )
2508 {
2509         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2510         return FALSE;
2511 }
2512
2513
2514 WINBOOL
2515 STDCALL
2516 InitAtomTable (
2517         DWORD nSize
2518         )
2519 {
2520         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2521         return FALSE;
2522 }
2523
2524
2525 DWORD
2526 STDCALL
2527 InvalidateConsoleDIBits (
2528         DWORD   Unknown0,
2529         DWORD   Unknown1
2530         )
2531 {
2532         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2533         return 0;
2534 }
2535
2536
2537 WINBOOL
2538 STDCALL
2539 IsDBCSLeadByte (
2540         BYTE    TestChar
2541         )
2542 {
2543         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2544         return FALSE;
2545 }
2546
2547
2548 WINBOOL
2549 STDCALL
2550 IsDBCSLeadByteEx (
2551         UINT    CodePage,
2552         BYTE    TestChar
2553         )
2554 {
2555         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2556         return FALSE;
2557 }
2558
2559
2560 WINBOOL
2561 STDCALL
2562 IsValidCodePage (
2563         UINT    CodePage
2564         )
2565 {
2566         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2567         return FALSE;
2568 }
2569
2570
2571 WINBOOL
2572 STDCALL
2573 IsValidLocale (
2574         LCID    Locale,
2575         DWORD   dwFlags
2576         )
2577 {
2578         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2579         return FALSE;
2580 }
2581
2582
2583 int
2584 STDCALL
2585 LCMapStringA (
2586         LCID    Locale,
2587         DWORD   dwMapFlags,
2588         LPCSTR  lpSrcStr,
2589         int     cchSrc,
2590         LPSTR   lpDestStr,
2591         int     cchDest
2592         )
2593 {
2594         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2595         return 0;
2596 }
2597
2598
2599 int
2600 STDCALL
2601 LCMapStringW (
2602         LCID    Locale,
2603         DWORD   dwMapFlags,
2604         LPCWSTR lpSrcStr,
2605         int     cchSrc,
2606         LPWSTR  lpDestStr,
2607         int     cchDest
2608         )
2609 {
2610         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2611         return 0;
2612 }
2613
2614
2615 DWORD
2616 STDCALL
2617 LoadModule (
2618         LPCSTR  lpModuleName,
2619         LPVOID  lpParameterBlock
2620         )
2621 {
2622         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2623         return 0;
2624 }
2625
2626
2627
2628
2629
2630 HLOCAL
2631 STDCALL
2632 LocalAlloc (
2633         UINT    uFlags,
2634         UINT    uBytes
2635         )
2636 {
2637         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2638         return 0;
2639 }
2640
2641
2642 UINT
2643 STDCALL
2644 LocalCompact (
2645         UINT    uMinFree
2646         )
2647 {
2648         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2649         return 0;
2650 }
2651
2652
2653 UINT
2654 STDCALL
2655 LocalFlags (
2656         HLOCAL  hMem
2657         )
2658 {
2659         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2660         return 0;
2661 }
2662
2663
2664 HLOCAL
2665 STDCALL
2666 LocalFree (
2667         HLOCAL  hMem
2668         )
2669 {
2670         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2671         return hMem;
2672 }
2673
2674
2675 HLOCAL
2676 STDCALL
2677 LocalHandle (
2678         LPCVOID pMem
2679         )
2680 {
2681         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2682         return 0;
2683 }
2684
2685
2686 LPVOID
2687 STDCALL
2688 LocalLock (
2689         HLOCAL  hMem
2690         )
2691 {
2692         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2693         return NULL;
2694 }
2695
2696
2697 HLOCAL
2698 STDCALL
2699 LocalReAlloc (
2700         HLOCAL  hMem,
2701         UINT    uBytes,
2702         UINT    uFlags
2703         )
2704 {
2705         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2706         return 0;
2707 }
2708
2709
2710 UINT
2711 STDCALL
2712 LocalShrink (
2713         HLOCAL  hMem,
2714         UINT    cbNewSize
2715         )
2716 {
2717         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2718         return 0;
2719 }
2720
2721
2722 UINT
2723 STDCALL
2724 LocalSize (
2725         HLOCAL  hMem
2726         )
2727 {
2728         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2729         return 0;
2730 }
2731
2732
2733 WINBOOL
2734 STDCALL
2735 LocalUnlock (
2736         HLOCAL  hMem
2737         )
2738 {
2739         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2740         return FALSE;
2741 }
2742
2743
2744
2745
2746
2747 int
2748 STDCALL
2749 MulDiv (
2750         int     nNumber,
2751         int     nNumerator,
2752         int     nDenominator
2753         )
2754 {
2755         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2756         return 0;
2757 }
2758
2759
2760 /**********************************************************************
2761  * NAME                                                 PRIVATE
2762  *      IsInstalledCP@4
2763  *
2764  * RETURN VALUE
2765  *      TRUE if CodePage is installed in the system.
2766  */
2767 static
2768 BOOL
2769 STDCALL
2770 IsInstalledCP (
2771         UINT    CodePage
2772         )
2773 {
2774         /* FIXME */
2775         return TRUE;
2776 }
2777
2778
2779 /**********************************************************************
2780  * NAME                                                 EXPORTED
2781  *      MultiByteToWideChar@24
2782  *
2783  * ARGUMENTS
2784  *      CodePage
2785  *              CP_ACP          ANSI code page
2786  *              CP_MACCP        Macintosh code page
2787  *              CP_OEMCP        OEM code page
2788  *              (UINT)          Any installed code page
2789  *
2790  *      dwFlags
2791  *              MB_PRECOMPOSED
2792  *              MB_COMPOSITE
2793  *              MB_ERR_INVALID_CHARS
2794  *              MB_USEGLYPHCHARS
2795  *
2796  *      lpMultiByteStr
2797  *              Input buffer;
2798  *
2799  *      cchMultiByte
2800  *              Size of MultiByteStr, or -1 if MultiByteStr is
2801  *              NULL terminated;
2802  *
2803  *      lpWideCharStr
2804  *              Output buffer;
2805  *
2806  *      cchWideChar
2807  *              Size (in WCHAR unit) of WideCharStr, or 0
2808  *              if the caller just wants to know how large
2809  *              WideCharStr should be for a successful
2810  *              conversion.
2811  *
2812  * RETURN VALUE
2813  *      0 on error; otherwise the number of WCHAR written
2814  *      in the WideCharStr buffer.
2815  *
2816  * NOTE
2817  *      A raw converter for now. It assumes lpMultiByteStr is
2818  *      NEVER multi-byte (that is each input character is
2819  *      8-bit ASCII) and is ALWAYS NULL terminated.
2820  *      FIXME-FIXME-FIXME-FIXME
2821  */
2822 INT
2823 STDCALL
2824 MultiByteToWideChar (
2825         UINT    CodePage,
2826         DWORD   dwFlags,
2827         LPCSTR  lpMultiByteStr,
2828         int     cchMultiByte,
2829         LPWSTR  lpWideCharStr,
2830         int     cchWideChar
2831         )
2832 {
2833         int     InStringLength = 0;
2834         BOOL    InIsNullTerminated = TRUE;
2835         PCHAR   r;
2836         PWCHAR  w;
2837         int     cchConverted;
2838
2839         /*
2840          * Check the parameters.
2841          */
2842         if (    /* --- CODE PAGE --- */
2843                 (       (CP_ACP != CodePage)
2844                         && (CP_MACCP != CodePage)
2845                         && (CP_OEMCP != CodePage)
2846                         && (FALSE == IsInstalledCP (CodePage))
2847                         )
2848                 /* --- FLAGS --- */
2849                 || (dwFlags ^ ( MB_PRECOMPOSED
2850                                 | MB_COMPOSITE
2851                                 | MB_ERR_INVALID_CHARS
2852                                 | MB_USEGLYPHCHARS
2853                                 )
2854                         )
2855                 /* --- INPUT BUFFER --- */
2856                 || (NULL == lpMultiByteStr)
2857                 )
2858         {
2859                 SetLastError (ERROR_INVALID_PARAMETER);
2860                 return 0;
2861         }
2862         /*
2863          * Compute the input buffer length.
2864          */
2865         if (-1 == cchMultiByte)
2866         {
2867                 InStringLength = lstrlen (lpMultiByteStr);
2868         }
2869         else
2870         {
2871                 InIsNullTerminated = FALSE;
2872                 InStringLength = cchMultiByte;
2873         }
2874         /*
2875          * Does caller query for output
2876          * buffer size?
2877          */
2878         if (0 == cchWideChar)
2879         {
2880                 SetLastError (ERROR_SUCCESS);
2881                 return InStringLength;
2882         }
2883         /*
2884          * Is space provided for the translated
2885          * string enough?
2886          */
2887         if (cchWideChar < InStringLength)
2888         {
2889                 SetLastError (ERROR_INSUFFICIENT_BUFFER);
2890                 return 0;
2891         }
2892         /*
2893          * Raw 8- to 16-bit conversion.
2894          */
2895         for (   cchConverted = 0,
2896                 r = (PCHAR) lpMultiByteStr,
2897                 w = (PWCHAR) lpWideCharStr;
2898
2899                 ((*r) && (cchConverted < cchWideChar));
2900
2901                 r++,
2902                 cchConverted++
2903                 )
2904         {
2905                 *w = (WCHAR) *r;
2906         }
2907         /*
2908          * Is the input string NULL terminated?
2909          */
2910         if (TRUE == InIsNullTerminated)
2911         {
2912                 *w = L'\0';
2913                 ++cchConverted;
2914         }
2915         /*
2916          * Return how many characters we
2917          * wrote in the output buffer.
2918          */
2919         SetLastError (ERROR_SUCCESS);
2920         return cchConverted;
2921 }
2922
2923
2924 DWORD
2925 STDCALL
2926 OpenConsoleW (
2927         DWORD   Unknown0,
2928         DWORD   Unknown1,
2929         DWORD   Unknown2,
2930         DWORD   Unknown3
2931         )
2932 {
2933         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2934         return 0;
2935 }
2936
2937
2938 HANDLE
2939 STDCALL
2940 OpenMutexA (
2941         DWORD   dwDesiredAccess,
2942         WINBOOL bInheritHandle,
2943         LPCSTR  lpName
2944         )
2945 {
2946         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2947         return INVALID_HANDLE_VALUE;
2948 }
2949
2950
2951 HANDLE
2952 STDCALL
2953 OpenMutexW (
2954         DWORD   dwDesiredAccess,
2955         WINBOOL bInheritHandle,
2956         LPCWSTR lpName
2957         )
2958 {
2959         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2960         return INVALID_HANDLE_VALUE;
2961 }
2962
2963
2964 DWORD
2965 STDCALL
2966 OpenProfileUserMapping (VOID)
2967 {
2968         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2969         return 0;
2970 }
2971
2972
2973 HANDLE
2974 STDCALL
2975 OpenSemaphoreA (
2976         DWORD   dwDesiredAccess,
2977         WINBOOL bInheritHandle,
2978         LPCSTR  lpName
2979         )
2980 {
2981         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2982         return INVALID_HANDLE_VALUE;
2983 }
2984
2985
2986 HANDLE
2987 STDCALL
2988 OpenSemaphoreW (
2989         DWORD   dwDesiredAccess,
2990         WINBOOL bInheritHandle,
2991         LPCWSTR lpName
2992         )
2993 {
2994         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2995         return INVALID_HANDLE_VALUE;
2996 }
2997
2998
2999 WINBOOL
3000 STDCALL
3001 PeekNamedPipe (
3002         HANDLE  hNamedPipe,
3003         LPVOID  lpBuffer,
3004         DWORD   nBufferSize,
3005         LPDWORD lpBytesRead,
3006         LPDWORD lpTotalBytesAvail,
3007         LPDWORD lpBytesLeftThisMessage
3008         )
3009 {
3010         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3011         return FALSE;
3012 }
3013
3014
3015 DWORD
3016 STDCALL
3017 PrepareTape (
3018         HANDLE  hDevice,
3019         DWORD   dwOperation,
3020         WINBOOL bImmediate
3021         )
3022 {
3023         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3024         return 0;
3025 }
3026
3027
3028 WINBOOL
3029 STDCALL
3030 PurgeComm (
3031         HANDLE  hFile,
3032         DWORD   dwFlags
3033         )
3034 {
3035         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3036         return FALSE;
3037 }
3038
3039
3040 WINBOOL
3041 STDCALL
3042 QueryPerformanceCounter (
3043         LARGE_INTEGER   * lpPerformanceCount
3044         )
3045 {
3046         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3047         return FALSE;
3048 }
3049
3050
3051 WINBOOL
3052 STDCALL
3053 QueryPerformanceFrequency (
3054         LARGE_INTEGER   * lpFrequency
3055         )
3056 {
3057         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3058         return FALSE;
3059 }
3060
3061
3062 WINBOOL
3063 STDCALL
3064 QueryWin31IniFilesMappedToRegistry (
3065         DWORD   Unknown0,
3066         DWORD   Unknown1,
3067         DWORD   Unknown2,
3068         DWORD   Unknown3
3069         )
3070 {
3071         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3072         return FALSE;
3073 }
3074
3075
3076 VOID
3077 STDCALL
3078 RaiseException (
3079         DWORD           dwExceptionCode,
3080         DWORD           dwExceptionFlags,
3081         DWORD           nNumberOfArguments,
3082         CONST DWORD     * lpArguments
3083         )
3084 {
3085         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3086 }
3087
3088
3089
3090
3091
3092 WINBOOL
3093 STDCALL
3094 RegisterConsoleVDM (
3095         DWORD   Unknown0,
3096         DWORD   Unknown1,
3097         DWORD   Unknown2,
3098         DWORD   Unknown3,
3099         DWORD   Unknown4,
3100         DWORD   Unknown5,
3101         DWORD   Unknown6,
3102         DWORD   Unknown7,
3103         DWORD   Unknown8,
3104         DWORD   Unknown9,
3105         DWORD   Unknown10
3106         )
3107 {
3108         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3109         return FALSE;
3110 }
3111
3112
3113 WINBOOL
3114 STDCALL
3115 RegisterWowBaseHandlers (
3116         DWORD   Unknown0
3117         )
3118 {
3119         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3120         return FALSE;
3121 }
3122
3123
3124 WINBOOL
3125 STDCALL
3126 RegisterWowExec (
3127         DWORD   Unknown0
3128         )
3129 {
3130         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3131         return FALSE;
3132 }
3133
3134
3135 WINBOOL
3136 STDCALL
3137 ReleaseMutex (
3138         HANDLE  hMutex
3139         )
3140 {
3141         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3142         return FALSE;
3143 }
3144
3145
3146 WINBOOL
3147 STDCALL
3148 ReleaseSemaphore (
3149         HANDLE  hSemaphore,
3150         LONG    lReleaseCount,
3151         LPLONG  lpPreviousCount
3152         )
3153 {
3154         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3155         return FALSE;
3156 }
3157
3158
3159
3160
3161 WINBOOL
3162 STDCALL
3163 SetCommBreak (
3164         HANDLE  hFile
3165         )
3166 {
3167         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3168         return FALSE;
3169 }
3170
3171
3172 WINBOOL
3173 STDCALL
3174 SetCommConfig (
3175         HANDLE          hCommDev,
3176         LPCOMMCONFIG    lpCC,
3177         DWORD           dwSize
3178         )
3179 {
3180         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3181         return FALSE;
3182 }
3183
3184
3185 WINBOOL
3186 STDCALL
3187 SetCommMask (
3188         HANDLE  hFile,
3189         DWORD   dwEvtMask
3190         )
3191 {
3192         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3193         return FALSE;
3194 }
3195
3196
3197 WINBOOL
3198 STDCALL
3199 SetCommState (
3200         HANDLE  hFile,
3201         LPDCB   lpDCB
3202         )
3203 {
3204         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3205         return FALSE;
3206 }
3207
3208
3209 WINBOOL
3210 STDCALL
3211 SetCommTimeouts (
3212         HANDLE          hFile,
3213         LPCOMMTIMEOUTS  lpCommTimeouts
3214         )
3215 {
3216         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3217         return FALSE;
3218 }
3219
3220
3221 WINBOOL
3222 STDCALL
3223 SetComputerNameA (
3224         LPCSTR  lpComputerName
3225         )
3226 {
3227         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3228         return FALSE;
3229 }
3230
3231
3232 WINBOOL
3233 STDCALL
3234 SetComputerNameW (
3235     LPCWSTR lpComputerName
3236     )
3237 {
3238         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3239         return FALSE;
3240 }
3241
3242
3243 WINBOOL
3244 STDCALL
3245 SetConsoleCommandHistoryMode (
3246         DWORD   dwMode
3247         )
3248 {
3249         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3250         return FALSE;
3251 }
3252
3253
3254 WINBOOL
3255 STDCALL
3256 SetConsoleCursor (
3257         DWORD   Unknown0,
3258         DWORD   Unknown1
3259         )
3260 {
3261         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3262         return FALSE;
3263 }
3264
3265
3266 WINBOOL
3267 STDCALL
3268 SetConsoleDisplayMode (
3269         DWORD   Unknown0,
3270         DWORD   Unknown1,
3271         DWORD   Unknown2
3272         )
3273 {
3274         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3275         return FALSE;
3276 }
3277
3278
3279 WINBOOL
3280 STDCALL
3281 SetConsoleFont (
3282         DWORD   Unknown0,
3283         DWORD   Unknown1
3284         )
3285 {
3286         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3287         return FALSE;
3288 }
3289
3290
3291 WINBOOL
3292 STDCALL
3293 SetConsoleHardwareState (
3294         DWORD   Unknown0,
3295         DWORD   Unknown1,
3296         DWORD   Unknown2
3297         )
3298 {
3299         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3300         return FALSE;
3301 }
3302
3303
3304 WINBOOL
3305 STDCALL
3306 SetConsoleKeyShortcuts (
3307         DWORD   Unknown0,
3308         DWORD   Unknown1,
3309         DWORD   Unknown2,
3310         DWORD   Unknown3
3311         )
3312 {
3313         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3314         return FALSE;
3315 }
3316
3317
3318 WINBOOL
3319 STDCALL
3320 SetConsoleMaximumWindowSize (
3321         DWORD   Unknown0,
3322         DWORD   Unknown1
3323         )
3324 {
3325         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3326         return FALSE;
3327 }
3328
3329
3330 WINBOOL
3331 STDCALL
3332 SetConsoleMenuClose (
3333         DWORD   Unknown0
3334         )
3335 {
3336         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3337         return FALSE;
3338 }
3339
3340
3341 WINBOOL
3342 STDCALL
3343 SetConsoleNumberOfCommandsA (
3344         DWORD   Unknown0,
3345         DWORD   Unknown1
3346         )
3347 {
3348         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3349         return FALSE;
3350 }
3351
3352
3353 WINBOOL
3354 STDCALL
3355 SetConsoleNumberOfCommandsW (
3356         DWORD   Unknown0,
3357         DWORD   Unknown1
3358         )
3359 {
3360         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3361         return FALSE;
3362 }
3363
3364
3365 WINBOOL
3366 STDCALL
3367 SetConsolePalette (
3368         DWORD   Unknown0,
3369         DWORD   Unknown1,
3370         DWORD   Unknown2
3371         )
3372 {
3373         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3374         return FALSE;
3375 }
3376
3377
3378 WINBOOL
3379 STDCALL
3380 SetDefaultCommConfigA (
3381         LPCSTR          lpszName,
3382         LPCOMMCONFIG    lpCC,
3383         DWORD           dwSize
3384         )
3385 {
3386         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3387         return FALSE;
3388 }
3389
3390
3391 WINBOOL
3392 STDCALL
3393 SetDefaultCommConfigW (
3394         LPCWSTR         lpszName,
3395         LPCOMMCONFIG    lpCC,
3396         DWORD           dwSize
3397         )
3398 {
3399         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3400         return FALSE;
3401 }
3402
3403
3404 WINBOOL
3405 STDCALL
3406 SetLastConsoleEventActive (VOID)
3407 {
3408         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3409         return FALSE;
3410 }
3411
3412
3413 WINBOOL
3414 STDCALL
3415 SetLocaleInfoA (
3416         LCID    Locale,
3417         LCTYPE  LCType,
3418         LPCSTR  lpLCData
3419         )
3420 {
3421         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3422         return FALSE;
3423 }
3424
3425
3426 WINBOOL
3427 STDCALL
3428 SetLocaleInfoW (
3429         LCID    Locale,
3430         LCTYPE  LCType,
3431         LPCWSTR lpLCData
3432         )
3433 {
3434         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3435         return FALSE;
3436 }
3437
3438
3439 WINBOOL
3440 STDCALL
3441 SetMailslotInfo (
3442         HANDLE  hMailslot,
3443         DWORD   lReadTimeout
3444         )
3445 {
3446         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3447         return FALSE;
3448 }
3449
3450
3451 WINBOOL
3452 STDCALL
3453 SetNamedPipeHandleState (
3454         HANDLE  hNamedPipe,
3455         LPDWORD lpMode,
3456         LPDWORD lpMaxCollectionCount,
3457         LPDWORD lpCollectDataTimeout
3458         )
3459 {
3460         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3461         return FALSE;
3462 }
3463
3464
3465 WINBOOL
3466 STDCALL
3467 SetProcessShutdownParameters (
3468         DWORD   dwLevel,
3469         DWORD   dwFlags
3470         )
3471 {
3472         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3473         return FALSE;
3474 }
3475
3476
3477 WINBOOL
3478 STDCALL
3479 SetProcessWorkingSetSize (
3480         HANDLE  hProcess,
3481         DWORD   dwMinimumWorkingSetSize,
3482         DWORD   dwMaximumWorkingSetSize
3483         )
3484 {
3485         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3486         return FALSE;
3487 }
3488
3489
3490 WINBOOL
3491 STDCALL
3492 SetSystemPowerState (
3493         DWORD   Unknown0,
3494         DWORD   Unknown1
3495         )
3496 {
3497         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3498         return FALSE;
3499 }
3500
3501
3502 DWORD
3503 STDCALL
3504 SetTapeParameters (
3505         HANDLE  hDevice,
3506         DWORD   dwOperation,
3507         LPVOID  lpTapeInformation
3508         )
3509 {
3510         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3511         return 0;
3512 }
3513
3514
3515 DWORD
3516 STDCALL
3517 SetTapePosition (
3518         HANDLE  hDevice,
3519         DWORD   dwPositionMethod,
3520         DWORD   dwPartition,
3521         DWORD   dwOffsetLow,
3522         DWORD   dwOffsetHigh,
3523         WINBOOL bImmediate
3524         )
3525 {
3526         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3527         return FALSE;
3528 }
3529
3530
3531 WINBOOL
3532 STDCALL
3533 SetThreadLocale (
3534         LCID    Locale
3535         )
3536 {
3537         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3538         return FALSE;
3539 }
3540
3541
3542 WINBOOL
3543 STDCALL
3544 SetVDMCurrentDirectories (
3545         DWORD   Unknown0,
3546         DWORD   Unknown1
3547         )
3548 {
3549         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3550         return FALSE;
3551 }
3552
3553
3554 WINBOOL
3555 STDCALL
3556 SetupComm (
3557         HANDLE  hFile,
3558         DWORD   dwInQueue,
3559         DWORD   dwOutQueue
3560         )
3561 {
3562         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3563         return FALSE;
3564 }
3565
3566
3567 DWORD
3568 STDCALL
3569 ShowConsoleCursor (
3570         DWORD   Unknown0,
3571         DWORD   Unknown1
3572         )
3573 {
3574         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3575         return 0;
3576 }
3577
3578
3579
3580
3581
3582
3583
3584
3585
3586 WINBOOL
3587 STDCALL
3588 TransactNamedPipe (
3589         HANDLE          hNamedPipe,
3590         LPVOID          lpInBuffer,
3591         DWORD           nInBufferSize,
3592         LPVOID          lpOutBuffer,
3593         DWORD           nOutBufferSize,
3594         LPDWORD         lpBytesRead,
3595         LPOVERLAPPED    lpOverlapped
3596         )
3597 {
3598         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3599         return FALSE;
3600 }
3601
3602
3603 WINBOOL
3604 STDCALL
3605 TransmitCommChar (
3606         HANDLE  hFile,
3607         char    cChar
3608         )
3609 {
3610         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3611         return FALSE;
3612 }
3613
3614
3615 DWORD
3616 STDCALL
3617 TrimVirtualBuffer (
3618         DWORD   Unknown0
3619         )
3620 {
3621         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3622         return 0;
3623 }
3624
3625
3626 WINBOOL
3627 STDCALL
3628 UpdateResourceA (
3629         HANDLE  hUpdate,
3630         LPCSTR  lpType,
3631         LPCSTR  lpName,
3632         WORD    wLanguage,
3633         LPVOID  lpData,
3634         DWORD   cbData
3635         )
3636 {
3637         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3638         return FALSE;
3639 }
3640
3641
3642 WINBOOL
3643 STDCALL
3644 UpdateResourceW (
3645         HANDLE  hUpdate,
3646         LPCWSTR lpType,
3647         LPCWSTR lpName,
3648         WORD    wLanguage,
3649         LPVOID  lpData,
3650         DWORD   cbData
3651         )
3652 {
3653         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3654         return FALSE;
3655 }
3656
3657
3658 DWORD
3659 STDCALL
3660 VDMConsoleOperation (
3661         DWORD   Unknown0,
3662         DWORD   Unknown1
3663         )
3664 {
3665         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3666         return 0;
3667 }
3668
3669
3670 DWORD
3671 STDCALL
3672 VDMOperationStarted (
3673         DWORD   Unknown0
3674         )
3675 {
3676         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3677         return 0;
3678 }
3679
3680
3681 DWORD
3682 STDCALL
3683 VerLanguageNameA (
3684         DWORD   wLang,
3685         LPSTR   szLang,
3686         DWORD   nSize
3687         )
3688 {
3689         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3690         return 0;
3691 }
3692
3693
3694 DWORD
3695 STDCALL
3696 VerLanguageNameW (
3697         DWORD   wLang,
3698         LPWSTR  szLang,
3699         DWORD   nSize
3700         )
3701 {
3702         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3703         return 0;
3704 }
3705
3706
3707 DWORD
3708 STDCALL
3709 VerifyConsoleIoHandle (
3710         DWORD   Unknown0
3711         )
3712 {
3713         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3714         return 0;
3715 }
3716
3717
3718 DWORD
3719 STDCALL
3720 VirtualBufferExceptionHandler (
3721         DWORD   Unknown0,
3722         DWORD   Unknown1,
3723         DWORD   Unknown2
3724         )
3725 {
3726         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3727         return 0;
3728 }
3729
3730
3731 WINBOOL
3732 STDCALL
3733 WaitCommEvent (
3734         HANDLE          hFile,
3735         LPDWORD         lpEvtMask,
3736         LPOVERLAPPED    lpOverlapped
3737         )
3738 {
3739         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3740         return FALSE;
3741 }
3742
3743
3744 WINBOOL
3745 STDCALL
3746 WaitNamedPipeA (
3747         LPCSTR  lpNamedPipeName,
3748         DWORD   nTimeOut
3749         )
3750 {
3751         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3752         return FALSE;
3753 }
3754
3755
3756 WINBOOL
3757 STDCALL
3758 WaitNamedPipeW (
3759         LPCWSTR lpNamedPipeName,
3760         DWORD   nTimeOut
3761         )
3762 {
3763         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3764         return FALSE;
3765 }
3766
3767
3768 int
3769 STDCALL
3770 WideCharToMultiByte (
3771         UINT    CodePage,
3772         DWORD   dwFlags,
3773         LPCWSTR lpWideCharStr,
3774         int     cchWideChar,
3775         LPSTR   lpMultiByteStr,
3776         int     cchMultiByte,
3777         LPCSTR  lpDefaultChar,
3778         LPBOOL  lpUsedDefaultChar
3779         )
3780 {
3781         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3782         return FALSE;
3783 }
3784
3785
3786 DWORD
3787 STDCALL
3788 WriteConsoleInputVDMA (
3789         DWORD   Unknown0,
3790         DWORD   Unknown1,
3791         DWORD   Unknown2,
3792         DWORD   Unknown3
3793         )
3794 {
3795         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3796         return 0;
3797 }
3798
3799
3800 DWORD
3801 STDCALL
3802 WriteConsoleInputVDMW (
3803         DWORD   Unknown0,
3804         DWORD   Unknown1,
3805         DWORD   Unknown2,
3806         DWORD   Unknown3
3807         )
3808 {
3809         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3810         return 0;
3811 }
3812
3813
3814 WINBOOL
3815 STDCALL
3816 WritePrivateProfileSectionA (
3817         LPCSTR  lpAppName,
3818         LPCSTR  lpString,
3819         LPCSTR  lpFileName
3820         )
3821 {
3822         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3823         return FALSE;
3824 }
3825
3826
3827 WINBOOL
3828 STDCALL
3829 WritePrivateProfileSectionW (
3830         LPCWSTR lpAppName,
3831         LPCWSTR lpString,
3832         LPCWSTR lpFileName
3833         )
3834 {
3835         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3836         return FALSE;
3837 }
3838
3839
3840 WINBOOL
3841 STDCALL
3842 WritePrivateProfileStringA (
3843         LPCSTR  lpAppName,
3844         LPCSTR  lpKeyName,
3845         LPCSTR  lpString,
3846         LPCSTR  lpFileName
3847         )
3848 {
3849         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3850         return FALSE;
3851 }
3852
3853
3854 WINBOOL
3855 STDCALL
3856 WritePrivateProfileStringW (
3857         LPCWSTR lpAppName,
3858         LPCWSTR lpKeyName,
3859         LPCWSTR lpString,
3860         LPCWSTR lpFileName
3861         )
3862 {
3863         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3864         return FALSE;
3865 }
3866
3867
3868 WINBOOL
3869 STDCALL
3870 WritePrivateProfileStructA (
3871         DWORD   Unknown0,
3872         DWORD   Unknown1,
3873         DWORD   Unknown2,
3874         DWORD   Unknown3,
3875         DWORD   Unknown4
3876         )
3877 {
3878         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3879         return FALSE;
3880 }
3881
3882
3883 WINBOOL
3884 STDCALL
3885 WritePrivateProfileStructW (
3886         DWORD   Unknown0,
3887         DWORD   Unknown1,
3888         DWORD   Unknown2,
3889         DWORD   Unknown3,
3890         DWORD   Unknown4
3891         )
3892 {
3893         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3894         return FALSE;
3895 }
3896
3897
3898
3899
3900 WINBOOL
3901 STDCALL
3902 WriteProfileSectionA (
3903         LPCSTR  lpAppName,
3904         LPCSTR  lpString
3905         )
3906 {
3907         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3908         return FALSE;
3909 }
3910
3911
3912 WINBOOL
3913 STDCALL
3914 WriteProfileSectionW (
3915         LPCWSTR lpAppName,
3916         LPCWSTR lpString
3917         )
3918 {
3919         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3920         return FALSE;
3921 }
3922
3923
3924 WINBOOL
3925 STDCALL
3926 WriteProfileStringA (
3927         LPCSTR  lpAppName,
3928         LPCSTR  lpKeyName,
3929         LPCSTR  lpString
3930         )
3931 {
3932         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3933         return FALSE;
3934 }
3935
3936
3937 WINBOOL
3938 STDCALL
3939 WriteProfileStringW (
3940         LPCWSTR lpAppName,
3941         LPCWSTR lpKeyName,
3942         LPCWSTR lpString
3943         )
3944 {
3945         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3946         return FALSE;
3947 }
3948
3949
3950 DWORD
3951 STDCALL
3952 WriteTapemark (
3953         HANDLE  hDevice,