reactos/lib/kernel32/misc/stubs.c

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