reactos/lib/kernel32/misc/stubs.c

   1 /* $Id: stubs.c,v 1.6 1999/10/03 23:19:15 ea Exp $
   2  *
   3  * KERNEL32.DLL stubs (unimplemented functions)
   4  * Remove from this file, if you implement them.
   5  */
   6 #include <windows.h>
   7
   8 ATOM
   9 STDCALL
  10 AddAtomA (
  11         LPCSTR  lpString
  12         )
  13 {
  14         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  15         return 0;
  16 }
  17
  18
  19 ATOM
  20 STDCALL
  21 AddAtomW (
  22         LPCWSTR lpString
  23         )
  24 {
  25         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  26         return 0;
  27 }
  28
  29 BOOL
  30 STDCALL
  31 AddConsoleAliasA (
  32         DWORD a0,
  33         DWORD a1,
  34         DWORD a2
  35         )
  36 {
  37         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  38         return FALSE;
  39 }
  40
  41 BOOL
  42 STDCALL
  43 AddConsoleAliasW (
  44         DWORD a0,
  45         DWORD a1,
  46         DWORD a2
  47         )
  48 {
  49         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  50         return FALSE;
  51 }
  52
  53 WINBOOL
  54 STDCALL
  55 BackupRead (
  56         HANDLE  hFile,
  57         LPBYTE  lpBuffer,
  58         DWORD   nNumberOfBytesToRead,
  59         LPDWORD lpNumberOfBytesRead,
  60         WINBOOL bAbort,
  61         WINBOOL bProcessSecurity,
  62         LPVOID  * lpContext
  63         )
  64 {
  65         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  66         return FALSE;
  67 }
  68
  69
  70 WINBOOL
  71 STDCALL
  72 BackupSeek (
  73         HANDLE  hFile,
  74         DWORD   dwLowBytesToSeek,
  75         DWORD   dwHighBytesToSeek,
  76         LPDWORD lpdwLowByteSeeked,
  77         LPDWORD lpdwHighByteSeeked,
  78         LPVOID  * lpContext
  79         )
  80 {
  81         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  82         return FALSE;
  83 }
  84
  85
  86 WINBOOL
  87 STDCALL
  88 BackupWrite (
  89         HANDLE  hFile,
  90         LPBYTE  lpBuffer,
  91         DWORD   nNumberOfBytesToWrite,
  92         LPDWORD lpNumberOfBytesWritten,
  93         WINBOOL bAbort,
  94         WINBOOL bProcessSecurity,
  95         LPVOID  * lpContext
  96         )
  97 {
  98         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  99         return FALSE;
 100 }
 101
 102
 103 BOOL
 104 STDCALL
 105 BaseAttachCompleteThunk (VOID)
 106 {
 107         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 108         return FALSE;
 109 }
 110
 111
 112 HANDLE
 113 STDCALL
 114 BeginUpdateResourceW (
 115         LPCWSTR pFileName,
 116         WINBOOL bDeleteExistingResources
 117         )
 118 {
 119         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 120         return FALSE;
 121 }
 122
 123
 124 HANDLE
 125 STDCALL
 126 BeginUpdateResourceA (
 127         LPCSTR  pFileName,
 128         WINBOOL bDeleteExistingResources
 129         )
 130 {
 131         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 132         return FALSE;
 133 }
 134
 135
 136 WINBOOL
 137 STDCALL
 138 BuildCommDCBA (
 139         LPCSTR  lpDef,
 140         LPDCB   lpDCB
 141         )
 142 {
 143         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 144         return FALSE;
 145 }
 146
 147
 148 WINBOOL
 149 STDCALL
 150 BuildCommDCBW (
 151         LPCWSTR lpDef,
 152         LPDCB   lpDCB
 153         )
 154 {
 155         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 156         return FALSE;
 157 }
 158
 159
 160 WINBOOL
 161 STDCALL
 162 BuildCommDCBAndTimeoutsA (
 163         LPCSTR          lpDef,
 164         LPDCB           lpDCB,
 165         LPCOMMTIMEOUTS  lpCommTimeouts
 166         )
 167 {
 168         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 169         return FALSE;
 170 }
 171
 172
 173 WINBOOL
 174 STDCALL
 175 BuildCommDCBAndTimeoutsW (
 176         LPCWSTR         lpDef,
 177         LPDCB           lpDCB,
 178         LPCOMMTIMEOUTS  lpCommTimeouts
 179         )
 180 {
 181         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 182         return FALSE;
 183 }
 184
 185
 186 WINBOOL
 187 STDCALL
 188 CallNamedPipeA (
 189         LPCSTR  lpNamedPipeName,
 190         LPVOID  lpInBuffer,
 191         DWORD   nInBufferSize,
 192         LPVOID  lpOutBuffer,
 193         DWORD   nOutBufferSize,
 194         LPDWORD lpBytesRead,
 195         DWORD   nTimeOut
 196         )
 197 {
 198         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 199         return FALSE;
 200 }
 201
 202
 203 WINBOOL
 204 STDCALL
 205 CallNamedPipeW (
 206         LPCWSTR lpNamedPipeName,
 207         LPVOID  lpInBuffer,
 208         DWORD   nInBufferSize,
 209         LPVOID  lpOutBuffer,
 210         DWORD   nOutBufferSize,
 211         LPDWORD lpBytesRead,
 212         DWORD   nTimeOut
 213         )
 214 {
 215         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 216         return FALSE;
 217 }
 218
 219
 220 WINBOOL
 221 STDCALL
 222 ClearCommBreak (
 223         HANDLE  hFile
 224         )
 225 {
 226         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 227         return FALSE;
 228 }
 229
 230
 231 WINBOOL
 232 STDCALL
 233 ClearCommError (
 234         HANDLE          hFile,
 235         LPDWORD         lpErrors,
 236         LPCOMSTAT       lpStat
 237         )
 238 {
 239         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 240         return FALSE;
 241 }
 242
 243
 244 BOOL
 245 STDCALL
 246 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 OpenMutexA (
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 OpenMutexW (
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 DWORD
3065 STDCALL
3066 OpenProfileUserMapping (VOID)
3067 {
3068         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3069         return 0;
3070 }
3071
3072
3073 HANDLE
3074 STDCALL
3075 OpenSemaphoreA (
3076         DWORD   dwDesiredAccess,
3077         WINBOOL bInheritHandle,
3078         LPCSTR  lpName
3079         )
3080 {
3081         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3082         return INVALID_HANDLE_VALUE;
3083 }
3084
3085
3086 HANDLE
3087 STDCALL
3088 OpenSemaphoreW (
3089         DWORD   dwDesiredAccess,
3090         WINBOOL bInheritHandle,
3091         LPCWSTR lpName
3092         )
3093 {
3094         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3095         return INVALID_HANDLE_VALUE;
3096 }
3097
3098
3099 WINBOOL
3100 STDCALL
3101 PeekNamedPipe (
3102         HANDLE  hNamedPipe,
3103         LPVOID  lpBuffer,
3104         DWORD   nBufferSize,
3105         LPDWORD lpBytesRead,
3106         LPDWORD lpTotalBytesAvail,
3107         LPDWORD lpBytesLeftThisMessage
3108         )
3109 {
3110         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3111         return FALSE;
3112 }
3113
3114
3115 DWORD
3116 STDCALL
3117 PrepareTape (
3118         HANDLE  hDevice,
3119         DWORD   dwOperation,
3120         WINBOOL bImmediate
3121         )
3122 {
3123         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3124         return 0;
3125 }
3126
3127
3128 WINBOOL
3129 STDCALL
3130 PurgeComm (
3131         HANDLE  hFile,
3132         DWORD   dwFlags
3133         )
3134 {
3135         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3136         return FALSE;
3137 }
3138
3139
3140 WINBOOL
3141 STDCALL
3142 QueryPerformanceCounter (
3143         LARGE_INTEGER   * lpPerformanceCount
3144         )
3145 {
3146         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3147         return FALSE;
3148 }
3149
3150
3151 WINBOOL
3152 STDCALL
3153 QueryPerformanceFrequency (
3154         LARGE_INTEGER   * lpFrequency
3155         )
3156 {
3157         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3158         return FALSE;
3159 }
3160
3161
3162 WINBOOL
3163 STDCALL
3164 QueryWin31IniFilesMappedToRegistry (
3165         DWORD   Unknown0,
3166         DWORD   Unknown1,
3167         DWORD   Unknown2,
3168         DWORD   Unknown3
3169         )
3170 {
3171         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3172         return FALSE;
3173 }
3174
3175
3176 VOID
3177 STDCALL
3178 RaiseException (
3179         DWORD           dwExceptionCode,
3180         DWORD           dwExceptionFlags,
3181         DWORD           nNumberOfArguments,
3182         CONST DWORD     * lpArguments
3183         )
3184 {
3185         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3186 }
3187
3188
3189 WINBOOL
3190 STDCALL
3191 ReadProcessMemory (
3192         HANDLE  hProcess,
3193         LPCVOID lpBaseAddress,
3194         LPVOID  lpBuffer,
3195         DWORD   nSize,
3196         LPDWORD lpNumberOfBytesRead
3197         )
3198 {
3199         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3200         return FALSE;
3201 }
3202
3203
3204 WINBOOL
3205 STDCALL
3206 RegisterConsoleVDM (
3207         DWORD   Unknown0,
3208         DWORD   Unknown1,
3209         DWORD   Unknown2,
3210         DWORD   Unknown3,
3211         DWORD   Unknown4,
3212         DWORD   Unknown5,
3213         DWORD   Unknown6,
3214         DWORD   Unknown7,
3215         DWORD   Unknown8,
3216         DWORD   Unknown9,
3217         DWORD   Unknown10
3218         )
3219 {
3220         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3221         return FALSE;
3222 }
3223
3224
3225 WINBOOL
3226 STDCALL
3227 RegisterWowBaseHandlers (
3228         DWORD   Unknown0
3229         )
3230 {
3231         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3232         return FALSE;
3233 }
3234
3235
3236 WINBOOL
3237 STDCALL
3238 RegisterWowExec (
3239         DWORD   Unknown0
3240         )
3241 {
3242         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3243         return FALSE;
3244 }
3245
3246
3247 WINBOOL
3248 STDCALL
3249 ReleaseMutex (
3250         HANDLE  hMutex
3251         )
3252 {
3253         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3254         return FALSE;
3255 }
3256
3257
3258 WINBOOL
3259 STDCALL
3260 ReleaseSemaphore (
3261         HANDLE  hSemaphore,
3262         LONG    lReleaseCount,
3263         LPLONG  lpPreviousCount
3264         )
3265 {
3266         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3267         return FALSE;
3268 }
3269
3270
3271 /* FIXME: KERNEL32.RtlFillMemory == NTDLL.RtlFillMemory */
3272 DWORD
3273 STDCALL
3274 RtlFillMemory (
3275         DWORD   Unknown0,
3276         DWORD   Unknown1,
3277         DWORD   Unknown2
3278         )
3279 {
3280         return 0;
3281 }
3282
3283
3284 /* FIXME: KERNEL32.RtlMoveMemory == NTDLL.RtlMoveMemory */
3285 DWORD
3286 STDCALL
3287 RtlMoveMemory (
3288         DWORD   Unknown0,
3289         DWORD   Unknown1,
3290         DWORD   Unknown2
3291         )
3292 {
3293         return 0;
3294 }
3295
3296
3297 /* FIXME: KERNEL32.RtlUnwind == NTDLL.RtlUnwind */
3298 DWORD
3299 STDCALL
3300 RtlUnwind (
3301         DWORD   Unknown0,
3302         DWORD   Unknown1,
3303         DWORD   Unknown2,
3304         DWORD   Unknown3
3305         )
3306 {
3307         return 0;
3308 }
3309
3310
3311 /* FIXME: KERNEL32.RtlZeroMemory == NTDLL.RtlZeroMemory */
3312 DWORD
3313 STDCALL
3314 RtlZeroMemory (
3315         DWORD   Unknown0,
3316         DWORD   Unknown1
3317         )
3318 {
3319         return 0;
3320 }
3321
3322
3323 WINBOOL
3324 STDCALL
3325 SetCommBreak (
3326         HANDLE  hFile
3327         )
3328 {
3329         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3330         return FALSE;
3331 }
3332
3333
3334 WINBOOL
3335 STDCALL
3336 SetCommConfig (
3337         HANDLE          hCommDev,
3338         LPCOMMCONFIG    lpCC,
3339         DWORD           dwSize
3340         )
3341 {
3342         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3343         return FALSE;
3344 }
3345
3346
3347 WINBOOL
3348 STDCALL
3349 SetCommMask (
3350         HANDLE  hFile,
3351         DWORD   dwEvtMask
3352         )
3353 {
3354         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3355         return FALSE;
3356 }
3357
3358
3359 WINBOOL
3360 STDCALL
3361 SetCommState (
3362         HANDLE  hFile,
3363         LPDCB   lpDCB
3364         )
3365 {
3366         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3367         return FALSE;
3368 }
3369
3370
3371 WINBOOL
3372 STDCALL
3373 SetCommTimeouts (
3374         HANDLE          hFile,
3375         LPCOMMTIMEOUTS  lpCommTimeouts
3376         )
3377 {
3378         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3379         return FALSE;
3380 }
3381
3382
3383 WINBOOL
3384 STDCALL
3385 SetComputerNameA (
3386         LPCSTR  lpComputerName
3387         )
3388 {
3389         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3390         return FALSE;
3391 }
3392
3393
3394 WINBOOL
3395 STDCALL
3396 SetComputerNameW (
3397     LPCWSTR lpComputerName
3398     )
3399 {
3400         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3401         return FALSE;
3402 }
3403
3404
3405 WINBOOL
3406 STDCALL
3407 SetConsoleCommandHistoryMode (
3408         DWORD   dwMode
3409         )
3410 {
3411         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3412         return FALSE;
3413 }
3414
3415
3416 WINBOOL
3417 STDCALL
3418 SetConsoleCursor (
3419         DWORD   Unknown0,
3420         DWORD   Unknown1
3421         )
3422 {
3423         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3424         return FALSE;
3425 }
3426
3427
3428 WINBOOL
3429 STDCALL
3430 SetConsoleDisplayMode (
3431         DWORD   Unknown0,
3432         DWORD   Unknown1,
3433         DWORD   Unknown2
3434         )
3435 {
3436         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3437         return FALSE;
3438 }
3439
3440
3441 WINBOOL
3442 STDCALL
3443 SetConsoleFont (
3444         DWORD   Unknown0,
3445         DWORD   Unknown1
3446         )
3447 {
3448         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3449         return FALSE;
3450 }
3451
3452
3453 WINBOOL
3454 STDCALL
3455 SetConsoleHardwareState (
3456         DWORD   Unknown0,
3457         DWORD   Unknown1,
3458         DWORD   Unknown2
3459         )
3460 {
3461         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3462         return FALSE;
3463 }
3464
3465
3466 WINBOOL
3467 STDCALL
3468 SetConsoleKeyShortcuts (
3469         DWORD   Unknown0,
3470         DWORD   Unknown1,
3471         DWORD   Unknown2,
3472         DWORD   Unknown3
3473         )
3474 {
3475         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3476         return FALSE;
3477 }
3478
3479
3480 WINBOOL
3481 STDCALL
3482 SetConsoleMaximumWindowSize (
3483         DWORD   Unknown0,
3484         DWORD   Unknown1
3485         )
3486 {
3487         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3488         return FALSE;
3489 }
3490
3491
3492 WINBOOL
3493 STDCALL
3494 SetConsoleMenuClose (
3495         DWORD   Unknown0
3496         )
3497 {
3498         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3499         return FALSE;
3500 }
3501
3502
3503 WINBOOL
3504 STDCALL
3505 SetConsoleNumberOfCommandsA (
3506         DWORD   Unknown0,
3507         DWORD   Unknown1
3508         )
3509 {
3510         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3511         return FALSE;
3512 }
3513
3514
3515 WINBOOL
3516 STDCALL
3517 SetConsoleNumberOfCommandsW (
3518         DWORD   Unknown0,
3519         DWORD   Unknown1
3520         )
3521 {
3522         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3523         return FALSE;
3524 }
3525
3526
3527 WINBOOL
3528 STDCALL
3529 SetConsolePalette (
3530         DWORD   Unknown0,
3531         DWORD   Unknown1,
3532         DWORD   Unknown2
3533         )
3534 {
3535         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3536         return FALSE;
3537 }
3538
3539
3540 WINBOOL
3541 STDCALL
3542 SetDefaultCommConfigA (
3543         LPCSTR          lpszName,
3544         LPCOMMCONFIG    lpCC,
3545         DWORD           dwSize
3546         )
3547 {
3548         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3549         return FALSE;
3550 }
3551
3552
3553 WINBOOL
3554 STDCALL
3555 SetDefaultCommConfigW (
3556         LPCWSTR         lpszName,
3557         LPCOMMCONFIG    lpCC,
3558         DWORD           dwSize
3559         )
3560 {
3561         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3562         return FALSE;
3563 }
3564
3565
3566 WINBOOL
3567 STDCALL
3568 SetLastConsoleEventActive (VOID)
3569 {
3570         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3571         return FALSE;
3572 }
3573
3574
3575 WINBOOL
3576 STDCALL
3577 SetLocaleInfoA (
3578         LCID    Locale,
3579         LCTYPE  LCType,
3580         LPCSTR  lpLCData
3581         )
3582 {
3583         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3584         return FALSE;
3585 }
3586
3587
3588 WINBOOL
3589 STDCALL
3590 SetLocaleInfoW (
3591         LCID    Locale,
3592         LCTYPE  LCType,
3593         LPCWSTR lpLCData
3594         )
3595 {
3596         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3597         return FALSE;
3598 }
3599
3600
3601 WINBOOL
3602 STDCALL
3603 SetMailslotInfo (
3604         HANDLE  hMailslot,
3605         DWORD   lReadTimeout
3606         )
3607 {
3608         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3609         return FALSE;
3610 }
3611
3612
3613 WINBOOL
3614 STDCALL
3615 SetNamedPipeHandleState (
3616         HANDLE  hNamedPipe,
3617         LPDWORD lpMode,
3618         LPDWORD lpMaxCollectionCount,
3619         LPDWORD lpCollectDataTimeout
3620         )
3621 {
3622         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3623         return FALSE;
3624 }
3625
3626
3627 WINBOOL
3628 STDCALL
3629 SetPriorityClass (
3630         HANDLE  hProcess,
3631         DWORD   dwPriorityClass
3632         )
3633 {
3634         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3635         return FALSE;
3636 }
3637
3638
3639 WINBOOL
3640 STDCALL
3641 SetProcessShutdownParameters (
3642         DWORD   dwLevel,
3643         DWORD   dwFlags
3644         )
3645 {
3646         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3647         return FALSE;
3648 }
3649
3650
3651 WINBOOL
3652 STDCALL
3653 SetProcessWorkingSetSize (
3654         HANDLE  hProcess,
3655         DWORD   dwMinimumWorkingSetSize,
3656         DWORD   dwMaximumWorkingSetSize
3657         )
3658 {
3659         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3660         return FALSE;
3661 }
3662
3663
3664 WINBOOL
3665 STDCALL
3666 SetSystemPowerState (
3667         DWORD   Unknown0,
3668         DWORD   Unknown1
3669         )
3670 {
3671         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3672         return FALSE;
3673 }
3674
3675
3676 DWORD
3677 STDCALL
3678 SetTapeParameters (
3679         HANDLE  hDevice,
3680         DWORD   dwOperation,
3681         LPVOID  lpTapeInformation
3682         )
3683 {
3684         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3685         return 0;
3686 }
3687
3688
3689 DWORD
3690 STDCALL
3691 SetTapePosition (
3692         HANDLE  hDevice,
3693         DWORD   dwPositionMethod,
3694         DWORD   dwPartition,
3695         DWORD   dwOffsetLow,
3696         DWORD   dwOffsetHigh,
3697         WINBOOL bImmediate
3698         )
3699 {
3700         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3701         return FALSE;
3702 }
3703
3704
3705 WINBOOL
3706 STDCALL
3707 SetThreadLocale (
3708         LCID    Locale
3709         )
3710 {
3711         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3712         return FALSE;
3713 }
3714
3715
3716 WINBOOL
3717 STDCALL
3718 SetVDMCurrentDirectories (
3719         DWORD   Unknown0,
3720         DWORD   Unknown1
3721         )
3722 {
3723         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3724         return FALSE;
3725 }
3726
3727
3728 WINBOOL
3729 STDCALL
3730 SetupComm (
3731         HANDLE  hFile,
3732         DWORD   dwInQueue,
3733         DWORD   dwOutQueue
3734         )
3735 {
3736         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3737         return FALSE;
3738 }
3739
3740
3741 DWORD
3742 STDCALL
3743 ShowConsoleCursor (
3744         DWORD   Unknown0,
3745         DWORD   Unknown1
3746         )
3747 {
3748         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3749         return 0;
3750 }
3751
3752
3753 DWORD
3754 STDCALL
3755 SizeofResource (
3756         HINSTANCE       hModule,
3757         HRSRC           hResInfo
3758         )
3759 {
3760         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3761         return 0;
3762 }
3763
3764
3765
3766
3767 LPVOID
3768 STDCALL
3769 TlsGetValue (
3770         DWORD   dwTlsIndex
3771         )
3772 {
3773         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3774         return NULL;
3775 }
3776
3777
3778 WINBOOL
3779 STDCALL
3780 TransactNamedPipe (
3781         HANDLE          hNamedPipe,
3782         LPVOID          lpInBuffer,
3783         DWORD           nInBufferSize,
3784         LPVOID          lpOutBuffer,
3785         DWORD           nOutBufferSize,
3786         LPDWORD         lpBytesRead,
3787         LPOVERLAPPED    lpOverlapped
3788         )
3789 {
3790         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3791         return FALSE;
3792 }
3793
3794
3795 WINBOOL
3796 STDCALL
3797 TransmitCommChar (
3798         HANDLE  hFile,
3799         char    cChar
3800         )
3801 {
3802         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3803         return FALSE;
3804 }
3805
3806
3807 DWORD
3808 STDCALL
3809 TrimVirtualBuffer (
3810         DWORD   Unknown0
3811         )
3812 {
3813         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3814         return 0;
3815 }
3816
3817
3818
3819
3820 WINBOOL
3821 STDCALL
3822 UpdateResourceA (
3823         HANDLE  hUpdate,
3824         LPCSTR  lpType,
3825         LPCSTR  lpName,
3826         WORD    wLanguage,
3827         LPVOID  lpData,
3828         DWORD   cbData
3829         )
3830 {
3831         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3832         return FALSE;
3833 }
3834
3835
3836 WINBOOL
3837 STDCALL
3838 UpdateResourceW (
3839         HANDLE  hUpdate,
3840         LPCWSTR lpType,
3841         LPCWSTR lpName,
3842         WORD    wLanguage,
3843         LPVOID  lpData,
3844         DWORD   cbData
3845         )
3846 {
3847         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3848         return FALSE;
3849 }
3850
3851
3852 DWORD
3853 STDCALL
3854 VDMConsoleOperation (
3855         DWORD   Unknown0,
3856         DWORD   Unknown1
3857         )
3858 {
3859         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3860         return 0;
3861 }
3862
3863
3864 DWORD
3865 STDCALL
3866 VDMOperationStarted (
3867         DWORD   Unknown0
3868         )
3869 {
3870         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3871         return 0;
3872 }
3873
3874
3875 DWORD
3876 STDCALL
3877 VerLanguageNameA (
3878         DWORD   wLang,
3879         LPSTR   szLang,
3880         DWORD   nSize
3881         )
3882 {
3883         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3884         return 0;
3885 }
3886
3887
3888 DWORD
3889 STDCALL
3890 VerLanguageNameW (
3891         DWORD   wLang,
3892         LPWSTR  szLang,
3893         DWORD   nSize
3894         )
3895 {
3896         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3897         return 0;
3898 }
3899
3900
3901 DWORD
3902 STDCALL
3903 VerifyConsoleIoHandle (
3904         DWORD   Unknown0
3905         )
3906 {
3907         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3908         return 0;
3909 }
3910
3911
3912 DWORD
3913 STDCALL
3914 VirtualBufferExceptionHandler (
3915         DWORD   Unknown0,
3916         DWORD   Unknown1,
3917         DWORD   Unknown2
3918         )
3919 {
3920         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3921         return 0;
3922 }
3923
3924
3925
3926
3927
3928 WINBOOL
3929 STDCALL
3930 WaitCommEvent (
3931         HANDLE          hFile,
3932         LPDWORD         lpEvtMask,
3933         LPOVERLAPPED    lpOverlapped
3934         )
3935 {
3936         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3937         return FALSE;
3938 }
3939
3940
3941 WINBOOL
3942 STDCALL
3943 WaitForDebugEvent (
3944         LPDEBUG_EVENT   lpDebugEvent,
3945         DWORD           dwMilliseconds
3946         )
3947 {
3948         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3949         return FALSE;
3950 }
3951
3952
3953 WINBOOL
3954 STDCALL
3955 WaitNamedPipeA (
3956         LPCSTR  lpNamedPipeName,
3957         DWORD   nTimeOut
3958         )
3959 {
3960         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3961         return FALSE;
3962 }
3963
3964
3965 WINBOOL
3966 STDCALL
3967 WaitNamedPipeW (
3968         LPCWSTR lpNamedPipeName,
3969         DWORD   nTimeOut
3970         )
3971 {
3972         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3973         return FALSE;
3974 }
3975
3976
3977 int
3978 STDCALL
3979 WideCharToMultiByte (
3980         UINT    CodePage,
3981         DWORD   dwFlags,
3982         LPCWSTR lpWideCharStr,
3983         int     cchWideChar,
3984         LPSTR   lpMultiByteStr,
3985         int     cchMultiByte,
3986         LPCSTR  lpDefaultChar,
3987         LPBOOL  lpUsedDefaultChar
3988         )
3989 {
3990         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3991         return FALSE;
3992 }
3993
3994
3995 DWORD
3996 STDCALL
3997 WriteConsoleInputVDMA (
3998         DWORD   Unknown0,
3999         DWORD   Unknown1,
4000         DWORD   Unknown2,
4001         DWORD   Unknown3
4002         )
4003 {
4004         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4005         return 0;
4006 }
4007
4008
4009 DWORD
4010 STDCALL
4011 WriteConsoleInputVDMW (
4012         DWORD   Unknown0,
4013         DWORD   Unknown1,
4014         DWORD   Unknown2,
4015         DWORD   Unknown3
4016         )
4017 {
4018         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4019         return 0;
4020 }
4021
4022
4023
4024
4025
4026 WINBOOL
4027 STDCALL
4028 WritePrivateProfileSectionA (
4029         LPCSTR  lpAppName,
4030         LPCSTR  lpString,
4031         LPCSTR  lpFileName
4032         )
4033 {
4034         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4035         return FALSE;
4036 }
4037
4038
4039 WINBOOL
4040 STDCALL
4041 WritePrivateProfileSectionW (
4042         LPCWSTR lpAppName,
4043         LPCWSTR lpString,
4044         LPCWSTR lpFileName
4045         )
4046 {
4047         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4048         return FALSE;
4049 }
4050
4051
4052 WINBOOL
4053 STDCALL
4054 WritePrivateProfileStringA (
4055         LPCSTR  lpAppName,
4056         LPCSTR  lpKeyName,
4057         LPCSTR  lpString,
4058         LPCSTR  lpFileName
4059         )
4060 {
4061         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4062         return FALSE;
4063 }
4064
4065
4066 WINBOOL
4067 STDCALL
4068 WritePrivateProfileStringW (
4069         LPCWSTR lpAppName,
4070         LPCWSTR lpKeyName,
4071         LPCWSTR lpString,
4072         LPCWSTR lpFileName
4073         )
4074 {
4075         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4076         return FALSE;
4077 }
4078
4079
4080 WINBOOL
4081 STDCALL
4082 WritePrivateProfileStructA (
4083         DWORD   Unknown0,
4084         DWORD   Unknown1,
4085         DWORD   Unknown2,
4086         DWORD   Unknown3,
4087         DWORD   Unknown4
4088         )
4089 {
4090         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4091         return FALSE;
4092 }
4093
4094
4095 WINBOOL
4096 STDCALL
4097 WritePrivateProfileStructW (
4098         DWORD   Unknown0,
4099         DWORD   Unknown1,
4100         DWORD   Unknown2,
4101         DWORD   Unknown3,
4102         DWORD   Unknown4
4103         )
4104 {
4105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4106         return FALSE;
4107 }
4108
4109
4110 WINBOOL
4111 STDCALL
4112 WriteProcessMemory (
4113         HANDLE  hProcess,
4114         LPVOID  lpBaseAddress,
4115         LPVOID  lpBuffer,
4116         DWORD   nSize,
4117         LPDWORD lpNumberOfBytesWritten
4118         )
4119 {
4120         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4121         return FALSE;
4122 }
4123
4124
4125 WINBOOL
4126 STDCALL
4127 WriteProfileSectionA (
4128         LPCSTR  lpAppName,
4129         LPCSTR  lpString
4130         )
4131 {
4132         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4133         return FALSE;
4134 }
4135
4136
4137 WINBOOL
4138 STDCALL
4139 WriteProfileSectionW (
4140         LPCWSTR lpAppName,
4141         LPCWSTR lpString
4142         )
4143 {
4144         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4145         return FALSE;
4146 }
4147
4148
4149 WINBOOL
4150 STDCALL
4151 WriteProfileStringA (
4152         LPCSTR  lpAppName,
4153         LPCSTR  lpKeyName,
4154         LPCSTR  lpString
4155         )
4156 {
4157         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4158         return FALSE;
4159 }
4160
4161
4162 WINBOOL
4163 STDCALL
4164 WriteProfileStringW (
4165         LPCWSTR lpAppName,
4166         LPCWSTR lpKeyName,
4167         LPCWSTR lpString
4168         )
4169 {
4170         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4171         return FALSE;
4172 }
4173
4174
4175 DWORD
4176 STDCALL
4177 WriteTapemark (
4178         HANDLE  hDevice,
4179         DWORD   dwTapemarkType,
4180         DWORD   dwTapemarkCount,
4181         WINBOOL bImmediate
4182         )
4183 {
4184         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4185         return 0;
4186 }
4187
4188 DWORD
4189 STDCALL
4190 GetTapePosition (
4191         HANDLE  hDevice,
4192         DWORD   dwPositionType,
4193         LPDWORD lpdwPartition,
4194         LPDWORD lpdwOffsetLow,
4195         LPDWORD lpdwOffsetHigh
4196         )
4197 {
4198         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4199         return 0;
4200 }
4201
4202
4203
4204 /* EOF */