reactos/lib/kernel32/misc/stubs.c

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